couchbase 3.2.2 → 3.2.5

package/dist/queryindexmanager.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryIndexManager = exports.QueryIndex = void 0;
 const errors_1 = require("./errors");
@@ -50,56 +41,54 @@ class QueryIndexManager {
     get _http() {
         return new httpexecutor_1.HttpExecutor(this._cluster._getClusterConn());
     }
-    _createIndex(bucketName, options, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let qs = '';
-            if (!options.fields) {
-                qs += 'CREATE PRIMARY INDEX';
-            }
-            else {
-                qs += 'CREATE INDEX';
-            }
-            if (options.name) {
-                qs += ' `' + options.name + '`';
-            }
-            qs += ' ON `' + bucketName + '`';
-            if (options.fields && options.fields.length > 0) {
-                qs += '(';
-                for (let i = 0; i < options.fields.length; ++i) {
-                    if (i > 0) {
-                        qs += ', ';
-                    }
-                    qs += '`' + options.fields[i] + '`';
+    async _createIndex(bucketName, options, callback) {
+        let qs = '';
+        if (!options.fields) {
+            qs += 'CREATE PRIMARY INDEX';
+        }
+        else {
+            qs += 'CREATE INDEX';
+        }
+        if (options.name) {
+            qs += ' `' + options.name + '`';
+        }
+        qs += ' ON `' + bucketName + '`';
+        if (options.fields && options.fields.length > 0) {
+            qs += '(';
+            for (let i = 0; i < options.fields.length; ++i) {
+                if (i > 0) {
+                    qs += ', ';
                 }
-                qs += ')';
-            }
-            const withOpts = {};
-            if (options.deferred) {
-                withOpts.defer_build = true;
-            }
-            if (options.numReplicas) {
-                withOpts.num_replica = options.numReplicas;
+                qs += '`' + options.fields[i] + '`';
             }
-            if (Object.keys(withOpts).length > 0) {
-                qs += ' WITH ' + JSON.stringify(withOpts);
+            qs += ')';
+        }
+        const withOpts = {};
+        if (options.deferred) {
+            withOpts.defer_build = true;
+        }
+        if (options.numReplicas) {
+            withOpts.num_replica = options.numReplicas;
+        }
+        if (Object.keys(withOpts).length > 0) {
+            qs += ' WITH ' + JSON.stringify(withOpts);
+        }
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            try {
+                await this._cluster.query(qs, {
+                    parentSpan: options.parentSpan,
+                    timeout: options.timeout,
+                });
             }
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield this._cluster.query(qs, {
-                        parentSpan: options.parentSpan,
-                        timeout: options.timeout,
-                    });
+            catch (err) {
+                if (options.ignoreIfExists && err instanceof errors_1.IndexExistsError) {
+                    // swallow the error if the user wants us to
                 }
-                catch (err) {
-                    if (options.ignoreIfExists && err instanceof errors_1.IndexExistsError) {
-                        // swallow the error if the user wants us to
-                    }
-                    else {
-                        throw err;
-                    }
+                else {
+                    throw err;
                 }
-            }), callback);
-        });
+            }
+        }, callback);
     }
     /**
      * Creates a new query index.
@@ -110,25 +99,23 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    createIndex(bucketName, indexName, fields, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[2];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            return this._createIndex(bucketName, {
-                name: indexName,
-                fields: fields,
-                ignoreIfExists: options.ignoreIfExists,
-                numReplicas: options.numReplicas,
-                deferred: options.deferred,
-                parentSpan: options.parentSpan,
-                timeout: options.timeout,
-            }, callback);
-        });
+    async createIndex(bucketName, indexName, fields, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[3];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        return this._createIndex(bucketName, {
+            name: indexName,
+            fields: fields,
+            ignoreIfExists: options.ignoreIfExists,
+            numReplicas: options.numReplicas,
+            deferred: options.deferred,
+            parentSpan: options.parentSpan,
+            timeout: options.timeout,
+        }, callback);
     }
     /**
      * Creates a new primary query index.
@@ -137,51 +124,47 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    createPrimaryIndex(bucketName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[0];
-                options = undefined;
+    async createPrimaryIndex(bucketName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        return this._createIndex(bucketName, {
+            name: options.name,
+            ignoreIfExists: options.ignoreIfExists,
+            deferred: options.deferred,
+            parentSpan: options.parentSpan,
+            timeout: options.timeout,
+        }, callback);
+    }
+    async _dropIndex(bucketName, options, callback) {
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            let qs = '';
+            if (!options.name) {
+                qs += 'DROP PRIMARY INDEX `' + bucketName + '`';
             }
-            if (!options) {
-                options = {};
+            else {
+                qs += 'DROP INDEX `' + bucketName + '`.`' + options.name + '`';
             }
-            return this._createIndex(bucketName, {
-                name: options.name,
-                ignoreIfExists: options.ignoreIfExists,
-                deferred: options.deferred,
-                parentSpan: options.parentSpan,
-                timeout: options.timeout,
-            }, callback);
-        });
-    }
-    _dropIndex(bucketName, options, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                let qs = '';
-                if (!options.name) {
-                    qs += 'DROP PRIMARY INDEX `' + bucketName + '`';
+            try {
+                await this._cluster.query(qs, {
+                    parentSpan: options.parentSpan,
+                    timeout: timeout,
+                });
+            }
+            catch (err) {
+                if (options.ignoreIfNotExists && err instanceof errors_1.IndexNotFoundError) {
+                    // swallow the error if the user wants us to
                 }
                 else {
-                    qs += 'DROP INDEX `' + bucketName + '`.`' + options.name + '`';
+                    throw err;
                 }
-                try {
-                    yield this._cluster.query(qs, {
-                        parentSpan: options.parentSpan,
-                        timeout: timeout,
-                    });
-                }
-                catch (err) {
-                    if (options.ignoreIfNotExists && err instanceof errors_1.IndexNotFoundError) {
-                        // swallow the error if the user wants us to
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }), callback);
-        });
+            }
+        }, callback);
     }
     /**
      * Drops an existing query index.
@@ -191,22 +174,20 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    dropIndex(bucketName, indexName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[2];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            return this._dropIndex(bucketName, {
-                name: indexName,
-                ignoreIfNotExists: options.ignoreIfNotExists,
-                parentSpan: options.parentSpan,
-                timeout: options.timeout,
-            }, callback);
-        });
+    async dropIndex(bucketName, indexName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[2];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        return this._dropIndex(bucketName, {
+            name: indexName,
+            ignoreIfNotExists: options.ignoreIfNotExists,
+            parentSpan: options.parentSpan,
+            timeout: options.timeout,
+        }, callback);
     }
     /**
      * Drops an existing primary index.
@@ -215,22 +196,20 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    dropPrimaryIndex(bucketName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[0];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            return this._dropIndex(bucketName, {
-                name: options.name,
-                ignoreIfNotExists: options.ignoreIfNotExists,
-                parentSpan: options.parentSpan,
-                timeout: options.timeout,
-            }, callback);
-        });
+    async dropPrimaryIndex(bucketName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        return this._dropIndex(bucketName, {
+            name: options.name,
+            ignoreIfNotExists: options.ignoreIfNotExists,
+            parentSpan: options.parentSpan,
+            timeout: options.timeout,
+        }, callback);
     }
     /**
      * Returns a list of indexes for a specific bucket.
@@ -239,40 +218,38 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    getAllIndexes(bucketName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[1];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const qs = `SELECT idx.* FROM system:indexes AS idx
+    async getAllIndexes(bucketName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const qs = `SELECT idx.* FROM system:indexes AS idx
               WHERE (
                 (\`bucket_id\` IS MISSING AND \`keyspace_id\`="${bucketName}")
                 OR \`bucket_id\`="${bucketName}"
               ) AND \`using\`="gsi" ORDER BY is_primary DESC, name ASC`;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield this._cluster.query(qs, {
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                const indexes = res.rows.map((row) => new QueryIndex({
-                    name: row.name,
-                    isPrimary: row.is_primary,
-                    type: row.using,
-                    state: row.state,
-                    keyspace: row.keyspace_id,
-                    indexKey: row.index_key,
-                    condition: row.condition,
-                    partition: row.partition,
-                }));
-                return indexes;
-            }), callback);
-        });
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const res = await this._cluster.query(qs, {
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            const indexes = res.rows.map((row) => new QueryIndex({
+                name: row.name,
+                isPrimary: row.is_primary,
+                type: row.using,
+                state: row.state,
+                keyspace: row.keyspace_id,
+                indexKey: row.index_key,
+                condition: row.condition,
+                partition: row.partition,
+            }));
+            return indexes;
+        }, callback);
     }
     /**
      * Starts building any indexes which were previously created with deferred=true.
@@ -281,49 +258,47 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    buildDeferredIndexes(bucketName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[1];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
+    async buildDeferredIndexes(bucketName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        const timer = new utilities_1.CompoundTimeout(timeout);
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const indexes = await this.getAllIndexes(bucketName, {
+                parentSpan: parentSpan,
+                timeout: timer.left(),
+            });
+            // Filter out the index names that need to be built
+            const deferredList = indexes
+                .filter((index) => index.state === 'deferred' || index.state === 'pending')
+                .map((index) => index.name);
+            // If there are no deferred indexes, we have nothing to do.
+            if (deferredList.length === 0) {
+                return [];
             }
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            const timer = new utilities_1.CompoundTimeout(timeout);
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const indexes = yield this.getAllIndexes(bucketName, {
-                    parentSpan: parentSpan,
-                    timeout: timer.left(),
-                });
-                // Filter out the index names that need to be built
-                const deferredList = indexes
-                    .filter((index) => index.state === 'deferred' || index.state === 'pending')
-                    .map((index) => index.name);
-                // If there are no deferred indexes, we have nothing to do.
-                if (deferredList.length === 0) {
-                    return [];
-                }
-                let qs = '';
-                qs += 'BUILD INDEX ON `' + bucketName + '` ';
-                qs += '(';
-                for (let j = 0; j < deferredList.length; ++j) {
-                    if (j > 0) {
-                        qs += ', ';
-                    }
-                    qs += '`' + deferredList[j] + '`';
+            let qs = '';
+            qs += 'BUILD INDEX ON `' + bucketName + '` ';
+            qs += '(';
+            for (let j = 0; j < deferredList.length; ++j) {
+                if (j > 0) {
+                    qs += ', ';
                 }
-                qs += ')';
-                // Run our deferred build query
-                yield this._cluster.query(qs, {
-                    timeout: timer.left(),
-                });
-                // Return the list of indices that we built
-                return deferredList;
-            }), callback);
-        });
+                qs += '`' + deferredList[j] + '`';
+            }
+            qs += ')';
+            // Run our deferred build query
+            await this._cluster.query(qs, {
+                timeout: timer.left(),
+            });
+            // Return the list of indices that we built
+            return deferredList;
+        }, callback);
     }
     /**
      * Waits for a number of indexes to finish creation and be ready to use.
@@ -334,54 +309,52 @@ class QueryIndexManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    watchIndexes(bucketName, indexNames, timeout, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[3];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            if (options.watchPrimary) {
-                indexNames = [...indexNames, '#primary'];
-            }
-            const parentSpan = options.parentSpan;
-            const timer = new utilities_1.CompoundTimeout(timeout);
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                let curInterval = 50;
-                for (;;) {
-                    // Get all the indexes that are currently registered
-                    const foundIdxs = yield this.getAllIndexes(bucketName, {
-                        parentSpan: parentSpan,
-                        timeout: timer.left(),
-                    });
-                    const onlineIdxs = foundIdxs.filter((idx) => idx.state === 'online');
-                    const onlineIdxNames = onlineIdxs.map((idx) => idx.name);
-                    // Check if all the indexes we want are online
-                    let allOnline = true;
-                    indexNames.forEach((indexName) => {
-                        allOnline = allOnline && onlineIdxNames.indexOf(indexName) !== -1;
-                    });
-                    // If all the indexes are online, we've succeeded
-                    if (allOnline) {
-                        break;
-                    }
-                    // Add 500 to our interval to a max of 1000
-                    curInterval = Math.min(1000, curInterval + 500);
-                    // Make sure we don't go past our user-specified duration
-                    const userTimeLeft = timer.left();
-                    if (userTimeLeft !== undefined) {
-                        curInterval = Math.min(curInterval, userTimeLeft);
-                    }
-                    if (curInterval <= 0) {
-                        throw new errors_1.CouchbaseError('Failed to find all indexes online within the alloted time.');
-                    }
-                    // Wait until curInterval expires
-                    yield new Promise((resolve) => setTimeout(() => resolve(true), curInterval));
+    async watchIndexes(bucketName, indexNames, timeout, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[3];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        if (options.watchPrimary) {
+            indexNames = [...indexNames, '#primary'];
+        }
+        const parentSpan = options.parentSpan;
+        const timer = new utilities_1.CompoundTimeout(timeout);
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            let curInterval = 50;
+            for (;;) {
+                // Get all the indexes that are currently registered
+                const foundIdxs = await this.getAllIndexes(bucketName, {
+                    parentSpan: parentSpan,
+                    timeout: timer.left(),
+                });
+                const onlineIdxs = foundIdxs.filter((idx) => idx.state === 'online');
+                const onlineIdxNames = onlineIdxs.map((idx) => idx.name);
+                // Check if all the indexes we want are online
+                let allOnline = true;
+                indexNames.forEach((indexName) => {
+                    allOnline = allOnline && onlineIdxNames.indexOf(indexName) !== -1;
+                });
+                // If all the indexes are online, we've succeeded
+                if (allOnline) {
+                    break;
                 }
-            }), callback);
-        });
+                // Add 500 to our interval to a max of 1000
+                curInterval = Math.min(1000, curInterval + 500);
+                // Make sure we don't go past our user-specified duration
+                const userTimeLeft = timer.left();
+                if (userTimeLeft !== undefined) {
+                    curInterval = Math.min(curInterval, userTimeLeft);
+                }
+                if (curInterval <= 0) {
+                    throw new errors_1.CouchbaseError('Failed to find all indexes online within the alloted time.');
+                }
+                // Wait until curInterval expires
+                await new Promise((resolve) => setTimeout(() => resolve(true), curInterval));
+            }
+        }, callback);
     }
 }
 exports.QueryIndexManager = QueryIndexManager;

package/dist/scope.js

@@ -76,7 +76,10 @@ class Scope {
         const bucket = this.bucket;
         const exec = new queryexecutor_1.QueryExecutor(bucket.conn);
         const options_ = options;
-        return utilities_1.PromiseHelper.wrapAsync(() => exec.query(statement, Object.assign(Object.assign({}, options_), { queryContext: `${bucket.name}.${this.name}` })), callback);
+        return utilities_1.PromiseHelper.wrapAsync(() => exec.query(statement, {
+            ...options_,
+            queryContext: `${bucket.name}.${this.name}`,
+        }), callback);
     }
     /**
      * Executes an analytics query against the cluster scoped this scope.
@@ -96,7 +99,10 @@ class Scope {
         const bucket = this.bucket;
         const exec = new analyticsexecutor_1.AnalyticsExecutor(bucket.conn);
         const options_ = options;
-        return utilities_1.PromiseHelper.wrapAsync(() => exec.query(statement, Object.assign(Object.assign({}, options_), { queryContext: `${bucket.name}.${this.name}` })), callback);
+        return utilities_1.PromiseHelper.wrapAsync(() => exec.query(statement, {
+            ...options_,
+            queryContext: `${bucket.name}.${this.name}`,
+        }), callback);
     }
 }
 exports.Scope = Scope;

package/dist/searchexecutor.js

@@ -50,6 +50,9 @@ class SearchExecutor {
         if (options.disableScoring) {
             queryObj.score = 'none';
         }
+        if (options.includeLocations !== undefined) {
+            queryObj.includeLocations = options.includeLocations;
+        }
         if (options.consistency) {
             queryObjCtl.consistency = {
                 level: options.consistency,