couchbase 3.2.0 → 3.2.4

package/dist/collectionmanager.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.CollectionManager = exports.ScopeSpec = exports.CollectionSpec = void 0;
 const errors_1 = require("./errors");
@@ -101,97 +92,93 @@ class CollectionManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    getAllScopes(options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[0];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const bucketName = this._bucket.name;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield this._http.request({
-                    type: httpexecutor_1.HttpServiceType.Management,
-                    method: httpexecutor_1.HttpMethod.Post,
-                    path: `/pools/default/buckets/${bucketName}/scopes`,
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                if (res.statusCode !== 200) {
-                    const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                    const errText = res.body.toString().toLowerCase();
-                    if (errText.includes('not allowed on this version of cluster') ||
-                        res.statusCode === 404) {
-                        throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
-                    }
-                    throw new errors_1.CouchbaseError('failed to get scopes', undefined, errCtx);
+    async getAllScopes(options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[0];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const bucketName = this._bucket.name;
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const res = await this._http.request({
+                type: httpexecutor_1.HttpServiceType.Management,
+                method: httpexecutor_1.HttpMethod.Get,
+                path: `/pools/default/buckets/${bucketName}/scopes`,
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            if (res.statusCode !== 200) {
+                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
+                const errText = res.body.toString().toLowerCase();
+                if (errText.includes('not allowed on this version of cluster') ||
+                    res.statusCode === 404) {
+                    throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
                 }
-                const scopesData = JSON.parse(res.body.toString());
-                const scopes = scopesData.map((scopeData) => ScopeSpec._fromNsData(scopeData));
-                return scopes;
-            }), callback);
-        });
+                throw new errors_1.CouchbaseError('failed to get scopes', undefined, errCtx);
+            }
+            const scopesData = JSON.parse(res.body.toString());
+            const scopes = scopesData.scopes.map((scopeData) => ScopeSpec._fromNsData(scopeData));
+            return scopes;
+        }, callback);
     }
     /**
      * @internal
      */
-    createCollection() {
-        return __awaiter(this, arguments, void 0, function* () {
-            let collectionSpec = arguments[0];
-            let options = arguments[1];
-            let callback = arguments[2];
-            // Deprecated usage conversion for (name, scopeName, options, callback)
-            if (typeof collectionSpec === 'string') {
-                collectionSpec = {
-                    name: arguments[0],
-                    scopeName: arguments[1],
-                };
-                options = arguments[2];
-                callback = arguments[3];
-            }
-            if (options instanceof Function) {
-                callback = arguments[2];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const bucketName = this._bucket.name;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const collectionData = CollectionSpec._toNsData(collectionSpec);
-                const res = yield this._http.request({
-                    type: httpexecutor_1.HttpServiceType.Management,
-                    method: httpexecutor_1.HttpMethod.Post,
-                    path: `/pools/default/buckets/${bucketName}/scopes/${collectionSpec.scopeName}/collections`,
-                    contentType: 'application/x-www-form-urlencoded',
-                    body: utilities_1.cbQsStringify(collectionData),
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                if (res.statusCode !== 200) {
-                    const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                    const errText = res.body.toString().toLowerCase();
-                    if (errText.includes('already exists') &&
-                        errText.includes('collection')) {
-                        throw new errors_1.CollectionExistsError(undefined, errCtx);
-                    }
-                    if (errText.includes('not found') && errText.includes('scope')) {
-                        throw new errors_1.ScopeNotFoundError(undefined, errCtx);
-                    }
-                    if (errText.includes('not allowed on this version of cluster') ||
-                        res.statusCode === 404) {
-                        throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
-                    }
-                    throw new errors_1.CouchbaseError('failed to create collection', undefined, errCtx);
+    async createCollection() {
+        let collectionSpec = arguments[0];
+        let options = arguments[1];
+        let callback = arguments[2];
+        // Deprecated usage conversion for (name, scopeName, options, callback)
+        if (typeof collectionSpec === 'string') {
+            collectionSpec = {
+                name: arguments[0],
+                scopeName: arguments[1],
+            };
+            options = arguments[2];
+            callback = arguments[3];
+        }
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const bucketName = this._bucket.name;
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const collectionData = CollectionSpec._toNsData(collectionSpec);
+            const res = await this._http.request({
+                type: httpexecutor_1.HttpServiceType.Management,
+                method: httpexecutor_1.HttpMethod.Post,
+                path: `/pools/default/buckets/${bucketName}/scopes/${collectionSpec.scopeName}/collections`,
+                contentType: 'application/x-www-form-urlencoded',
+                body: utilities_1.cbQsStringify(collectionData),
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            if (res.statusCode !== 200) {
+                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
+                const errText = res.body.toString().toLowerCase();
+                if (errText.includes('already exists') &&
+                    errText.includes('collection')) {
+                    throw new errors_1.CollectionExistsError(undefined, errCtx);
                 }
-            }), callback);
-        });
+                if (errText.includes('not found') && errText.includes('scope')) {
+                    throw new errors_1.ScopeNotFoundError(undefined, errCtx);
+                }
+                if (errText.includes('not allowed on this version of cluster') ||
+                    res.statusCode === 404) {
+                    throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
+                }
+                throw new errors_1.CouchbaseError('failed to create collection', undefined, errCtx);
+            }
+        }, callback);
     }
     /**
      * Drops a collection from a scope.
@@ -201,40 +188,41 @@ class CollectionManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    dropCollection(collectionName, scopeName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[2];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const bucketName = this._bucket.name;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield this._http.request({
-                    type: httpexecutor_1.HttpServiceType.Management,
-                    method: httpexecutor_1.HttpMethod.Delete,
-                    path: `/pools/default/buckets/${bucketName}/scopes/${scopeName}/collections/${collectionName}`,
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                if (res.statusCode !== 200) {
-                    const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                    const errText = res.body.toString().toLowerCase();
-                    if (errText.includes('not found') && errText.includes('collection')) {
-                        throw new errors_1.CollectionNotFoundError(undefined, errCtx);
-                    }
-                    if (errText.includes('not allowed on this version of cluster') ||
-                        res.statusCode === 404) {
-                        throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
-                    }
-                    throw new errors_1.CouchbaseError('failed to drop collection', undefined, errCtx);
+    async dropCollection(collectionName, scopeName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[2];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const bucketName = this._bucket.name;
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const res = await this._http.request({
+                type: httpexecutor_1.HttpServiceType.Management,
+                method: httpexecutor_1.HttpMethod.Delete,
+                path: `/pools/default/buckets/${bucketName}/scopes/${scopeName}/collections/${collectionName}`,
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            if (res.statusCode !== 200) {
+                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
+                const errText = res.body.toString().toLowerCase();
+                if (errText.includes('not found') && errText.includes('collection')) {
+                    throw new errors_1.CollectionNotFoundError(undefined, errCtx);
                 }
-            }), callback);
-        });
+                if (errText.includes('not found') && errText.includes('scope')) {
+                    throw new errors_1.ScopeNotFoundError(undefined, errCtx);
+                }
+                if (errText.includes('not allowed on this version of cluster') ||
+                    res.statusCode === 404) {
+                    throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
+                }
+                throw new errors_1.CouchbaseError('failed to drop collection', undefined, errCtx);
+            }
+        }, callback);
     }
     /**
      * Creates a new scope.
@@ -243,44 +231,42 @@ class CollectionManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    createScope(scopeName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[1];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const bucketName = this._bucket.name;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield this._http.request({
-                    type: httpexecutor_1.HttpServiceType.Management,
-                    method: httpexecutor_1.HttpMethod.Post,
-                    path: `/pools/default/buckets/${bucketName}/scopes`,
-                    contentType: 'application/x-www-form-urlencoded',
-                    body: utilities_1.cbQsStringify({
-                        name: scopeName,
-                    }),
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                if (res.statusCode !== 200) {
-                    const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                    const errText = res.body.toString().toLowerCase();
-                    if (errText.includes('already exists') && errText.includes('scope')) {
-                        throw new errors_1.ScopeExistsError(undefined, errCtx);
-                    }
-                    if (errText.includes('not allowed on this version of cluster') ||
-                        res.statusCode === 404) {
-                        throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
-                    }
-                    throw new errors_1.CouchbaseError('failed to create scope', undefined, errCtx);
+    async createScope(scopeName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const bucketName = this._bucket.name;
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const res = await this._http.request({
+                type: httpexecutor_1.HttpServiceType.Management,
+                method: httpexecutor_1.HttpMethod.Post,
+                path: `/pools/default/buckets/${bucketName}/scopes`,
+                contentType: 'application/x-www-form-urlencoded',
+                body: utilities_1.cbQsStringify({
+                    name: scopeName,
+                }),
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            if (res.statusCode !== 200) {
+                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
+                const errText = res.body.toString().toLowerCase();
+                if (errText.includes('already exists') && errText.includes('scope')) {
+                    throw new errors_1.ScopeExistsError(undefined, errCtx);
                 }
-            }), callback);
-        });
+                if (errText.includes('not allowed on this version of cluster') ||
+                    res.statusCode === 404) {
+                    throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
+                }
+                throw new errors_1.CouchbaseError('failed to create scope', undefined, errCtx);
+            }
+        }, callback);
     }
     /**
      * Drops a scope.
@@ -289,40 +275,38 @@ class CollectionManager {
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    dropScope(scopeName, options, callback) {
-        return __awaiter(this, arguments, void 0, function* () {
-            if (options instanceof Function) {
-                callback = arguments[2];
-                options = undefined;
-            }
-            if (!options) {
-                options = {};
-            }
-            const bucketName = this._bucket.name;
-            const parentSpan = options.parentSpan;
-            const timeout = options.timeout;
-            return utilities_1.PromiseHelper.wrapAsync(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield this._http.request({
-                    type: httpexecutor_1.HttpServiceType.Management,
-                    method: httpexecutor_1.HttpMethod.Delete,
-                    path: `/pools/default/buckets/${bucketName}/scopes/${scopeName}`,
-                    parentSpan: parentSpan,
-                    timeout: timeout,
-                });
-                if (res.statusCode !== 200) {
-                    const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
-                    const errText = res.body.toString().toLowerCase();
-                    if (errText.includes('not found') && errText.includes('scope')) {
-                        throw new errors_1.ScopeNotFoundError(undefined, errCtx);
-                    }
-                    if (errText.includes('not allowed on this version of cluster') ||
-                        res.statusCode === 404) {
-                        throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
-                    }
-                    throw new errors_1.CouchbaseError('failed to drop scope', undefined, errCtx);
+    async dropScope(scopeName, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[1];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const bucketName = this._bucket.name;
+        const parentSpan = options.parentSpan;
+        const timeout = options.timeout;
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const res = await this._http.request({
+                type: httpexecutor_1.HttpServiceType.Management,
+                method: httpexecutor_1.HttpMethod.Delete,
+                path: `/pools/default/buckets/${bucketName}/scopes/${scopeName}`,
+                parentSpan: parentSpan,
+                timeout: timeout,
+            });
+            if (res.statusCode !== 200) {
+                const errCtx = httpexecutor_1.HttpExecutor.errorContextFromResponse(res);
+                const errText = res.body.toString().toLowerCase();
+                if (errText.includes('not found') && errText.includes('scope')) {
+                    throw new errors_1.ScopeNotFoundError(undefined, errCtx);
                 }
-            }), callback);
-        });
+                if (errText.includes('not allowed on this version of cluster') ||
+                    res.statusCode === 404) {
+                    throw new errors_1.FeatureNotAvailableError(undefined, errCtx);
+                }
+                throw new errors_1.CouchbaseError('failed to drop scope', undefined, errCtx);
+            }
+        }, callback);
     }
 }
 exports.CollectionManager = CollectionManager;

package/dist/connection.d.ts

@@ -36,7 +36,8 @@ export declare class Connection {
     private _connected;
     private _opened;
     private _closed;
-    private _httpWaiters;
+    private _closedErr;
+    private _connectWaiters;
     constructor(options: ConnectionOptions);
     connect(callback: (err: Error | null) => void): void;
     selectBucket(bucketName: string, callback: (err: Error | null) => void): void;
@@ -58,6 +59,7 @@ export declare class Connection {
     httpRequest(...args: CppCbToNew<CppConnection['httpRequest']>): ReturnType<CppConnection['httpRequest']>;
     ping(...args: CppCbToNew<CppConnection['ping']>): ReturnType<CppConnection['ping']>;
     diag(...args: CppCbToNew<CppConnection['diag']>): ReturnType<CppConnection['diag']>;
+    private _proxyOnBootstrap;
     private _proxyToConn;
 }
 export {};

package/dist/connection.js

@@ -25,9 +25,10 @@ function getClientString() {
 class Connection {
     constructor(options) {
         this._closed = false;
+        this._closedErr = null;
         this._connected = false;
         this._opened = false;
-        this._httpWaiters = [];
+        this._connectWaiters = [];
         const lcbDsnObj = connspec_1.ConnSpec.parse(options.connStr);
         // This function converts a timeout value expressed in milliseconds into
         // a string for the connection string, represented in seconds.
@@ -49,6 +50,9 @@ class Connection {
         if (options.kvConnectTimeout) {
             lcbDsnObj.options.config_total_timeout = fmtTmt(options.kvConnectTimeout);
         }
+        else {
+            lcbDsnObj.options.config_total_timeout = '30s';
+        }
         if (options.kvTimeout) {
             lcbDsnObj.options.timeout = fmtTmt(options.kvTimeout);
         }
@@ -82,7 +86,8 @@ class Connection {
                     lcbDsnObj.options.tracing_threshold_queue_flush_interval = fmtTmt(tracerOpts.emitInterval);
                 }
                 if (tracerOpts.sampleSize) {
-                    lcbDsnObj.options.tracing_threshold_queue_size = tracerOpts.sampleSize.toString();
+                    lcbDsnObj.options.tracing_threshold_queue_size =
+                        tracerOpts.sampleSize.toString();
                 }
                 if (tracerOpts.kvThreshold) {
                     lcbDsnObj.options.tracing_threshold_kv = fmtTmt(tracerOpts.kvThreshold);
@@ -142,13 +147,16 @@ class Connection {
         this._inst.connect((err) => {
             if (err) {
                 this._closed = true;
-                callback(bindingutilities_1.translateCppError(err));
+                this._closedErr = bindingutilities_1.translateCppError(err);
+                callback(this._closedErr);
+                this._connectWaiters.forEach((waitFn) => waitFn());
+                this._connectWaiters = [];
                 return;
             }
             this._connected = true;
             callback(null);
-            this._httpWaiters.forEach((waitFn) => waitFn(err));
-            this._httpWaiters = [];
+            this._connectWaiters.forEach((waitFn) => waitFn());
+            this._connectWaiters = [];
         });
     }
     selectBucket(bucketName, callback) {
@@ -165,6 +173,7 @@ class Connection {
             return;
         }
         this._closed = true;
+        this._closedErr = new errors_1.ConnectionClosedError();
         this._inst.shutdown();
         callback(null);
     }
@@ -211,27 +220,29 @@ class Connection {
         return this._proxyToConn(this._inst, this._inst.searchQuery, ...args);
     }
     httpRequest(...args) {
-        if (this._connected) {
-            return this._proxyToConn(this._inst, this._inst.httpRequest, ...args);
-        }
-        else {
-            this._httpWaiters.push(() => {
-                return this._proxyToConn(this._inst, this._inst.httpRequest, ...args);
-            });
-        }
+        return this._proxyOnBootstrap(this._inst, this._inst.httpRequest, ...args);
     }
     ping(...args) {
-        return this._proxyToConn(this._inst, this._inst.ping, ...args);
+        return this._proxyOnBootstrap(this._inst, this._inst.ping, ...args);
     }
     diag(...args) {
         return this._proxyToConn(this._inst, this._inst.diag, ...args);
     }
+    _proxyOnBootstrap(thisArg, fn, ...newArgs) {
+        if (this._closed || this._connected) {
+            return this._proxyToConn(thisArg, fn, ...newArgs);
+        }
+        else {
+            this._connectWaiters.push(() => {
+                return this._proxyToConn(thisArg, fn, ...newArgs);
+            });
+        }
+    }
     _proxyToConn(thisArg, fn, ...newArgs) {
         const wrappedArgs = newArgs;
         const callback = wrappedArgs.pop();
         if (this._closed) {
-            const closeErr = new errors_1.ConnectionClosedError();
-            return callback(closeErr);
+            return callback(this._closedErr);
         }
         wrappedArgs.push((err, ...cbArgs) => {
             const translatedErr = bindingutilities_1.translateCppError(err);

package/dist/couchbase.d.ts

@@ -30,6 +30,7 @@ export * from './datastructures';
 export * from './diagnosticstypes';
 export * from './errorcontexts';
 export * from './errors';
+export * from './eventingfunctionmanager';
 export * from './generaltypes';
 export * from './logging';
 export * from './metrics';

package/dist/couchbase.js

@@ -9,15 +9,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,10 +26,8 @@ const cluster_1 = require("./cluster");
  *
  * @category Core
  */
-function connect(connStr, options, callback) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return cluster_1.Cluster.connect(connStr, options, callback);
-    });
+async function connect(connStr, options, callback) {
+    return cluster_1.Cluster.connect(connStr, options, callback);
 }
 exports.connect = connect;
 /**
@@ -60,6 +49,7 @@ __exportStar(require("./datastructures"), exports);
 __exportStar(require("./diagnosticstypes"), exports);
 __exportStar(require("./errorcontexts"), exports);
 __exportStar(require("./errors"), exports);
+__exportStar(require("./eventingfunctionmanager"), exports);
 __exportStar(require("./generaltypes"), exports);
 __exportStar(require("./logging"), exports);
 __exportStar(require("./metrics"), exports);