mapper-factory 2.0.3 → 3.0.1

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

@@ -5,7 +5,7 @@ export interface MapInterface<T> {
     toModel: (object: any) => T;
     empty: () => boolean;
     filled: () => boolean;
-    get: (path: string) => T;
+    get: (path: string) => any;
     set: (path: string, value: any) => void;
     copy: () => T;
 }

package/dist/example.js

@@ -9,127 +9,98 @@ 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 {
-    id;
-    name;
-    testControl;
-    daysActive;
-    testConcatenation;
+const class_decorator_1 = require("./class.decorator");
+/*import { MapperFactory } from "../src/mapper";
+
+class TestClass extends MapperFactory {
+    field1: string;
+    field2: string;
 }
-__decorate([
-    (0, field_decorator_1.MapField)({
+
+const testInstance = new TestClass({ field1: 'value1', field2: 'value2' });
+console.log('Test instance:', testInstance);
+
+class History extends MapperFactory {
+    id: string;
+
+    @MapField({
         transformer: (arr) => " TEST TRASFORMER",
         reverser: (arr) => " TEST REVERSER",
-    }),
-    __metadata("design:type", String)
-], History.prototype, "name", void 0);
-__decorate([
-    (0, field_decorator_1.MapField)({
+    })
+    name: string;
+
+    @MapField({
         src: "control"
-    }),
-    __metadata("design:type", String)
-], History.prototype, "testControl", void 0);
-__decorate([
-    (0, field_decorator_1.MapField)({
+    })
+    testControl: string;
+
+    @MapField({
         initialize: true,
-        transformer: (arr, obj) => { return [obj.monday, obj.tuesday]; },
+        transformer: (arr, obj) => { return [obj.monday, obj.tuesday] },
         reverser: (arr) => {
-            return { monday: arr && arr[0], tuesday: arr && arr[1] };
+            return { monday: arr && arr[0], tuesday: arr && arr[1] }
         },
-    }),
-    __metadata("design:type", Array)
-], History.prototype, "daysActive", void 0);
-__decorate([
-    (0, field_decorator_1.MapField)({
+    })
+    daysActive: string[];
+
+    @MapField({
         src: "test.concatenation"
-    }),
-    __metadata("design:type", String)
-], History.prototype, "testConcatenation", void 0);
-class User extends mapper_1.MapperFactory {
-    id;
-    username;
-    name;
-    surname;
-    roles;
-    employees;
-    boss;
-    histories;
+    })
+    testConcatenation: string;
 }
-__decorate([
-    (0, field_decorator_1.MapField)({
+
+class User extends MapperFactory {
+    @MapField({
         src: 'firstName'
-    }),
-    __metadata("design:type", String)
-], User.prototype, "name", void 0);
-__decorate([
-    (0, field_decorator_1.MapField)({
+    })
+    name: string;
+
+    @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" } };
+    })
+    surname: string;
+
+}
+
+//let emp1: User = new User({ firstName: "Summer", lastName: "Smith" });
+//let emp2: User = 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);
-console.log("\n\n");
+//let u = new User(JSONObject);
+
+//const passedConstructorTest: boolean = u.name == JSONObject.firstName && u.surname == JSONObject.lastName && u.employees?.map(emp => emp.name == emp1.name) && u.roles?.map(role => role == "CEO") && u.boss.name == "Nello" && u.boss.surname == "Stanco";
+//console.log("TEST constructor", passedConstructorTest ? '✅' : '❌');
+
 //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());
@@ -137,6 +108,7 @@ 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" });
@@ -145,29 +117,33 @@ 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);
+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)
 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(toMap(emp1));
+const testEmp = toModel<User>(toMap(emp1));
 console.log("USER MODEL: ", testEmp);
-console.log((0, _1.objToModel)(emp1, { name: "test", surname: "prova" }));
+console.log(objToModel(emp1, { name: "test", surname: "prova" }));
 console.log("\n\n");
+*/
 //TEST NEW MapperFactory
-console.log("\nTEST NEW MapperFactory");
+console.log("\nNew MapperFactory");
 let Test = class Test {
     a;
 };
@@ -176,51 +152,59 @@ __decorate([
         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.MapClass)()
 ], Test);
-const test = new Test().from( /** INSIDE HERE YOUR OBJECT TO MAP */);
-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("COPY: ", test.copy());
-console.log("\n\n");
+const testEmpty = new Test().from();
+const testFilled = new Test().from({ b: 'filled' });
+const checkTest1 = (testEmpty && testEmpty.empty() == true && testEmpty.filled() == false);
+const checkTest2 = (testFilled && testFilled.empty() == false && testFilled.filled() == true);
+console.log("TEST EMPTY/FILLED", (checkTest1 && checkTest2) ? '✅' : '❌');
+const model3 = new Test().toModel({ a: 'test to model' });
+console.log("TEST TO MODEL", (model3.a == 'test to model') ? '✅' : '❌');
+const model4 = model3.toMap();
+console.log("TEST TO MAP", (model4.b.a == 'test reverser') ? '✅' : '❌');
+const model5 = model3.copy();
+console.log("TEST COPY", (Object.keys(model5).every(k => model5[k] == model3[k])) ? '✅' : '❌');
+console.log("\n");
 //TEST TestFlag with initialize
-console.log("\nTEST TestFlag with initialize");
+console.log("TestFlag with initialize");
 let TestFlag = class TestFlag {
     flTest;
+    a;
 };
 __decorate([
     (0, field_decorator_1.MapField)({
-        transformer: (num) => {
-            console.log("sto trasformando da num a bool");
-            return num == '1';
-        },
-        reverser: bool => {
-            console.log("sto trasformando da bool a num");
-            return bool ? '1' : '0';
-        },
+        transformer: (num) => num == '1',
+        reverser: bool => bool ? '1' : '0',
         initialize: true,
     }),
-    __metadata("design:type", String)
+    __metadata("design:type", Boolean)
 ], TestFlag.prototype, "flTest", void 0);
+__decorate([
+    (0, field_decorator_1.MapField)({
+        src: 'b',
+        transformer: value => 'test transformer',
+        reverser: value => ({ a: 'test reverser' }),
+        initialize: true,
+    }),
+    __metadata("design:type", String)
+], TestFlag.prototype, "a", void 0);
 TestFlag = __decorate([
     (0, class_decorator_1.MapClass)()
 ], TestFlag);
-const testFlag0 = new TestFlag().from({ flTest: '0' });
-console.log("TEST FLAG0", testFlag0);
-console.log("TO MAP: ", testFlag0.toMap());
+const testFlagInitialize = new TestFlag().from();
+console.log("TEST INITIALIZE", (testFlagInitialize && testFlagInitialize.a == 'test transformer') ? '✅' : '❌');
+const testFlag0 = new TestFlag().from();
+const testFlag0Map = testFlag0.toMap();
+console.log("TEST FLAG0", ((testFlag0.flTest === false) && testFlag0Map.flTest == '0') ? '✅' : '❌');
 const testFlag1 = new TestFlag().from({ flTest: '1' });
-console.log("TEST FLAG1", testFlag1);
-console.log("TO MAP: ", testFlag1.toMap());
-console.log("\n\n");
+const testFlag1Map = testFlag1.toMap();
+console.log("TEST FLAG1", (testFlag1.flTest && testFlag1Map.flTest == '1') ? '✅' : '❌');
+const testFlag2 = new TestFlag().from({ flTest: '0' });
+const testFlag2Map = testFlag2.toMap();
+console.log("TEST FLAG2", (!testFlag2.flTest && testFlag2Map.flTest == '0') ? '✅' : '❌');
+console.log("\n");