couchbase 4.4.2 → 4.4.4

package/dist/analyticsindexmanager.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyticsIndexManager = exports.AzureExternalAnalyticsLink = exports.S3ExternalAnalyticsLink = exports.CouchbaseRemoteAnalyticsLink = exports.AnalyticsLink = exports.CouchbaseAnalyticsEncryptionSettings = exports.AnalyticsIndex = exports.AnalyticsDataset = exports.AnalyticsEncryptionLevel = exports.AnalyticsLinkType = void 0;
 const errors_1 = require("./errors");
-const httpexecutor_1 = require("./httpexecutor");
+const bindingutilities_1 = require("./bindingutilities");
 const utilities_1 = require("./utilities");
 /**
  * Represents the type of an analytics link.
@@ -102,19 +102,21 @@ class AnalyticsLink {
      */
     constructor() {
         this.linkType = '';
+        this.dataverse = '';
+        this.name = '';
     }
     /**
      * @internal
      */
     static _toHttpData(data) {
         if (data.linkType === AnalyticsLinkType.CouchbaseRemote) {
-            return CouchbaseRemoteAnalyticsLink._toHttpData(data);
+            return CouchbaseRemoteAnalyticsLink._toHttpData(new CouchbaseRemoteAnalyticsLink(data));
         }
         else if (data.linkType === AnalyticsLinkType.S3External) {
-            return S3ExternalAnalyticsLink._toHttpData(data);
+            return S3ExternalAnalyticsLink._toHttpData(new S3ExternalAnalyticsLink(data));
         }
         else if (data.linkType === AnalyticsLinkType.AzureBlobExternal) {
-            return AzureExternalAnalyticsLink._toHttpData(data);
+            return AzureExternalAnalyticsLink._toHttpData(new AzureExternalAnalyticsLink(data));
         }
         else {
             throw new Error('invalid link type');
@@ -143,6 +145,39 @@ exports.AnalyticsLink = AnalyticsLink;
  * Provides information about a analytics remote Couchbase link.
  */
 class CouchbaseRemoteAnalyticsLink extends AnalyticsLink {
+    /**
+     * Validates the CouchbaseRemoteAnalyticsLink.
+     */
+    validate() {
+        if (!this.dataverse) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a dataverse for the CouchbaseRemoteAnalyticsLink.'));
+        }
+        if (!this.name) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a name for the CouchbaseRemoteAnalyticsLink.'));
+        }
+        if (!this.hostname) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a hostname for the CouchbaseRemoteAnalyticsLink.'));
+        }
+        if (this.encryption) {
+            if ([AnalyticsEncryptionLevel.None, AnalyticsEncryptionLevel.Half].includes(this.encryption.encryptionLevel)) {
+                if (!this.username || !this.password) {
+                    throw new errors_1.InvalidArgumentError(new Error('When encryption level is half or none, username and password must be set for the CouchbaseRemoteAnalyticsLink.'));
+                }
+            }
+            else {
+                if (!this.encryption.certificate ||
+                    this.encryption.certificate.length == 0) {
+                    throw new errors_1.InvalidArgumentError(new Error('When encryption level full, a certificate must be set for the CouchbaseRemoteAnalyticsLink.'));
+                }
+                const clientCertificateInvalid = !this.encryption.clientCertificate ||
+                    this.encryption.clientCertificate.length == 0;
+                const clientKeyInvalid = !this.encryption.clientKey || this.encryption.clientKey.length == 0;
+                if (clientCertificateInvalid || clientKeyInvalid) {
+                    throw new errors_1.InvalidArgumentError(new Error('When encryption level full, a client key and certificate must be set for the CouchbaseRemoteAnalyticsLink.'));
+                }
+            }
+        }
+    }
     /**
      * @internal
      */
@@ -159,61 +194,27 @@ class CouchbaseRemoteAnalyticsLink extends AnalyticsLink {
     /**
      * @internal
      */
-    static _toHttpData(data) {
-        let dvSpecific;
-        if (data.dataverse.indexOf('/') !== -1) {
-            const encDataverse = encodeURIComponent(data.dataverse);
-            const encName = encodeURIComponent(data.name);
-            dvSpecific = {
-                httpPath: `/analytics/link/${encDataverse}/${encName}`,
-            };
-        }
-        else {
-            dvSpecific = {
-                httpPath: `/analytics/link`,
-                dataverse: data.dataverse,
-                name: data.name,
-            };
-        }
+    static _toCppData(data) {
+        data.validate();
         return {
-            type: 'couchbase',
-            ...dvSpecific,
+            link_name: data.name,
+            dataverse: data.dataverse,
             hostname: data.hostname,
-            username: data.username,
+            username: data.hostname,
             password: data.password,
-            encryption: data.encryption ? data.encryption.encryptionLevel : undefined,
-            certificate: data.encryption
-                ? data.encryption.certificate
-                    ? data.encryption.certificate.toString()
-                    : undefined
-                : undefined,
-            clientCertificate: data.encryption
-                ? data.encryption.clientCertificate
-                    ? data.encryption.clientCertificate.toString()
-                    : undefined
-                : undefined,
-            clientKey: data.encryption
-                ? data.encryption.clientKey
-                    ? data.encryption.clientKey.toString()
-                    : undefined
-                : undefined,
+            encryption: (0, bindingutilities_1.encryptionSettingsToCpp)(data.encryption),
         };
     }
     /**
      * @internal
      */
-    static _fromHttpData(data) {
+    static _fromCppData(data) {
         return new CouchbaseRemoteAnalyticsLink({
             linkType: AnalyticsLinkType.CouchbaseRemote,
-            dataverse: data.dataverse || data.scope,
-            name: data.name,
-            hostname: data.activeHostname,
-            encryption: new CouchbaseAnalyticsEncryptionSettings({
-                encryptionLevel: data.encryption,
-                certificate: Buffer.from(data.certificate),
-                clientCertificate: Buffer.from(data.clientCertificate),
-                clientKey: Buffer.from(data.clientKey),
-            }),
+            dataverse: data.dataverse,
+            name: data.link_name,
+            hostname: data.hostname,
+            encryption: (0, bindingutilities_1.encryptionSettingsFromCpp)(data.encryption),
             username: data.username,
             password: undefined,
         });
@@ -239,47 +240,53 @@ class S3ExternalAnalyticsLink extends AnalyticsLink {
         this.serviceEndpoint = data.serviceEndpoint;
     }
     /**
-     * @internal
+     * Validates the S3ExternalAnalyticsLink.
      */
-    static _toHttpData(data) {
-        let dvSpecific;
-        if (data.dataverse.indexOf('/') !== -1) {
-            const encDataverse = encodeURIComponent(data.dataverse);
-            const encName = encodeURIComponent(data.name);
-            dvSpecific = {
-                httpPath: `/analytics/link/${encDataverse}/${encName}`,
-            };
+    validate() {
+        if (!this.dataverse) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a dataverse for the S3ExternalAnalyticsLink.'));
         }
-        else {
-            dvSpecific = {
-                httpPath: `/analytics/link`,
-                dataverse: data.dataverse,
-                name: data.name,
-            };
+        if (!this.name) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a name for the S3ExternalAnalyticsLink.'));
+        }
+        if (!this.accessKeyId) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide an accessKeyId for the S3ExternalAnalyticsLink.'));
+        }
+        if (!this.secretAccessKey) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide an secretAccessKey for the S3ExternalAnalyticsLink.'));
+        }
+        if (!this.region) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide an region for the S3ExternalAnalyticsLink.'));
         }
+    }
+    /**
+     * @internal
+     */
+    static _toCppData(data) {
+        data.validate();
         return {
-            type: 's3',
-            ...dvSpecific,
-            accessKeyId: data.accessKeyId,
-            secretAccessKey: data.secretAccessKey,
+            link_name: data.name,
+            dataverse: data.dataverse,
+            access_key_id: data.accessKeyId,
+            secret_access_key: data.secretAccessKey,
+            session_token: data.sessionToken,
             region: data.region,
-            sessionToken: data.sessionToken,
-            serviceEndpoint: data.serviceEndpoint,
+            service_endpoint: data.serviceEndpoint,
         };
     }
     /**
      * @internal
      */
-    static _fromHttpData(data) {
+    static _fromCppData(data) {
         return new S3ExternalAnalyticsLink({
+            name: data.link_name,
             linkType: AnalyticsLinkType.S3External,
-            dataverse: data.dataverse || data.scope,
-            name: data.name,
-            accessKeyId: data.accessKeyId,
+            dataverse: data.dataverse,
+            accessKeyId: data.access_key_id,
             secretAccessKey: undefined,
-            region: data.region,
             sessionToken: undefined,
-            serviceEndpoint: data.serviceEndpoint,
+            region: data.region,
+            serviceEndpoint: data.service_endpoint,
         });
     }
 }
@@ -304,49 +311,54 @@ class AzureExternalAnalyticsLink extends AnalyticsLink {
         this.endpointSuffix = data.endpointSuffix;
     }
     /**
-     * @internal
+     * Validates the AzureExternalAnalyticsLink.
      */
-    static _toHttpData(data) {
-        let dvSpecific;
-        if (data.dataverse.indexOf('/') !== -1) {
-            const encDataverse = encodeURIComponent(data.dataverse);
-            const encName = encodeURIComponent(data.name);
-            dvSpecific = {
-                httpPath: `/analytics/link/${encDataverse}/${encName}`,
-            };
+    validate() {
+        if (!this.dataverse) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a dataverse for the AzureExternalAnalyticsLink.'));
         }
-        else {
-            dvSpecific = {
-                httpPath: `/analytics/link`,
-                dataverse: data.dataverse,
-                name: data.name,
-            };
+        if (!this.name) {
+            throw new errors_1.InvalidArgumentError(new Error('Must provide a name for the AzureExternalAnalyticsLink.'));
         }
+        if (!this.connectionString) {
+            const missingAcctNameAndKey = !(this.accountName && this.accountKey);
+            const missingAcctNameAndSharedAccessSignature = !(this.accountName && this.sharedAccessSignature);
+            if (missingAcctNameAndKey && missingAcctNameAndSharedAccessSignature) {
+                throw new errors_1.InvalidArgumentError(new Error('If not providing connectionString, accountName and either accountKey' +
+                    ' or sharedAccessSignature must be provided for the AzureExternalAnalyticsLink.'));
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    static _toCppData(data) {
+        data.validate();
         return {
-            type: 'azure',
-            ...dvSpecific,
-            connectionString: data.connectionString,
-            accountName: data.accountName,
-            accountKey: data.accountKey,
-            sharedAccessSignature: data.sharedAccessSignature,
-            blobEndpoint: data.blobEndpoint,
-            endpointSuffix: data.endpointSuffix,
+            link_name: data.name,
+            dataverse: data.dataverse,
+            connection_string: data.connectionString,
+            account_name: data.accountName,
+            account_key: data.accountKey,
+            shared_access_signature: data.sharedAccessSignature,
+            blob_endpoint: data.blobEndpoint,
+            endpoint_suffix: data.endpointSuffix,
         };
     }
     /**
      * @internal
      */
-    static _fromHttpData(data) {
+    static _fromCppData(data) {
         return new AzureExternalAnalyticsLink({
+            name: data.link_name,
             linkType: AnalyticsLinkType.AzureBlobExternal,
-            dataverse: data.dataverse || data.scope,
-            name: data.name,
+            dataverse: data.dataverse,
             connectionString: undefined,
-            accountName: data.accountName,
+            accountName: data.account_name,
             accountKey: undefined,
             sharedAccessSignature: undefined,
-            blobEndpoint: data.blobEndpoint,
-            endpointSuffix: data.endpointSuffix,
+            blobEndpoint: data.blob_endpoint,
+            endpointSuffix: data.endpoint_suffix,
         });
     }
 }
@@ -364,9 +376,6 @@ class AnalyticsIndexManager {
     constructor(cluster) {
         this._cluster = cluster;
     }
-    get _http() {
-        return new httpexecutor_1.HttpExecutor(this._cluster.conn);
-    }
     /**
      * Creates a new dataverse.
      *
@@ -382,25 +391,20 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'CREATE DATAVERSE';
-        qs += ' `' + dataverseName.split('/').join('`.`') + '`';
-        if (options.ignoreIfExists) {
-            qs += ' IF NOT EXISTS';
-        }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            try {
-                await this._cluster.analyticsQuery(qs, {
-                    timeout: timeout,
-                });
-            }
-            catch (err) {
-                if (err instanceof errors_1.DataverseExistsError) {
-                    throw err;
+        const ignoreIfExists = options.ignoreIfExists || false;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsDataverseCreate({
+                dataverse_name: dataverseName,
+                timeout: timeout,
+                ignore_if_exists: ignoreIfExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to create dataverse', err);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -418,25 +422,20 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'DROP DATAVERSE';
-        qs += ' `' + dataverseName.split('/').join('`.`') + '`';
-        if (options.ignoreIfNotExists) {
-            qs += ' IF EXISTS';
-        }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            try {
-                await this._cluster.analyticsQuery(qs, {
-                    timeout: timeout,
-                });
-            }
-            catch (err) {
-                if (err instanceof errors_1.DataverseNotFoundError) {
-                    throw err;
+        const ignoreIfNotExists = options.ignoreIfNotExists || false;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsDataverseDrop({
+                dataverse_name: dataverseName,
+                timeout: timeout,
+                ignore_if_does_not_exist: ignoreIfNotExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to drop dataverse', err);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -455,39 +454,24 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'CREATE DATASET';
-        if (options.ignoreIfExists) {
-            qs += ' IF NOT EXISTS';
-        }
-        if (options.dataverseName) {
-            qs +=
-                ' `' +
-                    options.dataverseName.split('/').join('`.`') +
-                    '`.`' +
-                    datasetName +
-                    '`';
-        }
-        else {
-            qs += ' `' + datasetName + '`';
-        }
-        qs += ' ON `' + bucketName + '`';
-        if (options.condition) {
-            qs += ' WHERE ' + options.condition;
-        }
+        const dataverseName = options.dataverseName || 'Default';
+        const ignoreIfExists = options.ignoreIfExists || false;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            try {
-                await this._cluster.analyticsQuery(qs, {
-                    timeout: timeout,
-                });
-            }
-            catch (err) {
-                if (err instanceof errors_1.DatasetExistsError) {
-                    throw err;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsDatasetCreate({
+                dataverse_name: dataverseName,
+                dataset_name: datasetName,
+                bucket_name: bucketName,
+                condition: options === null || options === void 0 ? void 0 : options.condition,
+                timeout: timeout,
+                ignore_if_exists: ignoreIfExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to create dataset', err);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -505,35 +489,22 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'DROP DATASET';
-        if (options.dataverseName) {
-            qs +=
-                ' `' +
-                    options.dataverseName.split('/').join('`.`') +
-                    '`.`' +
-                    datasetName +
-                    '`';
-        }
-        else {
-            qs += ' `' + datasetName + '`';
-        }
-        if (options.ignoreIfNotExists) {
-            qs += ' IF EXISTS';
-        }
+        const dataverseName = options.dataverseName || 'Default';
+        const ignoreIfNotExists = options.ignoreIfNotExists || false;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            try {
-                await this._cluster.analyticsQuery(qs, {
-                    timeout: timeout,
-                });
-            }
-            catch (err) {
-                if (err instanceof errors_1.DatasetNotFoundError) {
-                    throw err;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsDatasetDrop({
+                dataverse_name: dataverseName,
+                dataset_name: datasetName,
+                timeout: timeout,
+                ignore_if_does_not_exist: ignoreIfNotExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to drop dataset', err);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -550,19 +521,23 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        const qs = 'SELECT d.* FROM `Metadata`.`Dataset` d WHERE d.DataverseName <> "Metadata"';
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._cluster.analyticsQuery(qs, {
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsDatasetGetAll({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const dataSets = resp.datasets.map((dataset) => new AnalyticsDataset({
+                    name: dataset.name,
+                    dataverseName: dataset.dataverse_name,
+                    linkName: dataset.link_name,
+                    bucketName: dataset.bucket_name,
+                }));
+                wrapCallback(null, dataSets);
             });
-            const datasets = res.rows.map((row) => new AnalyticsDataset({
-                name: row.DatasetName,
-                dataverseName: row.DataverseName,
-                linkName: row.LinkName,
-                bucketName: row.BucketName,
-            }));
-            return datasets;
         }, callback);
     }
     /**
@@ -582,32 +557,23 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'CREATE INDEX';
-        qs += ' `' + indexName + '`';
-        if (options.ignoreIfExists) {
-            qs += ' IF NOT EXISTS';
-        }
-        if (options.dataverseName) {
-            qs +=
-                ' ON `' +
-                    options.dataverseName.split('/').join('`.`') +
-                    '`.`' +
-                    datasetName +
-                    '`';
-        }
-        else {
-            qs += ' ON `' + datasetName + '`';
-        }
-        qs += ' (';
-        qs += Object.keys(fields)
-            .map((i) => '`' + i + '`: ' + fields[i])
-            .join(', ');
-        qs += ')';
+        const dataverseName = options.dataverseName || 'Default';
+        const ignoreIfExists = options.ignoreIfExists || false;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            await this._cluster.analyticsQuery(qs, {
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsIndexCreate({
+                dataverse_name: dataverseName,
+                dataset_name: datasetName,
+                index_name: indexName,
+                fields: fields,
                 timeout: timeout,
+                ignore_if_exists: ignoreIfExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
         }, callback);
     }
@@ -627,27 +593,22 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        let qs = '';
-        qs += 'DROP INDEX';
-        if (options.dataverseName) {
-            qs +=
-                ' `' +
-                    options.dataverseName.split('/').join('`.`') +
-                    '`.`' +
-                    datasetName +
-                    '`';
-        }
-        else {
-            qs += ' `' + datasetName + '`';
-        }
-        qs += '.`' + indexName + '`';
-        if (options.ignoreIfNotExists) {
-            qs += ' IF EXISTS';
-        }
+        const dataverseName = options.dataverseName || 'Default';
+        const ignoreIfNotExists = options.ignoreIfNotExists || false;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            await this._cluster.analyticsQuery(qs, {
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsIndexDrop({
+                dataverse_name: dataverseName,
+                dataset_name: datasetName,
+                index_name: indexName,
                 timeout: timeout,
+                ignore_if_does_not_exist: ignoreIfNotExists,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
             });
         }, callback);
     }
@@ -665,29 +626,41 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        const qs = 'SELECT d.* FROM `Metadata`.`Index` d WHERE d.DataverseName <> "Metadata"';
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._cluster.analyticsQuery(qs, {
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsIndexGetAll({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const indexes = resp.indexes.map((index) => new AnalyticsIndex({
+                    name: index.name,
+                    dataverseName: index.dataverse_name,
+                    datasetName: index.dataset_name,
+                    isPrimary: index.is_primary,
+                }));
+                wrapCallback(null, indexes);
             });
-            const indexes = res.rows.map((row) => new AnalyticsIndex({
-                name: row.IndexName,
-                datasetName: row.DatasetName,
-                dataverseName: row.DataverseName,
-                isPrimary: row.IsPrimary,
-            }));
-            return indexes;
         }, callback);
     }
     /**
-     * Connects a not yet connected link.
-     *
-     * @param linkName The name of the link to connect.
-     * @param options Optional parameters for this operation.
-     * @param callback A node-style callback to be invoked after execution.
+     * @internal
+     */
+    async connectLink() {
+        if (typeof arguments[0] === 'string') {
+            return this._connectLinkDeprecated(arguments[0], arguments[1], arguments[2]);
+        }
+        else {
+            return this._connectLink(arguments[0], arguments[1]);
+        }
+    }
+    // TODO(JSCBC-1293):  Remove deprecated path
+    /**
+     * @internal
      */
-    async connectLink(linkName, options, callback) {
+    async _connectLinkDeprecated(linkStr, options, callback) {
         if (options instanceof Function) {
             callback = arguments[1];
             options = undefined;
@@ -695,8 +668,12 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        const qs = 'CONNECT LINK ' + linkName;
+        const force = options.force || false;
         const timeout = options.timeout || this._cluster.managementTimeout;
+        let qs = 'CONNECT LINK ' + linkStr;
+        if (force) {
+            qs += ' WITH {"force": true}';
+        }
         return utilities_1.PromiseHelper.wrapAsync(async () => {
             await this._cluster.analyticsQuery(qs, {
                 timeout: timeout,
@@ -704,13 +681,9 @@ class AnalyticsIndexManager {
         }, callback);
     }
     /**
-     * Disconnects a previously connected link.
-     *
-     * @param linkName The name of the link to disconnect.
-     * @param options Optional parameters for this operation.
-     * @param callback A node-style callback to be invoked after execution.
+     * @internal
      */
-    async disconnectLink(linkName, options, callback) {
+    async _connectLink(options, callback) {
         if (options instanceof Function) {
             callback = arguments[1];
             options = undefined;
@@ -718,7 +691,49 @@ class AnalyticsIndexManager {
         if (!options) {
             options = {};
         }
-        const qs = 'DISCONNECT LINK ' + linkName;
+        const dataverseName = options.dataverseName || 'Default';
+        const linkName = options.linkName || 'Local';
+        const force = options.force || false;
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsLinkConnect({
+                dataverse_name: dataverseName,
+                link_name: linkName,
+                timeout: timeout,
+                force: force,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
+    /**
+     * @internal
+     */
+    async disconnectLink() {
+        if (typeof arguments[0] === 'string') {
+            return this._disconnectLinkDeprecated(arguments[0], arguments[1], arguments[2]);
+        }
+        else {
+            return this._disconnectLink(arguments[0], arguments[1]);
+        }
+    }
+    // TODO(JSCBC-1293):  Remove deprecated path
+    /**
+     * @internal
+     */
+    async _disconnectLinkDeprecated(linkStr, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const qs = 'DISCONNECT LINK ' + linkStr;
         const timeout = options.timeout || this._cluster.managementTimeout;
         return utilities_1.PromiseHelper.wrapAsync(async () => {
             await this._cluster.analyticsQuery(qs, {
@@ -726,6 +741,34 @@ class AnalyticsIndexManager {
             });
         }, callback);
     }
+    /**
+     * @internal
+     */
+    async _disconnectLink(options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const dataverseName = options.dataverseName || 'Default';
+        const linkName = options.linkName || 'Local';
+        const timeout = options.timeout || this._cluster.managementTimeout;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsLinkDisconnect({
+                dataverse_name: dataverseName,
+                link_name: linkName,
+                timeout: timeout,
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err);
+            });
+        }, callback);
+    }
     /**
      * Returns a list of all pending mutations.
      *
@@ -741,18 +784,19 @@ class AnalyticsIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Analytics,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/analytics/node/agg/stats/remaining`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsGetPendingMutations({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const stats = {
+                    stats: resp.stats,
+                };
+                wrapCallback(null, stats);
             });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                throw new errors_1.CouchbaseError('failed to get pending mutations', undefined, errCtx);
-            }
-            return JSON.parse(res.body.toString());
         }, callback);
     }
     /**
@@ -771,31 +815,51 @@ class AnalyticsIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const linkData = AnalyticsLink._toHttpData(link);
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Analytics,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: linkData.httpPath,
-                contentType: 'application/x-www-form-urlencoded',
-                body: (0, utilities_1.cbQsStringify)({
-                    linkData,
-                    httpPath: undefined,
-                }),
-                timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('24055')) {
-                    throw new errors_1.LinkExistsError(undefined, errCtx);
-                }
-                else if (errText.includes('24034')) {
-                    throw new errors_1.DataverseNotFoundError(undefined, errCtx);
-                }
-                throw new errors_1.CouchbaseError('failed to create link', undefined, errCtx);
-            }
-        }, callback);
+        if (link.linkType == AnalyticsLinkType.CouchbaseRemote) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkCreateCouchbaseRemoteLink({
+                    link: CouchbaseRemoteAnalyticsLink._toCppData(new CouchbaseRemoteAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else if (link.linkType == AnalyticsLinkType.S3External) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkCreateS3ExternalLink({
+                    link: S3ExternalAnalyticsLink._toCppData(new S3ExternalAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else if (link.linkType == AnalyticsLinkType.AzureBlobExternal) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkCreateAzureBlobExternalLink({
+                    link: AzureExternalAnalyticsLink._toCppData(new AzureExternalAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else {
+            throw new Error('invalid link type');
+        }
     }
     /**
      * Replaces an existing analytics remote link.
@@ -813,31 +877,51 @@ class AnalyticsIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const linkData = AnalyticsLink._toHttpData(link);
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Analytics,
-                method: httpexecutor_1.HttpMethod.Put,
-                path: linkData.httpPath,
-                contentType: 'application/x-www-form-urlencoded',
-                body: (0, utilities_1.cbQsStringify)({
-                    linkData,
-                    httpPath: undefined,
-                }),
-                timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('24055')) {
-                    throw new errors_1.LinkExistsError(undefined, errCtx);
-                }
-                else if (errText.includes('24034')) {
-                    throw new errors_1.DataverseNotFoundError(undefined, errCtx);
-                }
-                throw new errors_1.CouchbaseError('failed to replace link', undefined, errCtx);
-            }
-        }, callback);
+        if (link.linkType == AnalyticsLinkType.CouchbaseRemote) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkReplaceCouchbaseRemoteLink({
+                    link: CouchbaseRemoteAnalyticsLink._toCppData(new CouchbaseRemoteAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else if (link.linkType == AnalyticsLinkType.S3External) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkReplaceS3ExternalLink({
+                    link: S3ExternalAnalyticsLink._toCppData(new S3ExternalAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else if (link.linkType == AnalyticsLinkType.AzureBlobExternal) {
+            return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+                this._cluster.conn.managementAnalyticsLinkReplaceAzureBlobExternalLink({
+                    link: AzureExternalAnalyticsLink._toCppData(new AzureExternalAnalyticsLink(link)),
+                    timeout: timeout,
+                }, (cppErr) => {
+                    const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                    if (err) {
+                        return wrapCallback(err, null);
+                    }
+                    wrapCallback(err);
+                });
+            }, callback);
+        }
+        else {
+            throw new Error('invalid link type');
+        }
     }
     /**
      * Drops an existing analytics remote link.
@@ -856,41 +940,18 @@ class AnalyticsIndexManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            let httpPath;
-            let httpParams;
-            if (dataverseName.indexOf('/') !== -1) {
-                const encDataverse = encodeURIComponent(dataverseName);
-                const encName = encodeURIComponent(linkName);
-                httpPath = `/analytics/link/${encDataverse}/${encName}`;
-                httpParams = {};
-            }
-            else {
-                httpPath = `/analytics/link`;
-                httpParams = {
-                    dataverse: dataverseName,
-                    name: linkName,
-                };
-            }
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Analytics,
-                method: httpexecutor_1.HttpMethod.Delete,
-                path: httpPath,
-                contentType: 'application/x-www-form-urlencoded',
-                body: (0, utilities_1.cbQsStringify)(httpParams),
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsLinkDrop({
+                dataverse_name: dataverseName,
+                link_name: linkName,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('24055')) {
-                    throw new errors_1.LinkExistsError(undefined, errCtx);
-                }
-                else if (errText.includes('24034')) {
-                    throw new errors_1.DataverseNotFoundError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to delete link', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -911,49 +972,29 @@ class AnalyticsIndexManager {
         const linkName = options.name;
         const linkType = options.linkType;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            let httpPath;
-            if (dataverseName && dataverseName.indexOf('/') !== -1) {
-                const encDataverse = encodeURIComponent(dataverseName);
-                httpPath = `/analytics/link/${encDataverse}`;
-                if (linkName) {
-                    const encName = encodeURIComponent(linkName);
-                    httpPath += `/${encName}`;
-                }
-                httpPath += '?';
-                if (linkType) {
-                    httpPath += `type=${linkType}&`;
-                }
-            }
-            else {
-                httpPath = `/analytics/link?`;
-                if (dataverseName) {
-                    httpPath += `dataverse=${dataverseName}&`;
-                    if (linkName) {
-                        httpPath += `dataverse=${linkName}&`;
-                    }
-                }
-                if (linkType) {
-                    httpPath += `type=${linkType}&`;
-                }
-            }
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Analytics,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: httpPath,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementAnalyticsLinkGetAll({
+                link_type: linkType,
+                link_name: linkName,
+                dataverse_name: dataverseName,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('24034')) {
-                    throw new errors_1.DataverseNotFoundError(undefined, errCtx);
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to get links', undefined, errCtx);
-            }
-            const linksData = JSON.parse(res.body.toString());
-            const links = linksData.map((linkData) => AnalyticsLink._fromHttpData(linkData));
-            return links;
+                const links = [];
+                resp.couchbase.forEach((link) => {
+                    links.push(CouchbaseRemoteAnalyticsLink._fromCppData(link));
+                });
+                resp.s3.forEach((link) => {
+                    links.push(S3ExternalAnalyticsLink._fromCppData(link));
+                });
+                resp.azure_blob.forEach((link) => {
+                    links.push(AzureExternalAnalyticsLink._fromCppData(link));
+                });
+                wrapCallback(null, links);
+            });
         }, callback);
     }
 }