@samet-it/be-couchbase-common 1.0.1

package/dist/repo/cb.repo.d.ts

@@ -0,0 +1,95 @@
+import { CbAdapterService, type CbEntity, type CbError, type CbExecMutationOpt, type CbExecOpt, type CbExecTrashOpt } from "../adapter";
+import { Bucket, Cluster, Collection, type QueryOptions, Scope } from "couchbase";
+import type { CbRepoDef, CbRepoLike } from "./index.types";
+export declare abstract class CbRepo<E extends CbEntity, ID> implements CbRepoLike<E, ID> {
+    protected colName: string;
+    protected cb: CbAdapterService;
+    private _scopeName?;
+    private _bucketName?;
+    /** @inheritDoc */
+    readonly fullPath: string;
+    /** @inheritDoc */
+    readonly path: string;
+    /** @inheritDoc */
+    readonly cluster: Cluster;
+    /** @inheritDoc */
+    readonly bucket: Bucket;
+    /** @inheritDoc */
+    readonly scope: Scope;
+    /** @inheritDoc */
+    readonly collection: Collection;
+    protected constructor(colName: string, cb: CbAdapterService, _scopeName?: string, _bucketName?: string);
+    protected _pushIgnoredError<O extends CbExecMutationOpt>(opt: O, err: CbError): O;
+    /**
+     * Fetch urn from doc as doc._urn
+     * */
+    protected _urnFromDoc(doc: Partial<E>, method: string): string;
+    /**
+     * Check array keys as id list or urn list
+     * */
+    protected _checkKeys<I extends string | number = string>(keys: I[]): I[];
+    /**
+     * Build update sql as set and unset
+     * */
+    protected _updateSql<T>(urn: string, doc: T): string;
+    /**
+     * Create indices
+     * */
+    protected abstract _createIndices(): Promise<void>;
+    /** @inheritDoc */
+    get def(): CbRepoDef;
+    /** @inheritDoc */
+    abstract urn(part: ID): string;
+    /** @inheritDoc */
+    onModuleInit(): Promise<void>;
+    /** @inheritDoc */
+    urnByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<string | undefined>;
+    /** @inheritDoc */
+    urnById(id: string, opt?: CbExecOpt): Promise<string | undefined>;
+    /** @inheritDoc */
+    existsByUrn(urn: string, opt?: CbExecOpt): Promise<boolean>;
+    /** @inheritDoc */
+    existsByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<boolean>;
+    /** @inheritDoc */
+    existsById(id: string, opt?: CbExecOpt): Promise<boolean>;
+    /** @inheritDoc */
+    existsByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<boolean>;
+    /** @inheritDoc */
+    getByUrn(urn: string, opt?: CbExecOpt): Promise<E | undefined>;
+    /** @inheritDoc */
+    getByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<E | undefined>;
+    /** @inheritDoc */
+    getById(id: string, opt?: CbExecOpt): Promise<E | undefined>;
+    /** @inheritDoc */
+    getByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<E | undefined>;
+    /** @inheritDoc */
+    listByUrn(urnList: string[], opt?: CbExecOpt): Promise<Array<E>>;
+    /** @inheritDoc */
+    listByUrnExtended(urnList: string[], query: QueryOptions, opt?: CbExecOpt): Promise<Array<E>>;
+    /** @inheritDoc */
+    listById(ids: string[], opt?: CbExecOpt): Promise<Array<E>>;
+    /** @inheritDoc */
+    listByIdExtended(ids: string[], query: QueryOptions, opt?: CbExecOpt): Promise<Array<E>>;
+    /** @inheritDoc */
+    removeByUrn(urn: string, opt?: CbExecOpt): Promise<string>;
+    /** @inheritDoc */
+    removeByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<string>;
+    /** @inheritDoc */
+    removeById(id: string, opt?: CbExecOpt): Promise<string>;
+    /** @inheritDoc */
+    removeByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<string>;
+    /** @inheritDoc */
+    insert(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /** @inheritDoc */
+    replace(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /** @inheritDoc */
+    upsert(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /** @inheritDoc */
+    update(doc: Partial<E>, opt?: CbExecOpt): Promise<unknown>;
+    /** @inheritDoc */
+    updateExtended(doc: Partial<E>, query: QueryOptions, opt?: CbExecOpt): Promise<unknown>;
+    /** @inheritDoc */
+    trash(doc: E, opt?: CbExecTrashOpt): Promise<unknown>;
+    /** @inheritDoc */
+    trashExtended(doc: E, query: QueryOptions, opt?: CbExecTrashOpt): Promise<unknown>;
+}

package/dist/repo/cb.repo.js

@@ -0,0 +1,375 @@
+"use strict";
+// ~~console.log(__filename);
+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.CbRepo = void 0;
+const common_1 = require("@leyyo/common");
+const config_1 = require("../config");
+const line_1 = require("../line");
+const node_crypto_1 = require("node:crypto");
+let F_ID;
+let F_URN;
+let F_TRASH_ID;
+// noinspection JSUnusedGlobalSymbols
+class CbRepo {
+    constructor(colName, cb, _scopeName, _bucketName) {
+        this.colName = colName;
+        this.cb = cb;
+        this._scopeName = _scopeName;
+        this._bucketName = _bucketName;
+        if (!F_ID) {
+            F_ID = this.cb.f('id');
+            F_URN = this.cb.f('_urn');
+            F_TRASH_ID = this.cb.f('_trashId');
+        }
+    }
+    // noinspection JSUnusedLocalSymbols
+    _pushIgnoredError(opt, err) {
+        if (!opt) {
+            opt = { ignoredErrors: [err] };
+        }
+        else if (!Array.isArray(opt.ignoredErrors)) {
+            opt.ignoredErrors = [err];
+        }
+        else if (!opt.ignoredErrors.includes(err)) {
+            opt.ignoredErrors.push(err);
+        }
+        return opt;
+    }
+    /**
+     * Fetch urn from doc as doc._urn
+     * */
+    _urnFromDoc(doc, method) {
+        common_1.$assert.object(doc, () => {
+            return { field: 'doc', where: 'CbRepo', path: this.path, method };
+        });
+        const urn = doc._urn;
+        common_1.$assert.text(urn, () => {
+            return { field: 'urn', where: 'CbRepo', path: this.path, method };
+        });
+        return urn;
+    }
+    /**
+     * Check array keys as id list or urn list
+     * */
+    _checkKeys(keys) {
+        if (!keys || !Array.isArray(keys) || keys.length < 1) {
+            return [];
+        }
+        return keys
+            .map(item => {
+            switch (typeof item) {
+                case "string":
+                    const str = item.trim();
+                    return str ? str : undefined;
+                case "number":
+                    return item;
+                default:
+                    return undefined;
+            }
+        })
+            .filter(item => item !== undefined);
+    }
+    /**
+     * Build update sql as set and unset
+     * */
+    _updateSql(urn, doc) {
+        const set = [];
+        const unset = [];
+        for (const [k, v] of Object.entries(doc)) {
+            if (!['_urn', 'id'].includes(k)) {
+                if (v === undefined) {
+                    unset.push(this.cb.f(k));
+                }
+                else {
+                    set.push([this.cb.f(k), this.cb.v(v)]);
+                }
+            }
+        }
+        const lines = (0, line_1.cbLine)();
+        lines
+            .add(`UPDATE ${this.fullPath}`)
+            .add(`USE KEYS ${this.cb.s(urn)}`);
+        if (unset.length > 0) {
+            lines.add('UNSET ', unset.join(', '));
+        }
+        if (set.length > 0) {
+            lines.add('SET ', set.join(',\n    '));
+        }
+        lines.add(`RETURNING meta().id ${F_URN}`);
+        return lines.end();
+    }
+    /** @inheritDoc */
+    get def() {
+        return this;
+    }
+    /** @inheritDoc */
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const mutable = this;
+            mutable.cluster = yield this.cb.connectDb();
+            mutable.bucket = this.cluster.bucket((_a = this._bucketName) !== null && _a !== void 0 ? _a : config_1.couchbaseCommonConfig.raw.CB_BUCKET);
+            mutable.scope = this.bucket.scope((_b = this._scopeName) !== null && _b !== void 0 ? _b : config_1.couchbaseCommonConfig.raw.CB_SCOPE);
+            mutable.collection = this.scope.collection(this.colName);
+            mutable.path = `${this.bucket.name}.${this.scope.name}.${this.collection.name}`;
+            mutable.fullPath = this.cb.f(`${this.bucket.name}.${this.scope.name}.${this.collection.name}`);
+            if (config_1.couchbaseCommonConfig.raw.CB_CREATE_INDICES) {
+                yield this._createIndices();
+            }
+        });
+    }
+    /** @inheritDoc */
+    urnByIdExtended(id, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT meta().id as ${F_URN}`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_ID} = ${this.cb.s(id)})`)
+                .add(`AND (a.${F_TRASH_ID} is missing)`)
+                .add('LIMIT 1');
+            return (_a = (yield this.cb.execFirstExtended(this, lines.end(), query, opt))) === null || _a === void 0 ? void 0 : _a._urn;
+        });
+    }
+    /** @inheritDoc */
+    urnById(id, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.urnByIdExtended(id, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    existsByUrn(urn, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.existsByUrnExtended(urn, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    existsByUrnExtended(urn, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT meta().id as ${F_URN}`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add(`USE KEYS ${this.cb.s(urn)}`)
+                .add('LIMIT 1');
+            return ((_a = (yield this.cb.execFirstExtended(this, lines.end(), query, opt))) === null || _a === void 0 ? void 0 : _a._urn) !== undefined;
+        });
+    }
+    /** @inheritDoc */
+    existsById(id, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.urnByIdExtended(id, undefined, opt)) !== undefined;
+        });
+    }
+    /** @inheritDoc */
+    existsByIdExtended(id, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.urnByIdExtended(id, query, opt)) !== undefined;
+        });
+    }
+    /** @inheritDoc */
+    getByUrn(urn, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getByUrnExtended(urn, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    getByUrnExtended(urn, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT a.*`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add(`USE KEYS ${this.cb.s(urn)}`)
+                .add('LIMIT 1');
+            return this.cb.execFirstExtended(this, lines.end(), query, opt);
+        });
+    }
+    /** @inheritDoc */
+    getById(id, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getByIdExtended(id, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    getByIdExtended(id, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT a.*`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_ID} = ${this.cb.s(id)})`)
+                .add(`AND (a.${F_TRASH_ID} is missing)`)
+                .add('LIMIT 1');
+            return this.cb.first(yield this.cb.execExtended(this, lines.end(), query, opt));
+        });
+    }
+    /** @inheritDoc */
+    listByUrn(urnList, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listByUrnExtended(urnList, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    listByUrnExtended(urnList, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            urnList = this._checkKeys(urnList);
+            if (urnList.length < 1) {
+                return [];
+            }
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT a.*`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add(`USE KEYS [${urnList.map(urn => this.cb.s(urn)).join(',')}]`);
+            return this.cb.execExtended(this, lines.end(), query, opt);
+        });
+    }
+    /** @inheritDoc */
+    listById(ids, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listByIdExtended(ids, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    listByIdExtended(ids, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ids = this._checkKeys(ids);
+            if (ids.length < 1) {
+                return [];
+            }
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`SELECT a.*`)
+                .add(`FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_ID} IN [${ids.map(id => this.cb.s(id)).join(',')}])`)
+                .add(`AND (a.${F_TRASH_ID} is missing)`);
+            return this.cb.execExtended(this, lines.end(), query, opt);
+        });
+    }
+    /** @inheritDoc */
+    removeByUrn(urn, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.removeByUrnExtended(urn, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    removeByUrnExtended(urn, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`DELETE
+                  FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add(`USE KEYS ${this.cb.s(urn)}`)
+                .add(`RETURNING a.${F_ID}`);
+            return (_a = (yield this.cb.execFirstExtended(this, lines.end(), query, opt))) === null || _a === void 0 ? void 0 : _a.id;
+        });
+    }
+    /** @inheritDoc */
+    removeById(id, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.removeByIdExtended(id, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    removeByIdExtended(id, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`DELETE FROM ${this.fullPath} a`)
+                .add(`WHERE (a.${F_ID} = ${this.cb.s(id)})`)
+                .add(`AND (a.${F_TRASH_ID} is missing)`)
+                .add(`RETURNING meta().id ${F_URN}`);
+            return (_a = (yield this.cb.execFirstExtended(this, lines.end(), query, opt))) === null || _a === void 0 ? void 0 : _a._urn;
+        });
+    }
+    /** @inheritDoc */
+    insert(doc, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urn = this._urnFromDoc(doc, 'insert');
+            doc.createdAt = new Date().toISOString();
+            doc.updatedAt = new Date().toISOString();
+            const result = yield this.cb.exec1(this, this.collection.insert(urn, doc), opt);
+            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'inserted';
+        });
+    }
+    /** @inheritDoc */
+    replace(doc, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urn = this._urnFromDoc(doc, 'replace');
+            doc.updatedAt = new Date().toISOString();
+            const result = yield this.cb.exec1(this, this.collection.replace(urn, doc), opt);
+            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'inserted';
+        });
+    }
+    /** @inheritDoc */
+    upsert(doc, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urn = this._urnFromDoc(doc, 'upsert');
+            doc.updatedAt = new Date().toISOString();
+            const result = yield this.cb.exec1(this, this.collection.upsert(urn, doc), opt);
+            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'modified';
+        });
+    }
+    /** @inheritDoc */
+    update(doc, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.updateExtended(doc, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    updateExtended(doc, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const urn = this._urnFromDoc(doc, 'update');
+            doc.updatedAt = new Date().toISOString();
+            doc.updatedAt = new Date().toISOString();
+            const sql = this._updateSql(urn, doc);
+            return (_a = (yield this.cb.execFirstExtended(this, sql, query, opt))) === null || _a === void 0 ? void 0 : _a._urn;
+        });
+    }
+    /** @inheritDoc */
+    trash(doc, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.trashExtended(doc, undefined, opt);
+        });
+    }
+    /** @inheritDoc */
+    trashExtended(doc, query, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urn = this._urnFromDoc(doc, 'trash');
+            if (!opt) {
+                opt = { trashId: (0, node_crypto_1.randomUUID)() };
+            }
+            else if (!opt.trashId) {
+                opt.trashId = (0, node_crypto_1.randomUUID)();
+            }
+            const lines = (0, line_1.cbLine)();
+            lines
+                .add(`UPDATE ${this.fullPath} a`)
+                .add(`SET a.${F_TRASH_ID} = ${this.cb.s(opt.trashId)}`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add(`USE KEYS ${this.cb.s(urn)}`);
+            yield this.cb.execExtended(this, lines.end(), query, opt);
+            return opt.trashId;
+        });
+    }
+}
+exports.CbRepo = CbRepo;

package/dist/repo/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.types';
+export * from './cb.repo';

package/dist/repo/index.js

@@ -0,0 +1,18 @@
+"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.repo"), exports);

package/dist/repo/index.types.d.ts

@@ -0,0 +1,144 @@
+import type { Bucket, Cluster, Collection, QueryOptions, Scope } from "couchbase";
+import type { CbEntity, CbExecMutationOpt, CbExecOpt, CbExecTrashOpt } from "../adapter";
+export interface CbRepoLike<E extends CbEntity, ID> {
+    /**
+     * Readable Bucket/Scope/Collection path
+     * */
+    readonly path: string;
+    /**
+     * Formatted Bucket/Scope/Collection path
+     * */
+    readonly fullPath: string;
+    /**
+     * CB Cluster
+     * */
+    readonly cluster: Cluster;
+    /**
+     * CB Bucket
+     * */
+    readonly bucket: Bucket;
+    /**
+     * CB Scope
+     * */
+    readonly scope: Scope;
+    /**
+     * CB Collection
+     * */
+    readonly collection: Collection;
+    get def(): CbRepoDef;
+    /**
+     * Build URN with id model
+     * */
+    urn(part: ID): string;
+    /**
+     * It will be triggered when module is initialized
+     * */
+    onModuleInit(): Promise<void>;
+    /**
+     * Get urn by id
+     * */
+    urnById(id: string, opt?: CbExecOpt): Promise<string | undefined>;
+    /**
+     * Get urn by id with CB configuration
+     * */
+    urnByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<string | undefined>;
+    /**
+     * Doc exists by urn?
+     * */
+    existsByUrn(urn: string, opt?: CbExecOpt): Promise<boolean>;
+    /**
+     * Doc exists by urn? with CB configuration
+     * */
+    existsByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<boolean>;
+    /**
+     * Doc exists by id?
+     * */
+    existsById(id: string, opt?: CbExecOpt): Promise<boolean>;
+    /**
+     * Doc exists by id? with CB configuration
+     * */
+    existsByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<boolean>;
+    /**
+     * Get doc by urn
+     * */
+    getByUrn(urn: string, opt?: CbExecOpt): Promise<E | undefined>;
+    /**
+     * Get doc by urn with CB configuration
+     * */
+    getByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<E | undefined>;
+    /**
+     * Get doc by id
+     * */
+    getById(id: string, opt?: CbExecOpt): Promise<E | undefined>;
+    /**
+     * Get doc by id with CB configuration
+     * */
+    getByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<E | undefined>;
+    /**
+     * Get doc by urn
+     * */
+    listByUrn(urnList: string[], opt?: CbExecOpt): Promise<Array<E>>;
+    /**
+     * Get doc by urn with CB configuration
+     * */
+    listByUrnExtended(urnList: string[], query: QueryOptions, opt?: CbExecOpt): Promise<Array<E>>;
+    /**
+     * Get doc by id
+     * */
+    listById(ids: string[], opt?: CbExecOpt): Promise<Array<E>>;
+    /**
+     * Get doc by id with CB configuration
+     * */
+    listByIdExtended(ids: string[], query: QueryOptions, opt?: CbExecOpt): Promise<Array<E>>;
+    /**
+     * Remove doc by urn
+     * */
+    removeByUrn(urn: string, opt?: CbExecOpt): Promise<string>;
+    /**
+     * Remove doc by urn with CB configuration
+     * */
+    removeByUrnExtended(urn: string, query: QueryOptions, opt?: CbExecOpt): Promise<string>;
+    /**
+     * Remove doc by urn
+     * */
+    removeById(id: string, opt?: CbExecOpt): Promise<string>;
+    /**
+     * Remove doc by urn with CB configuration
+     * */
+    removeByIdExtended(id: string, query: QueryOptions, opt?: CbExecOpt): Promise<string>;
+    /**
+     * Create doc by entity
+     * */
+    insert(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /**
+     * Replace doc by entity
+     * */
+    replace(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /**
+     * Upsert doc by entity (insert vs update)
+     * */
+    upsert(doc: E, opt?: CbExecMutationOpt): Promise<string>;
+    /**
+     * Update doc
+     * */
+    update(doc: Partial<E>, opt?: CbExecOpt): Promise<unknown>;
+    /**
+     * Update doc with CB configuration
+     * */
+    updateExtended(doc: Partial<E>, query: QueryOptions, opt?: CbExecOpt): Promise<unknown>;
+    /**
+     * Trash doc by entity
+     * */
+    trash(doc: E, opt?: CbExecTrashOpt): Promise<unknown>;
+    /**
+     * Trash doc by entity with CB configuration
+     * */
+    trashExtended(doc: E, query: QueryOptions, opt?: CbExecTrashOpt): Promise<unknown>;
+}
+export interface CbOnlyUrnRec {
+    _urn: string;
+}
+export interface CbOnlyIdRec {
+    id: string;
+}
+export type CbRepoDef = CbRepoLike<CbEntity, Record<string, string>>;

package/dist/repo/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });