couchbase 4.2.9 → 4.2.11-rc.1

package/dist/searchexecutor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchExecutor = void 0;
 /* eslint jsdoc/require-jsdoc: off */
 const bindingutilities_1 = require("./bindingutilities");
+const searchquery_1 = require("./searchquery");
 const searchtypes_1 = require("./searchtypes");
 const streamablepromises_1 = require("./streamablepromises");
 /**
@@ -12,8 +13,10 @@ class SearchExecutor {
     /**
      * @internal
      */
-    constructor(cluster) {
+    constructor(cluster, bucketName, scopeName) {
         this._cluster = cluster;
+        this._bucketName = bucketName;
+        this._scopeName = scopeName;
     }
     /**
      * @internal
@@ -25,11 +28,16 @@ class SearchExecutor {
                 meta: meta,
             });
         });
+        const searchQuery = query instanceof searchquery_1.SearchQuery
+            ? JSON.stringify(query)
+            : query.searchQuery
+                ? JSON.stringify(query.searchQuery)
+                : JSON.stringify(new searchquery_1.MatchNoneSearchQuery());
         const timeout = options.timeout || this._cluster.searchTimeout;
-        this._cluster.conn.search({
+        const request = {
             timeout,
             index_name: indexName,
-            query: JSON.stringify(query),
+            query: searchQuery,
             limit: options.limit,
             skip: options.skip,
             explain: options.explain || false,
@@ -59,7 +67,22 @@ class SearchExecutor {
                     .map(([k, v]) => [k, JSON.stringify(v)]))
                 : {},
             body_str: '',
-        }, (cppErr, resp) => {
+        };
+        if (query instanceof searchtypes_1.SearchRequest) {
+            request.show_request = false;
+            if (query.vectorSearch) {
+                request.vector_search = JSON.stringify(query.vectorSearch.queries);
+                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) {
                 emitter.emit('error', 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>;
 }

package/dist/searchindexmanager.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchIndexManager = exports.SearchIndex = void 0;
-const errors_1 = require("./errors");
-const httpexecutor_1 = require("./httpexecutor");
 const utilities_1 = require("./utilities");
+const bindingutilities_1 = require("./bindingutilities");
 /**
  * This class is currently incomplete and must be casted to `any` in
  * TypeScript to be used.
@@ -15,7 +14,57 @@ class SearchIndex {
      * @internal
      */
     constructor(data) {
+        this.uuid = data.uuid;
         this.name = data.name;
+        this.sourceName = data.sourceName;
+        this.type = data.type;
+        this.params = data.params;
+        this.sourceUuid = data.sourceUuid;
+        this.sourceParams = data.sourceParams;
+        this.sourceType = data.sourceType;
+        this.planParams = data.planParams;
+    }
+    /**
+     * @internal
+     */
+    static _toCppData(data) {
+        return {
+            uuid: data.uuid,
+            name: data.name,
+            type: data.type,
+            params_json: JSON.stringify(data.params),
+            source_uuid: data.sourceUuid,
+            source_name: data.sourceName,
+            source_type: data.sourceType,
+            source_params_json: JSON.stringify(data.sourceParams),
+            plan_params_json: JSON.stringify(data.planParams),
+        };
+    }
+    /**
+     * @internal
+     */
+    static _fromCppData(data) {
+        const idx = new SearchIndex({
+            uuid: data.uuid,
+            name: data.name,
+            type: data.type,
+            params: {},
+            sourceUuid: data.source_uuid,
+            sourceName: data.source_name,
+            sourceType: data.source_type,
+            sourceParams: {},
+            planParams: {},
+        });
+        if (data.params_json) {
+            idx.params = JSON.parse(data.params_json);
+        }
+        if (data.source_params_json) {
+            idx.sourceParams = JSON.parse(data.source_params_json);
+        }
+        if (data.plan_params_json) {
+            idx.planParams = JSON.parse(data.plan_params_json);
+        }
+        return idx;
     }
 }
 exports.SearchIndex = SearchIndex;
@@ -32,9 +81,6 @@ class SearchIndexManager {
     constructor(cluster) {
         this._cluster = cluster;
     }
-    get _http() {
-        return new httpexecutor_1.HttpExecutor(this._cluster.conn);
-    }
     /**
      * Returns an index by it's name.
      *
@@ -51,18 +97,18 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/index/${indexName}`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGet({
+                index_name: indexName,
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const index = SearchIndex._fromCppData(resp.index);
+                wrapCallback(null, index);
             });
-            if (res.statusCode !== 200) {
-                throw new errors_1.IndexNotFoundError();
-            }
-            const idxData = JSON.parse(res.body.toString());
-            return idxData.indexDef;
         }, callback);
     }
     /**
@@ -80,18 +126,17 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/index`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGetAll({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const indexes = resp.indexes.map((indexData) => SearchIndex._fromCppData(indexData));
+                wrapCallback(null, indexes);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to fetch search indices');
-            }
-            const idxsData = JSON.parse(res.body.toString());
-            return Object.values(idxsData.indexDefs.indexDefs);
         }, callback);
     }
     /**
@@ -109,20 +154,18 @@ class SearchIndexManager {
         if (!options) {
             options = {};
         }
-        const indexName = indexDefinition.name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Put,
-                path: `/api/index/${indexName}`,
-                contentType: 'application/json',
-                body: JSON.stringify(indexDefinition),
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexUpsert({
+                index: SearchIndex._toCppData(indexDefinition),
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to create index');
-            }
         }, callback);
     }
     /**
@@ -141,17 +184,17 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Delete,
-                path: `/api/index/${indexName}`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexDrop({
+                index_name: indexName,
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to delete search index');
-            }
-            return JSON.parse(res.body.toString());
         }, callback);
     }
     /**
@@ -170,17 +213,17 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/index/${indexName}/count`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexGetDocumentsCount({
+                index_name: indexName,
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(null, resp.count);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to get search indexed documents count');
-            }
-            return JSON.parse(res.body.toString()).count;
         }, callback);
     }
     /**
@@ -199,16 +242,18 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/ingestControl/pause`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlIngest({
+                index_name: indexName,
+                pause: true,
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to pause search index ingestion');
-            }
         }, callback);
     }
     /**
@@ -227,16 +272,18 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/ingestControl/resume`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlIngest({
+                index_name: indexName,
+                pause: false,
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to resume search index ingestion');
-            }
         }, callback);
     }
     /**
@@ -255,16 +302,18 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/queryControl/allow`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlQuery({
+                index_name: indexName,
+                allow: true,
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to allow search index quering');
-            }
         }, callback);
     }
     /**
@@ -283,16 +332,18 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/queryControl/disallow`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlQuery({
+                index_name: indexName,
+                allow: false,
                 timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to disallow search index quering');
-            }
         }, callback);
     }
     /**
@@ -311,16 +362,48 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/planFreezeControl/freeze`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexControlPlanFreeze({
+                index_name: indexName,
+                freeze: true,
+                timeout: timeout,
+            }, (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,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to freeze search index plan');
-            }
         }, callback);
     }
     /**
@@ -340,18 +423,19 @@ class SearchIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Search,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/index/${indexName}/analyzeDoc`,
-                body: JSON.stringify(document),
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementSearchIndexAnalyzeDocument({
+                index_name: indexName,
+                encoded_document: JSON.stringify(document),
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const result = JSON.parse(resp.analysis);
+                wrapCallback(result, null);
             });
-            if (res.statusCode !== 200) {
-                throw new Error('failed to perform search index document analysis');
-            }
-            return JSON.parse(res.body.toString()).analyze;
         }, callback);
     }
 }

package/dist/searchtypes.d.ts

@@ -1,6 +1,8 @@
 import { MutationState } from './mutationstate';
 import { SearchFacet } from './searchfacet';
+import { SearchQuery } from './searchquery';
 import { SearchSort } from './searchsort';
+import { VectorSearch } from './vectorsearch';
 /**
  * SearchMetaData represents the meta-data available from a search query.
  * This class is currently incomplete and must be casted to `any` in
@@ -145,3 +147,47 @@ export interface SearchQueryOptions {
      */
     timeout?: number;
 }
+/**
+ *  Represents a search query and/or vector search to execute via the Couchbase Full Text Search (FTS) service.
+ *
+ *  Volatile: This API is subject to change at any time.
+ *
+ * @category Full Text Search
+ */
+export declare class SearchRequest {
+    private _searchQuery;
+    private _vectorSearch;
+    constructor(query: SearchQuery | VectorSearch);
+    /**
+     * @internal
+     */
+    get searchQuery(): SearchQuery | undefined;
+    /**
+     * @internal
+     */
+    get vectorSearch(): VectorSearch | undefined;
+    /**
+     * Adds a search query to the request if the request does not already have a search query.
+     *
+     * Volatile: This API is subject to change at any time.
+     *
+     * @param query A SearchQuery to add to the request.
+     */
+    withSearchQuery(query: SearchQuery): SearchRequest;
+    /**
+     * Adds a vector search to the request if the request does not already have a vector search.
+     *
+     * Volatile: This API is subject to change at any time.
+     *
+     * @param search A VectorSearch to add to the request.
+     */
+    withVectorSearch(search: VectorSearch): SearchRequest;
+    /**
+     * Creates a search request.
+     *
+     * Volatile: This API is subject to change at any time.
+     *
+     * @param query Either a SearchQuery or VectorSearch to add to the search request.
+     */
+    static create(query: SearchQuery | VectorSearch): SearchRequest;
+}