couchset 0.2.7 → 0.4.0

package/docs/beta-migration.md

@@ -0,0 +1,175 @@
+# CouchSet Beta Migration
+
+The beta release keeps the main `couchset` import on the legacy implementation so existing projects can upgrade safely. The modern implementation is available from `couchset/next`.
+
+```ts
+import {Model as LegacyModel} from 'couchset';
+import {Model as NextModel} from 'couchset/next';
+
+const legacyUsers = new LegacyModel('User');
+const nextUsers = new NextModel('User');
+```
+
+Use `couchset` when an application depends on old pagination or custom query behavior. New work should use `couchset/next`.
+
+Modern and legacy models share the same connection singleton. Initialize CouchSet once and use both model APIs side by side while migrating.
+
+```ts
+import {couchset, Model} from 'couchset';
+import {Model as NextModel} from 'couchset/next';
+
+await couchset(args);
+
+const legacyUsers = new Model('User');
+const nextUsers = new NextModel('User');
+```
+
+## Connection Lifecycle
+
+Models can be constructed before the Couchbase connection is ready. Model methods wait for the shared connection before touching the bucket or collection.
+
+```ts
+import {couchset, Model, ready, health, ping, shutdown} from 'couchset/next';
+
+const users = new Model('User');
+
+await couchset({
+    connectionString: process.env.COUCHBASE_URL || 'couchbase://localhost',
+    username: process.env.COUCHBASE_USERNAME || 'admin',
+    password: process.env.COUCHBASE_PASSWORD || '1234',
+    bucketName: process.env.COUCHBASE_BUCKET || 'dev',
+});
+
+await ready();
+await ping();
+console.log(health());
+
+await couchset.ready();
+
+const user = await users.insert({userId: 'ceddy'});
+
+await shutdown();
+```
+
+Reconnect is enabled by default. It can be controlled with connection args or environment variables.
+
+```ts
+await couchset({
+    connectionString: 'couchbase://localhost',
+    username: 'admin',
+    password: '1234',
+    bucketName: 'dev',
+    autoReconnect: true,
+    reconnectIntervalMs: 5000,
+});
+```
+
+Environment flags:
+
+- `COUCHSET_RECONNECT`: defaults to enabled. Use `false`, `0`, or `no` to disable.
+- `COUCHSET_RECONNECT_INTERVAL_MS`: reconnect and health-check interval in milliseconds. Defaults to `5000`.
+
+`couchset/next` also exports env-based starter helpers:
+
+```ts
+import {startCouchbase, startCouchbaseServerless} from 'couchset/next';
+
+await startCouchbase();
+await startCouchbaseServerless();
+```
+
+The starters read `COUCHBASE_URL`, `COUCHBASE_BUCKET`, `COUCHBASE_USERNAME`, `COUCHBASE_PASSWORD`, and `COUCHBASE_PROXY`, and accept `CouchsetArgs` overrides.
+
+## Query Behavior
+
+Modern query helpers throw by default. This makes production failures visible and keeps silent fallbacks explicit.
+
+```ts
+const rows = await users.findMany({
+    where: {userId: {$eq: 'ceddy'}},
+});
+
+const page = await users.page({
+    where: {userId: {$eq: 'ceddy'}},
+    limit: 25,
+    page: 0,
+});
+
+const customRows = await users.queryRows(
+    `SELECT * FROM ${users.bucket()} WHERE userId=$userId LIMIT $limit`,
+    {userId: 'ceddy', limit: 25}
+);
+```
+
+If a caller intentionally wants the old empty-result fallback, pass `throwOnError: false`.
+
+```ts
+const rows = await users.findMany({
+    where: {userId: {$eq: 'ceddy'}},
+    limit: 25,
+    page: 0,
+    throwOnError: false,
+});
+```
+
+## Safer SQL++ Helpers
+
+Use the model keyspace helpers instead of hardcoding bucket names.
+
+```ts
+users.bucket(); // `dev`
+users.from('u'); // `dev` AS u
+```
+
+For scoped collections, `from()` includes the full keyspace.
+
+```ts
+const audit = new Model('AuditEvent', {
+    scope: 'app',
+    collection: 'events',
+});
+
+audit.from('event'); // `dev`.`app`.`events` AS event
+```
+
+## New Model APIs
+
+The modern path includes safer read, write, document, TTL, include, index, and time series helpers.
+
+```ts
+await users.insert({id: 'user::1', userId: 'ceddy'});
+await users.patchById('user::1', {$set: {email: 'ceddy@example.com'}});
+await users.softDeleteById('user::1');
+await users.restoreById('user::1');
+
+const exists = await users.exists({where: {userId: {$eq: 'ceddy'}}});
+const count = await users.count({where: {userId: {$eq: 'ceddy'}}});
+```
+
+## Removed Modern Model Aliases
+
+The old method names belong to the default `couchset` entrypoint and the explicit `couchset/legacy` alias.
+
+| Old method | Modern method |
+| --- | --- |
+| `create()` | `insert()` or `upsert()` |
+| `findById()` | `getById()` |
+| `updateById()` / `save()` | `replaceById()` or `patchById()` |
+| `delete()` | `deleteById()` |
+| `pagination()` | `findMany()` or `page()` |
+| `customQuery()` | `queryRows()`, `queryOne()`, or `queryPage()` |
+
+Index declarations can live on the model and be created at app boot.
+
+```ts
+const users = new Model('User', {
+    indexes: [
+        {
+            name: 'idx_user_userId',
+            fields: ['userId'],
+        },
+    ],
+});
+
+await couchset.ensureIndexes();
+```

package/docs/document-modeling.md

@@ -0,0 +1,133 @@
+# Document Modeling
+
+CouchSet keeps document modeling explicit. Large application objects should not
+be the documents that list pages paginate over. Use one model for lightweight
+list and routing metadata, then keep the full payload in a separate document
+that is fetched by id when a detail view, offline view, export, or worker needs
+the whole object.
+
+## Large Documents
+
+Prefer this read shape:
+
+- Fetch large documents by id with `getById()` or `findDocById()`.
+- Page smaller metadata documents with `page()` or `findMany()`.
+- Denormalize the fields needed for cards, tables, filters, sort order, auth,
+  and cleanup onto the paged metadata document.
+- Store the heavy nested state, snapshots, logs, source data, or arrays in a
+  companion model.
+- Join or fetch the companion document only after the caller has selected the
+  specific item that needs it.
+
+This keeps list queries fast and predictable. A list page should not read a
+large payload only to render a title, status, timestamp, and a few counters.
+
+## Example
+
+```ts
+import {Model} from 'couchset/next';
+
+type ReportSummary = {
+    id: string;
+    tenantId: string;
+    payloadId: string;
+    title: string;
+    status: 'draft' | 'running' | 'complete';
+    updatedAt: Date;
+    itemCount: number;
+    errorCount: number;
+};
+
+type ReportPayload = {
+    id: string;
+    reportId: string;
+    tenantId: string;
+    sourceRows: unknown[];
+    generatedSections: unknown[];
+    auditLog: unknown[];
+};
+
+const reports = new Model('Report', {
+    indexes: [
+        {
+            name: 'idx_report_tenant_updated',
+            fields: ['tenantId', 'updatedAt'],
+        },
+    ],
+});
+
+const reportPayloads = new Model('ReportPayload');
+```
+
+Page the lightweight model:
+
+```ts
+const page = await reports.page<ReportSummary>({
+    select: [
+        'id',
+        'tenantId',
+        'payloadId',
+        'title',
+        'status',
+        'updatedAt',
+        'itemCount',
+        'errorCount',
+    ],
+    where: {tenantId: {$eq: tenantId}},
+    orderBy: {updatedAt: 'DESC'},
+    limit: 25,
+});
+```
+
+Fetch the heavy document by id only when needed:
+
+```ts
+const summary = await reports.getById<ReportSummary>(reportId);
+const payload = await reportPayloads.getById<ReportPayload>(summary.payloadId);
+```
+
+Use stable id formulas so the relationship is obvious and easy to backfill:
+
+```ts
+const reportId = 'report::123';
+const payloadId = `report-payload::${reportId}`;
+```
+
+## Joining
+
+CouchSet includes can join related documents by key, but large payload joins
+should be reserved for focused detail reads or small result sets.
+
+```ts
+const report = await reports.findOne<ReportSummary & {payload: ReportPayload}>({
+    where: {id: {$eq: reportId}},
+    include: [
+        {
+            as: 'payload',
+            key: 'payloadId',
+            model: reportPayloads,
+            optional: true,
+        },
+    ],
+});
+```
+
+For list pages, keep the companion model out of the query and rely on summary
+fields instead.
+
+## Migrations
+
+When splitting an existing large document:
+
+- Add the summary fields to the lightweight model first.
+- Backfill companion payload documents with deterministic ids.
+- Keep ownership fields such as `tenantId`, `workspaceId`, or `userId` on both
+  documents when they are needed for authorization or cleanup.
+- Keep lifecycle fields such as `createdAt`, `updatedAt`, `deleted`, and
+  `deletedAt` on both documents if each document can be cleaned up separately.
+- Switch list reads to the lightweight model before removing legacy heavy
+  fields from the list path.
+
+The split is a read-model decision, not a CouchSet requirement. Keep a single
+document when callers normally need the whole object and the document remains
+small enough for the expected list and query volume.

package/docs/next-primitives.md

@@ -0,0 +1,81 @@
+# CouchSet next primitives
+
+`couchset/next` adds a client-owned API without changing the singleton-based `Model` and `couchset` APIs. The new client is useful when an application needs dependency injection, isolated tests, model manifests, or an administrative bootstrap connection.
+
+```ts
+import {createCouchsetClient, dateCodec, defineModel} from 'couchset/next';
+
+const sessions = defineModel<{id: string; userId: string; expiresAt: Date}>({
+  name: 'Session',
+  scope: 'auth',
+  collection: 'sessions',
+  codecs: {expiresAt: dateCodec},
+  indexes: [{name: 'idx_session_user', fields: ['userId']}],
+});
+
+const db = createCouchsetClient({
+  connectionString: process.env.COUCHBASE_URL,
+  bucketName: 'app',
+  username: process.env.COUCHBASE_USERNAME,
+  password: process.env.COUCHBASE_PASSWORD,
+  models: [sessions],
+});
+```
+
+`defineModel()` only describes metadata; `db.model(sessions)` only binds and registers the model. Neither operation creates Couchbase resources. Legacy `new Model()` remains supported and continues to use the existing singleton.
+
+## Provisioning and dynamic models
+
+Run administrative DDL explicitly, with credentials that have `Manage Scopes` and query-index permissions:
+
+```ts
+await db.ensureCollections(); // creates missing named scopes, then collections
+await db.ensureIndexes();     // CREATE INDEX IF NOT EXISTS only
+
+// An explicitly dynamic model can provision itself.
+const reports = await db.registerModel(reportDefinition, {
+  provision: {collections: true, indexes: true, waitForIndexes: true},
+});
+```
+
+Collection creation is idempotent: concurrent already-exists responses are accepted, while existing scopes and collections are never updated, renamed, or dropped. The built-in `_default` scope and collection are not created. A named collection in `_default` is supported. Conflicting collection settings declared for the same target fail instead of silently choosing one.
+
+## Transactions and CAS
+
+```ts
+await db.transaction(async (tx) => {
+  const session = tx.model(sessions);
+  const found = await session.getById(id);
+  if (found) await session.remove(found);
+});
+```
+
+Transaction-bound models use only the SDK transaction attempt context. Couchbase may retry the callback, so it must not send an email, webhook, or other non-idempotent external side effect. Perform that work after the transaction resolves, or use an outbox/idempotency key. Commit-ambiguous errors are surfaced to the caller; CouchSet does not claim success or rerun external work.
+
+For an optimistic single-document workflow:
+
+```ts
+const current = await model.getWithCas(id);
+await model.replaceIfCas(id, nextValue, current.cas);
+
+const outcome = await model.consumeOnce(id, current.cas);
+// {status: 'consumed'} | {status: 'missing'} | {status: 'conflict'}
+```
+
+`consumeOnce` issues exactly one conditional remove. It does not re-read and retry with a fresh CAS.
+
+## Index drift
+
+`ensureIndexes()` remains intentionally create-only. It never compares, changes, drops, or rebuilds an existing index. Operators can instead review a plan:
+
+```ts
+const plan = await db.planIndexes();
+await db.applyIndexPlan(plan); // create missing/versioned replacement indexes and wait for online
+await db.applyIndexPlan(plan, {dropReplaced: true}); // explicit old-index removal after review
+```
+
+When a live definition drifts, the plan creates a versioned physical replacement and waits for it to become online before an old index can be dropped. This avoids an unindexed interval and makes destructive cleanup an affirmative operator action.
+
+## Tests
+
+`createCouchsetTestFixture(client, definition)` provisions a unique named scope/collection and returns an explicit `cleanup()` helper. Use it in test setup/teardown; fixture cleanup is the only helper that drops a resource.

package/legacy/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/legacy');

package/legacy/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "../dist/legacy/index.js",
+    "types": "../dist/legacy/index.d.ts"
+}

package/next/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist');

package/next/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "../dist/index.js",
+    "types": "../dist/index.d.ts"
+}

package/package.json

@@ -1,22 +1,26 @@
 {
     "name": "couchset",
-    "version": "0.2.7",
+    "version": "0.4.0",
     "description": "Couchbase ORM",
     "private": false,
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "main": "dist/legacy/index.js",
+    "types": "dist/legacy/index.d.ts",
     "files": [
+        "CHANGELOG.md",
         "docs/",
         "dist/",
+        "legacy/",
+        "next/",
         "register/",
         "LICENSE"
     ],
     "scripts": {
         "lint": "tslint \"src/**/*.ts\" --project tsconfig.json",
         "build": "rimraf dist && ./node_modules/.bin/tsc --skipLibCheck",
-        "test": "mocha src/index.test.ts --exit",
+        "test": "npm run test:unit && npm run test:integration",
+        "test:unit": "mocha \"src/**/*.test.ts\" --ignore src/index.test.ts --ignore src/index.serverless.test.ts --exit",
+        "test:integration": "mocha src/index.test.ts --exit",
         "test:serverless": "mocha src/index.serverless.test.ts --exit",
-        "test:auto": "mocha src/automation.test.ts --exit",
         "prepublishOnly": "npm run build",
         "eslint": "eslint ./src --fix --ext=ts"
     },
@@ -65,7 +69,7 @@
         "@types/dotenv": "^6.1.1",
         "@types/express": "^4.17.13",
         "@types/lodash": "^4.17.10",
-        "@types/mocha": "^8.2.0",
+        "@types/mocha": "^10.0.10",
         "@types/node": "^10.0.3",
         "@types/source-map-support": "^0.4.0",
         "@types/uuid": "^8.3.0",
@@ -83,7 +87,7 @@
         "eslint-plugin-typescript": "^0.14.0",
         "husky": "^4.2.5",
         "lint-staged": "^10.1.7",
-        "mocha": "^9.2.0",
+        "mocha": "^12.0.0",
         "prettier": "^2.0.5",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^2.5.4",
@@ -94,10 +98,14 @@
         "typescript": "^5.6.3"
     },
     "dependencies": {
-        "couchbase": "^4.4.2",
+        "couchbase": "^4.7.0",
         "couchbase-serverless": "^0.0.4",
         "debug": "^4.3.1",
-        "lodash": "^4.17.21",
-        "uuid": "^8.3.2"
+        "lodash": "^4.18.1",
+        "uuid": "^14.0.0"
+    },
+    "overrides": {
+        "serialize-javascript": "^7.0.5",
+        "js-yaml": "^4.1.1"
     }
 }

package/dist/connection.d.ts

@@ -1,42 +0,0 @@
-import type { Collection, Cluster, Bucket } from 'couchbase';
-export interface CouchsetArgs {
-    connectionString: string;
-    bucketName: string;
-    username: string;
-    password: string;
-    proxy?: string;
-}
-/**
- * CouchbaseConnection class
- * Only one CouchbaseConnection can exist that's why it's a singleton
- */
-export declare class CouchbaseConnection implements CouchsetArgs {
-    private static _instance;
-    bucket: Bucket;
-    cluster: Cluster;
-    connectionString: string;
-    bucketName: string;
-    username: string;
-    password: string;
-    static get Instance(): CouchbaseConnection;
-    private constructor();
-    /**
-     * start
-     */
-    init: (args: CouchsetArgs) => Promise<CouchbaseConnection>;
-    /**
-     * start serverless start
-     */
-    initServerless: (args: CouchsetArgs) => CouchbaseConnection;
-    /**
-     * getCollection
-     */
-    getCollection: () => Collection;
-    getCluster: () => Cluster;
-    getBucket: () => string;
-    /**
-     * shutdown cluster
-     */
-    shutdown: () => Promise<void>;
-}
-export default CouchbaseConnection;

package/dist/connection.js

@@ -1,156 +0,0 @@
-"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;
-};
-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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CouchbaseConnection = void 0;
-var couchbase = __importStar(require("couchbase"));
-/**
- * CouchbaseConnection class
- * Only one CouchbaseConnection can exist that's why it's a singleton
- */
-var CouchbaseConnection = /** @class */ (function () {
-    function CouchbaseConnection() {
-        var _this = this;
-        this.bucket = null;
-        this.cluster = null;
-        // Args
-        this.connectionString = null;
-        this.bucketName = null;
-        this.username = null;
-        this.password = null;
-        /**
-         * start
-         */
-        this.init = function (args) { return __awaiter(_this, void 0, void 0, function () {
-            var connectionString, password, username, _a, bucketName, cluster;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        connectionString = args.connectionString, password = args.password, username = args.username, _a = args.bucketName, bucketName = _a === void 0 ? 'default' : _a;
-                        this.connectionString = connectionString;
-                        this.bucketName = bucketName;
-                        this.username = username;
-                        this.password = password;
-                        return [4 /*yield*/, couchbase.connect(connectionString, {
-                                username: username,
-                                password: password,
-                            })];
-                    case 1:
-                        cluster = _b.sent();
-                        this.cluster = cluster;
-                        this.bucket = this.cluster.bucket(bucketName);
-                        return [2 /*return*/, this];
-                }
-            });
-        }); };
-        /**
-         * start serverless start
-         */
-        this.initServerless = function (args) {
-            var connectionString = args.connectionString, password = args.password, username = args.username, _a = args.bucketName, bucketName = _a === void 0 ? 'default' : _a;
-            _this.connectionString = connectionString;
-            _this.bucketName = bucketName;
-            _this.username = username;
-            _this.password = password;
-            var connectionOpt = {
-                username: username,
-                password: password,
-            };
-            if (args.proxy) {
-                connectionOpt['proxy'] = args.proxy;
-            }
-            var cluster = new couchbase.Cluster(connectionString, connectionOpt);
-            _this.cluster = cluster;
-            _this.bucket = _this.cluster.bucket(bucketName);
-            return _this;
-        };
-        /**
-         * getCollection
-         */
-        this.getCollection = function () {
-            return _this.bucket.defaultCollection();
-        };
-        this.getCluster = function () {
-            return _this.cluster;
-        };
-        this.getBucket = function () {
-            return _this.bucketName;
-        };
-        /**
-         * shutdown cluster
-         */
-        this.shutdown = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cluster.close()];
-            });
-        }); };
-    }
-    Object.defineProperty(CouchbaseConnection, "Instance", {
-        get: function () {
-            return this._instance || (this._instance = new this());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return CouchbaseConnection;
-}());
-exports.CouchbaseConnection = CouchbaseConnection;
-exports.default = CouchbaseConnection;
-//# sourceMappingURL=connection.js.map

package/dist/connection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection.js","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"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","sourcesContent":["import type {Collection, Cluster, Bucket} from 'couchbase';\nimport * as couchbase from 'couchbase';\n\nexport interface CouchsetArgs {\n    connectionString: string;\n    bucketName: string;\n    username: string;\n    password: string;\n    proxy?: string;\n}\n\n/**\n * CouchbaseConnection class\n * Only one CouchbaseConnection can exist that's why it's a singleton\n */\nexport class CouchbaseConnection implements CouchsetArgs {\n    private static _instance: CouchbaseConnection;\n\n    bucket: Bucket = null;\n    cluster: Cluster = null;\n\n    // Args\n    connectionString: string = null;\n    bucketName: string = null;\n    username: string = null;\n    password: string = null;\n\n    public static get Instance(): CouchbaseConnection {\n        return this._instance || (this._instance = new this());\n    }\n\n    private constructor() {}\n\n    /**\n     * start\n     */\n    public init = async (args: CouchsetArgs): Promise<CouchbaseConnection> => {\n        const {connectionString, password, username, bucketName = 'default'} = args;\n\n        this.connectionString = connectionString;\n        this.bucketName = bucketName;\n        this.username = username;\n        this.password = password;\n\n        const cluster = await couchbase.connect(connectionString, {\n            username,\n            password,\n        });\n\n        this.cluster = cluster as any;\n        this.bucket = this.cluster.bucket(bucketName);\n\n        return this;\n    };\n\n    /**\n     * start serverless start\n     */\n    public initServerless = (args: CouchsetArgs): CouchbaseConnection => {\n        const {connectionString, password, username, bucketName = 'default'} = args;\n\n        this.connectionString = connectionString;\n        this.bucketName = bucketName;\n        this.username = username;\n        this.password = password;\n\n        const connectionOpt = {\n            username,\n            password,\n        };\n\n        if (args.proxy) {\n            connectionOpt['proxy'] = args.proxy;\n        }\n\n        const cluster = new couchbase.Cluster(connectionString, connectionOpt);\n\n        this.cluster = cluster as any;\n        this.bucket = this.cluster.bucket(bucketName);\n\n        return this;\n    };\n\n    /**\n     * getCollection\n     */\n    public getCollection = (): Collection => {\n        return this.bucket.defaultCollection();\n    };\n\n    public getCluster = (): Cluster => {\n        return this.cluster;\n    };\n\n    public getBucket = (): string => {\n        return this.bucketName;\n    };\n\n    /**\n     * shutdown cluster\n     */\n    public shutdown = async (): Promise<void> => {\n        return this.cluster.close();\n    };\n}\n\nexport default CouchbaseConnection;\n"]}