@samet-it/be-couchbase-common 1.0.16 → 1.1.1

package/dist/repo/cb.repo.js

@@ -1,5 +1,4 @@
 "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) {
@@ -12,144 +11,85 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CbRepo = void 0;
 const couchbase_1 = require("couchbase");
-const common_1 = require("@leyyo/common");
-const config_1 = require("../config");
-const line_1 = require("../line");
-const node_crypto_1 = require("node:crypto");
-const common_2 = require("@nestjs/common");
-let F_ID;
+const be_db_common_1 = require("@samet-it/be-db-common");
+const type_1 = require("@leyyo/type");
+const type_2 = require("@leyyo/type");
+const cb_schema_error_1 = require("./cb-schema.error");
 let F_URN;
+let F_ID;
 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;
-        this._tryCount = 0;
-        this.logger = new common_2.Logger(this.constructor.name);
-        if (!F_ID) {
-            F_ID = cb.f('id');
-            F_URN = cb.f('_urn');
-            F_TRASH_ID = cb.f('_trashId');
-        }
-    }
-    get _randomIndexName() {
-        return 'idx_' + (0, node_crypto_1.randomUUID)().match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
-            .map(s => s.toLowerCase())
-            .join('_');
-    }
-    _indexName(name) {
-        if (typeof name !== 'string') {
-            return this._randomIndexName;
-        }
-        name = name.trim();
-        if (name === '') {
-            return this._randomIndexName;
+/**
+ * Couchbase repository abstract class
+ * */
+class CbRepo extends be_db_common_1.DbRepo {
+    // endregion protected-property
+    constructor(conn, opt) {
+        var _a, _b, _c;
+        super(conn, opt);
+        conn.onFirstConnected(() => this._afterConnected());
+        const { _props: props } = this;
+        props.bucketName = this._checkName(props.bucketName);
+        props.scopeName = this._checkName(props.scopeName);
+        props.collectionName = this._checkName(props.collectionName);
+        props.bucketName = (_a = props.bucketName) !== null && _a !== void 0 ? _a : conn.props.bucketName;
+        props.scopeName = (_b = props.scopeName) !== null && _b !== void 0 ? _b : conn.props.scopeName;
+        props.createIndices = (_c = props.createIndices) !== null && _c !== void 0 ? _c : conn.props.createIndices;
+        if (!props.bucketName) {
+            throw new be_db_common_1.DbInvalidValueError('Bucket', typeof props.bucketName, 'CbRepo', 'constructor');
         }
-        name = name.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
-            .map(s => s.toLowerCase())
-            .join('_');
-        name = name.replace(/^_+|_+$/g, '');
-        if (name === '') {
-            return this._randomIndexName;
+        if (!props.scopeName) {
+            throw new be_db_common_1.DbInvalidValueError('Scope', typeof props.scopeName, 'CbRepo', 'constructor');
         }
-        if (!name.startsWith('idx_')) {
-            name = 'idx_' + name;
+        if (!props.collectionName) {
+            throw new be_db_common_1.DbInvalidValueError('Collection', typeof props.collectionName, 'CbRepo', 'constructor');
         }
-        if (name.length > 30) {
-            name = name.substring(0, 30);
-        }
-        return name;
-    }
-    /**
-     * 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 [];
+        if (!F_URN) {
+            F_URN = props.conn.f('_urn');
+            F_ID = props.conn.f('id');
+            F_TRASH_ID = props.conn.f('_trashId');
         }
-        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 cb = this.cb;
-        const set = [];
-        const unset = [];
-        for (const [k, v] of Object.entries(doc)) {
-            if (!['_urn', 'id'].includes(k)) {
-                if (v === undefined) {
-                    unset.push(cb.f(k));
-                }
-                else {
-                    set.push([cb.f(k), cb.v(v)]);
-                }
+    // region protected-method
+    _checkName(value) {
+        if (typeof value === 'string') {
+            value = value.trim();
+            if (!value) {
+                value = undefined;
             }
         }
-        const lines = (0, line_1.cbLine)();
-        lines
-            .add(`UPDATE ${this.fullPath}`)
-            .add(`USE KEYS ${cb.v(urn)}`);
-        if (unset.length > 0) {
-            lines.add('UNSET ', unset.join(', '));
+        else {
+            value = undefined;
         }
-        if (set.length > 0) {
-            lines.add('SET ', set.join(',\n    '));
-        }
-        lines.add(`RETURNING meta().id ${F_URN}`);
-        return lines.end();
+        return value;
     }
     /**
      * Execute the creation of index
      * */
     _createIndex(p1, name) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn, full, path } = this._props;
             let sql;
             const fields = [];
             if (Array.isArray(p1)) {
                 const given = p1;
-                if (!common_1.$is.text(name)) {
+                if (!(0, type_1.isText)(name)) {
                     name = given.map(item => item.split('.').pop()).join('.');
                 }
-                fields.push(...given.map(f => this.cb.f(f)));
+                fields.push(...given.map(f => conn.f(f)));
             }
             else {
                 fields.push(p1);
                 name = p1;
             }
             name = this._indexName(name);
-            sql = `CREATE INDEX ${this.cb.f(name)} ON ${this.fullPath} (${fields.join(', ')})`;
-            yield this.cb.one(this.def, sql, { name: `${this.path}.index`, ignoredErrors: [couchbase_1.IndexExistsError] });
+            sql = `CREATE INDEX ${conn.f(name)} ON ${full} (${fields.join(', ')}) IF NOT EXISTS`;
+            yield conn.one(this.$def, sql, {
+                name: `${path}.index`,
+                ignoredErrors: [couchbase_1.IndexExistsError.name]
+            });
         });
     }
+    // noinspection JSUnusedGlobalSymbols
     /**
      * Execute the creation of indexes with keys
      * */
@@ -165,9 +105,7 @@ class CbRepo {
                 return true;
             })
                 .map(k => this._createIndex(k));
-            if (!this._pkIndexed) {
-                promises.push(this._createPk());
-            }
+            promises.push(this._createPk());
             if (promises.length > 0) {
                 yield Promise.all(promises);
             }
@@ -178,246 +116,519 @@ class CbRepo {
      * */
     _createPk() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._pkIndexed) {
-                const sql = `CREATE PRIMARY INDEX \`pk\` ON ${this.fullPath}`;
-                yield this.cb.one(this.def, sql, { name: `${this.path}.pk`, ignoredErrors: [couchbase_1.IndexExistsError] });
-                this._pkIndexed = true;
-            }
+            const { full, path, conn } = this._props;
+            const sql = `CREATE PRIMARY INDEX \`pk\` ON ${full} IF NOT EXISTS`;
+            yield conn.one(this.$def, sql, {
+                name: `${path}.pk`,
+                ignoredErrors: [couchbase_1.IndexExistsError.name]
+            });
         });
     }
     /** @inheritDoc */
-    get def() {
-        return this;
+    _afterConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _props: props } = this;
+            props.cluster = props.conn.props.cluster;
+            yield this._loadBucket();
+            yield this._loadScope();
+            yield this._loadCollection();
+            props.path = `${props.bucket.name}.${props.scope.name}.${props.collection.name}`;
+            props.full = props.conn.f(props.path);
+            if (props.createIndices) {
+                yield this.$createIndices();
+            }
+        });
     }
-    /** @inheritDoc */
-    onModuleInit() {
+    _loadBucket() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const cb = this.cb;
-            const mutable = this;
-            try {
-                mutable.cluster = yield 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 = cb.f(`${this.bucket.name}.${this.scope.name}.${this.collection.name}`);
-                if (config_1.couchbaseCommonConfig.raw.CB_CREATE_INDICES) {
-                    yield this._createIndices();
+            const { _props: props } = this;
+            (0, type_2.assertText)(props.bucketName, { field: 'bucket', where: 'CbRepo', method: '_loadBucket' });
+            let spec = Array.from(CbRepo._specs.keys())
+                .find(s => s.name === props.bucketName);
+            if (!spec) {
+                const bucketManager = props.cluster.buckets();
+                const allBuckets = yield bucketManager.getAllBuckets();
+                spec = allBuckets.find(b => b.name === props.bucketName);
+                if (!spec) {
+                    throw new cb_schema_error_1.CbSchemaError('Bucket', props.bucketName, 'CbRepo', '_loadBucket');
                 }
+                CbRepo._specs.set(spec, []);
             }
-            catch (e) {
-                if (this._tryCount > 100) {
-                    throw e;
+            const ins = props.cluster.bucket(props.bucketName);
+            ins.$spec = spec;
+            props.bucket = ins;
+        });
+    }
+    _loadScope() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _props: props } = this;
+            (0, type_2.assertText)(props.scopeName, { field: 'scopeName', where: 'CbRepo', method: '_loadScope' });
+            let spec = CbRepo._specs.get(props.bucket.$spec)
+                .find(s => s.name === props.scopeName);
+            if (!spec) {
+                const scopeManager = props.bucket.collections();
+                const allScopes = yield scopeManager.getAllScopes();
+                spec = allScopes.find(s => s.name === props.scopeName);
+                if (!spec) {
+                    throw new cb_schema_error_1.CbSchemaError('Scope', `${props.bucketName}.${props.scopeName}`, 'CbRepo', '_loadScope');
                 }
-                this._tryCount++;
-                setTimeout(() => this.onModuleInit().then().catch(e2 => {
-                    throw e2;
-                }), 1000);
+                CbRepo._specs.get(props.bucket.$spec).push(spec);
+            }
+            const ins = props.bucket.scope(props.scopeName);
+            ins.$spec = spec;
+            props.scope = ins;
+        });
+    }
+    _loadCollection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _props: props } = this;
+            (0, type_2.assertText)(props.collectionName, { field: 'collectionName', where: 'CbRepo', method: '_loadCollection' });
+            const spec = props.scope.$spec.collections
+                .find(s => s.name === props.collectionName);
+            if (!spec) {
+                throw new cb_schema_error_1.CbSchemaError('Collection', `${props.bucketName}.${props.scopeName}.${props.collectionName}`, 'CbRepo', '_loadCollection');
             }
+            const ins = props.scope.collection(props.collectionName);
+            ins.$spec = spec;
+            props.collection = ins;
+        });
+    }
+    /**
+     * Create indices in final repo
+     * */
+    $createIndices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // can be overloaded
         });
     }
+    // endregion protected-method
+    // region getter
+    /** @inheritDoc */
+    get $def() {
+        return this;
+    }
+    /** @inheritDoc */
+    get props() {
+        return this._props;
+    }
+    // endregion getter
+    // region get
     /** @inheritDoc */
-    urnById(id, p1) {
+    $getByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'urnById');
-            const lines = (0, line_1.cbLine)();
+            if (!ignoreCheck) {
+                (0, type_2.assertText)(key, { field: 'id', where: 'CbRepo', method: '$getByPrimary' });
+            }
+            const { conn, useSoftDelete, collection, full } = this._props;
+            const opt = conn.buildOpt(p1, '$getById');
+            if (!useSoftDelete) {
+                if (!Array.isArray(opt.ignoredErrors)) {
+                    opt.ignoredErrors = [];
+                }
+                opt.ignoredErrors.push(couchbase_1.DocumentNotFoundError.name);
+                const result = yield conn.exec(collection.get(key, opt), opt);
+                return result === null || result === void 0 ? void 0 : result.content;
+            }
+            const lines = (0, be_db_common_1.dbLines)();
             lines
-                .add(`SELECT meta().id as ${F_URN}`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`WHERE (a.${F_ID} = ${cb.v(id)})`)
-                .add(`AND (a.${F_TRASH_ID} is missing)`)
+                .add(`SELECT a.*`)
+                .add(`FROM ${full} a`)
+                .add(`USE KEYS $key`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
                 .add('LIMIT 1');
-            return (_a = (yield cb.one(this, lines.end(), opt)).row) === null || _a === void 0 ? void 0 : _a._urn;
+            const parameters = { key };
+            return (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row;
         });
     }
     /** @inheritDoc */
-    existsByUrn(urn, p1) {
+    $getBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'existsByUrn');
-            const lines = (0, line_1.cbLine)();
+            const { conn, useSoftDelete, useNumericId, full } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$getBySecondary' });
+                }
+                else {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$getBySecondary' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$getBySecondary');
+            const lines = (0, be_db_common_1.dbLines)();
             lines
-                .add(`SELECT meta().id as ${F_URN}`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`USE KEYS ${cb.v(urn)}`)
-                .add(`WHERE (a.${F_TRASH_ID} IS MISSING)`)
+                .add(`SELECT a.*`)
+                .add(`FROM ${full} a`)
+                .add(`WHERE (a.${F_ID} = $key)`)
+                .no(useSoftDelete, `  AND (a.${F_TRASH_ID} is missing)`)
                 .add('LIMIT 1');
-            return ((_a = (yield cb.one(this, lines.end(), opt)).row) === null || _a === void 0 ? void 0 : _a._urn) !== undefined;
+            const parameters = { key };
+            return (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row;
         });
     }
+    // endregion get
+    // region exists
     /** @inheritDoc */
-    existsById(id, p1) {
+    $existsByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.cb.buildOpt(p1, 'existsById');
-            return (yield this.urnById(id, opt)) !== undefined;
+            var _a, _b, _c;
+            if (!ignoreCheck) {
+                (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$existsByPrimary' });
+            }
+            const { useSoftDelete, conn, collection, full } = this._props;
+            const opt = conn.buildOpt(p1, '$existsByPrimary');
+            if (!useSoftDelete) {
+                return (_b = (_a = (yield conn.exec(collection.exists(key, opt), opt))) === null || _a === void 0 ? void 0 : _a.exists) !== null && _b !== void 0 ? _b : false;
+            }
+            const lines = (0, be_db_common_1.dbLines)();
+            lines
+                .add(`SELECT meta().id \`x\``)
+                .add(`FROM ${full} a`)
+                .add(`USE KEYS $key`)
+                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
+                .add('LIMIT 1');
+            const parameters = { key };
+            return ((_c = (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row) === null || _c === void 0 ? void 0 : _c.x) === undefined;
         });
     }
     /** @inheritDoc */
-    getByUrn(urn, p1) {
+    $existsBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'getByUrn');
-            const lines = (0, line_1.cbLine)();
+            var _a;
+            const { useSoftDelete, useNumericId, conn, full } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$existsBySecondary' });
+                }
+                else {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$existsBySecondary' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$existsBySecondary');
+            const lines = (0, be_db_common_1.dbLines)();
             lines
-                .add(`SELECT a.*`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`USE KEYS ${cb.v(urn)}`)
-                .add(`WHERE (a.${F_TRASH_ID} IS MISSING)`)
+                .add(`SELECT meta().id \`x\``)
+                .add(`FROM ${full} a`)
+                .add(`USE KEYS $key`)
+                .yes(useSoftDelete, `WHERE (a.${F_TRASH_ID} IS MISSING)`)
                 .add('LIMIT 1');
-            return (yield cb.one(this, lines.end(), opt)).row;
+            const parameters = { key };
+            return ((_a = (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row) === null || _a === void 0 ? void 0 : _a.x) === undefined;
         });
     }
+    // endregion exists
+    // region list
     /** @inheritDoc */
-    getById(id, p1) {
+    $listByPrimary(keys, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'getById');
-            const lines = (0, line_1.cbLine)();
+            if (!ignoreCheck) {
+                (0, type_2.assertArray)(keys, { field: 'keys', where: 'CbRepo', method: '$listByPrimary' });
+                keys.forEach((key, index) => {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$listByPrimary', index });
+                });
+            }
+            const { useSoftDelete, conn, full } = this._props;
+            const opt = conn.buildOpt(p1, '$listByIds');
+            const lines = (0, be_db_common_1.dbLines)();
             lines
                 .add(`SELECT a.*`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`WHERE (a.${F_ID} = ${cb.v(id)})`)
-                .add(`AND (a.${F_TRASH_ID} is missing)`)
-                .add('LIMIT 1');
-            return (yield cb.one(this, lines.end(), opt)).row;
+                .add(`FROM ${full} a`)
+                .add(`USE KEYS $keys`)
+                .yes(useSoftDelete, `WHERE (a.${F_TRASH_ID} is missing)`);
+            const parameters = { keys };
+            return (yield conn.more(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).rows;
         });
     }
     /** @inheritDoc */
-    listByUrn(urnList, p1) {
+    $listBySecondary(keys, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'listByUrn');
-            urnList = this._checkKeys(urnList);
-            if (urnList.length < 1) {
-                return [];
+            const { useSoftDelete, useNumericId, conn, full } = this._props;
+            if (!ignoreCheck) {
+                (0, type_2.assertArray)(keys, { field: 'keys', where: 'CbRepo', method: '$listBySecondary' });
+                keys.forEach((key, index) => {
+                    if (useNumericId) {
+                        (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$listBySecondary', index });
+                    }
+                    else {
+                        (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$listBySecondary', index });
+                    }
+                });
             }
-            const lines = (0, line_1.cbLine)();
+            const opt = conn.buildOpt(p1, '$listBySecondary');
+            const lines = (0, be_db_common_1.dbLines)();
             lines
                 .add(`SELECT a.*`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`USE KEYS ${cb.v(urnList)}`)
-                .add(`WHERE (a.${F_TRASH_ID} IS MISSING)`);
-            return (yield cb.more(this, lines.end(), opt)).rows;
+                .add(`FROM ${full} a`)
+                .add(`WHERE (a.${F_ID} IN $keys)`)
+                .yes(useSoftDelete, `  AND (a.${F_TRASH_ID} IS MISSING)`);
+            const parameters = { keys };
+            return (yield conn.more(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).rows;
         });
     }
+    // endregion list
+    // region filter
     /** @inheritDoc */
-    listById(ids, p1) {
+    $filter(query, p1) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'listById');
-            ids = this._checkKeys(ids);
-            if (ids.length < 1) {
-                return [];
-            }
-            const lines = (0, line_1.cbLine)();
+            const { useSoftDelete, conn, full } = this._props;
+            const opt = conn.buildOpt(p1, '$filter');
+            // @todo - work for query builder
+            const lines = (0, be_db_common_1.dbLines)();
             lines
                 .add(`SELECT a.*`)
-                .add(`FROM ${this.fullPath} a`)
-                .add(`WHERE (a.${F_ID} ${ids.length === 1 ? '=' : 'IN'} ${cb.v(ids)})`)
-                .add(`AND (a.${F_TRASH_ID} is missing)`);
-            return (yield cb.more(this, lines.end(), opt)).rows;
+                .add(`FROM ${full} a`)
+                .both(useSoftDelete, `WHERE (a.${F_TRASH_ID} is missing)`, `WHERE (meta().id is not missing)`);
+            return (yield conn.more(this.$def, lines.end(), opt)).rows;
         });
     }
+    // endregion filter
+    // region insert
     /** @inheritDoc */
-    removeByUrn(urn, p1) {
+    $insert(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'removeByUrn');
-            const lines = (0, line_1.cbLine)();
-            lines
-                .add(`DELETE
-                  FROM ${this.fullPath} a`)
-                .add(`USE KEYS ${cb.v(urn)}`)
-                .add(`WHERE (a.${F_TRASH_ID} is missing)`)
-                .add(`RETURNING a.${F_ID}`);
-            return (_a = (yield cb.one(this, lines.end(), opt)).row) === null || _a === void 0 ? void 0 : _a.id;
+            const { conn, collection, useNumericId } = this._props;
+            if (!ignoreCheck) {
+                (0, type_2.assertObject)(doc, { field: 'doc', where: 'CbRepo', method: '$insert' });
+                (0, type_2.assertText)(doc._urn, { field: 'doc._urn', where: 'CbRepo', method: '$insert' });
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'CbRepo', method: '$insert' });
+                }
+                else {
+                    (0, type_2.assertText)(doc.id, { field: 'doc.id', where: 'CbRepo', method: '$insert' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$insert');
+            yield conn.exec(collection.insert(doc._urn, doc), opt);
+            return doc._urn;
         });
     }
+    // endregion insert
+    // region replace
     /** @inheritDoc */
-    removeById(id, p1) {
+    $replace(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'removeById');
-            const lines = (0, line_1.cbLine)();
-            lines
-                .add(`DELETE FROM ${this.fullPath} a`)
-                .add(`WHERE (a.${F_ID} = ${cb.v(id)})`)
-                .add(`AND (a.${F_TRASH_ID} is missing)`)
-                .add(`RETURNING meta().id ${F_URN}`);
-            return (_a = (yield cb.one(this, lines.end(), opt)).row) === null || _a === void 0 ? void 0 : _a._urn;
+            const { conn, collection, useNumericId } = this._props;
+            if (!ignoreCheck) {
+                (0, type_2.assertObject)(doc, { field: 'doc', where: 'CbRepo', method: '$replace' });
+                (0, type_2.assertText)(doc._urn, { field: 'doc._urn', where: 'CbRepo', method: '$replace' });
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'CbRepo', method: '$replace' });
+                }
+                else {
+                    (0, type_2.assertText)(doc.id, { field: 'doc.id', where: 'CbRepo', method: '$replace' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$replace');
+            yield conn.exec(collection.replace(doc._urn, doc), opt);
+            return doc._urn;
         });
     }
+    // endregion replace
+    // region update
     /** @inheritDoc */
-    insert(doc, p1) {
+    $updateByPrimary(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'insert');
-            const urn = this._urnFromDoc(doc, 'insert');
-            doc.createdAt = new Date().toISOString();
-            doc.updatedAt = new Date().toISOString();
-            const result = yield cb.exec(this.collection.insert(urn, doc), opt);
-            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'inserted';
+            if (!ignoreCheck) {
+                (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$updateByPrimary' });
+                (0, type_2.assertObject)(doc, { field: 'doc', where: 'CbRepo', method: '$updateByPrimary' });
+            }
+            const { conn, full, useSoftDelete } = this._props;
+            const opt = conn.buildOpt(p1, '$updateByPrimary');
+            const parameters = {};
+            let paramId = 0;
+            const set = [];
+            const unset = [];
+            for (const [k, v] of Object.entries(doc)) {
+                if (v === undefined) {
+                    unset.push('a.' + conn.f(k));
+                }
+                else {
+                    set.push(['a.' + conn.f(k), '$param_' + paramId]);
+                    parameters['param_' + paramId] = v;
+                    paramId++;
+                }
+            }
+            if (set.length > 0 || unset.length > 0) {
+                const lines = (0, be_db_common_1.dbLines)();
+                lines.add(`UPDATE ${full} a`);
+                lines.add(`USE KEYS $key`);
+                parameters['key'] = key;
+                if (set.length > 0) {
+                    lines.add('SET').add(set.join(',\n  '));
+                }
+                if (unset.length > 0) {
+                    lines.add('UNSET').add(unset.join(', '));
+                }
+                lines
+                    .yes(useSoftDelete, `WHERE (a.${F_TRASH_ID} is missing)`);
+                yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }));
+                return key;
+            }
+            return undefined;
         });
     }
     /** @inheritDoc */
-    replace(doc, p1) {
+    $updateBySecondary(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'replace');
-            const urn = this._urnFromDoc(doc, 'replace');
-            doc.updatedAt = new Date().toISOString();
-            const result = yield cb.exec(this.collection.replace(urn, doc), opt);
-            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'inserted';
+            var _a;
+            const { useNumericId, useSoftDelete, conn, full } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$updateBySecondary' });
+                }
+                else {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$updateBySecondary' });
+                }
+                (0, type_2.assertObject)(doc, { field: 'doc', where: 'CbRepo', method: '$updateBySecondary' });
+            }
+            const opt = conn.buildOpt(p1, '$updateBySecondary');
+            const parameters = {};
+            let paramId = 0;
+            const set = [];
+            const unset = [];
+            for (const [k, v] of Object.entries(doc)) {
+                if (v === undefined) {
+                    unset.push('a.' + conn.f(k));
+                }
+                else {
+                    set.push(['a.' + conn.f(k), '$param_' + paramId]);
+                    parameters['param_' + paramId] = v;
+                    paramId++;
+                }
+            }
+            if (set.length > 0 || unset.length > 0) {
+                const lines = (0, be_db_common_1.dbLines)();
+                lines.add(`UPDATE ${full} a`);
+                if (set.length > 0) {
+                    lines.add('SET').add(set.join(',\n  '));
+                }
+                if (unset.length > 0) {
+                    lines.add('UNSET').add(unset.join(', '));
+                }
+                lines
+                    .add(`WHERE (a.${F_ID} = $key)`)
+                    .yes(useSoftDelete, `  AND (a.${F_TRASH_ID} is missing)`);
+                parameters['key'] = key;
+                lines.add('RETURNING meta().id \`x\`');
+                return (_a = (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row) === null || _a === void 0 ? void 0 : _a.x;
+            }
+            return undefined;
         });
     }
+    // endregion update
+    // region remove
     /** @inheritDoc */
-    upsert(doc, p1) {
+    $removeByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'upsert');
-            const urn = this._urnFromDoc(doc, 'upsert');
-            doc.updatedAt = new Date().toISOString();
-            const result = yield cb.exec(this.collection.upsert(urn, doc), opt);
-            return (result === null || result === void 0 ? void 0 : result.token) ? result.token.toString() : 'modified';
+            if (!ignoreCheck) {
+                (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$removeByPrimary' });
+            }
+            const { useSoftDelete, conn, full, collection } = this._props;
+            const opt = conn.buildOpt(p1, '$removeByPrimary');
+            if (!useSoftDelete) {
+                yield conn.exec(collection.remove(key, opt), opt);
+                return key;
+            }
+            const lines = (0, be_db_common_1.dbLines)();
+            lines
+                .add('DELETE')
+                .add(`FROM ${full} a`)
+                .add(`USE KEYS $key`)
+                .yes(useSoftDelete, `  AND (a.${F_TRASH_ID} is missing)`);
+            const parameters = { key };
+            yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }));
+            return key;
         });
     }
     /** @inheritDoc */
-    update(doc, p1) {
+    $removeBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'update');
-            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 cb.one(this, sql, opt)).row) === null || _a === void 0 ? void 0 : _a._urn;
+            const { useNumericId, useSoftDelete, conn, full } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$removeBySecondary' });
+                }
+                else {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$removeBySecondary' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$removeBySecondary');
+            const lines = (0, be_db_common_1.dbLines)();
+            lines
+                .add('DELETE')
+                .add(`FROM ${full} a`)
+                .add(`WHERE (a.${F_ID} = $key)`)
+                .yes(useSoftDelete, `  AND (a.${F_TRASH_ID} is missing)`)
+                .add('RETURNING meta().id \`x\`');
+            const parameters = { key };
+            return (_a = (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row) === null || _a === void 0 ? void 0 : _a.x;
         });
     }
+    // endregion remove
+    // region trash
     /** @inheritDoc */
-    trash(doc, p1) {
+    $trashByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.cb;
-            const opt = cb.buildOpt(p1, 'trash');
-            const urn = this._urnFromDoc(doc, 'trash');
-            if (opt.trashId === undefined) {
-                opt.trashId = (0, node_crypto_1.randomUUID)();
+            const { useSoftDelete, conn, full } = this._props;
+            if (!useSoftDelete) {
+                throw new be_db_common_1.DbNotSupportedError('Soft delete', 'CbRepo', '$trashByPrimary');
             }
-            const lines = (0, line_1.cbLine)();
+            if (!ignoreCheck) {
+                (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$trashByPrimary' });
+            }
+            const opt = conn.buildOpt(p1, '$trashByPrimary');
+            const lines = (0, be_db_common_1.dbLines)();
             lines
-                .add(`UPDATE ${this.fullPath} a`)
-                .add(`USE KEYS ${cb.v(urn)}`)
-                .add(`SET a.${F_TRASH_ID} = ${cb.v(opt.trashId)}`)
+                .add(`UPDATE ${full} a`)
+                .add(`SET`)
+                .add(`  \`updatedAt\` = $updated,`)
+                .add(`  ${F_TRASH_ID} = $trashId`)
+                .add(`USE KEYS $key`)
                 .add(`WHERE (a.${F_TRASH_ID} is missing)`);
-            yield cb.one(this, lines.end(), opt);
-            return opt.trashId;
+            const parameters = {
+                updated: this._now,
+                trashId: opt.trashId,
+                key,
+            };
+            yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }));
+            return key;
+        });
+    }
+    /** @inheritDoc */
+    $trashBySecondary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { useSoftDelete, useNumericId, conn, full } = this._props;
+            if (!useSoftDelete) {
+                throw new be_db_common_1.DbNotSupportedError('Soft delete', 'CbRepo', '$trashBySecondary');
+            }
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'CbRepo', method: '$trashBySecondary' });
+                }
+                else {
+                    (0, type_2.assertText)(key, { field: 'key', where: 'CbRepo', method: '$trashBySecondary' });
+                }
+            }
+            const opt = conn.buildOpt(p1, '$trashBySecondary');
+            const lines = (0, be_db_common_1.dbLines)();
+            lines
+                .add(`UPDATE ${full} a`)
+                .add(`SET`)
+                .add(`  \`updatedAt\` = $updated,`)
+                .add(`  ${F_TRASH_ID} = $trashId`)
+                .add(`WHERE (a.${F_ID} = $key)`)
+                .add(`  AND (a.${F_TRASH_ID} is missing)`)
+                .add('RETURNING meta().id \`x\`');
+            const parameters = {
+                updated: this._now,
+                trashId: opt.trashId,
+                key,
+            };
+            return (_a = (yield conn.one(this.$def, lines.end(), Object.assign(Object.assign({}, opt), { parameters }))).row) === null || _a === void 0 ? void 0 : _a.x;
         });
     }
 }
 exports.CbRepo = CbRepo;
+// region private-property
+// {bucket: scope[]}
+CbRepo._specs = new Map;