mapper-factory 3.0.0 → 3.1.0

package/README.md

@@ -213,179 +213,3 @@ let emp2: User = new User().from({ firstName: "Morty", lastName: "Smith" });
 
 let u = new User().from({ firstName: "Rick", lastName: "Sanchez", employees: [emp1.toMap(), emp2.toMap()], rolesToMap: ["CEO", "EMPLOYEE"] });
 ```
-
-## Usage V1
-
-### Mapping simple objects
-
-Your class must extends _MapperFactory_
-
-```
-class User extends MapperFactory {
-    ...
-}
-```
-
-After that, you can use _@MapField_ decorator over single property to specify the mapping:
-
-```
-class User extends MapperFactory {
-
-    @MapField({
-        src: 'firstName'
-    })
-    name: string;
-
-    @MapField({
-        src: 'obj.obj[0][1]',
-        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
-        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
-    })
-    roles?: string[];
-
-    @MapField({
-        transformer: (user) => new User(user)
-    })
-    boss: User;
-}
-```
-
-Inside _@MapField_ you can use:
-
-- **_src_**: define a string of original field name (also using a path like _"obj.obj[0][1]"_)
-- **_transform_**: function to transform data input in _constructor_ of the class
-- **_reverse_**: function to transform data input in _toMap_ method of the class
-
-In this example:
-
-```
-class User extends MapperFactory {
-
-    id: string;
-    username: string;
-
-    @MapField({
-        src: 'firstName'
-    })
-    name: string;
-
-    @MapField({
-        src: 'lastName'
-    })
-    surname: string;
-
-    @MapField({
-        src: 'rolesToMap',
-        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
-        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
-    })
-    roles?: string[];
-
-    @MapField({
-        transformer: (arr) => arr.map(user => new User(user))
-    })
-    employees?: User[];
-
-    @MapField({
-        transformer: (user) => new User(user)
-    })
-    boss: User;
-}
-```
-
-You can define a new User **_u_**:
-
-```
-let emp1: User = new User({ firstName: "Summer", lastName: "Smith" });
-let emp2: User = new User({ firstName: "Morty", lastName: "Smith" });
-
-let u = new User({ firstName: "Rick", lastName: "Sanchez", employees: [emp1, emp2], rolesToMap: ["CEO", "EMPLOYEE"] });
-```
-
-In that way you can create a new JS Object User passing a JSON object. Automatically constructor use _src_ and _transformer_ to obtain the correct object you want.
-
-In the specific case considered we have trasformed a JSON object:
-
-```
-{
-  firstName: 'Rick',
-  lastName: 'Sanchez',
-  employees: [
-    { firstName: 'Summer', lastName: 'Smith' },
-    { firstName: 'Morty', lastName: 'Smith' }
-  ],
-  rolesToMap: [ 'CEO', 'EMPLOYEE' ],
-  boss: { firstName: 'Jesus', lastName: 'Christ' }
-}
-```
-
-In this JS Object:
-
-```
-User {
-  name: 'Rick',
-  surname: 'Sanchez',
-  employees: [
-    User { name: 'Summer', surname: 'Smith' },
-    User { name: 'Morty', surname: 'Smith' }
-  ],
-  roles: [ 'CEO TEST TRASFORMER', 'EMPLOYEE TEST TRASFORMER' ],
-  boss: User { name: 'Jesus', surname: 'Christ' }
-}
-```
-
-Just using the constructor of _User_ class.
-
-If you want to return to the original JSON Object you can just call **_toMap()_** method, in that way:
-
-```
-u.toMap()
-```
-
-Obtaining the original JSON Object.
-
-You can also fill properties of an object from another (typically with same class) by using **_objToModel()_** method, in that way:
-
-```
-let uCopy = new User();
-uCopy.objToModel(u);
-```
-
-This method is meant to be used also when you have a JSON object but in the correct format, for example:
-
-```
-let uCopy = new User();
-uCopy.objToModel({ name: "Rick", surname: "Sanchez", employees: [emp1, emp2], roles: ["CEO", "EMPLOYEE"] })
-```
-
-Another utility method is **_empty()_** method, you can check if your object is empty or not in that way:
-
-```
-let user = new User();
-user.empty(); //TRUE
-
-user.name = "Rick";
-user.empty(); //FALSE
-```
-
-It is implemented also a GET/SET method whitch use the path. Using **_get(path: string)_** and **_set(path: string, value: any)_** you can access to the property you want and then GET or SET the value:
-
-```
-u.set("name", "Rick TEST-SET");
-console.log(u.get("name"));
-```
-
-With this mapper you can easily obtain a performant **_deep copy_** of your object doing:
-
-```
-let userDeepCopy = new User(u.toMap());
-```
-
-### Functions
-
-You can also use the following functions:
-
-- **_toMap(model: MapperFactory): Object_**: function to transform data input in _toMap_ method of the class
-- **_toModel\<T extends MapperFactory>(obj: Object)_**: T: function to transform data input (JSON) in the specified model _T_
-- **_objToModel\<T extends MapperFactory>(model: MapperFactory, obj: Object): T_**: T: function to get an instance of the object from a JSON representation without mapping it
-- **_copy\<T extends MapperFactory>(model: MapperFactory): T_**: T: function to get an instance of the object from a JSON representation without mapping it

package/dist/class.decorator.d.ts

@@ -1,11 +1,11 @@
-export declare function MapClass(): (constructor: any) => void;
-export interface MapInterface<T> {
-    from: (object?: any) => T;
-    toMap: () => any;
-    toModel: (object: any) => T;
-    empty: () => boolean;
-    filled: () => boolean;
-    get: (path: string) => any;
-    set: (path: string, value: any) => void;
-    copy: () => T;
-}
+export declare function MapClass(): (constructor: any) => void;
+export interface MapInterface<T> {
+    from: (object?: any) => T;
+    toMap: () => any;
+    toModel: (object: any) => T;
+    empty: () => boolean;
+    filled: () => boolean;
+    get: (path: string) => any;
+    set: (path: string, value: any) => void;
+    copy: () => T;
+}

package/dist/class.decorator.js

@@ -1,17 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapClass = void 0;
-const functions_1 = require("./functions");
-function MapClass() {
-    return function (constructor) {
-        constructor.prototype.from = functions_1.from;
-        constructor.prototype.toMap = functions_1.toMap;
-        constructor.prototype.toModel = functions_1.objToModel;
-        constructor.prototype.empty = functions_1.empty;
-        constructor.prototype.filled = functions_1.filled;
-        constructor.prototype.get = functions_1.get;
-        constructor.prototype.set = functions_1.set;
-        constructor.prototype.copy = functions_1.copy;
-    };
-}
-exports.MapClass = MapClass;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapClass = MapClass;
+const functions_1 = require("./functions");
+function MapClass() {
+    return function (constructor) {
+        constructor.prototype.from = functions_1.from;
+        constructor.prototype.toMap = functions_1.toMap;
+        constructor.prototype.toModel = functions_1.objToModel;
+        constructor.prototype.empty = functions_1.empty;
+        constructor.prototype.filled = functions_1.filled;
+        constructor.prototype.get = functions_1.get;
+        constructor.prototype.set = functions_1.set;
+        constructor.prototype.copy = functions_1.copy;
+    };
+}

package/dist/field.decorator.d.ts

@@ -1,22 +1,22 @@
-import 'reflect-metadata';
-import { ClassType } from './types';
-export declare const MAP_FIELD: unique symbol;
-export interface MapperMetadata<T = any> {
-    src?: keyof T;
-    initialize?: boolean;
-    transformer?: {
-        (input: any, ref: any): any;
-    };
-    reverser?: {
-        (input: any): any;
-    };
-}
-export declare function isClass(func: any): func is ClassType;
-export declare function getPrototype(target: Record<string, unknown> | ClassType): any;
-export declare const MapField: <T = any>({ transformer, reverser, src, initialize, }?: MapperMetadata<T>) => PropertyDecorator;
-export declare const getMapFieldMetadataList: (target: Record<string, unknown> | ClassType | any) => {
-    [key: string]: MapperMetadata<any>;
-};
-export declare const hasMapFieldMetadataList: (target: Record<string, unknown> | ClassType) => boolean;
-export declare const getMapFieldMetadata: (target: Record<string, unknown> | ClassType, propertyName: string | symbol) => MapperMetadata | undefined;
-export declare const hasMapFieldMetadata: (target: Record<string, unknown> | ClassType, propertyName: string) => boolean;
+import 'reflect-metadata';
+import { ClassType } from './types';
+export declare const MAP_FIELD: unique symbol;
+export interface MapperMetadata<T = any> {
+    src?: keyof T;
+    initialize?: boolean;
+    transformer?: {
+        (input: any, ref: any): any;
+    };
+    reverser?: {
+        (input: any): any;
+    };
+}
+export declare function isClass(func: any): func is ClassType;
+export declare function getPrototype(target: Record<string, unknown> | ClassType): any;
+export declare const MapField: <T = any>({ transformer, reverser, src, initialize, }?: MapperMetadata<T>) => PropertyDecorator;
+export declare const getMapFieldMetadataList: (target: Record<string, unknown> | ClassType | any) => {
+    [key: string]: MapperMetadata;
+} | undefined;
+export declare const hasMapFieldMetadataList: (target: Record<string, unknown> | ClassType) => boolean;
+export declare const getMapFieldMetadata: (target: Record<string, unknown> | ClassType, propertyName: string | symbol) => MapperMetadata | undefined;
+export declare const hasMapFieldMetadata: (target: Record<string, unknown> | ClassType, propertyName: string) => boolean;

package/dist/field.decorator.js

@@ -1,54 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasMapFieldMetadata = exports.getMapFieldMetadata = exports.hasMapFieldMetadataList = exports.getMapFieldMetadataList = exports.MapField = exports.getPrototype = exports.isClass = exports.MAP_FIELD = void 0;
-require("reflect-metadata");
-exports.MAP_FIELD = Symbol('MAP_FIELD');
-function isClass(func) {
-    return (typeof func === 'function' &&
-        /^class\s/.test(Function.prototype.toString.call(func)));
-}
-exports.isClass = isClass;
-function getPrototype(target) {
-    return isClass(target) || !target?.prototype ? !target?.constructor ? target : target?.constructor : target?.prototype;
-}
-exports.getPrototype = getPrototype;
-const MapField = ({ transformer, reverser, src, initialize = false, } = {}) => {
-    return (target, property) => {
-        const classConstructor = target.constructor;
-        const propertyName = property.toString();
-        const metadata = Reflect.getMetadata(exports.MAP_FIELD, classConstructor) || {};
-        // create new object reference to avoid this issue: https://github.com/rbuckton/reflect-metadata/issues/62
-        const newMetadata = { ...metadata };
-        const previousValues = metadata[propertyName];
-        newMetadata[propertyName] = {
-            ...previousValues,
-            src,
-            initialize,
-            transformer,
-            reverser,
-        };
-        Reflect.defineMetadata(exports.MAP_FIELD, newMetadata, classConstructor);
-    };
-};
-exports.MapField = MapField;
-const getMapFieldMetadataList = (target) => {
-    return Reflect.getMetadata(exports.MAP_FIELD, getPrototype(target));
-};
-exports.getMapFieldMetadataList = getMapFieldMetadataList;
-const hasMapFieldMetadataList = (target) => {
-    return Reflect.hasMetadata(exports.MAP_FIELD, getPrototype(target));
-};
-exports.hasMapFieldMetadataList = hasMapFieldMetadataList;
-const getMapFieldMetadata = (target, propertyName) => {
-    const metadata = (0, exports.getMapFieldMetadataList)(target);
-    const name = propertyName.toString();
-    if (!metadata || !metadata[name])
-        return undefined;
-    return metadata[name];
-};
-exports.getMapFieldMetadata = getMapFieldMetadata;
-const hasMapFieldMetadata = (target, propertyName) => {
-    const metadata = Reflect.getMetadata(exports.MAP_FIELD, getPrototype(target));
-    return metadata && !!metadata[propertyName];
-};
-exports.hasMapFieldMetadata = hasMapFieldMetadata;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMapFieldMetadata = exports.getMapFieldMetadata = exports.hasMapFieldMetadataList = exports.getMapFieldMetadataList = exports.MapField = exports.MAP_FIELD = void 0;
+exports.isClass = isClass;
+exports.getPrototype = getPrototype;
+require("reflect-metadata");
+exports.MAP_FIELD = Symbol('MAP_FIELD');
+function isClass(func) {
+    return (typeof func === 'function' &&
+        /^class\s/.test(Function.prototype.toString.call(func)));
+}
+function getPrototype(target) {
+    return isClass(target) || !target?.prototype ? !target?.constructor ? target : target?.constructor : target?.prototype;
+}
+const MapField = ({ transformer, reverser, src, initialize = false, } = {}) => {
+    return (target, property) => {
+        const classConstructor = target.constructor;
+        const propertyName = property.toString();
+        const metadata = Reflect.getMetadata(exports.MAP_FIELD, classConstructor) || {};
+        // create new object reference to avoid this issue: https://github.com/rbuckton/reflect-metadata/issues/62
+        const newMetadata = { ...metadata };
+        const previousValues = metadata[propertyName];
+        newMetadata[propertyName] = {
+            ...previousValues,
+            src,
+            initialize,
+            transformer,
+            reverser,
+        };
+        Reflect.defineMetadata(exports.MAP_FIELD, newMetadata, classConstructor);
+    };
+};
+exports.MapField = MapField;
+const getMapFieldMetadataList = (target) => {
+    return Reflect.getMetadata(exports.MAP_FIELD, getPrototype(target));
+};
+exports.getMapFieldMetadataList = getMapFieldMetadataList;
+const hasMapFieldMetadataList = (target) => {
+    return Reflect.hasMetadata(exports.MAP_FIELD, getPrototype(target));
+};
+exports.hasMapFieldMetadataList = hasMapFieldMetadataList;
+const getMapFieldMetadata = (target, propertyName) => {
+    const metadata = (0, exports.getMapFieldMetadataList)(target);
+    const name = propertyName.toString();
+    if (!metadata || !metadata[name])
+        return undefined;
+    return metadata[name];
+};
+exports.getMapFieldMetadata = getMapFieldMetadata;
+const hasMapFieldMetadata = (target, propertyName) => {
+    const metadata = Reflect.getMetadata(exports.MAP_FIELD, getPrototype(target));
+    return metadata && !!metadata[propertyName];
+};
+exports.hasMapFieldMetadata = hasMapFieldMetadata;

package/dist/functions.d.ts

@@ -1,49 +1,49 @@
-/**
-* Convert the instance of this class to JSON Object.
-*
-* @returns JSON object mapped considering metadata "src" and "reverser"
-*/
-export declare function toMap(): any;
-/**
- * Convert a JSON Object to an instance of this class.
- *
- * @param obj JSON Object
- * @returns Instance of this class
- */
-export declare function objToModel(obj: Object): any;
-/**
- * Check if this instance is empty.
- *
- * @returns true or false
- */
-export declare function empty(): boolean;
-/**
- * Check if this instance is filled.
- *
- * @returns true or false
- */
-export declare function filled(): boolean;
-/**
- * GET property value from a string path.
- *
- * @param path String path
- * @returns Value of the property
- */
-export declare function get<T>(path: string): T;
-/**
- * SET property value from a string path.
- *
- * @param path String path
- * @param value Value of the property
- */
-export declare function set(path: string, value: any): void;
-/**
- * Deep copy of the object caller
- */
-export declare function copy<T>(): T;
-/**
- * Constructor of the mapper.
- *
- * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
- */
-export declare function from(object: any): any;
+/**
+* Convert the instance of this class to JSON Object.
+*
+* @returns JSON object mapped considering metadata "src" and "reverser"
+*/
+export declare function toMap(): any;
+/**
+ * Convert a JSON Object to an instance of this class.
+ *
+ * @param obj JSON Object
+ * @returns Instance of this class
+ */
+export declare function objToModel(obj: Object): any;
+/**
+ * Check if this instance is empty.
+ *
+ * @returns true or false
+ */
+export declare function empty(): boolean;
+/**
+ * Check if this instance is filled.
+ *
+ * @returns true or false
+ */
+export declare function filled(): boolean;
+/**
+ * GET property value from a string path.
+ *
+ * @param path String path
+ * @returns Value of the property
+ */
+export declare function get<T>(path: string): T;
+/**
+ * SET property value from a string path.
+ *
+ * @param path String path
+ * @param value Value of the property
+ */
+export declare function set(path: string, value: any): void;
+/**
+ * Deep copy of the object caller
+ */
+export declare function copy<T>(): T;
+/**
+ * Constructor of the mapper.
+ *
+ * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
+ */
+export declare function from(object: any): any;