Merge pull request #359 from ml054/v5.4

merge v5.2 -> v5.4

Author: ml054

src/Documents/Commands/Batches/SingleNodeBatchCommand.ts

@@ -144,6 +144,7 @@ export class SingleNodeBatchCommand extends RavenCommand<BatchCommandResult> imp
             .objectKeysTransform({
                 defaultTransform: "camel",
                 ignoreKeys: [/^@/],
+                ignorePaths: [/results\.\[\]\.modifiedDocument\./i],
             })
             .process(bodyStream);
         return body;

src/Mapping/ObjectMapper.ts

@@ -1,4 +1,4 @@
-import { ObjectTypeDescriptor, ClassConstructor, ObjectLiteralDescriptor, EntityConstructor } from "../Types";
+import { ObjectTypeDescriptor, ObjectLiteralDescriptor, EntityConstructor } from "../Types";
 import { throwError } from "../Exceptions";
 import { TypeUtil } from "../Utility/TypeUtil";
 import { getLogger } from "../Utility/LogUtil";
@@ -338,8 +338,7 @@ export class TypesAwareObjectMapper implements ITypesAwareObjectMapper {
         if (!ctorOrTypeDescriptor) {
             instance = Object.assign({}, rawValue);
         } else if (TypeUtil.isClass(ctorOrTypeDescriptor)) {
-            instance = this._createEmptyObject(ctorOrTypeDescriptor as ClassConstructor);
-            instance = Object.assign(instance, rawValue);
+            instance = this.createEmptyObject(ctorOrTypeDescriptor, rawValue);
         } else if (TypeUtil.isObjectLiteralTypeDescriptor(ctorOrTypeDescriptor)) {
             instance = (ctorOrTypeDescriptor as ObjectLiteralDescriptor).construct(rawValue);
         } else {
@@ -367,12 +366,12 @@ export class TypesAwareObjectMapper implements ITypesAwareObjectMapper {
         return ctorOrTypeDescriptor;
     }
 
-    private _createEmptyObject<TResult extends object>(ctor: EntityConstructor<TResult>) {
+    protected createEmptyObject<TResult extends object>(ctor: EntityConstructor<TResult>, rawValue: object) {
         if (!ctor) {
             throwError("InvalidArgumentException", "ctor argument must not be null or undefined.");
         }
 
-        return new ctor() as TResult;
+        return Object.assign(new ctor(), rawValue) as TResult;
     }
 
     private _makeObjectLiteral(
@@ -445,12 +444,13 @@ export class TypesAwareObjectMapper implements ITypesAwareObjectMapper {
                         nestedTypeInfoKey = ObjectUtil[this._conventions.remoteEntityFieldNameConvention](key);
                     }
 
+                    let innerSkipTypes = skipTypes
                     if (!skipTypes) {
-                        skipTypes = key === CONSTANTS.Documents.Metadata.KEY;
+                        innerSkipTypes = key === CONSTANTS.Documents.Metadata.KEY;
                     }
 
                     const fullPath = objPathPrefix ? `${objPathPrefix}.${nestedTypeInfoKey}` : nestedTypeInfoKey;
-                    result[key] = this._makeObjectLiteral(obj[key], fullPath, typeInfoCallback, knownTypes, skipTypes);
+                    result[key] = this._makeObjectLiteral(obj[key], fullPath, typeInfoCallback, knownTypes, innerSkipTypes);
                     return result;
                 }, {});
         }

src/Utility/TypeUtil.ts

@@ -63,7 +63,7 @@ export class TypeUtil {
         return value === true || value === false;
     }
 
-    public static isClass(value: any): boolean {
+    public static isClass(value: any): value is ClassConstructor {
         return this.isFunction(value) && ("name" in value) && value.name !== ""
             && ("Object" !== value.name)
             && (!!value.prototype && !!value.prototype.constructor.name);

test/Documents/CustomKeyCaseConventionsTests.ts

@@ -1,7 +1,7 @@
 import { testContext, disposeTestDocumentStore } from "../Utils/TestUtil";
 import * as assert from "assert";
 import DocumentStore, {
-    IDocumentStore,
+    IDocumentStore, PatchCommandData, PatchRequest,
 } from "../../src";
 import { assertThat } from "../Utils/AssertExtensions";
 
@@ -391,4 +391,33 @@ describe("With custom key case conventions set", function () {
             assert.strictEqual(loaded.Equipment[0].Name, stored.equipment[0].name);
         }
     });
+
+    it("returns correct modified document after patch", async () => {
+        class PascalDoc {
+            public SIPCall: string
+        }
+
+        {
+            const session = regularStore.openSession();
+            const pascalDoc = new PascalDoc();
+            pascalDoc.SIPCall = "RavenDB";
+
+            await session.store(pascalDoc, "pascal/1");
+            await session.saveChanges();
+        }
+        let modifiedDocument
+        regularStore.addSessionListener("afterSaveChanges", event => {
+            modifiedDocument = event.entity
+        });
+
+        const session = regularStore.openSession();
+        await session.load("pascal/1");
+
+        const patchRequest = PatchRequest.forScript("this.SIPCall = \"Patched\"");
+        session.advanced.defer(new PatchCommandData("pascal/1", null, patchRequest))
+        await session.saveChanges();
+
+        assert.strictEqual(modifiedDocument.SIPCall, "Patched")
+        assert.ok(!("sipCall" in modifiedDocument));
+    });
 });

test/Issues/RDBC_681.ts

@@ -0,0 +1,50 @@
+import { IDocumentStore } from "../../src";
+import { disposeTestDocumentStore, testContext } from "../Utils/TestUtil";
+import * as assert from "assert";
+
+
+describe("[RDBC-681] @nested-object-types doesn’t store type information for newly added fields on update", function () {
+
+    let store: IDocumentStore;
+
+    beforeEach(async function () {
+        store = await testContext.getDocumentStore();
+    });
+
+    afterEach(async () =>
+        await disposeTestDocumentStore(store));
+
+    it("sets correct nested-object-types", async () => {
+        class DateDoc {
+            public firstDate: Date
+            public secondDate: Date
+        }
+
+        {
+            const session = store.openSession();
+            const dateDoc = new DateDoc();
+            dateDoc.firstDate = new Date();
+
+            await session.store(dateDoc, "date/1");
+            await session.saveChanges();
+        }
+        const session = store.openSession()
+        const doc = await session.load<DateDoc>("date/1")
+        doc.secondDate = new Date()
+        await session.saveChanges()
+        const metadata = session.advanced.getMetadataFor(doc)
+        assert.strictEqual(doc.firstDate instanceof Date, true)
+        assert.strictEqual(doc.secondDate instanceof Date, true)
+        assert.strictEqual(metadata["@nested-object-types"]["firstDate"], "date")
+        assert.strictEqual(metadata["@nested-object-types"]["secondDate"], "date")
+
+        const session2 = store.openSession()
+        const loaded = await session2.load<DateDoc>("date/1")
+        const loadedMetadata = session2.advanced.getMetadataFor(loaded)
+        assert.strictEqual(loaded.firstDate instanceof Date, true)
+        assert.strictEqual(loaded.secondDate instanceof Date, true)
+        assert.strictEqual(loadedMetadata["@nested-object-types"]["firstDate"], "date")
+        assert.strictEqual(loadedMetadata["@nested-object-types"]["secondDate"], "date")
+    })
+});
+