Merge pull request #151 from gregolsky/v4.0

RDBC-233 Do not revive types if there's a null midway when resolving …

Author: gregolsky

src/Mapping/MetadataAsDictionary.ts

@@ -43,6 +43,10 @@ class MetadataInternal {
     }
 
     private _metadataConvertValue(key, val) {
+        if (!val) {
+            return null;
+        }
+        
         if (typeof val !== "object") {
             return val;
         }

src/Mapping/ObjectMapper.ts

@@ -133,6 +133,11 @@ export class TypesAwareObjectMapper implements ITypesAwareObjectMapper {
 
     private _getFieldContext(parent: object, objPath: string[])
         : ObjectPropertyContext | ObjectPropertyContext[] {
+        
+        if (!parent) {
+            return null;
+        }
+        
         // tslint:disable-next-line:prefer-const
         let [field, ...fieldsPathTail] = objPath;
 

test/Documents/SessionApiTests.ts

@@ -258,6 +258,29 @@ describe("Session API dev experience tests", function () {
                 await session.saveChanges();
             }
         });
+
+        it("loads @metadata.Raven-Node-Type as null", async () => {
+            store.conventions.findCollectionNameForObjectLiteral =
+                (e: any) => e["collection"];
+
+            {
+                const user: any = {
+                    collection: "Users",
+                    name: "John"
+                };
+                const session = store.openSession();
+                await session.store(user, "users/1");
+                await session.saveChanges();
+            }
+
+            {
+                const session = store.openSession();
+                const loaded = await session.load("users/1");
+                assert.strictEqual(loaded["@metadata"]["Raven-Node-Type"], null);
+                assert.strictEqual(loaded["@metadata"]["@collection"], "Users");
+            }
+
+        });
     });
 
     describe("using classes", async () => {

test/Issues/RDBC_233.ts

@@ -0,0 +1,100 @@
+import * as mocha from "mocha";
+import * as BluebirdPromise from "bluebird";
+import * as assert from "assert";
+import { testContext, disposeTestDocumentStore } from "../Utils/TestUtil";
+
+import DocumentStore, {
+    RavenErrorType,
+    GetNextOperationIdCommand,
+    IDocumentStore,
+    TypesAwareObjectMapper,
+    DocumentConventions,
+    PatchOperation,
+} from "../../src";
+import { DateUtil } from "../../src/Utility/DateUtil";
+import { PatchRequest } from "../../src/Documents/Operations/PatchRequest";
+
+describe("RDBC-233", function () {
+
+    let mapper: TypesAwareObjectMapper;
+
+    beforeEach(() => {
+        mapper = new TypesAwareObjectMapper({
+            documentConventions: DocumentConventions.defaultConventions
+        });
+    });
+
+    it("object mapper does not revive types if there's null midway", async () => {
+        const obj = {
+            date: null,
+            anotherOne: {
+                start: "2018-01-02",
+                end: "2018-01-03"
+            }
+        };
+
+        const result: any = mapper.fromObjectLiteral(obj, {
+            nestedTypes: {
+                "date.start": "date",
+                "date.end": "date",
+                "anotherOne.start": "date",
+                "anotherOne.end": "date",
+            }
+        });
+
+        assert.ok(result);
+        assert.strictEqual(result.date, null);
+        assert.ok(result.anotherOne.start instanceof Date);
+        assert.strictEqual(result.anotherOne.start.toString(), DateUtil.parse(obj.anotherOne.start).toString());
+        assert.strictEqual(result.anotherOne.end.toString(), DateUtil.parse(obj.anotherOne.end).toString());
+    });
+
+    describe("entire flow - store, patch, load", async () => {
+
+        let store: IDocumentStore;
+
+        beforeEach(async function () {
+            store = await testContext.getDocumentStore();
+        });
+
+        afterEach(async () => disposeTestDocumentStore(store));
+
+        it("does not revive types if there's null midway", async () => {
+            const docStore = new DocumentStore(store.urls, store.database);
+            docStore.conventions.findCollectionNameForObjectLiteral = () => "test";
+            docStore.initialize();
+
+            try {
+                {
+                    const doc = {
+                        date: {
+                            start: new Date(),
+                            end: new Date()
+                        }
+                    };
+
+                    const session = docStore.openSession();
+                    await session.store(doc, "test/1");
+                    await session.saveChanges();
+                }
+
+                {
+                    const patchOp = new PatchOperation(
+                        "test/1", null, PatchRequest.forScript("this.date = null;"));
+                    await docStore.operations.send(patchOp);
+                }
+
+                {
+                    const session = docStore.openSession();
+                    const doc: any = await session.load("test/1");
+                    assert.ok(doc);
+                    assert.ok("date" in doc);
+                    assert.strictEqual(doc["@metadata"]["@nested-object-types"]["date.start"], "date");
+                    assert.strictEqual(doc.date, null);
+                }
+            } finally {
+                docStore.dispose();
+            }
+        });
+    });
+});