Merge pull request #242 from ml054/v4.2

sync with latest changes

Author: gregolsky

package-lock.json

@@ -54,25 +54,25 @@
   "author": "Hibernating Rhinos",
   "license": "MIT",
   "devDependencies": {
-    "@types/bluebird": "^3.5.32",
-    "@types/md5": "^2.2.0",
-    "@types/mocha": "^8.0.3",
+    "@types/bluebird": "^3.5.33",
+    "@types/md5": "^2.2.1",
+    "@types/mocha": "^8.0.4",
     "@types/pluralize": "0.0.27",
     "@types/rimraf": "^3.0.0",
-    "@types/sinon": "^9.0.6",
+    "@types/sinon": "^9.0.8",
     "@types/unzipper": "^0.10.3",
-    "@types/ws": "^7.2.6",
+    "@types/ws": "^7.4.0",
     "cross-os": "^1.3.0",
     "glob": "^7.1.6",
     "http-proxy-agent": "^4.0.1",
     "lodash.orderby": "^4.6.0",
-    "mocha": "^8.1.3",
+    "mocha": "^8.2.1",
     "nyc": "^15.1.0",
-    "open": "^7.2.1",
+    "open": "^7.3.0",
     "rimraf": "^3.0.2",
-    "sinon": "^9.0.3",
+    "sinon": "^9.2.1",
     "source-map-support": "^0.5.19",
-    "ts-node": "^8.10.2",
+    "ts-node": "^9.0.0",
     "tslint": "^6.1.3",
     "tslint-eslint-rules": "^5.4.0",
     "tslint-microsoft-contrib": "^6.2.0",
@@ -90,7 +90,7 @@
     "change-case": "^3.1.0",
     "deprecate": "^1.1.1",
     "md5": "^2.3.0",
-    "moment": "^2.29.0",
+    "moment": "^2.29.1",
     "node-fetch": "^2.6.1",
     "object.entries": "^1.1.2",
     "object.values": "^1.1.1",
@@ -100,11 +100,10 @@
     "safe-memory-cache": "^2.0.0",
     "semaphore": "^1.1.0",
     "stream-json": "^1.7.1",
-    "string-builder": "^0.1.6",
     "util.promisify": "^1.0.1",
-    "uuid": "^8.3.0",
+    "uuid": "^8.3.1",
     "verror": "^1.10.0",
-    "ws": "^7.3.1",
-    "xregexp": "^4.3.0"
+    "ws": "^7.4.0",
+    "xregexp": "^4.4.0"
   }
 }

package.json

@@ -31,6 +31,7 @@ export class BulkInsertOperation {
 
     private _first: boolean = true;
     private _operationId = -1;
+    private _nodeTag: string;
 
     private _useCompression: boolean = false;
 
@@ -45,6 +46,9 @@ export class BulkInsertOperation {
 
     public constructor(database: string, store: IDocumentStore) {
         this._conventions = store.conventions;
+        if (StringUtil.isNullOrEmpty(database)) {
+            this._throwNoDatabase();
+        }
         this._requestExecutor = store.getRequestExecutor(database);
 
         this._generateEntityIdOnTheClient = new GenerateEntityIdOnTheClient(this._requestExecutor.conventions,
@@ -65,8 +69,23 @@ export class BulkInsertOperation {
     }
 
     private async _throwBulkInsertAborted(e: Error) {
-        const error = await this._getExceptionFromOperation();
-        throwError("BulkInsertAbortedException", "Failed to execute bulk insert", error || e);
+        let errorFromServer: Error;
+        try {
+            errorFromServer = await this._getExceptionFromOperation();
+        } catch (ee) {
+            // server is probably down, will propagate the original exception
+        }
+
+        if (errorFromServer) {
+            throw errorFromServer;
+        }
+
+        throwError("BulkInsertAbortedException", "Failed to execute bulk insert", e);
+    }
+
+    private _throwNoDatabase(): void {
+        throwError("InvalidOperationException", "Cannot start bulk insert operation without specifying a name of a database to operate on."
+            + "Database name can be passed as an argument when bulk insert is being created or default database can be defined using 'DocumentStore.setDatabase' method.");
     }
 
     private async _waitForId(): Promise<void> {
@@ -77,6 +96,7 @@ export class BulkInsertOperation {
         const bulkInsertGetIdRequest = new GetNextOperationIdCommand();
         await this._requestExecutor.execute(bulkInsertGetIdRequest);
         this._operationId = bulkInsertGetIdRequest.result;
+        this._nodeTag = bulkInsertGetIdRequest.nodeTag;
     }
 
     private static _typeCheckStoreArgs(
@@ -242,7 +262,7 @@ export class BulkInsertOperation {
     }
 
     private async _getExceptionFromOperation(): Promise<Error> {
-        const stateRequest = new GetOperationStateCommand(this._conventions, this._operationId);
+        const stateRequest = new GetOperationStateCommand(this._conventions, this._operationId, this._nodeTag);
         await this._requestExecutor.execute(stateRequest);
         if (!stateRequest.result) {
             return null;
@@ -263,7 +283,8 @@ export class BulkInsertOperation {
 
             this._requestBodyStream = new stream.PassThrough();
             const bulkCommand =
-                new BulkInsertCommand(this._operationId, this._requestBodyStream, this._useCompression);
+                new BulkInsertCommand(this._operationId, this._requestBodyStream, this._nodeTag);
+            bulkCommand.useCompression = this._useCompression;
 
             const bulkCommandPromise = this._requestExecutor.execute(bulkCommand);
 
@@ -298,7 +319,7 @@ export class BulkInsertOperation {
             await this._waitForId();
 
             try {
-                await this._requestExecutor.execute(new KillOperationCommand(this._operationId));
+                await this._requestExecutor.execute(new KillOperationCommand(this._operationId, this._nodeTag));
             } catch (err) {
                 const bulkInsertError = getError("BulkInsertAbortedException",
                     "Unable to kill bulk insert operation, because it was not found on the server.", err);
@@ -365,14 +386,14 @@ export class BulkInsertCommand extends RavenCommand<void> {
 
     private readonly _stream: stream.Readable;
     private readonly _id: number;
-    private _useCompression: boolean;
+    public useCompression: boolean;
 
-    public constructor(id: number, stream: stream.Readable, useCompression: boolean) {
+    public constructor(id: number, stream: stream.Readable, nodeTag: string) {
         super();
 
         this._stream = stream;
         this._id = id;
-        this._useCompression = useCompression;
+        this._selectedNodeTag = nodeTag;
     }
 
     public createRequest(node: ServerNode): HttpRequestParameters {

src/Documents/BulkInsertOperation.ts

@@ -7,6 +7,7 @@ import { DocumentConventions } from "../Conventions/DocumentConventions";
 import { ServerNode } from "../../Http/ServerNode";
 import { IRaftCommand } from "../../Http/IRaftCommand";
 import { RaftIdGenerator } from "../../Utility/RaftIdGenerator";
+import { throwError } from "../../Exceptions";
 
 export class CreateSubscriptionCommand extends RavenCommand<CreateSubscriptionResult> implements IRaftCommand {
     private readonly _conventions: DocumentConventions;
@@ -16,6 +17,9 @@ export class CreateSubscriptionCommand extends RavenCommand<CreateSubscriptionRe
     public constructor(conventions: DocumentConventions, options: SubscriptionCreationOptions, id?: string) {
         super();
         this._conventions = conventions;
+        if (!options) {
+            throwError("InvalidArgumentException", "Options cannot be null");
+        }
         this._options = options;
         this._id = id;
     }

src/Documents/Commands/CreateSubscriptionCommand.ts

@@ -1,6 +1,7 @@
 import { RavenCommand } from "../../Http/RavenCommand";
 import { HttpRequestParameters } from "../../Primitives/Http";
 import { ServerNode } from "../../Http/ServerNode";
+import { StringUtil } from "../../Utility/StringUtil";
 
 export class DropSubscriptionConnectionCommand extends RavenCommand<void> {
 
@@ -12,7 +13,11 @@ export class DropSubscriptionConnectionCommand extends RavenCommand<void> {
     }
 
     public createRequest(node: ServerNode): HttpRequestParameters {
-        const uri = node.url + "/databases/" + node.database + "/subscriptions/drop?name=" + this._name;
+        let uri = node.url + "/databases/" + node.database + "/subscriptions/drop";
+
+        if (!StringUtil.isNullOrEmpty(this._name)) {
+            uri += "?name=" + encodeURIComponent(this._name);
+        }
 
         return {
             method: "POST",

src/Documents/Commands/DropSubscriptionConnectionCommand.ts

@@ -194,6 +194,7 @@ export class GetDocumentsCommand extends RavenCommand<GetDocumentsResult> {
         // if it is too big, we fallback to POST (note that means that we can't use the HTTP cache any longer)
         // we are fine with that, requests to load > 1024 items are going to be rare
         const isGet: boolean = Array.from(uniqueIds)
+            .filter(x => x)
             .map(x => x.length)
             .reduce((result, next) => result + next, 0) < 1024;
 

src/Documents/Commands/GetDocumentsCommand.ts

@@ -5,6 +5,12 @@ import * as stream from "readable-stream";
 
 export class GetNextOperationIdCommand extends RavenCommand<number> {
 
+    private _nodeTag: string;
+
+    public get nodeTag(): string {
+        return this._nodeTag;
+    }
+
     public get isReadRequest(): boolean {
         return false; // disable caching
     }
@@ -22,6 +28,11 @@ export class GetNextOperationIdCommand extends RavenCommand<number> {
                 if (typeof id !== "undefined") {
                     this.result = id;
                 }
+
+                const nodeTag = results["nodeTag"];
+                if (nodeTag) {
+                    this._nodeTag = nodeTag;
+                }
             });
         return body;
     }

src/Documents/Commands/GetNextOperationIdCommand.ts

@@ -7,13 +7,19 @@ export class KillOperationCommand extends RavenCommand<void> {
 
     private readonly _id: number;
 
-    public constructor(id: number) {
+    public constructor(id: number)
+    public constructor(id: number, nodeTag: string)
+    public constructor(id: number, nodeTag?: string) {
         super();
 
         if (!id) {
             throwError("InvalidArgumentException", "Id cannot be null.");
         }
         this._id = id;
+
+        if (nodeTag) {
+            this._selectedNodeTag = nodeTag;
+        }
     }
 
     public get isReadRequest(): boolean {

src/Documents/Commands/KillOperationCommand.ts

@@ -8,6 +8,7 @@ import { ServerNode } from "../../../Http/ServerNode";
 import { StatusCodes } from "../../../Http/StatusCode";
 import { getEtagHeader } from "../../../Utility/HttpUtil";
 import { DocumentConventions } from "../../Conventions/DocumentConventions";
+import { throwError } from "../../../Exceptions";
 
 export class MultiGetCommand extends RavenCommand<GetResponse[]> {
     private _cache: HttpCache;
@@ -17,6 +18,15 @@ export class MultiGetCommand extends RavenCommand<GetResponse[]> {
 
     public constructor(cache: HttpCache, conventions: DocumentConventions, commands: GetRequest[]) {
         super();
+
+        if (!cache) {
+            throwError("InvalidArgumentException", "Cache cannot be null");
+        }
+
+        if (!commands) {
+            throwError("InvalidArgumentException", "Commands cannot be null");
+        }
+
         this._cache = cache;
         this._commands = commands;
         this._conventions = conventions;

src/Documents/Commands/MultiGet/MultiGetCommand.ts

@@ -5,10 +5,10 @@ import { DocumentConventions } from "../Conventions/DocumentConventions";
 import { IndexQuery, writeIndexQuery } from "../Queries/IndexQuery";
 import { throwError } from "../../Exceptions";
 import { ServerNode } from "../../Http/ServerNode";
-import * as StringBuilder from "string-builder";
 import { JsonSerializer } from "../../Mapping/Json/Serializer";
 import * as stream from "readable-stream";
 import { RavenCommandResponsePipeline } from "../../Http/RavenCommandResponsePipeline";
+import { StringBuilder } from "../../Utility/StringBuilder";
 
 export interface QueryCommandOptions {
     metadataOnly?: boolean;

src/Documents/Commands/QueryCommand.ts

@@ -3,7 +3,7 @@ import { throwError } from "../../Exceptions/index";
 import { StringUtil } from "../../Utility/StringUtil";
 import * as XRegExp from "xregexp";
 
-const COMMENT_REGEX = new XRegExp("(?:/\\*(?:[^*]|(?:\\*+[^*/]))*\\*+/)|(?://.*)", "gm");
+const COMMENT_REGEX = XRegExp("(?:/\\*(?:[^*]|(?:\\*+[^*/]))*\\*+/)|(?://.*)", "gm");
 
 export class IndexDefinitionHelper {
     public static detectStaticIndexType(map: string, reduce: string): IndexType {

src/Documents/Indexes/IndexDefinitionHelper.ts

@@ -5,6 +5,7 @@ import { DocumentConventions } from "../../Conventions/DocumentConventions";
 import { RavenCommand } from "../../../Http/RavenCommand";
 import { ServerNode } from "../../../Http/ServerNode";
 import { RestoreBackupConfigurationBase } from "./RestoreBackupConfigurationBase";
+import { throwError } from "../../../Exceptions";
 
 export class RestoreBackupOperation implements IServerOperation<OperationIdResult> {
     private readonly _restoreConfiguration: RestoreBackupConfigurationBase;
@@ -16,7 +17,7 @@ export class RestoreBackupOperation implements IServerOperation<OperationIdResul
     }
 
     public getCommand(conventions: DocumentConventions): RavenCommand<OperationIdResult> {
-        return new RestoreBackupCommand(conventions, this._restoreConfiguration, this._nodeTag);
+        return new RestoreBackupCommand(this._restoreConfiguration, this._nodeTag);
     }
 
     public get resultType(): OperationResultType {
@@ -31,9 +32,13 @@ export class RestoreBackupOperation implements IServerOperation<OperationIdResul
 class RestoreBackupCommand extends RavenCommand<OperationIdResult> {
     private readonly _restoreConfiguration: RestoreBackupConfigurationBase;
 
-    public constructor(conventions: DocumentConventions, restoreConfiguration: RestoreBackupConfigurationBase, nodeTag: string) {
+    public constructor(restoreConfiguration: RestoreBackupConfigurationBase, nodeTag: string) {
         super();
 
+        if (!restoreConfiguration) {
+            throwError("InvalidArgumentException", "RestoreConfiguration cannot be null");
+        }
+
         this._restoreConfiguration = restoreConfiguration;
         this._selectedNodeTag = nodeTag;
     }

src/Documents/Operations/Backups/RestoreBackupOperation.ts

@@ -21,18 +21,16 @@ export class UpdatePeriodicBackupOperation implements IMaintenanceOperation<Upda
     }
 
     public getCommand(conventions: DocumentConventions): RavenCommand<UpdatePeriodicBackupOperationResult> {
-        return new UpdatePeriodicBackupCommand(conventions, this._configuration);
+        return new UpdatePeriodicBackupCommand(this._configuration);
     }
 }
 
 class UpdatePeriodicBackupCommand extends RavenCommand<UpdatePeriodicBackupOperationResult> implements IRaftCommand {
-    private readonly _conventions: DocumentConventions;
     private readonly _configuration: PeriodicBackupConfiguration;
 
-    public constructor(conventions: DocumentConventions, configuration: PeriodicBackupConfiguration) {
+    public constructor(configuration: PeriodicBackupConfiguration) {
         super();
 
-        this._conventions = conventions;
         this._configuration = configuration;
     }
 

src/Documents/Operations/Backups/UpdatePeriodicBackupOperation.ts

@@ -1,4 +1,3 @@
-import * as StringBuilder from "string-builder";
 import { HttpRequestParameters } from "../../../Primitives/Http";
 import { IOperation, OperationResultType } from "../OperationAbstractions";
 import { CompareExchangeValue } from "./CompareExchangeValue";
@@ -11,6 +10,7 @@ import { RavenCommand } from "../../../Http/RavenCommand";
 import { ServerNode } from "../../../Http/ServerNode";
 import { CompareExchangeValueResultParser, GetCompareExchangeValuesResponse } from "./CompareExchangeValueResultParser";
 import * as stream from "readable-stream";
+import { StringBuilder } from "../../../Utility/StringBuilder";
 
 export interface GetCompareExchangeValuesParameters<T> {
     keys?: string[];