@samet-it/be-couchbase-common 1.0.1

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2025 Samet Global
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Web: https://sametglobal.com
+Responsible: Mustafa Yelmer (mustafay@samet.com.tr)

package/README.md

@@ -0,0 +1,90 @@
+# Samet IT : Couchbase Common
+`ts` `component` `backend`
+```
+                          __    __                                                                
+  _________  __  _______/ /_  / /_  ____ _________     _________  ____ ___  ____ ___  ____  ____ 
+ / ___/ __ \/ / / / ___/ __ \/ __ \/ __ `/ ___/ _ \   / ___/ __ \/ __ `__ \/ __ `__ \/ __ \/ __ \
+/ /__/ /_/ / /_/ / /__/ / / / /_/ / /_/ (__  /  __/  / /__/ /_/ / / / / / / / / / / / /_/ / / / /
+\___/\____/\__,_/\___/_/ /_/_.___/\__,_/____/\___/   \___/\____/_/ /_/ /_/_/ /_/ /_/\____/_/ /_/ 
+```
+<!-- https://patorjk.com/software/taag/#p=display&f=Slant&t=couchbase+common&x=none&v=4&h=3&w=80&we=false -->
+- `EN`: Use it for Couchbase connections
+- `TR`: Couchbase bağlantıları için bu bileşeni kullanınız
+
+## Prerequisite
+- [Help](https://github.com/samet-digital/help)
+- [1 - Install Git](https://github.com/samet-digital/help/blob/main//install-git.MD)
+- [2 - Build Up a Git Connection](https://github.com/samet-digital/help/blob/main//build-git-connection.MD)
+- [3 - Install Node/NPM](https://github.com/samet-digital/help/blob/main//install-npm.MD)
+- [4 - Create Project Folder](https://github.com/samet-digital/help/blob/main//create-project-folder.MD)
+- [5 - Bind Projects Folder to Git](https://github.com/samet-digital/help/blob/main//bind-project-folder.MD)
+
+## Usage
+- `EN`: How to add into your project?
+- `TR`: Projene nasıl eklersin?
+
+```shell
+npm i @samet-it/be-couchbase-common
+```
+
+## Environments
+- [couchbaseCommonConfig](./src/config/couchbase-common.config.ts) : config
+
+| Name                | Type    | Default | Required | Secret | Description                                 |
+|---------------------|---------|---------|----------|--------|---------------------------------------------|
+| `CB_HOST`           | string  |         | ✅        | ⭕      | DB Host or IP Address                       |
+| `CB_USER`           | string  |         | ✅        | ⭕      | DB User                                     |
+| `CB_PASS`           | string  |         | ✅        | ⭕      | DB Password                                 |
+| `CB_BUCKET`         | string  |         | ✅        |        | Bucket/DB Name                              |
+| `CB_SCOPE`          | string  |         | ✅        |        | Scope/Schema Name                           |
+| `CB_CREATE_INDICES` | boolean | _false_ |          |        | Does it create the indices when it deploys? |
+
+
+## Contents
+- [CbAdapterService](./src/adapter/cb-adapter.service.ts) - Injectable service
+- [CbAdapterModule](./src/adapter/cb-adapter.module.ts) - Nestjs Module
+- [couchbaseCommonConfig](./src/config/couchbase-common.config.ts) - config
+- [cbFilterUtil](./src/filter/cb-filter-util.impl.ts) - query filter utility
+- [cbLine()](./src/line/cb-line.impl.ts) - sql line utility
+- [CbRepo](./src/repo/cb.repo.ts) - abstract repository
+
+
+## Development
+> You can start to develop on it
+>
+### Step 1
+- [Go to project folder](https://github.com/samet-digital/help/blob/main/go-to-project-folder.MD)
+
+### Step 2
+- `EN`: Clone the project
+- `TR`: Projeyi bilgisiyarına çek
+```shell
+git clone https://github.com/samet-digital/be-couchbase-common.git -b development
+```
+
+## Dependencies
+- `@samet-it/be-base-common`:  **samet** base common
+- `@leyyo/*`: leyyo utilities
+- `@nestjs/*`: nestjs framework
+- `couchbase`: couchbase client
+
+## Commands
+- [Component Commands](https://github.com/samet-digital/help/blob/main/commands-component.MD)
+
+## Standards
+```diff
++ language: TS 
++ lint: eslint
++ inspections: intelli-j code inspections
++ ddd: domain driven development
++ edd: exception driven development
+! tdd: test driven development
++ ldd: log driven development
++ ddd: document driven development
+```
+
+## History
+| Date       | Developer      | Info         | Ticket         |
+|------------|----------------|--------------|----------------|
+| 2025-08-13 | Mustafa Yelmer | _Created_    | ~~[none](./)~~ |
+| 2026-01-11 | Mustafa Yelmer | _Refactored_ | ~~[none](./)~~ |

package/dist/adapter/cb-adapter.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CbAdapterModule {
+}

package/dist/adapter/cb-adapter.module.js

@@ -0,0 +1,23 @@
+"use strict";
+// ~~console.log(__filename);
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CbAdapterModule = void 0;
+const common_1 = require("@nestjs/common");
+const cb_adapter_service_1 = require("./cb-adapter.service");
+let CbAdapterModule = class CbAdapterModule {
+};
+exports.CbAdapterModule = CbAdapterModule;
+exports.CbAdapterModule = CbAdapterModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        controllers: [],
+        providers: [cb_adapter_service_1.CbAdapterService],
+        exports: [cb_adapter_service_1.CbAdapterService],
+    })
+], CbAdapterModule);

package/dist/adapter/cb-adapter.service.d.ts

@@ -0,0 +1,70 @@
+import { type IgnoreFieldsByType, type ReplaceType } from "@leyyo/common";
+import { type QueryOptions } from 'couchbase';
+import { Cluster, Collection, QueryResult } from 'couchbase';
+import type { CbAdapterServiceLike, CbEntity, CbExecOpt, CbExecRec } from "./index.types";
+import type { CbRepoDef } from "../repo";
+export declare class CbAdapterService implements CbAdapterServiceLike {
+    private readonly _CLEAR_ERROR_INTERVAL;
+    private logger;
+    private _connected;
+    private _undefined;
+    private _cluster;
+    private readonly _cbErrors;
+    private readonly _nativeErrors;
+    constructor();
+    /**
+     * Clear native errors
+     * */
+    private _clearErrors;
+    /**
+     * Ping to DB
+     * */
+    private _ping;
+    /**
+     * Execute the creation of index
+     * */
+    private _createIndex;
+    /**
+     * Build json format of CB object
+     * */
+    private _toJson;
+    /** {@inheritDoc} */
+    f(field: string): string;
+    /** {@inheritDoc} */
+    field(field: string): string;
+    s(value: string): string;
+    v(value: unknown): string;
+    value(value: unknown): string;
+    /** {@inheritDoc} */
+    string(value: string): string;
+    /** {@inheritDoc} */
+    flatten<T>(result: QueryResult<T>): Array<T>;
+    /** {@inheritDoc} */
+    rows<T>(rows: Array<T>): Array<T>;
+    /** {@inheritDoc} */
+    row<T>(row: T): T | undefined;
+    /** {@inheritDoc} */
+    first<T>(rows: Array<T>): T | undefined;
+    /** {@inheritDoc} */
+    checkError(p1: string | Error, p2?: Error): void;
+    /** {@inheritDoc} */
+    createIndex<T = Record<string, unknown>>(coll: Collection, p1: (keyof T | string) | Array<keyof T | string>, name?: string): Promise<void>;
+    /** {@inheritDoc} */
+    createBaseIndices(coll: Collection, ...keys: Array<keyof CbEntity>): Promise<void>;
+    /** {@inheritDoc} */
+    createPk(coll: Collection): Promise<void>;
+    /** {@inheritDoc} */
+    castDates<T>(given: ReplaceType<T, Date, string> | T, ...fields: Array<IgnoreFieldsByType<T, Date>>): void;
+    /** {@inheritDoc} */
+    castDatesForList<T>(given: Array<ReplaceType<T, Date, string> | T>, ...fields: Array<IgnoreFieldsByType<T, Date>>): void;
+    protected _checkError<R = any>(err: Error, op: string, opt: CbExecOpt): R;
+    exec2<T>(repo: CbRepoDef, sql: string, opt?: CbExecOpt): Promise<Array<T>>;
+    exec2First<T>(repo: CbRepoDef, sql: string, opt?: CbExecOpt): Promise<T | undefined>;
+    execExtended<T>(repo: CbRepoDef, sql: string, query: QueryOptions, opt?: CbExecOpt): Promise<Array<T>>;
+    execFirstExtended<T>(repo: CbRepoDef, sql: string, query: QueryOptions, opt?: CbExecOpt): Promise<T | undefined>;
+    exec1<T>(repo: CbRepoDef, fn: Promise<T>, opt?: CbExecOpt): Promise<T>;
+    /** {@inheritDoc} */
+    exec<T>(opt: CbExecRec<T>): Promise<T>;
+    /** {@inheritDoc} */
+    connectDb(): Promise<Cluster>;
+}

package/dist/adapter/cb-adapter.service.js

@@ -0,0 +1,447 @@
+"use strict";
+// ~~console.log(__filename);
+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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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.CbAdapterService = void 0;
+const couchbase = __importStar(require("couchbase"));
+const common_1 = require("@nestjs/common");
+const common_2 = require("@leyyo/common");
+const couchbase_1 = require("couchbase");
+const config_1 = require("../config");
+// noinspection JSUnusedGlobalSymbols
+let CbAdapterService = class CbAdapterService {
+    constructor() {
+        this._CLEAR_ERROR_INTERVAL = 1000 * 60 * 60 * 24; // daily
+        this._undefined = 0;
+        this._cbErrors = new Map();
+        this._nativeErrors = new Map();
+        this.logger = new common_1.Logger(this.constructor.name);
+        this._clearErrors();
+        this._cbErrors.set('AmbiguousTimeoutError', { count: 0, log: true, known: true });
+        this._cbErrors.set('AuthenticationFailureError', { count: 0, log: true, known: true });
+        this._cbErrors.set('ConnectionClosedError', { count: 0, log: true, known: true });
+        this._cbErrors.set('InternalServerFailureError', { count: 0, log: true, known: true });
+        this._cbErrors.set('ServiceNotAvailableError', { count: 0, log: true, known: true });
+        this._cbErrors.set('TimeoutError', { count: 0, log: true, known: true });
+        this._cbErrors.set('UnambiguousTimeoutError', { count: 0, log: true, known: true });
+    }
+    /**
+     * Clear native errors
+     * */
+    _clearErrors() {
+        this._nativeErrors.clear();
+        setTimeout(() => this._clearErrors(), this._CLEAR_ERROR_INTERVAL);
+    }
+    /**
+     * Ping to DB
+     * */
+    _ping() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield this.exec({
+                    name: 'ping',
+                    promise: this._cluster.ping()
+                });
+            }
+            catch (err) {
+                this.logger.error(`!ping[${(_a = err.name) !== null && _a !== void 0 ? _a : ''}]`, err);
+            }
+            setTimeout(() => this._ping(), 30000);
+        });
+    }
+    /**
+     * Execute the creation of index
+     * */
+    _createIndex(scope, sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                return yield scope.query(sql);
+            }
+            catch (e) {
+                if (e instanceof couchbase_1.IndexExistsError) {
+                    return undefined;
+                }
+                this.logger.error(`!index[${(_a = e.name) !== null && _a !== void 0 ? _a : ''}] #${scope.name}] => ${sql}`, e);
+                // throw e; // TODO
+            }
+        });
+    }
+    /**
+     * Build json format of CB object
+     * */
+    _toJson(val) {
+        if ([undefined, null].includes(val)) {
+            return 'null';
+        }
+        switch (typeof val) {
+            case "string":
+            case "number":
+            case "bigint":
+            case "boolean":
+                return JSON.stringify(val);
+            case "object":
+                if (Array.isArray(val)) {
+                    return '[' + val
+                        .filter(v => v !== undefined)
+                        .map(v => this._toJson(v))
+                        .join(', ') + ']';
+                }
+                else if (val instanceof Map) {
+                    return this._toJson(Object.fromEntries(val.entries()));
+                }
+                else if (val instanceof Set) {
+                    return this._toJson(Array.from(val.values()));
+                }
+                else {
+                    return '{' + Array.from(Object.entries(val))
+                        .filter(item => item[1] !== undefined)
+                        .map(item => {
+                        const [k, v] = item;
+                        return '`' + k + '`: ' + this._toJson(v);
+                    }).join(', ') + '}';
+                }
+            case "symbol":
+                return JSON.stringify(val.description);
+            case "function":
+            case "undefined":
+                return 'null';
+        }
+    }
+    /** {@inheritDoc} */
+    f(field) {
+        if (field.includes('.')) {
+            return field.split('.').map(part => this.f(part)).join('.');
+        }
+        else if (field.startsWith('`')) {
+            return field;
+        }
+        return `\`${field}\``;
+    }
+    /** {@inheritDoc} */
+    field(field) {
+        return this.f(field);
+    }
+    s(value) {
+        if (typeof value === 'string') {
+            return value.includes('"') ? this._toJson(value) : `"${value}"`;
+        }
+        return this._toJson(value);
+    }
+    v(value) {
+        return this._toJson(value);
+    }
+    value(value) {
+        return this._toJson(value);
+    }
+    /** {@inheritDoc} */
+    string(value) {
+        return this.s(value);
+    }
+    /** {@inheritDoc} */
+    flatten(result) {
+        if (result && Array.isArray(result.rows) && (result.rows.length > 0)) {
+            return result.rows;
+        }
+        return [];
+    }
+    /** {@inheritDoc} */
+    rows(rows) {
+        if (rows && Array.isArray(rows) && (rows.length > 0)) {
+            return rows.filter(row => row['_trashId'] === undefined);
+        }
+        return [];
+    }
+    /** {@inheritDoc} */
+    row(row) {
+        if (row && row['_trashId'] === undefined) {
+            return row;
+        }
+        return undefined;
+    }
+    /** {@inheritDoc} */
+    first(rows) {
+        if (rows && Array.isArray(rows) && (rows.length > 0)) {
+            return rows[0];
+        }
+        return undefined;
+    }
+    /** {@inheritDoc} */
+    checkError(p1, p2) {
+        var _a;
+        let op;
+        let err;
+        if (typeof p1 === 'string') {
+            p1 = p1.trim();
+            op = p1 ? `(${p1})` : '';
+            err = p2;
+        }
+        else {
+            op = '';
+            err = p1;
+        }
+        const name = (_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name;
+        if (name) {
+            if (!this._cbErrors.has(name)) {
+                this.logger.warn(`!first[${name}] #${op} [1]`, err);
+                this._cbErrors.set(name, { count: 1, log: true });
+            }
+            else {
+                const obj = this._cbErrors.get(name);
+                obj.count++;
+                if (obj.known) {
+                    this.logger.error(`!known[${name}] #${op} [${obj.count}]`, err);
+                }
+                else {
+                    this.logger.warn(`!unknown[${name}] #${op} [${obj.count}]`, err);
+                }
+            }
+        }
+        else {
+            this._undefined++;
+            this.logger.warn(`!undefined[] #${op} [${this._undefined}]`, err);
+        }
+    }
+    /** {@inheritDoc} */
+    createIndex(coll, p1, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Array.isArray(p1)) {
+                const fields = p1.map(f => f.split('.').map(part => '`' + part + '`').join('.'));
+                name = name.split('.').join('_').split('-').join('_');
+                if (!name.startsWith('idx_')) {
+                    name = 'idx_' + name;
+                }
+                yield this._createIndex(coll.scope, `CREATE INDEX \`${name}\` ON \`${coll.name}\` (${fields.join(', ')})`);
+            }
+            else {
+                const field = p1;
+                if (!name) {
+                    name = 'idx_' + field.split('.').join('_').split('-').join('_');
+                }
+                else if (!name.startsWith('idx_')) {
+                    name = 'idx_' + name;
+                }
+                yield this._createIndex(coll.scope, `CREATE INDEX \`${name}\` ON \`${coll.name}\` (${field.split('.').map(part => '`' + part + '`').join('.')})`);
+            }
+        });
+    }
+    /** {@inheritDoc} */
+    createBaseIndices(coll, ...keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (keys.includes('id')) {
+                yield this.createIndex(coll, 'id');
+            }
+            if (keys.includes('createdAt')) {
+                yield this.createIndex(coll, 'createdAt');
+            }
+            if (keys.includes('updatedAt')) {
+                yield this.createIndex(coll, 'updatedAt');
+            }
+            if (keys.includes('_trashId')) {
+                yield this.createIndex(coll, '_trashId', 'trashId');
+            }
+            if (keys.includes('_urn')) {
+                yield this.createIndex(coll, '_urn', 'urn');
+            }
+        });
+    }
+    /** {@inheritDoc} */
+    createPk(coll) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._createIndex(coll.scope, `CREATE PRIMARY INDEX \`pk\` ON \`${coll.name}\``);
+        });
+    }
+    /** {@inheritDoc} */
+    castDates(given, ...fields) {
+        if (fields.length < 1) {
+            return;
+        }
+        if (!given || typeof given !== 'object' && Array.isArray(given)) {
+            return;
+        }
+        const doc = given;
+        fields.forEach(field => {
+            const val = doc[field];
+            if (typeof val === 'string' || (typeof val === 'number' && val > 0 && Number.isInteger(val))) {
+                doc[field] = new Date(val);
+            }
+        });
+    }
+    /** {@inheritDoc} */
+    castDatesForList(given, ...fields) {
+        if (fields.length < 1) {
+            return;
+        }
+        if (!given || !Array.isArray(given) || given.length < 1) {
+            return;
+        }
+        const arr = given;
+        arr.forEach(item => this.castDates(item, ...fields));
+    }
+    _checkError(err, op, opt) {
+        var _a;
+        if (!this._nativeErrors.has(err)) {
+            this._nativeErrors.set(err, 1);
+        }
+        else {
+            this._nativeErrors.set(err, this._nativeErrors.get(err) + 1);
+        }
+        if ((_a = opt === null || opt === void 0 ? void 0 : opt.ignoredErrors) === null || _a === void 0 ? void 0 : _a.includes(err)) {
+            return undefined;
+        }
+        this.logger.error(`${op}${err.message}`, err);
+        throw err;
+    }
+    exec2(repo, sql, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execExtended(repo, sql, undefined, opt);
+        });
+    }
+    exec2First(repo, sql, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.first(yield this.exec2(repo, sql, opt));
+        });
+    }
+    execExtended(repo, sql, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const op = (opt === null || opt === void 0 ? void 0 : opt.name) ? `[${opt.name}]` : '';
+            if (opt === null || opt === void 0 ? void 0 : opt.printSql) {
+                this.logger.log(`${repo.path} > SQL${op}`, sql);
+            }
+            try {
+                return this.flatten(yield repo.scope.query(sql, query));
+            }
+            catch (err) {
+                return this._checkError(err, op, opt);
+            }
+        });
+    }
+    execFirstExtended(repo, sql, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.first(yield this.execExtended(repo, sql, query, opt));
+        });
+    }
+    exec1(repo, fn, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const op = (opt === null || opt === void 0 ? void 0 : opt.name) ? `[${opt.name}]` : '';
+            common_2.$assert.object(fn, () => {
+                return { field: 'fn', where: 'CbAdapterService', path: repo.path, op: op };
+            });
+            common_2.$assert.func(fn.then, () => {
+                return { field: 'fn.then', where: 'CbAdapterService', path: repo.path, op: op };
+            });
+            try {
+                return yield fn;
+            }
+            catch (err) {
+                return this._checkError(err, op, opt);
+            }
+        });
+    }
+    /** {@inheritDoc} */
+    exec(opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!common_2.$is.bareObject(opt) || !common_2.$is.object(opt.promise) || !common_2.$is.func(opt.promise.then)) {
+                throw new Error(`Invalid exec options [${typeof opt}, ${typeof (opt === null || opt === void 0 ? void 0 : opt.promise)}]`);
+            }
+            try {
+                return yield opt.promise;
+            }
+            catch (err) {
+                const e = err;
+                if (!this._nativeErrors.has(e)) {
+                    this._nativeErrors.set(e, 1);
+                }
+                else {
+                    this._nativeErrors.set(e, this._nativeErrors.get(e) + 1);
+                }
+                if (Array.isArray(opt.ignoredErrors) && opt.ignoredErrors.includes(e)) {
+                    return undefined;
+                }
+                const op = opt.name ? `[${opt.name}] ` : '';
+                this.logger.error(`${op}${err.message}`, err);
+                throw err;
+            }
+        });
+    }
+    /** {@inheritDoc} */
+    connectDb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this._connected) {
+                return this._cluster;
+            }
+            const opt = config_1.couchbaseCommonConfig.raw;
+            try {
+                this._cluster = yield couchbase.connect(`couchbase://${opt.CB_HOST}`, {
+                    username: opt.CB_USER,
+                    password: opt.CB_PASS,
+                });
+                this._connected = true;
+                this.logger.log('Connected');
+                setTimeout(() => this._ping(), 30000);
+                return this._cluster;
+            }
+            catch (e) {
+                this.logger.error(`!connection[${(_a = e.name) !== null && _a !== void 0 ? _a : ''}]`, e);
+                throw e;
+            }
+        });
+    }
+};
+exports.CbAdapterService = CbAdapterService;
+exports.CbAdapterService = CbAdapterService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], CbAdapterService);

package/dist/adapter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './index.types';
+export * from './cb-adapter.service';
+export * from './cb-adapter.module';

package/dist/adapter/index.js

@@ -0,0 +1,19 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./cb-adapter.service"), exports);
+__exportStar(require("./cb-adapter.module"), exports);