couchbase 4.2.9 → 4.2.11-rc.1

package/dist/scope.js

@@ -4,6 +4,8 @@ exports.Scope = void 0;
 const analyticsexecutor_1 = require("./analyticsexecutor");
 const collection_1 = require("./collection");
 const queryexecutor_1 = require("./queryexecutor");
+const searchexecutor_1 = require("./searchexecutor");
+const scopesearchindexmanager_1 = require("./scopesearchindexmanager");
 const utilities_1 = require("./utilities");
 /**
  * Exposes the operations which are available to be performed against a scope.
@@ -64,6 +66,16 @@ class Scope {
     collection(collectionName) {
         return new collection_1.Collection(this, collectionName);
     }
+    /**
+     * Returns a SearchIndexManager which can be used to manage the search
+     * indexes of this scope.
+     *
+     * Volatile: This API is subject to change at any time.
+     *
+     */
+    searchIndexes() {
+        return new scopesearchindexmanager_1.ScopeSearchIndexManager(this.cluster, this.bucket.name, this._name);
+    }
     /**
      * Executes a N1QL query against the cluster scoped to this scope.
      *
@@ -110,5 +122,27 @@ class Scope {
             queryContext: `${bucket.name}.${this.name}`,
         }), callback);
     }
+    /**
+     * Executes a search query against the scope.
+     *
+     * Volatile: This API is subject to change at any time.
+     *
+     * @param indexName The name of the index to query.
+     * @param request The SearchRequest describing the search to execute.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    search(indexName, request, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[2];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const exec = new searchexecutor_1.SearchExecutor(this.cluster, this._bucket.name, this._name);
+        const options_ = options;
+        return utilities_1.PromiseHelper.wrapAsync(() => exec.query(indexName, request, options_), callback);
+    }
 }
 exports.Scope = Scope;

package/dist/scopesearchindexmanager.d.ts

@@ -0,0 +1,116 @@
+import { Cluster } from './cluster';
+import { NodeCallback } from './utilities';
+import { GetSearchIndexOptions, GetAllSearchIndexesOptions, UpsertSearchIndexOptions, GetSearchIndexedDocumentsCountOptions, DropSearchIndexOptions, PauseSearchIngestOptions, ResumeSearchIngestOptions, AllowSearchQueryingOptions, DisallowSearchQueryingOptions, FreezeSearchPlanOptions, UnfreezeSearchPlanOptions, AnalyzeSearchDocumentOptions, ISearchIndex, SearchIndex } from './searchindexmanager';
+/**
+ * SearchIndexManager provides an interface for managing the
+ * search indexes on the cluster.
+ *
+ * Volatile: This API is subject to change at any time.
+ *
+ * @category Management
+ */
+export declare class ScopeSearchIndexManager {
+    private _cluster;
+    private _bucketName;
+    private _scopeName;
+    /**
+     * @internal
+     */
+    constructor(cluster: Cluster, bucketName: string, scopeName: string);
+    /**
+     * Returns an index by it's name.
+     *
+     * @param indexName The index to retrieve.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    getIndex(indexName: string, options?: GetSearchIndexOptions, callback?: NodeCallback<SearchIndex>): Promise<SearchIndex>;
+    /**
+     * Returns a list of all existing indexes.
+     *
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    getAllIndexes(options?: GetAllSearchIndexesOptions, callback?: NodeCallback<SearchIndex[]>): Promise<SearchIndex[]>;
+    /**
+     * Creates or updates an existing index.
+     *
+     * @param indexDefinition The index to update.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    upsertIndex(indexDefinition: ISearchIndex, options?: UpsertSearchIndexOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Drops an index.
+     *
+     * @param indexName The name of the index to drop.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    dropIndex(indexName: string, options?: DropSearchIndexOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Returns the number of documents that have been indexed.
+     *
+     * @param indexName The name of the index to return the count for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    getIndexedDocumentsCount(indexName: string, options?: GetSearchIndexedDocumentsCountOptions, callback?: NodeCallback<number>): Promise<number>;
+    /**
+     * Pauses the ingestion of documents into an index.
+     *
+     * @param indexName The name of the index to pause.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    pauseIngest(indexName: string, options?: PauseSearchIngestOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Resumes the ingestion of documents into an index.
+     *
+     * @param indexName The name of the index to resume.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    resumeIngest(indexName: string, options?: ResumeSearchIngestOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Enables querying of an index.
+     *
+     * @param indexName The name of the index to enable querying for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    allowQuerying(indexName: string, options?: AllowSearchQueryingOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Disables querying of an index.
+     *
+     * @param indexName The name of the index to disable querying for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    disallowQuerying(indexName: string, options?: DisallowSearchQueryingOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Freezes the indexing plan for execution of queries.
+     *
+     * @param indexName The name of the index to freeze the plan of.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    freezePlan(indexName: string, options?: FreezeSearchPlanOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Unfreezes the indexing plan for execution of queries.
+     *
+     * @param indexName The name of the index to freeze the plan of.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    unfreezePlan(indexName: string, options?: UnfreezeSearchPlanOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Performs analysis of a specific document by an index.
+     *
+     * @param indexName The name of the index to use for the analysis.
+     * @param document The document to analyze.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    analyzeDocument(indexName: string, document: any, options?: AnalyzeSearchDocumentOptions, callback?: NodeCallback<any>): Promise<any>;
+}

package/dist/scopesearchindexmanager.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeSearchIndexManager = void 0;
+const utilities_1 = require("./utilities");
+const bindingutilities_1 = require("./bindingutilities");
+const searchindexmanager_1 = require("./searchindexmanager");
+/**
+ * SearchIndexManager provides an interface for managing the
+ * search indexes on the cluster.
+ *
+ * Volatile: This API is subject to change at any time.
+ *
+ * @category Management
+ */
+class ScopeSearchIndexManager {
+    /**
+     * @internal
+     */
+    constructor(cluster, bucketName, scopeName) {
+        this._cluster = cluster;
+        this._bucketName = bucketName;
+        this._scopeName = scopeName;
+    }
+    /**
+     * Returns an index by it's name.
+     *
+     * @param indexName The index to retrieve.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async getIndex(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGet({
+                index_name: indexName,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const index = searchindexmanager_1.SearchIndex._fromCppData(resp.index);
+                wrapCallback(null, index);
+            });
+        }, callback);
+    }
+    /**
+     * Returns a list of all existing indexes.
+     *
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async getAllIndexes(options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[0];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGetAll({
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const indexes = resp.indexes.map((indexData) => searchindexmanager_1.SearchIndex._fromCppData(indexData));
+                wrapCallback(null, indexes);
+            });
+        }, callback);
+    }
+    /**
+     * Creates or updates an existing index.
+     *
+     * @param indexDefinition The index to update.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async upsertIndex(indexDefinition, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexUpsert({
+                index: searchindexmanager_1.SearchIndex._toCppData(indexDefinition),
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Drops an index.
+     *
+     * @param indexName The name of the index to drop.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async dropIndex(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexDrop({
+                index_name: indexName,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Returns the number of documents that have been indexed.
+     *
+     * @param indexName The name of the index to return the count for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async getIndexedDocumentsCount(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGetDocumentsCount({
+                index_name: indexName,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(null, resp.count);
+            });
+        }, callback);
+    }
+    /**
+     * Pauses the ingestion of documents into an index.
+     *
+     * @param indexName The name of the index to pause.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async pauseIngest(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlIngest({
+                index_name: indexName,
+                pause: true,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Resumes the ingestion of documents into an index.
+     *
+     * @param indexName The name of the index to resume.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async resumeIngest(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlIngest({
+                index_name: indexName,
+                pause: false,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Enables querying of an index.
+     *
+     * @param indexName The name of the index to enable querying for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async allowQuerying(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlQuery({
+                index_name: indexName,
+                allow: true,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Disables querying of an index.
+     *
+     * @param indexName The name of the index to disable querying for.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async disallowQuerying(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlQuery({
+                index_name: indexName,
+                allow: false,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Freezes the indexing plan for execution of queries.
+     *
+     * @param indexName The name of the index to freeze the plan of.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async freezePlan(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlPlanFreeze({
+                index_name: indexName,
+                freeze: true,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Unfreezes the indexing plan for execution of queries.
+     *
+     * @param indexName The name of the index to freeze the plan of.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async unfreezePlan(indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlPlanFreeze({
+                index_name: indexName,
+                freeze: false,
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * Performs analysis of a specific document by an index.
+     *
+     * @param indexName The name of the index to use for the analysis.
+     * @param document The document to analyze.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    async analyzeDocument(indexName, document, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[2];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexAnalyzeDocument({
+                index_name: indexName,
+                encoded_document: JSON.stringify(document),
+                timeout: timeout,
+                bucket_name: this._bucketName,
+                scope_name: this._scopeName,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const result = JSON.parse(resp.analysis);
+                wrapCallback(result, null);
+            });
+        }, callback);
+    }
+}
+exports.ScopeSearchIndexManager = ScopeSearchIndexManager;

package/dist/sdspecs.js

@@ -81,19 +81,19 @@ class MutateInMacro {
      * A macro which references the cas of a document.
      */
     static get Cas() {
-        return new MutateInMacro('${document.CAS}');
+        return new MutateInMacro('${Mutation.CAS}');
     }
     /**
      * A macro which references the seqno of a document.
      */
     static get SeqNo() {
-        return new MutateInMacro('${document.seqno}');
+        return new MutateInMacro('${Mutation.seqno}');
     }
     /**
      * A macro which references the crc32 of the value of a document.
      */
     static get ValueCrc32c() {
-        return new MutateInMacro('${document.value_crc32c}');
+        return new MutateInMacro('${Mutation.value_crc32c}');
     }
 }
 exports.MutateInMacro = MutateInMacro;
@@ -200,18 +200,19 @@ class MutateInSpec {
             options = {};
         }
         let flags = 0;
-        if (value instanceof MutateInMacro) {
-            value = value._value;
+        if (options.createPath) {
             flags |=
                 binding_1.default.protocol_mutate_in_request_body_mutate_in_specs_path_flag
-                    .expand_macros;
+                    .create_parents;
         }
-        if (options.createPath) {
+        if (value instanceof MutateInMacro) {
+            value = value._value;
             flags |=
                 binding_1.default.protocol_mutate_in_request_body_mutate_in_specs_path_flag
-                    .create_parents;
+                    .expand_macros |
+                    binding_1.default.protocol_mutate_in_request_body_mutate_in_specs_path_flag.xattr;
         }
-        if (options.xattr) {
+        else if (options.xattr) {
             flags |=
                 binding_1.default.protocol_mutate_in_request_body_mutate_in_specs_path_flag.xattr;
         }

package/dist/sdutils.d.ts

@@ -4,4 +4,5 @@ export declare class SdUtils {
     static insertByPath(root: any, path: string, value: any): any;
     private static _getByPath;
     static getByPath(value: any, path: string): any;
+    static convertMacroCasToCas(cas: string): string;
 }

package/dist/sdutils.js

@@ -100,5 +100,9 @@ class SdUtils {
         const parts = this._parsePath(path);
         return this._getByPath(value, parts);
     }
+    static convertMacroCasToCas(cas) {
+        const buf = Buffer.from(cas.startsWith('0x') ? cas.slice(2) : cas, 'hex');
+        return `0x${buf.reverse().toString('hex')}`;
+    }
 }
 exports.SdUtils = SdUtils;

package/dist/searchexecutor.d.ts

@@ -1,18 +1,20 @@
 import { Cluster } from './cluster';
 import { SearchQuery } from './searchquery';
-import { SearchMetaData, SearchQueryOptions, SearchResult, SearchRow } from './searchtypes';
+import { SearchMetaData, SearchQueryOptions, SearchRequest, SearchResult, SearchRow } from './searchtypes';
 import { StreamableRowPromise } from './streamablepromises';
 /**
  * @internal
  */
 export declare class SearchExecutor {
     private _cluster;
+    private _bucketName;
+    private _scopeName;
     /**
      * @internal
      */
-    constructor(cluster: Cluster);
+    constructor(cluster: Cluster, bucketName?: string, scopeName?: string);
     /**
      * @internal
      */
-    query(indexName: string, query: SearchQuery, options: SearchQueryOptions): StreamableRowPromise<SearchResult, SearchRow, SearchMetaData>;
+    query(indexName: string, query: SearchQuery | SearchRequest, options: SearchQueryOptions): StreamableRowPromise<SearchResult, SearchRow, SearchMetaData>;
 }