1.1.0 Added by-reference mappable option. Improved tests. Decorators

cdibbs · cdibbs · commit 4fa3c26a8bd6 · 2017-04-02T17:13:01.000-05:00
context bug workaround.
diff --git a/.angular-cli.json b/.angular-cli.json
@@ -43,6 +43,11 @@
   "test": {
     "karma": {
       "config": "./karma.conf.js"
+    },
+    "codeCoverage": {
+      "exclude": [
+        "src/app/test-resources/**/*"
+      ]
     }
   },
   "defaults": {
diff --git a/README.md b/README.md
@@ -38,6 +38,21 @@ export class MyWidget {
 }
 ```
 
+If providing view names, then you must provide the view models collection during import (see [Setup](#Setup)). Alternatively, as of v1.1.0+, you can provide classes directly to the `@mappable`: 
+
+```typescript 
+export class MyWidget {
+    Id: number; /* not visible to the mapper. */
+    Name: string = null; /* visible due to null default. */
+    get Display(): string { 
+        return `${Name} (Id: ${Id})`;
+    }
+
+    @mappable(MyWidget)
+    Wiggy: MyWidget = null; 
+}
+```
+
 If a source property exists while a destination does not, a warning will be issued by default.
 You can turn this off by providing a third parameter:
 
@@ -54,6 +69,7 @@ mapper.MapJsonToVM(MyWidget, json, false);
 
 Run `npm install --save-dev simple-mapper` inside of an Angular 4 project.
 
+
 ## Setup
 Inside your application's app.module.ts file, make the following additions.
 
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "simple-mapper",
   "description": "Angular 2+ object-to-view-model mapper. Intended to facilitate working with JSON from web API endpoints.",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "license": "MIT",
   "repository": "https://github.com/cdibbs/simple-mapper",
   "scripts": {
diff --git a/src/app/decorators/mappable.decorator.spec.ts b/src/app/decorators/mappable.decorator.spec.ts
@@ -0,0 +1,81 @@
+/* tslint:disable:no-unused-variable */
+import { ClassProvider, ValueProvider } from '@angular/core';
+import { TestBed, async, inject } from '@angular/core/testing';
+import { Observable } from 'rxjs';
+
+import { MapperService, MapperConfiguration} from '../services/mapper.service';
+import { mappable, getMappableProperties } from '../decorators/mappable.decorator';
+import * as vm from '../test-resources/mappable.decorator.test-vms';
+import { IConfig } from '../services/i';
+
+
+describe('Mappable Decorator', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            providers: [
+            ]
+        });
+    });
+    it('should not throw when ref types defined in order.', () => {
+        class ByRefOutOfOrderTwo {
+            Name: string = "";
+            get Calculated(): string { return this.Name + " else"; }
+        }
+        class ByRefOutOfOrder {
+            Id: number = 3;
+            @mappable(ByRefOutOfOrderTwo)
+            Two: ByRefOutOfOrder = null;
+        }
+
+        expect(1).toBe(1);
+    });
+    it('should throw when reference types defined out-of-order.', () => {
+        try {
+            class ByRefOutOfOrder {
+                Id: number = 3;
+                @mappable(ByRefOutOfOrderTwo)
+                Two: ByRefOutOfOrder = null;
+            }
+
+            class ByRefOutOfOrderTwo {
+                Name: string = "";
+                get Calculated(): string { return this.Name + " else"; }
+            }
+            expect("").toBe("Should have thrown an error.");
+        } catch (err) {
+            expect(err).toBeDefined();
+            expect(err.toString()).toContain("Did you define the type before using it?");
+        }
+    });
+});
+
+describe('getMappableProperties', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: "UnheardOf", useValue: vm.UnheardOf },
+                { provide: "Mine", useValue: vm.Mine }
+            ]
+        });
+    });
+    it('should return an empty dictionary when no mappables configured.', inject([], () => {
+        let dict = getMappableProperties(vm.UnheardOf);
+        expect(dict).toBeDefined();
+        expect(Object.keys(dict).length).toBe(0);
+    }));
+    it('should return a dictionary with one entry when class has one mappable.', inject([], () => {
+        console.log("Here first, but shouldn't be.");
+        console.log("Of interest", vm.Mine);
+        let dict = getMappableProperties(vm.Mine);
+        console.log(dict);
+        expect(dict).toBeDefined();
+        expect(Object.keys(dict).length).toBe(1);
+        console.log(typeof dict["Prop"], typeof vm.UnheardOf);
+        expect(dict["Prop"]).toBe(vm.UnheardOf);
+    }));
+    it('should not return other classes mappables.', inject([], () => {
+        let dict = getMappableProperties(vm.UnheardOf);
+        expect(dict).toBeDefined();
+        expect(Object.keys(dict).length).toBe(0);
+    }));
+});
diff --git a/src/app/decorators/mappable.decorator.ts b/src/app/decorators/mappable.decorator.ts
@@ -1,18 +1,28 @@
 import { URLSearchParams } from '@angular/http';
+import { MappableInfo } from './mappable-info';
 
-const mapMetadataKey = "its.appdev.map.decorator";
-export function mappable<T>(type: string)
+const mapMetadataKey = "us.dibbern.oss.map.decorator";
+type decoratorInput = { new(): any } | string;
+
+export function mappable(type: decoratorInput)
 {
-    return (target: Object, propertyKey: string | symbol) => {
-        let d = Reflect.get(target, mapMetadataKey) || {};
+    return function (target: Object, propertyKey: string | symbol) {
+        if (typeof type === "undefined") {
+            throw new Error(`Provided type for property "${propertyKey}" on "${target.constructor.name}" is undefined. Did you define the type before using it?`);
+        }
+        let d: { [propKey: string]: decoratorInput }
+            = Reflect.get(target, mapMetadataKey) || {};
         d[propertyKey] = type;
-        //console.log(target, mapMetadataKey, d, type);
         Reflect.set(target, mapMetadataKey, d);
     };
 }
 
-export function getMappableProperties<T>(target: Object)
-    : { [propKey : string]: string }
+export function getMappableProperties(target: Object)
+    : { [propKey : string]: decoratorInput }
 {
+    if (typeof target === 'function') {
+        target = target['prototype'];
+    }
+
     return Reflect.get(target, mapMetadataKey) || {};
 }
diff --git a/src/app/services/mapper.service.spec.ts b/src/app/services/mapper.service.spec.ts
@@ -90,6 +90,19 @@ describe('MapperService', () => {
         expect(result.One).toBe(json.One);
         expect(warned).toBeFalsy();
     }));
+    it('should error when view model missing.',
+    inject([MapperService], (mapper: MapperService) => {
+        try {
+            var json = {
+                Id: 3,
+                Prop: "something"
+            };
+            var result = mapper.MapJsonToVM(vm.NestedTypo, json);
+            expect("").toBe("Should have thrown error before here");
+        } catch(err) {
+            expect(err).toBeTruthy();
+        }
+    }));
     it('should map nested types.', inject([MapperService], (mapper: MapperService) => {
         var json = {
             Id: 3,
@@ -105,8 +118,29 @@ describe('MapperService', () => {
         expect(result.Prop.Another).toBe(json.Prop.Another);
         expect(result.Prop.Computed).toBe("for you and me");
     }));
-
-    it('should map nested types under an observable.', inject([MapperService], (mapper: MapperService) => {
+    it('should map nested reference types.', inject([MapperService], (mapper: MapperService) => {
+        var json = {
+            Id: 3,
+            Two: { Name: "something" }
+        };
+        var result = mapper.MapJsonToVM(vm.ByRefNested, json);
+        expect(result.Id).toBe(3);
+        expect(result.Two).toBeDefined();
+        expect(result.Two.Name).toBe(json.Two.Name);
+        expect(result.Two.Calculated).toBe("something else");
+    }));
+    it('should map nested array reference types.', inject([MapperService], (mapper: MapperService) => {
+        var json = {
+            Id: 3,
+            Two: [{ Name: "something" }]
+        };
+        var result = mapper.MapJsonToVM(vm.ByRefNestedArray, json);
+        expect(result.Id).toBe(3);
+        expect(result.Two).toBeDefined();
+        expect(result.Two[0].Name).toBe(json.Two[0].Name);
+        expect(result.Two[0].Calculated).toBe("something else");
+    }));
+    it('should map nested types under an observable.', async(inject([MapperService], (mapper: MapperService) => {
         var json = {
             Id: 3,
             One: "something else",
@@ -122,7 +156,20 @@ describe('MapperService', () => {
             expect(result.Prop.Another).toBe(json.Prop.Another);
             expect(result.Prop.Computed).toBe("for you and me");
         });
-    }));
+    })));
+    it('should map nested reference types under an observable.', async(inject([MapperService], (mapper: MapperService) => {
+        var json = {
+            Id: 3,
+            Two: { Name: "something" },
+        };
+        Observable.from([json]).delay(100).subscribe(j => {
+            var result = mapper.MapJsonToVM(vm.ByRefNested, json);
+            expect(result.Id).toBe(3);
+            expect(result.Two).toBeTruthy();
+            expect(result.Two.Name).toBe("something");
+            expect(result.Two.Calculated).toBe("something else");
+        });
+    })));
     it('should map nested array types.', inject([MapperService], (mapper: MapperService) => {
         var json = {
             Id: 3,
diff --git a/src/app/services/mapper.service.ts b/src/app/services/mapper.service.ts
@@ -29,7 +29,7 @@ export class MapperService implements IMapperService {
      */
     public MapJsonToVM<T extends { [key: string]: any }>(t: { new (): T }, json: any, unmappedWarning = true): T {
         let vm = new t();
-        let tprops = getMappableProperties<T>(vm);
+        let tprops = getMappableProperties(vm);
         let keys = Object.keys(json || {});
 
         if (unmappedWarning) {
@@ -43,21 +43,28 @@ export class MapperService implements IMapperService {
             let desc = Object.getOwnPropertyDescriptor(vm, prop);
             if (!desc || !desc.writable)
                 continue;
-
             // If there is an explicit mappable, map no matter what.
             if (typeof tprops[prop] === "string") {
-                if (! this.viewModels.hasOwnProperty(tprops[prop]))
-                    this.log.warn(`View model ${tprops[prop]} does not exist. Did you type it correctly?`);
+                let p: string = <string>tprops[prop];
+                if (! this.viewModels.hasOwnProperty(p))
+                    throw new Error(`View model ${tprops[prop]} does not exist. Did you type it correctly?`);
                 // If either the source or destination is iterable,
                 // map as an iterable. This is not ideal, but neither
                 // is Typescript. :-P
                 if (this.iterable(vm, json, prop)) {
-                    vm[prop] = this.MapJsonToVMArray(this.viewModels[tprops[prop]], json[prop]);
+                    vm[prop] = this.MapJsonToVMArray(this.viewModels[p], json[prop]);
                 } else {
-                    vm[prop] = this.MapJsonToVM(this.viewModels[tprops[prop]], json[prop]);
+                    vm[prop] = this.MapJsonToVM(this.viewModels[p], json[prop]);
                 }
-            }
-            else if (typeof vm[prop] !== "undefined") {
+            } else if (typeof tprops[prop] === 'function') {
+
+                let p: { new(): any } = <{new():any}>tprops[prop];
+                if (this.iterable(vm, json, prop)) {
+                    vm[prop] = this.MapJsonToVMArray(p, json[prop]);
+                } else {
+                    vm[prop] = this.MapJsonToVM(p, json[prop]);
+                }
+            } else if (typeof vm[prop] !== "undefined") {
                 vm[prop] = json[prop];
             }
         }
diff --git a/src/app/test-resources/mappable.decorator.test-vms.ts b/src/app/test-resources/mappable.decorator.test-vms.ts
@@ -0,0 +1,11 @@
+import { mappable } from '../decorators/mappable.decorator';
+
+// Test view models
+export class UnheardOf {
+    Id: number = 3;
+}
+export class Mine {
+    Id: number = 4;
+    @mappable(UnheardOf)
+    Prop: UnheardOf = null;
+}
diff --git a/src/app/test-resources/view-models.ts b/src/app/test-resources/view-models.ts
@@ -31,6 +31,12 @@ export class Nested_Mine {
     Prop: Nested_MineTwo = null;
 }
 
+export class NestedTypo {
+    Id: number = 3;
+    @mappable("MySillyTypo")
+    Prop: Nested_MineTwo = null;
+}
+
 export class Observable_MineTwo {
     Id: number = 3;
     Another: string = "for me";
@@ -54,3 +60,20 @@ export class NestedArrayTypes_Mine {
     @mappable("NestedArrayTypes_MineTwo")
     Props: NestedArrayTypes_MineTwo[] = null;
 }
+
+export class ByRefTwo {
+    Name: string = "";
+    get Calculated(): string { return this.Name + " else"; }
+}
+
+export class ByRefNested {
+    Id: number = 3;
+    @mappable(ByRefTwo)
+    Two: ByRefTwo = null;
+}
+
+export class ByRefNestedArray {
+    Id: number = 3;
+    @mappable(ByRefTwo)
+    Two: ByRefTwo[] = null;
+}

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "simple-mapper",`
`3`	`3`	`"description": "Angular 2+ object-to-view-model mapper. Intended to facilitate working with JSON from web API endpoints.",`
`4`		`- "version": "1.0.5",`
	`4`	`+ "version": "1.1.0",`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"repository": "https://github.com/cdibbs/simple-mapper",`
`7`	`7`	`"scripts": {`