Merge pull request #20 from SyslogicNL/develop

 0.1.2

dist/graph-serializer.js

@@ -114,6 +114,8 @@
      * @returns {any}
      */
     function deserialize(type, src) {
+        if (src === null)
+            return null;
         var ret = new type();
         var isDerivedClass = Object.getPrototypeOf(type) instanceof Function;
         if (isDerivedClass) {

package.json

@@ -45,6 +45,6 @@
   "scripts": {
     "test": "node ./node_modules/mocha/bin/_mocha --require ts-node/register ./test/**/*.ts"
   },
-  "version": "0.1.1",
+  "version": "0.1.2",
   "typings": "dist/graph-serializer.d.ts"
 }

src/graph-serializer.ts

@@ -114,12 +114,15 @@ const store = new Store();
  */
 export function deserialize(type: any, src: any): any {
 
+	if(src === null)
+		return null;
+
 	let ret = new type();
 
 	let isDerivedClass = Object.getPrototypeOf(type) instanceof Function;
 	if(isDerivedClass) {
 		let extendedType = Object.getPrototypeOf(Object.getPrototypeOf(new type())).constructor;
-		Object.assign(ret,deserialize(extendedType,src));
+		Object.assign(ret, deserialize(extendedType,src));
 	}
 
 	store.get(type).properties.forEach((property: PropertyDescription, propertyName: string) => {

test/nullobject.ts

@@ -0,0 +1,78 @@
+import {expect} from 'chai';
+import {array, custom, date, deserialize, object, serializable, serialize} from "../src/graph-serializer";
+
+/** @todo find a strategy to handle any of the standard objects, such as defined in
+ * https://developer.mozilla.org/nl/docs/Web/JavaScript/Reference/Global_Objects
+ * and
+ * https://developer.mozilla.org/en-US/docs/Web/API
+ */
+
+describe('Extra tests', () => {
+
+    describe('null value in nested class', () => {
+
+        class Foo {
+            @serializable() name:string;
+        }
+        class Bar {
+            @serializable() name:string;
+            @serializable() nest:Foo;
+        }
+
+        it('deserialize', () => {
+
+            let output = deserialize(Bar,{
+                name: "bar",
+                nest: {
+                    name: "foo"
+                }
+            });
+            expect(output).to.be.instanceOf(Bar);
+            expect(output.nest.name).to.equal('foo');
+
+            output = deserialize(Bar,{
+                name: "bar",
+                nest: null
+            });
+            expect(output.nest).to.equal(null);
+
+        });
+    });
+
+    describe('null object value class', () => {
+        // Test for use case. If decorated object property is null, it should be deserialized as such
+        class Foo {
+            @serializable() fooName: string;
+        }
+        class Bar {
+            @serializable({scheme: object(Foo)}) foo: Foo;
+        }
+        it('deserialize', () => {
+            let output = deserialize(Bar,{
+                name: 'bar',
+                foo: null,
+            })
+            expect(output.foo).to.equal(null);
+        });
+    });
+
+    describe('null object value in decorator-less class', () => {
+
+        class Foo {
+            foo: string;
+        }
+        class Bar {
+            @serializable({scheme: object(Foo)}) foo: Foo;
+        }
+        it('deserialize', () => {
+            let output = deserialize(Bar,{
+                name: 'bar',
+                foo: null,
+            });
+            expect(output.foo).to.equal(null);
+        });
+    });
+
+
+});
+