couchbase 4.3.0 → 4.3.1

package/dist/eventingfunctionmanager.js

@@ -1,9 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventingFunctionManager = exports.EventingState = exports.EventingFunctionState = exports.EventingFunction = exports.EventingFunctionSettings = exports.EventingFunctionConstantBinding = exports.EventingFunctionUrlBinding = exports.EventingFunctionUrlAuthBearer = exports.EventingFunctionUrlAuthDigest = exports.EventingFunctionUrlAuthBasic = exports.EventingFunctionBucketBinding = exports.EventingFunctionKeyspace = exports.EventingFunctionUrlAuthMethod = exports.EventingFunctionBucketAccess = exports.EventingFunctionLogLevel = exports.EventingFunctionLanguageCompatibility = exports.EventingFunctionStatus = exports.EventingFunctionProcessingStatus = exports.EventingFunctionDeploymentStatus = exports.EventingFunctionDcpBoundary = void 0;
-const errors_1 = require("./errors");
-const httpexecutor_1 = require("./httpexecutor");
 const utilities_1 = require("./utilities");
+const bindingutilities_1 = require("./bindingutilities");
+const errs = __importStar(require("./errors"));
 /**
  * Represents the various dcp boundary options for eventing functions.
  *
@@ -107,6 +130,11 @@ var EventingFunctionLanguageCompatibility;
      * Couchbase Server 6.6.2.
      */
     EventingFunctionLanguageCompatibility["Version_6_6_2"] = "6.6.2";
+    /**
+     * Indicates that the function should run with compatibility with
+     * Couchbase Server 7.2.0.
+     */
+    EventingFunctionLanguageCompatibility["Version_7_2_0"] = "7.2.0";
 })(EventingFunctionLanguageCompatibility || (exports.EventingFunctionLanguageCompatibility = EventingFunctionLanguageCompatibility = {}));
 /**
  * Represents the various log levels for an eventing function.
@@ -203,27 +231,29 @@ class EventingFunctionBucketBinding {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingFunctionBucketBinding({
+            alias: data.alias,
             name: new EventingFunctionKeyspace({
-                bucket: data.bucket_name,
-                scope: data.scope_name,
-                collection: data.collection_name,
+                bucket: data.name.bucket,
+                scope: data.name.scope,
+                collection: data.name.collection,
             }),
-            alias: data.alias,
-            access: data.access,
+            access: (0, bindingutilities_1.eventingBucketBindingAccessFromCpp)(data.access),
         });
     }
     /**
      * @internal
      */
-    static _toEvtData(data) {
+    static _toCppData(data) {
         return {
-            bucket_name: data.name.bucket,
-            scope_name: data.name.scope,
-            collection_name: data.name.collection,
             alias: data.alias,
-            access: data.access,
+            name: {
+                bucket: data.name.bucket,
+                scope: data.name.scope,
+                collection: data.name.collection,
+            },
+            access: (0, bindingutilities_1.eventingBucketBindingAccessToCpp)(data.access),
         };
     }
 }
@@ -291,34 +321,37 @@ class EventingFunctionUrlBinding {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         let authObj;
-        if (data.auth_type === EventingFunctionUrlAuthMethod.None) {
+        if (data.auth_name === 'function_url_no_auth') {
             authObj = undefined;
         }
-        else if (data.auth_type === EventingFunctionUrlAuthMethod.Basic) {
+        else if (data.auth_name === 'function_url_auth_basic') {
             authObj = new EventingFunctionUrlAuthBasic({
-                username: data.username,
-                password: data.password,
+                username: data.auth_value
+                    .username,
+                password: data.auth_value
+                    .password,
             });
         }
-        else if (data.auth_type === EventingFunctionUrlAuthMethod.Digest) {
+        else if (data.auth_name === 'function_url_auth_digest') {
             authObj = new EventingFunctionUrlAuthDigest({
-                username: data.username,
-                password: data.password,
+                username: data.auth_value.username,
+                password: data.auth_value.password,
             });
         }
-        else if (data.auth_type === EventingFunctionUrlAuthMethod.Bearer) {
+        else if (data.auth_name === 'function_url_auth_bearer') {
             authObj = new EventingFunctionUrlAuthBearer({
-                key: data.bearer_key,
+                key: data.auth_value
+                    .key,
             });
         }
         else {
-            throw new Error('invalid auth type specified');
+            throw new errs.InvalidArgumentError(new Error('Unrecognized EventingFunctionUrlBinding: ' + data.auth_name));
         }
         return {
             hostname: data.hostname,
-            alias: data.value,
+            alias: data.alias,
             allowCookies: data.allow_cookies,
             validateSslCertificate: data.validate_ssl_certificate,
             auth: authObj,
@@ -327,18 +360,43 @@ class EventingFunctionUrlBinding {
     /**
      * @internal
      */
-    static _toEvtData(data) {
+    static _toCppData(data) {
+        let authObj;
+        let auth_name;
+        if (!data.auth || data.auth.method === EventingFunctionUrlAuthMethod.None) {
+            authObj = {};
+            auth_name = 'function_url_no_auth';
+        }
+        else if (data.auth.method === EventingFunctionUrlAuthMethod.Basic) {
+            authObj = {
+                username: data.auth.username,
+                password: data.auth.password,
+            };
+            auth_name = 'function_url_auth_basic';
+        }
+        else if (data.auth.method === EventingFunctionUrlAuthMethod.Digest) {
+            authObj = {
+                username: data.auth.username,
+                password: data.auth.password,
+            };
+            auth_name = 'function_url_auth_digest';
+        }
+        else if (data.auth.method === EventingFunctionUrlAuthMethod.Bearer) {
+            authObj = {
+                key: data.auth.key,
+            };
+            auth_name = 'function_url_auth_bearer';
+        }
+        else {
+            throw new errs.InvalidArgumentError(new Error('Unrecognized EventingFunctionUrlBinding'));
+        }
         return {
+            alias: data.alias,
             hostname: data.hostname,
-            value: data.alias,
             allow_cookies: data.allowCookies,
             validate_ssl_certificate: data.validateSslCertificate,
-            auth_type: data.auth
-                ? data.auth.method
-                : EventingFunctionUrlAuthMethod.None,
-            username: data.username,
-            password: data.password,
-            bearer_key: data.key,
+            auth_name: auth_name,
+            auth_value: authObj,
         };
     }
 }
@@ -356,18 +414,18 @@ class EventingFunctionConstantBinding {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingFunctionConstantBinding({
-            alias: data.value,
+            alias: data.alias,
             literal: data.literal,
         });
     }
     /**
      * @internal
      */
-    static _toEvtData(data) {
+    static _toCppData(data) {
         return {
-            value: data.alias,
+            alias: data.alias,
             literal: data.literal,
         };
     }
@@ -414,18 +472,20 @@ class EventingFunctionSettings {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingFunctionSettings({
-            cppWorkerThreadCount: data.cpp_worker_thread_count,
-            dcpStreamBoundary: data.dcp_stream_boundary,
+            cppWorkerThreadCount: data.cpp_worker_count,
+            dcpStreamBoundary: (0, bindingutilities_1.eventingFunctionDcpBoundaryFromCpp)(data.dcp_stream_boundary),
             description: data.description,
-            logLevel: data.log_level,
-            languageCompatibility: data.language_compatibility,
+            deploymentStatus: (0, bindingutilities_1.eventingFunctionDeploymentStatusFromCpp)(data.deployment_status),
+            processingStatus: (0, bindingutilities_1.eventingFunctionProcessingStatusFromCpp)(data.processing_status),
+            logLevel: (0, bindingutilities_1.eventingFunctionLogLevelFromCpp)(data.log_level),
+            languageCompatibility: (0, bindingutilities_1.eventingFunctionLanguageCompatibilityFromCpp)(data.language_compatibility),
             executionTimeout: data.execution_timeout,
             lcbInstCapacity: data.lcb_inst_capacity,
             lcbRetryCount: data.lcb_retry_count,
             lcbTimeout: data.lcb_timeout,
-            queryConsistency: data.n1ql_consistency,
+            queryConsistency: (0, bindingutilities_1.queryScanConsistencyFromCpp)(data.query_consistency),
             numTimerPartitions: data.num_timer_partitions,
             sockBatchSize: data.sock_batch_size,
             tickDuration: data.tick_duration,
@@ -434,43 +494,41 @@ class EventingFunctionSettings {
             bucketCacheSize: data.bucket_cache_size,
             bucketCacheAge: data.bucket_cache_age,
             curlMaxAllowedRespSize: data.curl_max_allowed_resp_size,
+            queryPrepareAll: data.query_prepare_all,
             workerCount: data.worker_count,
-            queryPrepareAll: data.n1ql_prepare_all,
             handlerHeaders: data.handler_headers,
             handlerFooters: data.handler_footers,
-            enableAppLogRotation: data.enable_applog_rotation,
+            enableAppLogRotation: data.enable_app_log_rotation,
             appLogDir: data.app_log_dir,
             appLogMaxSize: data.app_log_max_size,
             appLogMaxFiles: data.app_log_max_files,
             checkpointInterval: data.checkpoint_interval,
-            deploymentStatus: data.deployment_status
-                ? EventingFunctionDeploymentStatus.Deployed
-                : EventingFunctionDeploymentStatus.Undeployed,
-            processingStatus: data.processing_status
-                ? EventingFunctionProcessingStatus.Running
-                : EventingFunctionProcessingStatus.Paused,
         });
     }
     /**
      * @internal
      */
-    static _toEvtData(data) {
+    static _toCppData(data) {
+        var _a, _b;
         if (!data) {
             return {
-                deployment_status: false,
+                handler_headers: [],
+                handler_footers: [],
             };
         }
         return {
-            cpp_worker_thread_count: data.cppWorkerThreadCount,
-            dcp_stream_boundary: data.dcpStreamBoundary,
+            cpp_worker_count: data.cppWorkerThreadCount,
+            dcp_stream_boundary: (0, bindingutilities_1.eventingFunctionDcpBoundaryToCpp)(data.dcpStreamBoundary),
             description: data.description,
-            log_level: data.logLevel,
-            language_compatibility: data.languageCompatibility,
+            deployment_status: (0, bindingutilities_1.eventingFunctionDeploymentStatusToCpp)(data.deploymentStatus),
+            processing_status: (0, bindingutilities_1.eventingFunctionProcessingStatusToCpp)(data.processingStatus),
+            log_level: (0, bindingutilities_1.eventingFunctionLogLevelToCpp)(data.logLevel),
+            language_compatibility: (0, bindingutilities_1.eventingFunctionLanguageCompatibilityToCpp)(data.languageCompatibility),
             execution_timeout: data.executionTimeout,
             lcb_inst_capacity: data.lcbInstCapacity,
             lcb_retry_count: data.lcbRetryCount,
             lcb_timeout: data.lcbTimeout,
-            n1ql_consistency: data.queryConsistency,
+            query_consistency: (0, bindingutilities_1.queryScanConsistencyToCpp)(data.queryConsistency),
             num_timer_partitions: data.numTimerPartitions,
             sock_batch_size: data.sockBatchSize,
             tick_duration: data.tickDuration,
@@ -479,21 +537,15 @@ class EventingFunctionSettings {
             bucket_cache_size: data.bucketCacheSize,
             bucket_cache_age: data.bucketCacheAge,
             curl_max_allowed_resp_size: data.curlMaxAllowedRespSize,
+            query_prepare_all: data.queryPrepareAll,
             worker_count: data.workerCount,
-            n1ql_prepare_all: data.queryPrepareAll,
-            handler_headers: data.handlerHeaders,
-            handler_footers: data.handlerFooters,
-            enable_applog_rotation: data.enableAppLogRotation,
+            handler_headers: (_a = data.handlerHeaders) !== null && _a !== void 0 ? _a : [],
+            handler_footers: (_b = data.handlerFooters) !== null && _b !== void 0 ? _b : [],
+            enable_app_log_rotation: data.enableAppLogRotation,
             app_log_dir: data.appLogDir,
             app_log_max_size: data.appLogMaxSize,
             app_log_max_files: data.appLogMaxFiles,
             checkpoint_interval: data.checkpointInterval,
-            deployment_status: data.deploymentStatus === EventingFunctionDeploymentStatus.Deployed
-                ? true
-                : false,
-            processing_status: data.processingStatus === EventingFunctionProcessingStatus.Running
-                ? true
-                : false,
         };
     }
 }
@@ -521,53 +573,55 @@ class EventingFunction {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingFunction({
-            name: data.appname,
-            code: data.appcode,
-            settings: EventingFunctionSettings._fromEvtData(data.settings),
-            version: data.version,
-            enforceSchema: data.enforce_schema,
-            handlerUuid: data.handleruuid,
-            functionInstanceId: data.function_instance_id,
+            name: data.name,
+            code: data.code,
             metadataKeyspace: new EventingFunctionKeyspace({
-                bucket: data.depcfg.metadata_bucket,
-                scope: data.depcfg.metadata_scope,
-                collection: data.depcfg.metadata_collection,
+                bucket: data.metadata_keyspace.bucket,
+                scope: data.metadata_keyspace.scope,
+                collection: data.metadata_keyspace.collection,
             }),
             sourceKeyspace: new EventingFunctionKeyspace({
-                bucket: data.depcfg.source_bucket,
-                scope: data.depcfg.source_scope,
-                collection: data.depcfg.source_collection,
+                bucket: data.source_keyspace.bucket,
+                scope: data.source_keyspace.scope,
+                collection: data.source_keyspace.collection,
             }),
-            constantBindings: data.depcfg.constants.map((bindingData) => EventingFunctionConstantBinding._fromEvtData(bindingData)),
-            bucketBindings: data.depcfg.buckets.map((bindingData) => EventingFunctionBucketBinding._fromEvtData(bindingData)),
-            urlBindings: data.depcfg.curl.map((bindingData) => EventingFunctionUrlBinding._fromEvtData(bindingData)),
+            version: data.version,
+            enforceSchema: data.enforce_schema,
+            handlerUuid: data.handler_uuid,
+            functionInstanceId: data.function_instance_id,
+            bucketBindings: data.bucket_bindings.map((bindingData) => EventingFunctionBucketBinding._fromCppData(bindingData)),
+            urlBindings: data.url_bindings.map((bindingData) => EventingFunctionUrlBinding._fromCppData(bindingData)),
+            constantBindings: data.constant_bindings.map((bindingData) => EventingFunctionConstantBinding._fromCppData(bindingData)),
+            settings: EventingFunctionSettings._fromCppData(data.settings),
         });
     }
     /**
      * @internal
      */
-    static _toEvtData(data) {
+    static _toCppData(data) {
         return {
-            appname: data.name,
-            appcode: data.code,
-            settings: EventingFunctionSettings._toEvtData(data.settings),
+            name: data.name,
+            code: data.code,
+            metadata_keyspace: {
+                bucket: data.metadataKeyspace.bucket,
+                scope: data.metadataKeyspace.scope,
+                collection: data.metadataKeyspace.collection,
+            },
+            source_keyspace: {
+                bucket: data.sourceKeyspace.bucket,
+                scope: data.sourceKeyspace.scope,
+                collection: data.sourceKeyspace.collection,
+            },
             version: data.version,
             enforce_schema: data.enforceSchema,
-            handleruuid: data.handlerUuid,
+            handler_uuid: data.handlerUuid,
             function_instance_id: data.functionInstanceId,
-            depcfg: {
-                metadata_bucket: data.metadataKeyspace.bucket,
-                metadata_scope: data.metadataKeyspace.scope,
-                metadata_collection: data.metadataKeyspace.collection,
-                source_bucket: data.sourceKeyspace.bucket,
-                source_scope: data.sourceKeyspace.scope,
-                source_collection: data.sourceKeyspace.collection,
-                constants: data.constantBindings.map((binding) => EventingFunctionConstantBinding._toEvtData(binding)),
-                buckets: data.bucketBindings.map((binding) => EventingFunctionBucketBinding._toEvtData(binding)),
-                curl: data.urlBindings.map((binding) => EventingFunctionUrlBinding._toEvtData(binding)),
-            },
+            bucket_bindings: data.bucketBindings.map((binding) => EventingFunctionBucketBinding._toCppData(binding)),
+            url_bindings: data.urlBindings.map((binding) => EventingFunctionUrlBinding._toCppData(binding)),
+            constant_bindings: data.constantBindings.map((binding) => EventingFunctionConstantBinding._toCppData(binding)),
+            settings: EventingFunctionSettings._toCppData(data.settings),
         };
     }
 }
@@ -589,18 +643,15 @@ class EventingFunctionState {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingFunctionState({
             name: data.name,
-            status: data.composite_status,
+            status: (0, bindingutilities_1.eventingFunctionStatusFromCpp)(data.status),
             numBootstrappingNodes: data.num_bootstrapping_nodes,
             numDeployedNodes: data.num_deployed_nodes,
-            deploymentStatus: data.deployment_status
-                ? EventingFunctionDeploymentStatus.Deployed
-                : EventingFunctionDeploymentStatus.Undeployed,
-            processingStatus: data.processing_status
-                ? EventingFunctionProcessingStatus.Running
-                : EventingFunctionProcessingStatus.Paused,
+            // deploymentStatus & processingStatus are required in the EventingFunctionState, and always set in the c++ interface, so asserting the type here.
+            deploymentStatus: (0, bindingutilities_1.eventingFunctionDeploymentStatusFromCpp)(data.deployment_status),
+            processingStatus: (0, bindingutilities_1.eventingFunctionProcessingStatusFromCpp)(data.processing_status),
         });
     }
 }
@@ -618,10 +669,10 @@ class EventingState {
     /**
      * @internal
      */
-    static _fromEvtData(data) {
+    static _fromCppData(data) {
         return new EventingState({
             numEventingNodes: data.num_eventing_nodes,
-            functions: data.apps.map((functionData) => EventingFunctionState._fromEvtData(functionData)),
+            functions: data.functions.map((functionData) => EventingFunctionState._fromCppData(functionData)),
         });
     }
 }
@@ -629,7 +680,7 @@ exports.EventingState = EventingState;
 /**
  * EventingFunctionManager provides an interface for managing the
  * eventing functions on the cluster.
- * Volatile: This API is subject to change at any time.
+ * Uncommitted: This API is subject to change in the future.
  *
  * @category Management
  */
@@ -640,9 +691,6 @@ class EventingFunctionManager {
     constructor(cluster) {
         this._cluster = cluster;
     }
-    get _http() {
-        return new httpexecutor_1.HttpExecutor(this._cluster.conn);
-    }
     /**
      * Creates or updates an eventing function.
      *
@@ -658,32 +706,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = functionDefinition.name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const encodedData = EventingFunction._toEvtData(functionDefinition);
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/v1/functions/${functionName}`,
-                contentType: 'application/json',
-                body: JSON.stringify(encodedData),
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingUpsertFunction({
+                function: EventingFunction._toCppData(functionDefinition),
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_collection_missing')) {
-                    throw new errors_1.CollectionNotFoundError(undefined, errCtx);
-                }
-                if (errText.includes('err_src_mb_same')) {
-                    throw new errors_1.EventingFunctionIdenticalKeyspaceError(undefined, errCtx);
-                }
-                if (errText.includes('err_handler_compilation')) {
-                    throw new errors_1.EventingFunctionCompilationFailureError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to upsert function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -701,29 +735,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Delete,
-                path: `/api/v1/functions/${functionName}`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingDropFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(undefined, errCtx);
-                }
-                if (errText.includes('err_app_not_deployed')) {
-                    throw new errors_1.EventingFunctionNotDeployedError(undefined, errCtx);
-                }
-                if (errText.includes('err_app_not_undeployed')) {
-                    throw new errors_1.EventingFunctionDeployedError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to drop function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -741,20 +764,17 @@ class EventingFunctionManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/v1/functions`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingGetAllFunctions({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const functions = resp.functions.map((functionData) => EventingFunction._fromCppData(functionData));
+                wrapCallback(null, functions);
             });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                throw new errors_1.CouchbaseError('failed to get functions', undefined, errCtx);
-            }
-            const functionsData = JSON.parse(res.body.toString());
-            const functions = functionsData.map((functionData) => EventingFunction._fromEvtData(functionData));
-            return functions;
         }, callback);
     }
     /**
@@ -772,25 +792,19 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/v1/functions/${functionName}`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingGetFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(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 function', undefined, errCtx);
-            }
-            const functionData = JSON.parse(res.body.toString());
-            return EventingFunction._fromEvtData(functionData);
+                const eventingFunction = EventingFunction._fromCppData(resp.function);
+                wrapCallback(null, eventingFunction);
+            });
         }, callback);
     }
     /**
@@ -808,26 +822,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/v1/functions/${functionName}/deploy`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingDeployFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                if (errText.includes('err_app_not_bootstrapped')) {
-                    throw new errors_1.EventingFunctionNotBootstrappedError(undefined, errCtx);
-                }
-                throw new errors_1.CouchbaseError('failed to deploy function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -845,26 +851,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/v1/functions/${functionName}/undeploy`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingUndeployFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(undefined, errCtx);
-                }
-                if (errText.includes('err_app_not_deployed')) {
-                    throw new errors_1.EventingFunctionNotDeployedError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to undeploy function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -882,26 +880,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/v1/functions/${functionName}/pause`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingPauseFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(undefined, errCtx);
-                }
-                if (errText.includes('err_app_not_bootstrapped')) {
-                    throw new errors_1.EventingFunctionNotBootstrappedError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                throw new errors_1.CouchbaseError('failed to pause function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -919,26 +909,18 @@ class EventingFunctionManager {
         if (!options) {
             options = {};
         }
-        const functionName = name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Post,
-                path: `/api/v1/functions/${functionName}/resume`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingResumeFunction({
+                name: name,
                 timeout: timeout,
-            });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                const errText = res.body.toString().toLowerCase();
-                if (errText.includes('err_app_not_found_ts')) {
-                    throw new errors_1.EventingFunctionNotFoundError(undefined, errCtx);
+            }, (cppErr) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
                 }
-                if (errText.includes('err_app_not_deployed')) {
-                    throw new errors_1.EventingFunctionNotDeployedError(undefined, errCtx);
-                }
-                throw new errors_1.CouchbaseError('failed to resume function', undefined, errCtx);
-            }
+                wrapCallback(err);
+            });
         }, callback);
     }
     /**
@@ -956,19 +938,17 @@ class EventingFunctionManager {
             options = {};
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
-        return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const res = await this._http.request({
-                type: httpexecutor_1.HttpServiceType.Eventing,
-                method: httpexecutor_1.HttpMethod.Get,
-                path: `/api/v1/status`,
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._cluster.conn.managementEventingGetStatus({
                 timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                const state = EventingState._fromCppData(resp.status);
+                wrapCallback(null, state);
             });
-            if (res.statusCode !== 200) {
-                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                throw new errors_1.CouchbaseError('failed to fetch functions status', undefined, errCtx);
-            }
-            const statusData = JSON.parse(res.body.toString());
-            return EventingState._fromEvtData(statusData);
         }, callback);
     }
 }