sync with .net 98407a0366e31cd192fa435140fc6048d5376d22

Author: ml054

package-lock.json

@@ -148,9 +148,7 @@ export class SingleNodeBatchCommand extends RavenCommand<BatchCommandResult> imp
         if (replicationOptions) {
             result += `&waitForReplicasTimeout=${TimeUtil.millisToTimeSpan(replicationOptions.timeout)}`;
 
-            if (replicationOptions.throwOnTimeout) {
-                result += "&throwOnTimeoutInWaitForReplicas=true";
-            }
+            result += "&throwOnTimeoutInWaitForReplicas=" + (replicationOptions.throwOnTimeout ? "true" : "false");
 
             result += "&numberOfReplicasToWaitFor=";
             result += replicationOptions.majority ? "majority" : replicationOptions.replicas;

src/Documents/Commands/Batches/SingleNodeBatchCommand.ts

@@ -14,7 +14,7 @@ import {
     BeforeConversionToEntityEventArgs,
     AfterConversionToEntityEventArgs,
     FailedRequestEventArgs,
-    TopologyUpdatedEventArgs
+    TopologyUpdatedEventArgs, BeforeRequestEventArgs, SucceedRequestEventArgs
 } from "./Session/SessionEvents";
 import { OperationExecutor } from "./Operations/OperationExecutor";
 import { IDocumentSession } from "./Session/IDocumentSession";
@@ -275,6 +275,14 @@ export abstract class DocumentStoreBase
         eventName: "afterConversionToEntity",
         eventHandler: (eventArgs: AfterConversionToEntityEventArgs) => void
     ): this;
+    public addSessionListener(
+        eventName: "beforeRequest",
+        eventHandler: (eventArgs: BeforeRequestEventArgs) => void
+    ): this;
+    public addSessionListener(
+        eventName: "succeedRequest",
+        eventHandler: (eventArgs: SucceedRequestEventArgs) => void
+    ): this;
     public addSessionListener(eventName: any, eventHandler: (eventArgs: any) => void): this {
         this._eventHandlers.push([eventName, eventHandler]);
         return this;
@@ -308,6 +316,14 @@ export abstract class DocumentStoreBase
         eventName: "afterConversionToEntity",
         eventHandler: (eventArgs: AfterConversionToEntityEventArgs) => void
     ): void;
+    public removeSessionListener(
+        eventName: "beforeRequest",
+        eventHandler: (eventArgs: BeforeRequestEventArgs) => void
+    ): void;
+    public removeSessionListener(
+        eventName: "succeedRequest",
+        eventHandler: (eventArgs: SucceedRequestEventArgs) => void
+    ): void;
     public removeSessionListener(eventName: any, eventHandler: (eventArgs: any) => void): void {
         const toRemove = this._eventHandlers
             .filter(x => x[0] === eventName && x[1] === eventHandler)[0];
@@ -320,7 +336,10 @@ export abstract class DocumentStoreBase
     public registerEvents(session: DocumentSession): void;
     public registerEvents(requestExecutorOrSession: RequestExecutor | DocumentSession): void {
         this._eventHandlers.forEach(([eventName, eventHandler]) => {
-            if (eventName === "failedRequest" || eventName === "topologyUpdated") {
+            if (eventName === "failedRequest"
+                || eventName === "topologyUpdated"
+                || eventName === "beforeRequest"
+                || eventName === "succeedRequest") {
                 (requestExecutorOrSession as RequestExecutor).on(eventName as any, eventHandler);
             } else {
                 (requestExecutorOrSession as DocumentSession).on(eventName, eventHandler);

src/Documents/DocumentStoreBase.ts

@@ -26,6 +26,8 @@ export abstract class AbstractIndexCreationTask extends AbstractGenericIndexCrea
         indexDefinitionBuilder.patternReferencesCollectionName = this.patternReferencesCollectionName;
         indexDefinitionBuilder.additionalSources = this.additionalSources;
         indexDefinitionBuilder.configuration = this.configuration;
+        indexDefinitionBuilder.lockMode = this.lockMode;
+        indexDefinitionBuilder.priority = this.priority;
 
         return indexDefinitionBuilder.toIndexDefinition(this.conventions);
     }

src/Documents/Indexes/AbstractIndexCreationTask.ts

@@ -7,8 +7,6 @@ export class AbstractJavaScriptIndexCreationTask extends AbstractIndexCreationTa
 
     protected constructor() {
         super();
-        this._definition.lockMode = "Unlock";
-        this._definition.priority = "Normal";
     }
 
     public get maps() {
@@ -83,12 +81,16 @@ export class AbstractJavaScriptIndexCreationTask extends AbstractIndexCreationTa
 
     public createIndexDefinition(): IndexDefinition {
         this._definition.type = this.isMapReduce ? "JavaScriptMapReduce" : "JavaScriptMap";
+        this._definition.name = this.getIndexName();
 
         if (this.additionalSources) {
             this._definition.additionalSources = this.additionalSources;
         } else {
             this._definition.additionalSources = {};
         }
+        this._definition.configuration = this.configuration;
+        this._definition.lockMode = this.lockMode;
+        this._definition.priority = this.priority;
 
         return this._definition;
     }

src/Documents/Indexes/AbstractJavaScriptIndexCreationTask.ts

@@ -34,6 +34,8 @@ export class AbstractMultiMapIndexCreationTask extends AbstractIndexCreationTask
         indexDefinitionBuilder.patternReferencesCollectionName = this.patternReferencesCollectionName;
         indexDefinitionBuilder.additionalSources = this.additionalSources;
         indexDefinitionBuilder.configuration = this.configuration;
+        indexDefinitionBuilder.lockMode = this.lockMode;
+        indexDefinitionBuilder.priority = this.priority;
 
         const indexDefinition = indexDefinitionBuilder.toIndexDefinition(this.conventions, false);
         indexDefinition.maps = new Set(this.maps);

src/Documents/Indexes/AbstractMultiMapIndexCreationTask.ts

@@ -418,7 +418,24 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
         this._timeout = waitTimeout || AbstractDocumentQuery._getDefaultTimeout();
     }
 
+    protected _getLazyQueryOperation() {
+        if (!this._queryOperation) {
+            this._queryOperation = this._initializeQueryOperation();
+        }
+
+        const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
+        return  new LazyQueryOperation<T>(
+            this._theSession.conventions,
+            this._queryOperation,
+            this,
+            clazz);
+    }
+
     protected _initializeQueryOperation(): QueryOperation {
+        const beforeQueryEventArgs = new SessionBeforeQueryEventArgs(
+            this._theSession, new DocumentQueryCustomization(this));
+        this._theSession.emit("beforeQuery", beforeQueryEventArgs);
+
         const indexQuery = this.getIndexQuery();
         return new QueryOperation(
             this._theSession,
@@ -1951,10 +1968,6 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
             return Promise.resolve();
         }
 
-        const beforeQueryEventArgs = new SessionBeforeQueryEventArgs(
-            this._theSession, new DocumentQueryCustomization(this));
-        this._theSession.emit("beforeQuery", beforeQueryEventArgs);
-
         this._queryOperation = this._initializeQueryOperation();
         return this._executeActualQuery();
     }
@@ -2103,16 +2116,8 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
     }
 
     public lazily(): Lazy<T[]> {
-        if (!this._queryOperation) {
-            this._queryOperation = this._initializeQueryOperation();
-        }
+        const lazyQueryOperation = this._getLazyQueryOperation();
 
-        const clazz = this._conventions.getJsTypeByDocumentType(this._clazz);
-        const lazyQueryOperation = new LazyQueryOperation<T>(
-            this._theSession.conventions,
-            this._queryOperation,
-            this,
-            clazz);
         return (this._theSession as DocumentSession)
             .addLazyOperation(lazyQueryOperation);
     }

src/Documents/Session/AbstractDocumentQuery.ts

@@ -15,8 +15,9 @@ import { RevisionsCollectionObject } from "../../Types";
 import { ForceRevisionStrategy } from "./ForceRevisionStrategy";
 import { throwError } from "../../Exceptions/index";
 import { StringUtil } from "../../Utility/StringUtil";
+import {DocumentSessionRevisionsBase} from "./DocumentSessionRevisionsBase";
 
-export class DocumentSessionRevisions extends AdvancedSessionExtensionBase implements IRevisionsSessionOperations {
+export class DocumentSessionRevisions extends DocumentSessionRevisionsBase implements IRevisionsSessionOperations {
 
     public constructor(session: InMemoryDocumentSessionOperations) {
         super(session);
@@ -173,42 +174,5 @@ export class DocumentSessionRevisions extends AdvancedSessionExtensionBase imple
             : operation.getRevision(documentType);
     }
 
-    forceRevisionCreationFor<T extends object>(entity: T)
-    forceRevisionCreationFor<T extends object>(entity: T, strategy: ForceRevisionStrategy)
-    forceRevisionCreationFor<T extends object>(id: string)
-    forceRevisionCreationFor<T extends object>(id: string, strategy: ForceRevisionStrategy)
-    forceRevisionCreationFor<T extends object>(entityOrId: T | string, strategy: ForceRevisionStrategy = "Before") {
-        if (!entityOrId) {
-            throwError("InvalidArgumentException", "Entity cannot be null");
-        }
-
-        if (TypeUtil.isString(entityOrId)) {
-            this._addIdToList(entityOrId, strategy);
-        } else {
-            const documentInfo = this._session.documentsByEntity.get(entityOrId);
-            if (!documentInfo) {
-                throwError("InvalidOperationException", "Cannot create a revision for the requested entity because it is Not tracked by the session");
-            }
-
-            this._addIdToList(documentInfo.id, strategy);
-        }
-    }
 
-    private _addIdToList(id: string, requestedStrategy: ForceRevisionStrategy) {
-        if (StringUtil.isNullOrEmpty(id)) {
-            throwError("InvalidArgumentException", "Id cannot be null or empty");
-        }
-
-        const existingStrategy = this._session.idsForCreatingForcedRevisions.get(id);
-        const idAlreadyAdded = !!existingStrategy;
-        if (idAlreadyAdded && existingStrategy !== requestedStrategy) {
-            throwError("InvalidOperationException", "A request for creating a revision was already made for document "
-                + id + " in the current session but with a different force strategy. New strategy requested: " + requestedStrategy
-                + ". Previous strategy: " + existingStrategy + ".");
-        }
-
-        if (!idAlreadyAdded) {
-            this._session.idsForCreatingForcedRevisions.set(id, requestedStrategy);
-        }
-    }
 }

src/Documents/Session/DocumentSessionRevisions.ts

@@ -0,0 +1,46 @@
+import {ForceRevisionStrategy} from "./ForceRevisionStrategy";
+import {throwError} from "../../Exceptions";
+import {TypeUtil} from "../../Utility/TypeUtil";
+import {StringUtil} from "../../Utility/StringUtil";
+import {AdvancedSessionExtensionBase} from "./AdvancedSessionExtensionBase";
+
+export class DocumentSessionRevisionsBase extends AdvancedSessionExtensionBase {
+    forceRevisionCreationFor<T extends object>(entity: T)
+    forceRevisionCreationFor<T extends object>(entity: T, strategy: ForceRevisionStrategy)
+    forceRevisionCreationFor<T extends object>(id: string)
+    forceRevisionCreationFor<T extends object>(id: string, strategy: ForceRevisionStrategy)
+    forceRevisionCreationFor<T extends object>(entityOrId: T | string, strategy: ForceRevisionStrategy = "Before") {
+        if (!entityOrId) {
+            throwError("InvalidArgumentException", "Entity cannot be null");
+        }
+
+        if (TypeUtil.isString(entityOrId)) {
+            this._addIdToList(entityOrId, strategy);
+        } else {
+            const documentInfo = this._session.documentsByEntity.get(entityOrId);
+            if (!documentInfo) {
+                throwError("InvalidOperationException", "Cannot create a revision for the requested entity because it is Not tracked by the session");
+            }
+
+            this._addIdToList(documentInfo.id, strategy);
+        }
+    }
+
+    private _addIdToList(id: string, requestedStrategy: ForceRevisionStrategy) {
+        if (StringUtil.isNullOrEmpty(id)) {
+            throwError("InvalidArgumentException", "Id cannot be null or empty");
+        }
+
+        const existingStrategy = this._session.idsForCreatingForcedRevisions.get(id);
+        const idAlreadyAdded = !!existingStrategy;
+        if (idAlreadyAdded && existingStrategy !== requestedStrategy) {
+            throwError("InvalidOperationException", "A request for creating a revision was already made for document "
+                + id + " in the current session but with a different force strategy. New strategy requested: " + requestedStrategy
+                + ". Previous strategy: " + existingStrategy + ".");
+        }
+
+        if (!idAlreadyAdded) {
+            this._session.idsForCreatingForcedRevisions.set(id, requestedStrategy);
+        }
+    }
+}

src/Documents/Session/DocumentSessionRevisionsBase.ts

@@ -661,12 +661,18 @@ export abstract class InMemoryDocumentSessionOperations
         }
     }
 
-    public registerMissing(id: string): void {
+    public registerMissing(idOrIds: string | string[]): void {
         if (this.noTracking) {
             return;
         }
 
-        this._knownMissingIds.add(id);
+        if (TypeUtil.isArray(idOrIds)) {
+            for (const id of idOrIds) {
+                this._knownMissingIds.add(id);
+            }
+        } else {
+            this._knownMissingIds.add(idOrIds);
+        }
     }
 
     public unregisterMissing(id: string) {
@@ -1541,6 +1547,12 @@ export abstract class InMemoryDocumentSessionOperations
         documentInfo.document = document;
 
         Object.assign(entity, documentInfo.entity);
+
+        const documentInfoById = this.documentsById.getValue(documentInfo.id);
+
+        if (documentInfoById) {
+            documentInfoById.entity = entity;
+        }
     }
 
     /**