mapper-factory 1.0.37 → 1.0.40

package/dist/class.decorator.d.ts

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

package/dist/class.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperFactory = void 0;
+const functions_1 = require("../src/functions");
+function MapperFactory() {
+    return function (constructor) {
+        constructor.prototype.from = functions_1.constructorMap;
+        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.MapperFactory = MapperFactory;

package/dist/example.js

@@ -9,6 +9,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const class_decorator_1 = require("../src/class.decorator");
 const field_decorator_1 = require("../src/field.decorator");
 const mapper_1 = require("../src/mapper");
 class History extends mapper_1.MapperFactory {
@@ -91,30 +93,37 @@ let u = new User(JSONObject);
 console.log("\nTEST constructor");
 console.log(JSONObject);
 console.log(u);
+console.log("\n\n");
 //TEST objToModel method with JS Object
 let u1 = new User();
 console.log("\nTEST objToModel method with JS Object");
 console.log(u1.objToModel(u));
+console.log("\n\n");
 //TEST objToModel method with JSON Object
 console.log("\nTEST objToModel method with JSON Object");
 console.log(u.objToModel({ name: "Rick TEST-objToModel", roles: ["CEO TEST-objToModel", "EMPLOYEE TEST-objToModel"] }));
+console.log("\n\n");
 //TEST toMap method
 console.log("\nTEST toMap method");
 console.log(u.toMap());
+console.log("\n\n");
 //TEST empty method
 console.log("\nTEST empty method");
 console.log(u.empty());
+console.log("\n\n");
 //TEST get AND set method
 u.set("employees[1].name", "name editato");
 console.log("\nTEST get AND set method");
 console.log(u);
 console.log(u.get("employees[1].name"));
+console.log("\n\n");
 //TEST deep copy
 console.log("\nTEST deep copy");
 let dpCopy = new User(u.toMap());
 dpCopy.name = "nome dpCopy";
 console.log(u);
 console.log(dpCopy);
+console.log("\n\n");
 //TEST trasformer/reverser
 console.log("\nTEST reverser");
 let h1 = new History({ name: "h1" });
@@ -122,14 +131,52 @@ let h2 = new History({ name: "h2" });
 u.histories = [h1, h2];
 console.log(u);
 console.log(u.toMap());
+console.log("\n\n");
 //TEST ref
 console.log("\nTEST REF");
 let hTest = new History({ monday: "0", tuesday: "1", control: "control" });
 console.log(hTest);
 hTest.daysActive = ['1', '0'];
 console.log(hTest.toMap());
+console.log("\n\n");
 //TEST concat with point
 console.log("\nTEST CONCAT W POINT");
 let hTest2 = new History({ test: { concatenation: "resolve " }, control: "control" });
 console.log(hTest2);
 console.log(hTest2.toMap());
+console.log("\n\n");
+//TEST FUNC MAPPER
+console.log("\nTEST FUNC MAPPER");
+console.log(emp1);
+console.log((0, _1.toMap)(emp1));
+const testEmp = (0, _1.toModel)((0, _1.toMap)(emp1));
+console.log("USER MODEL: ", testEmp);
+console.log((0, _1.objToModel)(emp1, { name: "test", surname: "prova" }));
+console.log("\n\n");
+//TEST NEW MapperFactory
+console.log("\nTEST NEW MapperFactory");
+let Test = class Test {
+};
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: 'b',
+        transformer: value => 'test transformer',
+        reverser: value => ({ a: 'test reverser' }),
+        initialize: true,
+    }),
+    __metadata("design:type", String)
+], Test.prototype, "a", void 0);
+Test = __decorate([
+    (0, class_decorator_1.MapperFactory)()
+], Test);
+const test = new Test().from();
+console.log("TEST 1: ", test);
+console.log("EMPTY: ", test.empty());
+console.log("FILLED: ", test.filled());
+test.from({ b: 'filled' });
+console.log("TEST 2: ", test);
+console.log("EMPTY: ", test.empty());
+console.log("FILLED: ", test.filled());
+console.log("TO MODEL: ", test.toModel({ a: 'test to model' }));
+console.log("TO MAP: ", test.toMap());
+console.log("\n\n");

package/dist/field.decorator.js

@@ -9,7 +9,7 @@ function isClass(func) {
 }
 exports.isClass = isClass;
 function getPrototype(target) {
-    return isClass(target) || !target.prototype ? !target.constructor ? target : target.constructor : target.prototype;
+    return isClass(target) || !target?.prototype ? !target?.constructor ? target : target?.constructor : target?.prototype;
 }
 exports.getPrototype = getPrototype;
 const MapField = ({ transformer, reverser, src, initialize = false, } = {}) => {

package/dist/functions.d.ts

@@ -0,0 +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 constructorMap(object: any): any;

package/dist/functions.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructorMap = exports.copy = exports.set = exports.get = exports.filled = exports.empty = exports.objToModel = exports.toMap = void 0;
+const field_decorator_1 = require("./field.decorator");
+/**
+* Convert the instance of this class to JSON Object.
+*
+* @returns JSON object mapped considering metadata "src" and "reverser"
+*/
+function toMap() {
+    const metadataList = (0, field_decorator_1.getMapFieldMetadataList)(this);
+    let obj = {};
+    this && Object.keys(this).forEach(propertyName => {
+        if (metadataList && Object.keys(metadataList).some(prop => prop == propertyName)) {
+            const src = metadataList[propertyName].src || propertyName;
+            if (src.includes('.')) {
+                let props = src.split('.');
+                let propsStereoid = props.map(prop => {
+                    let index = prop.indexOf('[');
+                    return {
+                        prop: index > 0 ? prop.substring(0, index) : prop,
+                        isArray: prop.includes('[') && prop.includes(']'),
+                        arrIndex: prop.substring(index),
+                    };
+                });
+                let i;
+                let objCopy = obj;
+                let lastIndex;
+                for (i = 0; i < propsStereoid?.length; i++) {
+                    if (propsStereoid[i].isArray) {
+                        let arrIndex = propsStereoid[i].arrIndex?.split(/\[(\w+)\]/g)?.filter(index => index !== '');
+                        objCopy[propsStereoid[i].prop] = objCopy[propsStereoid[i].prop] || [];
+                        objCopy = objCopy[propsStereoid[i].prop];
+                        arrIndex.forEach((index, i) => {
+                            objCopy[index] = objCopy[index] || (i == arrIndex.length - 1 ? {} : []);
+                            if (!(i == propsStereoid.length - 1))
+                                objCopy = objCopy[index];
+                            else
+                                lastIndex = index;
+                        });
+                    }
+                    else {
+                        objCopy[propsStereoid[i].prop] = objCopy[propsStereoid[i].prop] || {};
+                        if (!(i == propsStereoid?.length - 1))
+                            objCopy = objCopy[propsStereoid[i].prop];
+                        else
+                            lastIndex = propsStereoid[i].prop;
+                    }
+                }
+                if (Array.isArray(this[propertyName])) {
+                    objCopy[lastIndex] = metadataList[propertyName].reverser ?
+                        metadataList[propertyName].reverser(this[propertyName], this)
+                        : this[propertyName].map(item => {
+                            return item?.toMap ? item.toMap() : item;
+                        });
+                }
+                else if (metadataList[propertyName].toMap) {
+                    objCopy[lastIndex] = this[propertyName]?.toMap();
+                }
+                else {
+                    objCopy[lastIndex] = metadataList[propertyName].reverser ? metadataList[propertyName].reverser(this[propertyName], this) : this[propertyName];
+                }
+            }
+            else {
+                /*if (metadataList[propertyName]?.initialize && metadataList[propertyName]?.reverser) {
+                    const revObj = metadataList[propertyName]?.reverser(this[propertyName]);
+                    revObj && Object.keys(revObj).forEach(key => {
+                        if (revObj[key])
+                            obj[key] = revObj[key];
+                    });
+                } else {*/
+                if (Array.isArray(this[propertyName]) && !metadataList[propertyName]?.reverser) {
+                    obj[src] = this[propertyName].map(item => {
+                        return item?.toMap ? item.toMap() : item;
+                    });
+                }
+                else if (metadataList[propertyName]?.reverser) {
+                    obj[src] = metadataList[propertyName].reverser(this[propertyName], this);
+                }
+                else if (this[propertyName]?.toMap) {
+                    obj[src] = this[propertyName]?.toMap();
+                }
+                else {
+                    obj[src] = this[propertyName];
+                }
+                /*}*/
+            }
+        }
+        else {
+            if (!obj[propertyName])
+                obj[propertyName] = (metadataList && metadataList[propertyName]?.reverser) ? metadataList[propertyName].reverser(this[propertyName], this) : this[propertyName];
+        }
+    });
+    return obj;
+}
+exports.toMap = toMap;
+/**
+ * Convert a JSON Object to an instance of this class.
+ *
+ * @param obj JSON Object
+ * @returns Instance of this class
+ */
+function objToModel(obj) {
+    const metadataList = (0, field_decorator_1.getMapFieldMetadataList)(this);
+    obj && Object.keys(obj).forEach(propertyName => {
+        if (metadataList && Object.keys(metadataList).some(prop => prop == propertyName)) {
+            if (metadataList[propertyName].transformer) {
+                if (Array.isArray(obj[propertyName])) {
+                    this[propertyName] = obj[propertyName].map(item => {
+                        return item;
+                    });
+                }
+                else {
+                    this[propertyName] = obj[propertyName];
+                }
+            }
+            else {
+                this[propertyName] = obj[propertyName];
+            }
+        }
+        else {
+            this[propertyName] = obj[propertyName];
+        }
+    });
+    return this;
+}
+exports.objToModel = objToModel;
+/**
+ * Check if this instance is empty.
+ *
+ * @returns true or false
+ */
+function empty() {
+    let check = true;
+    this && Object.keys(this).forEach(propertyName => {
+        if (this[propertyName] !== undefined && this[propertyName] !== null) {
+            check = false;
+            return;
+        }
+    });
+    return check;
+}
+exports.empty = empty;
+/**
+ * Check if this instance is filled.
+ *
+ * @returns true or false
+ */
+function filled() {
+    if (Object.keys(this)?.length == 0)
+        return false;
+    let check = true;
+    this && Object.keys(this).forEach(propertyName => {
+        if (this[propertyName] === undefined || this[propertyName] === null) {
+            check = false;
+            return;
+        }
+    });
+    return check;
+}
+exports.filled = filled;
+/**
+ * GET property value from a string path.
+ *
+ * @param path String path
+ * @returns Value of the property
+ */
+function get(path) {
+    let pathReplaced = path.replace(/\[(\w+)\]/g, '.$1');
+    let props = pathReplaced.split('.');
+    let rtn;
+    if (props?.length) {
+        rtn = this[props[0]];
+        for (let index in props) {
+            if (+index > 0)
+                rtn = rtn && rtn[props[index]];
+        }
+    }
+    return rtn;
+}
+exports.get = get;
+/**
+ * SET property value from a string path.
+ *
+ * @param path String path
+ * @param value Value of the property
+ */
+function set(path, value) {
+    path = path.replace(/\[(\w+)\]/g, '.$1');
+    let props = path.split('.');
+    let obj = this;
+    let i;
+    for (i = 0; i < props?.length - 1; i++) {
+        props?.[i] && (obj = obj?.[props?.[i]]);
+    }
+    props?.[i] && obj && (obj[props?.[i]] = value);
+}
+exports.set = set;
+/**
+ * Deep copy of the object caller
+ */
+function copy() {
+    return this.constructorMap(this.toMap());
+}
+exports.copy = copy;
+/**
+ * Constructor of the mapper.
+ *
+ * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
+ */
+function constructorMap(object) {
+    const metadataList = (0, field_decorator_1.getMapFieldMetadataList)(this);
+    object && Object.keys(object).forEach(propertyName => {
+        let metaKeys = metadataList && Object.keys(metadataList).filter(metadata => metadataList[metadata]?.src?.split('.')?.includes(propertyName));
+        if (metaKeys?.length) {
+            metaKeys.forEach(metaKey => {
+                let metaProp = metadataList[metaKey];
+                if (metaProp) {
+                    let props = metaProp.src?.split('.');
+                    let propsStereoid = props.map(prop => {
+                        let index = prop.indexOf('[');
+                        return {
+                            prop: index > 0 ? prop.substring(0, index) : prop,
+                            isArray: prop.includes('[') && prop.includes(']'),
+                            arrIndex: prop.substring(index),
+                        };
+                    });
+                    let i;
+                    let objCopy = { ...object };
+                    for (i = 0; i < propsStereoid.length; i++) {
+                        if (propsStereoid[i].isArray) {
+                            let arrIndex = propsStereoid[i].arrIndex?.split(/\[(\w+)\]/g)?.filter(index => index !== '');
+                            objCopy = objCopy[propsStereoid[i].prop];
+                            arrIndex.forEach((index, i) => {
+                                objCopy = objCopy[index];
+                            });
+                        }
+                        else {
+                            objCopy = objCopy[propsStereoid[i].prop];
+                        }
+                    }
+                    if (metaProp?.transformer) {
+                        this[metaKey] = metaProp.transformer(objCopy, object);
+                    }
+                    else {
+                        this[metaKey] = objCopy;
+                    }
+                }
+                else {
+                    let metaKey = metadataList && Object.keys(metadataList).find(metadata => metadataList[metadata]?.src == propertyName);
+                    if (metaKey) {
+                        const src = metadataList[metaKey].src || propertyName;
+                        if (metadataList[metaKey].transformer) {
+                            this[metaKey] = metadataList[metaKey].transformer(object[src], object);
+                        }
+                        else {
+                            this[metaKey] = object[src];
+                        }
+                    }
+                    else {
+                        if (metadataList[propertyName]?.transformer) {
+                            this[propertyName] = metadataList[propertyName].transformer(object[propertyName], object);
+                        }
+                        else {
+                            this[propertyName] = object[propertyName];
+                        }
+                    }
+                }
+            });
+        }
+        else {
+            let metaKey = metadataList && Object.keys(metadataList).find(metadata => metadataList[metadata]?.src == propertyName);
+            if (metaKey) {
+                const src = metadataList[metaKey].src || propertyName;
+                if (metadataList[metaKey].transformer) {
+                    this[metaKey] = metadataList[metaKey].transformer(object[src], object);
+                }
+                else {
+                    this[metaKey] = object[src];
+                }
+            }
+            else {
+                if (metadataList && metadataList[propertyName]?.transformer) {
+                    this[propertyName] = metadataList[propertyName].transformer(object[propertyName], object);
+                }
+                else {
+                    this[propertyName] = object[propertyName];
+                }
+            }
+        }
+    });
+    //MAP CASE initialize = true
+    metadataList && Object.keys(metadataList).forEach(metaName => {
+        if (metadataList[metaName]?.initialize && metadataList[metaName]?.transformer) {
+            this[metaName] = metadataList[metaName]?.transformer(null, object);
+        }
+    });
+    return this;
+}
+exports.constructorMap = constructorMap;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { MapField } from "./field.decorator";
 import { MapperFactory } from "./mapper";
+import { objToModel, toMap, toModel } from "./mapper-functions";
 import { ClassType } from "./types";
-export { MapField, MapperFactory, ClassType };
+export { ClassType, MapField, MapperFactory, objToModel, toMap, toModel };
 /**
  * npx tsc
  * npx ts-node src/example.ts

package/dist/index.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapperFactory = exports.MapField = void 0;
+exports.toModel = exports.toMap = exports.objToModel = exports.MapperFactory = exports.MapField = void 0;
 const field_decorator_1 = require("./field.decorator");
 Object.defineProperty(exports, "MapField", { enumerable: true, get: function () { return field_decorator_1.MapField; } });
 const mapper_1 = require("./mapper");
 Object.defineProperty(exports, "MapperFactory", { enumerable: true, get: function () { return mapper_1.MapperFactory; } });
+const mapper_functions_1 = require("./mapper-functions");
+Object.defineProperty(exports, "objToModel", { enumerable: true, get: function () { return mapper_functions_1.objToModel; } });
+Object.defineProperty(exports, "toMap", { enumerable: true, get: function () { return mapper_functions_1.toMap; } });
+Object.defineProperty(exports, "toModel", { enumerable: true, get: function () { return mapper_functions_1.toModel; } });
 /**
  * npx tsc
  * npx ts-node src/example.ts

package/dist/mapper-functions.d.ts

@@ -0,0 +1,5 @@
+import { MapperFactory } from "./mapper";
+export declare function toMap(model: MapperFactory): Object;
+export declare function toModel<T extends MapperFactory>(obj: Object): T;
+export declare function objToModel<T extends MapperFactory>(model: MapperFactory, obj: Object): T;
+export declare function copy<T extends MapperFactory>(model: MapperFactory): T;

package/dist/mapper-functions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy = exports.objToModel = exports.toModel = exports.toMap = void 0;
+const mapper_1 = require("./mapper");
+function toMap(model) {
+    return model.toMap();
+}
+exports.toMap = toMap;
+function toModel(obj) {
+    return new mapper_1.MapperFactory(obj);
+}
+exports.toModel = toModel;
+function objToModel(model, obj) {
+    return model.objToModel(obj);
+}
+exports.objToModel = objToModel;
+function copy(model) {
+    return new mapper_1.MapperFactory(model.toMap());
+}
+exports.copy = copy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapper-factory",
-  "version": "1.0.37",
+  "version": "1.0.40",
   "description": "mapper for typescript object",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",