refactor: rename methods with name class* to instance*

BREAKING CHANGE

Author: NoNameProvided

src/ClassTransformer.ts

@@ -12,9 +12,9 @@ export class ClassTransformer {
   /**
    * Converts class (constructor) object to plain (literal) object. Also works with arrays.
    */
-  classToPlain<T extends Record<string, any>>(object: T, options?: ClassTransformOptions): Record<string, any>;
-  classToPlain<T extends Record<string, any>>(object: T[], options?: ClassTransformOptions): Record<string, any>[];
-  classToPlain<T extends Record<string, any>>(
+  instanceToPlain<T extends Record<string, any>>(object: T, options?: ClassTransformOptions): Record<string, any>;
+  instanceToPlain<T extends Record<string, any>>(object: T[], options?: ClassTransformOptions): Record<string, any>[];
+  instanceToPlain<T extends Record<string, any>>(
     object: T | T[],
     options?: ClassTransformOptions
   ): Record<string, any> | Record<string, any>[] {
@@ -55,17 +55,17 @@ export class ClassTransformer {
   /**
    * Converts plain (literal) object to class (constructor) object. Also works with arrays.
    */
-  plainToClass<T extends Record<string, any>, V extends Array<any>>(
+  plainToInstance<T extends Record<string, any>, V extends Array<any>>(
     cls: ClassConstructor<T>,
     plain: V,
     options?: ClassTransformOptions
   ): T[];
-  plainToClass<T extends Record<string, any>, V>(
+  plainToInstance<T extends Record<string, any>, V>(
     cls: ClassConstructor<T>,
     plain: V,
     options?: ClassTransformOptions
   ): T;
-  plainToClass<T extends Record<string, any>, V>(
+  plainToInstance<T extends Record<string, any>, V>(
     cls: ClassConstructor<T>,
     plain: V | V[],
     options?: ClassTransformOptions
@@ -103,9 +103,9 @@ export class ClassTransformer {
   /**
    * Converts class (constructor) object to new class (constructor) object. Also works with arrays.
    */
-  classToClass<T>(object: T, options?: ClassTransformOptions): T;
-  classToClass<T>(object: T[], options?: ClassTransformOptions): T[];
-  classToClass<T>(object: T | T[], options?: ClassTransformOptions): T | T[] {
+  instanceToInstance<T>(object: T, options?: ClassTransformOptions): T;
+  instanceToInstance<T>(object: T[], options?: ClassTransformOptions): T[];
+  instanceToInstance<T>(object: T | T[], options?: ClassTransformOptions): T | T[] {
     const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, {
       ...defaultOptions,
       ...options,
@@ -134,22 +134,22 @@ export class ClassTransformer {
   serialize<T>(object: T, options?: ClassTransformOptions): string;
   serialize<T>(object: T[], options?: ClassTransformOptions): string;
   serialize<T>(object: T | T[], options?: ClassTransformOptions): string {
-    return JSON.stringify(this.classToPlain(object, options));
+    return JSON.stringify(this.instanceToPlain(object, options));
   }
 
   /**
    * Deserializes given JSON string to a object of the given class.
    */
   deserialize<T>(cls: ClassConstructor<T>, json: string, options?: ClassTransformOptions): T {
     const jsonObject: T = JSON.parse(json);
-    return this.plainToClass(cls, jsonObject, options);
+    return this.plainToInstance(cls, jsonObject, options);
   }
 
   /**
    * Deserializes given JSON string to an array of objects of the given class.
    */
   deserializeArray<T>(cls: ClassConstructor<T>, json: string, options?: ClassTransformOptions): T[] {
     const jsonObject: any[] = JSON.parse(json);
-    return this.plainToClass(cls, jsonObject, options);
+    return this.plainToInstance(cls, jsonObject, options);
   }
 }

src/decorators/index.ts

@@ -1,7 +1,7 @@
 export * from './exclude.decorator';
 export * from './expose.decorator';
-export * from './transform-class-to-class.decorator';
-export * from './transform-class-to-plain.decorator';
-export * from './transform-plain-to-class.decorator';
+export * from './transform-instance-to-instance.decorator';
+export * from './transform-instance-to-plain.decorator';
+export * from './transform-plain-to-instance.decorator';
 export * from './transform.decorator';
 export * from './type.decorator';

src/decorators/transform-class-to-class.decorator.ts renamed to src/decorators/transform-instance-to-instance.decorator.ts

@@ -6,7 +6,7 @@ import { ClassTransformOptions } from '../interfaces';
  *
  * Can be applied to functions and getters/setters only.
  */
-export function TransformClassToClass(params?: ClassTransformOptions): MethodDecorator {
+export function TransformInstanceToInstance(params?: ClassTransformOptions): MethodDecorator {
   return function (target: Record<string, any>, propertyKey: string | Symbol, descriptor: PropertyDescriptor): void {
     const classTransformer: ClassTransformer = new ClassTransformer();
     const originalMethod = descriptor.value;
@@ -16,8 +16,8 @@ export function TransformClassToClass(params?: ClassTransformOptions): MethodDec
       const isPromise =
         !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';
       return isPromise
-        ? result.then((data: any) => classTransformer.classToClass(data, params))
-        : classTransformer.classToClass(result, params);
+        ? result.then((data: any) => classTransformer.instanceToInstance(data, params))
+        : classTransformer.instanceToInstance(result, params);
     };
   };
 }

src/decorators/transform-class-to-plain.decorator.ts renamed to src/decorators/transform-instance-to-plain.decorator.ts

@@ -6,7 +6,7 @@ import { ClassTransformOptions } from '../interfaces';
  *
  * Can be applied to functions and getters/setters only.
  */
-export function TransformClassToPlain(params?: ClassTransformOptions): MethodDecorator {
+export function TransformInstanceToPlain(params?: ClassTransformOptions): MethodDecorator {
   return function (target: Record<string, any>, propertyKey: string | Symbol, descriptor: PropertyDescriptor): void {
     const classTransformer: ClassTransformer = new ClassTransformer();
     const originalMethod = descriptor.value;
@@ -16,8 +16,8 @@ export function TransformClassToPlain(params?: ClassTransformOptions): MethodDec
       const isPromise =
         !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';
       return isPromise
-        ? result.then((data: any) => classTransformer.classToPlain(data, params))
-        : classTransformer.classToPlain(result, params);
+        ? result.then((data: any) => classTransformer.instanceToPlain(data, params))
+        : classTransformer.instanceToPlain(result, params);
     };
   };
 }

src/decorators/transform-plain-to-class.decorator.ts renamed to src/decorators/transform-plain-to-instance.decorator.ts

@@ -6,7 +6,7 @@ import { ClassTransformOptions, ClassConstructor } from '../interfaces';
  *
  * Can be applied to functions and getters/setters only.
  */
-export function TransformPlainToClass(
+export function TransformPlainToInstance(
   classType: ClassConstructor<any>,
   params?: ClassTransformOptions
 ): MethodDecorator {
@@ -19,8 +19,8 @@ export function TransformPlainToClass(
       const isPromise =
         !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';
       return isPromise
-        ? result.then((data: any) => classTransformer.plainToClass(classType, data, params))
-        : classTransformer.plainToClass(classType, result, params);
+        ? result.then((data: any) => classTransformer.plainToInstance(classType, data, params))
+        : classTransformer.plainToInstance(classType, result, params);
     };
   };
 }

src/index.ts

@@ -12,19 +12,21 @@ const classTransformer = new ClassTransformer();
 /**
  * Converts class (constructor) object to plain (literal) object. Also works with arrays.
  */
-export function classToPlain<T>(object: T, options?: ClassTransformOptions): Record<string, any>;
-export function classToPlain<T>(object: T[], options?: ClassTransformOptions): Record<string, any>[];
-export function classToPlain<T>(
+export function instanceToPlain<T>(object: T, options?: ClassTransformOptions): Record<string, any>;
+export function instanceToPlain<T>(object: T[], options?: ClassTransformOptions): Record<string, any>[];
+export function instanceToPlain<T>(
   object: T | T[],
   options?: ClassTransformOptions
 ): Record<string, any> | Record<string, any>[] {
-  return classTransformer.classToPlain(object, options);
+  return classTransformer.instanceToPlain(object, options);
 }
 
 /**
  * Converts class (constructor) object to plain (literal) object.
  * Uses given plain object as source object (it means fills given plain object with data from class object).
  * Also works with arrays.
+ *
+ * @deprecated This function is being removed.
  */
 export function classToPlainFromExist<T>(
   object: T,
@@ -47,10 +49,14 @@ export function classToPlainFromExist<T>(
 /**
  * Converts plain (literal) object to class (constructor) object. Also works with arrays.
  */
-export function plainToClass<T, V>(cls: ClassConstructor<T>, plain: V[], options?: ClassTransformOptions): T[];
-export function plainToClass<T, V>(cls: ClassConstructor<T>, plain: V, options?: ClassTransformOptions): T;
-export function plainToClass<T, V>(cls: ClassConstructor<T>, plain: V | V[], options?: ClassTransformOptions): T | T[] {
-  return classTransformer.plainToClass(cls, plain as any, options);
+export function plainToInstance<T, V>(cls: ClassConstructor<T>, plain: V[], options?: ClassTransformOptions): T[];
+export function plainToInstance<T, V>(cls: ClassConstructor<T>, plain: V, options?: ClassTransformOptions): T;
+export function plainToInstance<T, V>(
+  cls: ClassConstructor<T>,
+  plain: V | V[],
+  options?: ClassTransformOptions
+): T | T[] {
+  return classTransformer.plainToInstance(cls, plain as any, options);
 }
 
 /**
@@ -69,10 +75,10 @@ export function plainToClassFromExist<T, V>(clsObject: T, plain: V | V[], option
 /**
  * Converts class (constructor) object to new class (constructor) object. Also works with arrays.
  */
-export function classToClass<T>(object: T, options?: ClassTransformOptions): T;
-export function classToClass<T>(object: T[], options?: ClassTransformOptions): T[];
-export function classToClass<T>(object: T | T[], options?: ClassTransformOptions): T | T[] {
-  return classTransformer.classToClass(object, options);
+export function instanceToInstance<T>(object: T, options?: ClassTransformOptions): T;
+export function instanceToInstance<T>(object: T[], options?: ClassTransformOptions): T[];
+export function instanceToInstance<T>(object: T | T[], options?: ClassTransformOptions): T | T[] {
+  return classTransformer.instanceToInstance(object, options);
 }
 
 /**
@@ -93,7 +99,7 @@ export function classToClassFromExist<T>(object: T, fromObject: T | T[], options
  *
  * @deprecated This function is being removed. Please use
  * ```
- * JSON.stringify(classToPlain(object, options))
+ * JSON.stringify(instanceToPlain(object, options))
  * ```
  */
 export function serialize<T>(object: T, options?: ClassTransformOptions): string;
@@ -107,7 +113,7 @@ export function serialize<T>(object: T | T[], options?: ClassTransformOptions):
  *
  * @deprecated This function is being removed. Please use the following instead:
  * ```
- * plainToClass(cls, JSON.parse(json), options)
+ * instanceToClass(cls, JSON.parse(json), options)
  * ```
  */
 export function deserialize<T>(cls: ClassConstructor<T>, json: string, options?: ClassTransformOptions): T {
@@ -119,7 +125,7 @@ export function deserialize<T>(cls: ClassConstructor<T>, json: string, options?:
  *
  * @deprecated This function is being removed. Please use the following instead:
  * ```
- * JSON.parse(json).map(value => plainToClass(cls, value, options))
+ * JSON.parse(json).map(value => instanceToClass(cls, value, options))
  * ```
  *
  */

src/interfaces/decorator-options/expose-options.interface.ts

@@ -12,7 +12,7 @@ export interface ExposeOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { version: 1.0 });
+   * instanceToPlain(payload, { version: 1.0 });
    * ```
    */
   since?: number;
@@ -22,7 +22,7 @@ export interface ExposeOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { version: 1.0 });
+   * instanceToPlain(payload, { version: 1.0 });
    * ```
    */
   until?: number;
@@ -34,7 +34,7 @@ export interface ExposeOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { groups: ['user'] });
+   * instanceToPlain(payload, { groups: ['user'] });
    * ```
    */
   groups?: string[];

src/interfaces/decorator-options/transform-options.interface.ts

@@ -7,7 +7,7 @@ export interface TransformOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { version: 1.0 });
+   * instanceToPlain(payload, { version: 1.0 });
    * ```
    */
   since?: number;
@@ -17,7 +17,7 @@ export interface TransformOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { version: 1.0 });
+   * instanceToPlain(payload, { version: 1.0 });
    * ```
    */
   until?: number;
@@ -29,7 +29,7 @@ export interface TransformOptions {
    *
    * Example:
    * ```ts
-   * classToPlain(payload, { groups: ['user'] });
+   * instanceToPlain(payload, { groups: ['user'] });
    * ```
    */
   groups?: string[];