Fix deserialization from object

js/typedjson/helpers.d.ts

@@ -11,6 +11,7 @@ export declare function isDirectlySerializableNativeType(type: Function): boolea
 export declare function isTypeTypedArray(type: Function): boolean;
 export declare function isPrimitiveValue(obj: any): boolean;
 export declare function isObject(value: any): value is Object;
+export declare function parseToJSObject(json: any, expectedType: Function): Object;
 /**
  * Determines if 'A' is a sub-type of 'B' (or if 'A' equals 'B').
  * @param A The supposed derived type.

spec/just-json.spec.ts

@@ -0,0 +1,94 @@
+import { jsonArrayMember, jsonMember, jsonObject, TypedJSON } from "../js/typedjson";
+
+describe('json (without automatic stringify)', function () {
+    describe('string', function () {
+        it('should deserialize', function () {
+            // stringified json version cuz ""
+            expect(TypedJSON.parse('"str"', String)).toEqual('str');
+            // already parsed
+            expect(TypedJSON.parse('str', String)).toEqual('str');
+
+            // because we detect naively
+            try {
+                expect(TypedJSON.parse('"sdfs"fdsf"', String)).toEqual(undefined);
+                fail();
+            } catch(e) {}
+        });
+
+        it('should serialize', function () {
+            expect(TypedJSON.toPlainJson('str', String)).toEqual('str');
+        });
+    });
+
+    describe('rest of primitives', function () {
+        it('should deserialize', function () {
+            expect(TypedJSON.parse(45834, Number)).toEqual(45834);
+            expect(TypedJSON.parse(true, Boolean)).toEqual(true);
+            expect(TypedJSON.parse(1543915254, Date)).toEqual(new Date(1543915254));
+            expect(TypedJSON.parse('1970-01-18T20:51:55.254Z', Date)).toEqual(new Date(1543915254));
+
+            const dataBuffer = Uint8Array.from([100, 117, 112, 97]) as any;
+            expect(TypedJSON.parse('畤慰', ArrayBuffer)).toEqual(dataBuffer);
+            expect(TypedJSON.parse('畤慰', DataView)).toEqual(dataBuffer);
+            expect(TypedJSON.parse([100, 117, 112, 97], Uint8Array)).toEqual(dataBuffer);
+        });
+
+        it('should serialize', function () {
+            expect(TypedJSON.toPlainJson(45834, Number)).toEqual(45834);
+            expect(TypedJSON.toPlainJson(true, Boolean)).toEqual(true);
+            const dateMs = new Date(1543915254);
+            expect(TypedJSON.toPlainJson(dateMs, Date)).toEqual(dateMs);
+            const dateStr = new Date('2018-12-04T09:20:54');
+            expect(TypedJSON.toPlainJson(dateStr, Date)).toEqual(dateStr);
+
+            const buffer = new ArrayBuffer(4);
+            const view = new DataView(buffer);
+            view.setInt8(0, 100);
+            view.setInt8(1, 117);
+            view.setInt8(2, 112);
+            view.setInt8(3, 97);
+            expect(TypedJSON.toPlainJson(buffer, ArrayBuffer)).toEqual('畤慰');
+            expect(TypedJSON.toPlainJson(view, DataView)).toEqual('畤慰');
+            expect(TypedJSON.toPlainJson(new Uint8Array(buffer), Uint8Array)).toEqual([100, 117, 112, 97]);
+        });
+    });
+
+    describe('object', function () {
+
+        @jsonObject
+        class SomeThing {
+            @jsonMember
+            propStr: String;
+            @jsonMember
+            propNum: number;
+            @jsonArrayMember(String)
+            propArr: String[];
+        }
+
+        const json = Object.freeze({
+            propStr: 'dsgs',
+            propNum: 653,
+            propArr: ['dslfks'],
+        });
+
+        it('should deserialize', function () {
+            expect(TypedJSON.parse(json, SomeThing)).toEqual(Object.assign(new SomeThing(), json));
+            expect(TypedJSON.parseAsArray([json], SomeThing)).toEqual([Object.assign(new SomeThing(), json)]);
+        });
+
+        it('should serialize', function () {
+            expect(TypedJSON.toPlainJson(Object.assign(new SomeThing(), json), SomeThing)).toEqual(json);
+            expect(TypedJSON.toPlainArray([Object.assign(new SomeThing(), json)], SomeThing)).toEqual([json]);
+        });
+    });
+
+    describe('array', function () {
+        it('should deserialize', function () {
+            expect(TypedJSON.parseAsArray(['alas', 'dfsd'], String)).toEqual(['alas', 'dfsd']);
+        });
+
+        it('should serialize', function () {
+          expect(TypedJSON.toPlainArray(['alas', 'dfsd'], String)).toEqual(['alas', 'dfsd']);
+        });
+    });
+});

spec/parse-to-object.spec.ts

@@ -0,0 +1,58 @@
+import { parseToJSObject } from '../src/typedjson/helpers';
+
+describe("parse To Object", function () {
+    it("should passthrough objects", function () {
+        const obj = {
+            a: 1,
+            b: 2,
+        };
+
+        const obj2 = parseToJSObject(obj, Object);
+        expect(obj2).toBe(obj);
+    });
+
+    it("should passthrough arrays", function () {
+        const arr = [{
+            a: 1,
+            b: 2,
+        }];
+
+        const arr2 = parseToJSObject(arr, Array);
+        expect(arr2).toBe(arr);
+    });
+
+    it("should parse object string", function () {
+        const arr = {
+            a: 1,
+            b: 2,
+        };
+
+        const arr2 = parseToJSObject(JSON.stringify(arr), Object);
+        expect(arr2).toEqual(arr);
+    });
+
+    it("should passthrough primitives", function () {
+        expect(parseToJSObject(1, Number)).toBe(1);
+        expect(parseToJSObject(false, Boolean)).toBe(false);
+    });
+
+    it("should parse strings with quotes, but passthrough other", function () {
+        // string is obvious
+        expect(parseToJSObject('"I am a string"', String)).toEqual('I am a string');
+        expect(parseToJSObject('just a string', String)).toBe('just a string');
+        // but also the types that are serialized to string
+        expect(parseToJSObject('"1970-01-18T20:51:55.254Z"', Date)).toEqual('1970-01-18T20:51:55.254Z');
+        expect(parseToJSObject('1970-01-18T20:51:55.254Z', Date)).toBe('1970-01-18T20:51:55.254Z');
+        expect(parseToJSObject('"畤慰"', ArrayBuffer)).toEqual('畤慰');
+        expect(parseToJSObject('畤慰', ArrayBuffer)).toBe('畤慰');
+        expect(parseToJSObject('"畤慰"', DataView)).toEqual('畤慰');
+        expect(parseToJSObject('畤慰', DataView)).toBe('畤慰');
+    });
+
+    it("should passthrough builtins", function () {
+      const date = new Date;
+      expect(parseToJSObject(date, Date)).toBe(date);
+      const buffer = new ArrayBuffer(3);
+      expect(parseToJSObject(buffer, ArrayBuffer)).toBe(buffer);
+    });
+});

src/typedjson.ts

@@ -1,4 +1,4 @@
-import { nameof, logError, logWarning } from './typedjson/helpers';
+import { nameof, logError, logWarning, parseToJSObject } from './typedjson/helpers';
 import { Constructor } from "./typedjson/types";
 import { JsonObjectMetadata } from "./typedjson/metadata";
 import { Deserializer } from "./typedjson/deserializer";
@@ -318,7 +318,7 @@ export class TypedJSON<T>
      */
     public parse(object: any): T|undefined
     {
-        const json = JSON.parse(object);
+        const json = parseToJSObject(object, this.rootConstructor);
 
         let rootMetadata = JsonObjectMetadata.getFromConstructor(this.rootConstructor);
         let result: T|undefined;
@@ -360,7 +360,7 @@ export class TypedJSON<T>
     public parseAsArray(object: any, dimensions: number): any[];
     public parseAsArray(object: any, dimensions: number = 1): any[]
     {
-        const json = JSON.parse(object);
+        const json = parseToJSObject(object, Array);
         if (json instanceof Array)
         {
             return this.deserializer.convertAsArray(json, {
@@ -382,7 +382,7 @@ export class TypedJSON<T>
 
     public parseAsSet(object: any): Set<T>
     {
-        const json = JSON.parse(object);
+        const json = parseToJSObject(object, Set);
         // A Set<T> is serialized as T[].
         if (json instanceof Array)
         {
@@ -404,7 +404,7 @@ export class TypedJSON<T>
 
     public parseAsMap<K>(object: any, keyConstructor: Constructor<K>): Map<K, T>
     {
-        const json = JSON.parse(object);
+        const json = parseToJSObject(object, Map);
         // A Set<T> is serialized as T[].
         if (json instanceof Array)
         {

src/typedjson/helpers.ts

@@ -60,6 +60,25 @@ export function isObject(value: any): value is Object
     return typeof value === "object";
 }
 
+function shouldOmitParseString(jsonStr: string, expectedType: Function): boolean {
+    const expectsTypesSerializedAsStrings = expectedType === String
+        || expectedType === ArrayBuffer
+        || expectedType === DataView;
+
+    const hasQuotes = jsonStr.length >= 2 && jsonStr[0] === '"' && jsonStr[jsonStr.length-1] === '"';
+    const isInteger = /^\d+$/.test(jsonStr.trim());
+
+    return (expectsTypesSerializedAsStrings && !hasQuotes) || ((!hasQuotes && !isInteger) && expectedType === Date);
+}
+
+export function parseToJSObject(json: any, expectedType: Function): Object {
+    if (typeof json !== 'string' || shouldOmitParseString(json, expectedType))
+    {
+      return json;
+    }
+    return JSON.parse(json);
+}
+
 /**
  * Determines if 'A' is a sub-type of 'B' (or if 'A' equals 'B').
  * @param A The supposed derived type.