couchbase 4.2.10 → 4.2.11-rc.1

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

@@ -7,10 +7,12 @@ import { StreamableRowPromise } from './streamablepromises';
  */
 export declare class SearchExecutor {
     private _cluster;
+    private _bucketName;
+    private _scopeName;
     /**
      * @internal
      */
-    constructor(cluster: Cluster);
+    constructor(cluster: Cluster, bucketName?: string, scopeName?: string);
     /**
      * @internal
      */

package/dist/searchexecutor.js

@@ -13,8 +13,10 @@ class SearchExecutor {
     /**
      * @internal
      */
-    constructor(cluster) {
+    constructor(cluster, bucketName, scopeName) {
         this._cluster = cluster;
+        this._bucketName = bucketName;
+        this._scopeName = scopeName;
     }
     /**
      * @internal
@@ -70,11 +72,16 @@ class SearchExecutor {
             request.show_request = false;
             if (query.vectorSearch) {
                 request.vector_search = JSON.stringify(query.vectorSearch.queries);
-                if (query.vectorSearch.options && query.vectorSearch.options.vectorQueryCombination) {
+                if (query.vectorSearch.options &&
+                    query.vectorSearch.options.vectorQueryCombination) {
                     request.vector_query_combination = (0, bindingutilities_1.vectorQueryCombinationToCpp)(query.vectorSearch.options.vectorQueryCombination);
                 }
             }
         }
+        if (this._bucketName && this._scopeName) {
+            request.bucket_name = this._bucketName;
+            request.scope_name = this._scopeName;
+        }
         this._cluster.conn.search(request, (cppErr, resp) => {
             const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
             if (err) {

package/dist/searchindexmanager.d.ts

@@ -1,5 +1,6 @@
 import { Cluster } from './cluster';
 import { NodeCallback } from './utilities';
+import { CppManagementSearchIndex } from './binding';
 /**
  * Provides information about a search index.  This class is currently
  * incomplete and must be casted from `any` in TypeScript.
@@ -57,15 +58,62 @@ export interface ISearchIndex {
  *
  * @category Management
  */
-export declare class SearchIndex {
+export declare class SearchIndex implements ISearchIndex {
+    /**
+     * The UUID of the search index.  Used for updates to ensure consistency.
+     */
+    uuid?: string;
     /**
      * The name of the search index.
      */
     name: string;
+    /**
+     * Name of the source of the data (ie: the bucket name).
+     */
+    sourceName: string;
+    /**
+     * The type of index to use (fulltext-index or fulltext-alias).
+     */
+    type: string;
+    /**
+     * Parameters to specify such as the store type and mappins.
+     */
+    params: {
+        [key: string]: any;
+    };
+    /**
+     * The UUID of the data source.
+     */
+    sourceUuid: string;
+    /**
+     * Extra parameters for the source.  These are usually things like advanced
+     * connection options and tuning parameters.
+     */
+    sourceParams: {
+        [key: string]: any;
+    };
+    /**
+     * The type of the source (couchbase or nil).
+     */
+    sourceType: string;
+    /**
+     * Plan properties such as the number of replicas and number of partitions.
+     */
+    planParams: {
+        [key: string]: any;
+    };
     /**
      * @internal
      */
     constructor(data: SearchIndex);
+    /**
+     * @internal
+     */
+    static _toCppData(data: ISearchIndex): any;
+    /**
+     * @internal
+     */
+    static _fromCppData(data: CppManagementSearchIndex): SearchIndex;
 }
 /**
  * @category Management
@@ -187,7 +235,6 @@ export declare class SearchIndexManager {
      * @internal
      */
     constructor(cluster: Cluster);
-    private get _http();
     /**
      * Returns an index by it's name.
      *
@@ -267,6 +314,14 @@ export declare class SearchIndexManager {
      * @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.
      *
@@ -275,5 +330,5 @@ export declare class SearchIndexManager {
      * @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<void>): Promise<void>;
+    analyzeDocument(indexName: string, document: any, options?: AnalyzeSearchDocumentOptions, callback?: NodeCallback<any>): Promise<any>;
 }