sync with java: 4c961f143020b34aec8edd04963b599b3475c365

Author: ml054

src/Documents/Session/AbstractDocumentQuery.ts

@@ -569,12 +569,12 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
     }
 
     public getIndexQuery(): IndexQuery {
-        let serverVersion = null;
+        let serverVersion: string = null;
         if (this._theSession && this._theSession.requestExecutor) {
             serverVersion = this._theSession.requestExecutor.lastServerVersion;
         }
 
-        const compatibilityMode = serverVersion && serverVersion.compare("4.2") < 0;
+        const compatibilityMode = serverVersion && serverVersion.localeCompare("4.2") < 0;
         const query = this.toString(compatibilityMode);
         const indexQuery = this._generateIndexQuery(query);
         this.emit("beforeQueryExecuted", indexQuery);

src/Documents/Session/InMemoryDocumentSessionOperations.ts

@@ -1645,7 +1645,7 @@ export abstract class InMemoryDocumentSessionOperations
                     const beforeDeleteEventArgs =
                         new SessionBeforeDeleteEventArgs(this, documentInfo.id, documentInfo.entity);
                     this.emit("beforeDelete", beforeDeleteEventArgs);
-                    result.sessionCommands.push(new DeleteCommandData(documentInfo.id, changeVector));
+                    result.sessionCommands.push(new DeleteCommandData(documentInfo.id, changeVector, documentInfo.changeVector));
                 }
 
                 if (!changes) {

src/Http/RequestExecutor.ts

@@ -1133,7 +1133,7 @@ export class RequestExecutor implements IDisposable {
     }
 
     private static _tryGetServerVersion(response: HttpResponse) {
-        return response.headers[HEADERS.SERVER_VERSION];
+        return response.headers.get(HEADERS.SERVER_VERSION);
     }
 
     private _throwFailedToContactAllNodes<TResult>(

test/Ported/Issues/RavenDB_16614.ts

@@ -0,0 +1,59 @@
+
+import { DocumentStore, SessionOptions } from "../../../src";
+import { disposeTestDocumentStore, testContext } from "../../Utils/TestUtil";
+import { User } from "../../Assets/Entities";
+import { assertThat, assertThrows } from "../../Utils/AssertExtensions";
+
+describe("RavenDB_16614Test", function () {
+
+    let store: DocumentStore;
+
+    beforeEach(async function () {
+        store = await testContext.getDocumentStore();
+    });
+
+    afterEach(async () =>
+        await disposeTestDocumentStore(store));
+
+    it("modificationInAnotherTransactionWillFailWithDelete", async () => {
+        const sessionOptions: SessionOptions = {
+            transactionMode: "ClusterWide"
+        };
+
+        {
+            const session = store.openSession(sessionOptions);
+            const user1 = new User();
+            user1.name = "arava";
+
+            const user2 = new User();
+            user2.name = "phoebe";
+
+            await session.store(user1, "users/arava");
+            await session.store(user2, "users/phoebe");
+            await session.saveChanges();
+            session.dispose();
+        }
+
+        {
+            const session = store.openSession(sessionOptions);
+
+            const user = await session.load("users/arava", User);
+            await session.delete(user);
+            const user2 = await session.load("users/phoebe", User);
+            user2.name = "Phoebe Eini";
+
+            {
+                const conflictedSession = store.openSession(sessionOptions);
+                const conflictedArava = await conflictedSession.load("users/arava", User);
+                conflictedArava.name = "Arava!";
+                await conflictedSession.saveChanges();
+                conflictedSession.dispose();
+            }
+
+            await assertThrows(async () => await session.saveChanges(), e => {
+                assertThat(e.name)
+                    .isEqualTo("ClusterTransactionConcurrencyException");
+            });
+        }
+    });
+});