mapper-factory 1.0.33 → 1.0.34

package/dist/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/example.js

@@ -0,0 +1,135 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 field_decorator_1 = require("../src/field.decorator");
+const mapper_1 = require("../src/mapper");
+class History extends mapper_1.MapperFactory {
+}
+__decorate([
+    (0, field_decorator_1.MapField)({
+        transformer: (arr) => " TEST TRASFORMER",
+        reverser: (arr) => " TEST REVERSER",
+    }),
+    __metadata("design:type", String)
+], History.prototype, "name", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: "control"
+    }),
+    __metadata("design:type", String)
+], History.prototype, "testControl", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        initialize: true,
+        transformer: (arr, obj) => { return [obj.monday, obj.tuesday]; },
+        reverser: (arr) => {
+            return { monday: arr && arr[0], tuesday: arr && arr[1] };
+        },
+    }),
+    __metadata("design:type", Array)
+], History.prototype, "daysActive", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: "test.concatenation"
+    }),
+    __metadata("design:type", String)
+], History.prototype, "testConcatenation", void 0);
+class User extends mapper_1.MapperFactory {
+}
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: 'firstName'
+    }),
+    __metadata("design:type", String)
+], User.prototype, "name", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: 'lastName'
+    }),
+    __metadata("design:type", String)
+], User.prototype, "surname", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: 'rolesToMap',
+        transformer: (arr) => arr?.map(role => role + " TEST TRASFORMER"),
+        reverser: (arr) => arr?.map(role => role.replace(" TEST TRASFORMER", "")),
+    }),
+    __metadata("design:type", Array)
+], User.prototype, "roles", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        transformer: (arr) => arr?.map(user => new User(user))
+    }),
+    __metadata("design:type", Array)
+], User.prototype, "employees", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        transformer: (user) => new User(user)
+    }),
+    __metadata("design:type", User)
+], User.prototype, "boss", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        transformer: histories => histories?.map(hst => new History(hst)),
+        reverser: histories => histories?.map(hst => hst.toMap()),
+    }),
+    __metadata("design:type", Array)
+], User.prototype, "histories", void 0);
+let emp1 = new User({ firstName: "Summer", lastName: "Smith" });
+let emp2 = new User({ firstName: "Morty", lastName: "Smith" });
+let JSONObject = { firstName: "Rick", lastName: "Sanchez", employees: [emp1.toMap(), emp2.toMap()], rolesToMap: ["CEO", "EMPLOYEE"], boss: { firstName: "Nello", lastName: "Stanco" } };
+//TEST constructor
+let u = new User(JSONObject);
+console.log("\nTEST constructor");
+console.log(JSONObject);
+console.log(u);
+//TEST objToModel method with JS Object
+let u1 = new User();
+console.log("\nTEST objToModel method with JS Object");
+console.log(u1.objToModel(u));
+//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"] }));
+//TEST toMap method
+console.log("\nTEST toMap method");
+console.log(u.toMap());
+//TEST empty method
+console.log("\nTEST empty method");
+console.log(u.empty());
+//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"));
+//TEST deep copy
+console.log("\nTEST deep copy");
+let dpCopy = new User(u.toMap());
+dpCopy.name = "nome dpCopy";
+console.log(u);
+console.log(dpCopy);
+//TEST trasformer/reverser
+console.log("\nTEST reverser");
+let h1 = new History({ name: "h1" });
+let h2 = new History({ name: "h2" });
+u.histories = [h1, h2];
+console.log(u);
+console.log(u.toMap());
+//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());
+//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());

package/dist/field.decorator.d.ts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+import { ClassType } from './types';
+export declare const MAP_FIELD: unique symbol;
+export interface MapperMetadata<T = any> {
+    src?: string;
+    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;

package/dist/field.decorator.js

@@ -0,0 +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;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { MapField } from "./field.decorator";
+import { MapperFactory } from "./mapper";
+import { ClassType } from "./types";
+export { MapField, MapperFactory, ClassType };
+/**
+ * npx tsc
+ * npx ts-node src/example.ts
+ * npm version patch
+ * npm publish
+ */ 

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });
+/**
+ * npx tsc
+ * npx ts-node src/example.ts
+ * npm version patch
+ * npm publish
+ */ 

package/dist/mapper.d.ts

@@ -0,0 +1,46 @@
+import { ClassType } from "./types";
+export declare class MapperFactory {
+    /**
+     * Constructor of the mapper.
+     *
+     * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
+     */
+    constructor(object?: any);
+    /**
+     * Convert the instance of this class to JSON Object.
+     *
+     * @returns JSON object mapped considering metadata "src" and "reverser"
+     */
+    toMap(): any;
+    /**
+     * Convert a JSON Object to an instance of this class.
+     *
+     * @param obj JSON Object
+     * @returns Instance of this class
+     */
+    objToModel(obj: Object): this;
+    /**
+     * Check if this instance is empty.
+     *
+     * @returns true or false
+     */
+    empty(): boolean;
+    /**
+     * GET property value from a string path.
+     *
+     * @param path String path
+     * @returns Value of the property
+     */
+    get<T>(path: string): T;
+    /**
+     * SET property value from a string path.
+     *
+     * @param path String path
+     * @param value Value of the property
+     */
+    set(path: string, value: any): void;
+}
+/**
+ * @deprecated The method should not be used
+ */
+export declare function MapperFactoryFun(baseClass?: ClassType): ClassType;

package/dist/mapper.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperFactoryFun = exports.MapperFactory = void 0;
+const field_decorator_1 = require("./field.decorator");
+class MapperFactory {
+    /**
+     * Constructor of the mapper.
+     *
+     * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
+     */
+    constructor(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);
+            }
+        });
+    }
+    /**
+     * Convert the instance of this class to JSON Object.
+     *
+     * @returns JSON object mapped considering metadata "src" and "reverser"
+     */
+    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 (this[propertyName]?.toMap) {
+                            obj[src] = this[propertyName]?.toMap();
+                        }
+                        else {
+                            obj[src] = metadataList[propertyName]?.reverser ? metadataList[propertyName].reverser(this[propertyName], this) : this[propertyName];
+                        }
+                    }
+                }
+            }
+            else {
+                if (!obj[propertyName])
+                    obj[propertyName] = (metadataList && metadataList[propertyName]?.reverser) ? metadataList[propertyName].reverser(this[propertyName], this) : this[propertyName];
+            }
+        });
+        return obj;
+    }
+    /**
+     * Convert a JSON Object to an instance of this class.
+     *
+     * @param obj JSON Object
+     * @returns Instance of this class
+     */
+    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;
+    }
+    /**
+     * Check if this instance is empty.
+     *
+     * @returns true or false
+     */
+    empty() {
+        let check = true;
+        this && Object.keys(this).forEach(propertyName => {
+            if (this[propertyName] !== undefined && this[propertyName] !== null) {
+                check = false;
+            }
+        });
+        return check;
+    }
+    /**
+     * GET property value from a string path.
+     *
+     * @param path String path
+     * @returns Value of the property
+     */
+    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;
+    }
+    /**
+     * SET property value from a string path.
+     *
+     * @param path String path
+     * @param value Value of the property
+     */
+    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.MapperFactory = MapperFactory;
+/**
+ * @deprecated The method should not be used
+ */
+function MapperFactoryFun(baseClass = Object) {
+    class Mapper extends baseClass {
+        /**
+         * Constructor of the mapper.
+         *
+         * @param object object to be mapped considering metadata "src" and "transformer"
+         * @param rest other optional parameters
+         */
+        constructor(object, ...rest) {
+            super(...rest);
+        }
+    }
+    return Mapper;
+}
+exports.MapperFactoryFun = MapperFactoryFun;

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export declare type ClassType<Class = any> = {
+    new (...args: any[]): Class;
+};
+export declare type AnyFunction<A = any> = (...input: any[]) => A;
+export declare type AnyConstructor<A = Record<string, unknown>> = new (...input: any[]) => A;
+export declare type Mixin<T extends AnyFunction> = InstanceType<ReturnType<T>>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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