@samet-it/be-db-common 1.0.11

package/dist/repo/db.repo.js

@@ -0,0 +1,924 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbRepo = void 0;
+const node_crypto_1 = require("node:crypto");
+const query_1 = require("@leyyo/query");
+const type_1 = require("@leyyo/type");
+const error_1 = require("../error");
+// noinspection JSUnusedGlobalSymbols
+/**
+ * DB repository abstract class
+ * */
+class DbRepo {
+    // endregion protected-property
+    constructor(conn, opt) {
+        /**
+         * Option of in-body usage in place of constructor param
+         * */
+        this._opt = {};
+        if (!(0, type_1.isObjectFilled)(conn)) {
+            throw new error_1.DbInvalidValueError('Connection', typeof conn, 'DbRepo', 'constructor');
+        }
+        if (!(0, type_1.isObjectBare)(this._opt)) {
+            this._opt = {};
+        }
+        if ((0, type_1.isObjectBare)(opt)) {
+            this._opt = Object.assign(Object.assign({}, this._opt), opt);
+        }
+        // handle invalid cache
+        if (!this._opt.cache) {
+            this._opt.cache = { isConnected: false };
+        }
+        if (this._opt.useVersion) {
+            if (typeof this._opt.version !== 'number') {
+                throw new error_1.DbInvalidValueError('Model version', typeof conn, 'DbRepo', 'constructor');
+            }
+        }
+        else {
+            this._opt.version = undefined;
+        }
+        if (typeof this._opt.urnDelimiter !== 'string') {
+            this._opt.urnDelimiter = ',';
+        }
+        else {
+            this._opt.urnDelimiter = this._opt.urnDelimiter.trim();
+            if (![',', '|', ';', '/'].includes(this._opt.urnDelimiter)) {
+                this._opt.urnDelimiter = ',';
+            }
+        }
+        if (typeof this._opt.urnPrefix !== 'string') {
+            this._opt.urnPrefix = undefined;
+        }
+        else {
+            this._opt.urnPrefix = this._opt.urnPrefix.trim();
+            if (!this._opt.urnPrefix) {
+                this._opt.urnPrefix = undefined;
+            }
+        }
+        if (!this._opt.urnPrefix) {
+            throw new error_1.DbInvalidValueError('Urn prefix', typeof conn, 'DbRepo', 'constructor');
+        }
+        this._opt.forbiddenSet = this._checkForbiddenList(this._opt.forbiddenSet, ['id', '_urn', '_trashId', 'createdAt', 'createdBy']);
+        this._opt.forbiddenUnset = this._checkForbiddenList(this._opt.forbiddenUnset, ['id', '_urn', '_trashId', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy']);
+        this._props = Object.assign({ conn }, this._opt);
+        delete this._opt;
+    }
+    // region protected-method
+    _removeFieldForForbidden(fields, flag, field) {
+        if (this._opt[flag] !== true) {
+            const index = fields.indexOf(field);
+            if (index >= 0) {
+                fields.splice(index, 0);
+            }
+        }
+    }
+    _checkForbiddenList(given, def) {
+        if (!Array.isArray(given)) {
+            given = [];
+        }
+        else {
+            given = given.filter(v => (0, type_1.isText)(v));
+        }
+        if (given.length < 1) {
+            given.push(...def);
+        }
+        this._removeFieldForForbidden(given, 'useSoftDelete', '_trashId');
+        this._removeFieldForForbidden(given, 'useCreatedAt', 'createdAt');
+        this._removeFieldForForbidden(given, 'useCreatedBy', 'createdBy');
+        this._removeFieldForForbidden(given, 'useUpdatedAt', 'updatedAt');
+        this._removeFieldForForbidden(given, 'useUpdatedBy', 'updatedBy');
+        this._removeFieldForForbidden(given, 'useRevision', '_rev');
+        this._removeFieldForForbidden(given, 'useVersion', '_ver');
+        return given;
+    }
+    get _now() {
+        const { useIsoDate } = this._props;
+        return useIsoDate ? new Date().toISOString() : Date.now();
+    }
+    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;
+        }
+        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 (!name.startsWith('idx_')) {
+            name = 'idx_' + name;
+        }
+        if (name.length > 30) {
+            name = name.substring(0, 30);
+        }
+        return name;
+    }
+    /**
+     * Fetch urn from doc as doc._urn
+     * */
+    _urnFromDoc(doc, method) {
+        const { path } = this._props;
+        (0, type_1.assertObject)(doc, () => {
+            return { field: 'doc', where: 'DbRepo', path, method };
+        });
+        const urn = doc._urn;
+        (0, type_1.assertObject)(urn, () => {
+            return { field: 'urn', where: 'DbRepo', path, method };
+        });
+        return urn;
+    }
+    _checkKey(value) {
+        const { useNumericId } = this._props;
+        let id;
+        switch (typeof value) {
+            case "string":
+                const str = value.trim();
+                if (str) {
+                    if (this._isUrn(str)) {
+                        return [str, '_urn'];
+                    }
+                    else {
+                        if (useNumericId) {
+                            try {
+                                id = parseInt(str);
+                            }
+                            catch (e) {
+                                // nothing
+                            }
+                            if (id !== undefined) {
+                                return [id, 'id'];
+                            }
+                        }
+                        else {
+                            return [str, 'id'];
+                        }
+                    }
+                }
+                break;
+            case "number":
+                if (useNumericId) {
+                    return [value, 'id'];
+                }
+                else {
+                    return [value.toString(10), 'id'];
+                }
+            case "object":
+                if (!value) {
+                    return [undefined, undefined];
+                }
+                const obj = value;
+                if (obj.id !== undefined) {
+                    return this._checkKey(obj.id);
+                }
+                if (obj.urn !== undefined) {
+                    return this._checkKey(obj.urn);
+                }
+                if (obj._urn !== undefined) {
+                    return this._checkKey(obj._urn);
+                }
+                break;
+        }
+        return [undefined, undefined];
+    }
+    /**
+     * Check array keys as id list or urn list
+     * */
+    _checkKeys(keys) {
+        const result = { urns: [], ids: [], ordered: [] };
+        if (!keys || !Array.isArray(keys) || keys.length < 1) {
+            return result;
+        }
+        for (const item of keys) {
+            const [key, field] = this._checkKey(item);
+            if (field) {
+                if ((field === '_urn') && !result.urns.includes(key)) {
+                    result.urns.push(key);
+                    result.ordered.push([key, field]);
+                }
+                else if ((field === 'id') && !result.ids.includes(key)) {
+                    result.ids.push(key);
+                    result.ordered.push([key, field]);
+                }
+            }
+        }
+        return result;
+    }
+    _isUrn(key) {
+        const { urnPrefix } = this._props;
+        return (typeof key === 'string') && key.startsWith(urnPrefix + ':');
+    }
+    // endregion protected-method
+    // region getter
+    /** @inheritDoc */
+    get props() {
+        return this._props;
+    }
+    /** @inheritDoc */
+    get $def() {
+        return this;
+    }
+    /** @inheritDoc */
+    $cast() {
+        return this;
+    }
+    // endregion getter
+    // region urn
+    _keyToUrn(key) {
+        const { urnPrefix } = this._props;
+        return `${urnPrefix}:${key}`;
+    }
+    /** @inheritDoc */
+    toUrn(urnRec) {
+        const { urnPrefix, urnDelimiter } = this._props;
+        return `${urnPrefix}:${this.$toUrnTuple(urnRec).join(urnDelimiter)}`;
+    }
+    /** @inheritDoc */
+    $toUrnTuple(urnRec) {
+        return [urnRec['id']];
+    }
+    // endregion urn
+    // region get
+    /** @inheritDoc */
+    get(k1, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [key, field] = this._checkKey(k1);
+            switch (field) {
+                case "_urn":
+                    return this.getByPrimary(key, p1, true);
+                case "id":
+                    return this.getBySecondary(key, p1, true);
+                default:
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'get' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    getByPrimary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary' });
+            }
+            let found;
+            if (cache.props.isConnected) {
+                try {
+                    found = (yield cache.getByPrimary(key))[0];
+                }
+                catch (e) {
+                    this.logger.warn(`getByPrimary.cache.getByPrimary <${e.name}> ${e.message}`);
+                }
+                if (found) {
+                    return found;
+                }
+            }
+            found = yield this.$getByPrimary(key, p1, true);
+            if (found && cache.props.isConnected) {
+                cache.ingestDoc(found)
+                    .then()
+                    .catch(e => this.logger.warn(`getByPrimary.cache.ingestDoc <${e.name}> ${e.message}`));
+            }
+            return found;
+        });
+    }
+    /** @inheritDoc */
+    getBySecondary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache, useNumericId, idSame } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                }
+                else {
+                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                }
+            }
+            if (idSame) {
+                return this.getByPrimary(this._keyToUrn(key), p1, true);
+            }
+            let found;
+            if (cache.props.isConnected) {
+                try {
+                    found = (yield cache.getBySecondary(key))[0];
+                    if (found) {
+                        return found;
+                    }
+                }
+                catch (e) {
+                    this.logger.warn(`getBySecondary.cache.getBySecondary <${e.name}> ${e.message}`);
+                }
+            }
+            found = yield this.$getBySecondary(key, p1, true);
+            if (found && cache.props.isConnected) {
+                cache.ingestDoc(found)
+                    .then()
+                    .catch(e => this.logger.warn(`getBySecondary.cache.ingestDoc <${e.name}> ${e.message}`));
+            }
+            return found;
+        });
+    }
+    // endregion get
+    // region exists
+    /** @inheritDoc */
+    exists(k1, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [key, field] = this._checkKey(k1);
+            switch (field) {
+                case "_urn":
+                    return this.existsByPrimary(key, p1, true);
+                case "id":
+                    return this.existsBySecondary(key, p1, true);
+                default:
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'exists' });
+                    break;
+            }
+        });
+    }
+    /** @inheritDoc */
+    existsByPrimary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary' });
+            }
+            if (cache.props.isConnected) {
+                try {
+                    const found = (yield cache.getByPrimary(key))[0];
+                    if (found) {
+                        return true;
+                    }
+                }
+                catch (e) {
+                    this.logger.warn(`existsByPrimary.cache.existsByPrimary <${e.name}> ${e.message}`);
+                }
+            }
+            return this.$existsByPrimary(key, p1, true);
+        });
+    }
+    /** @inheritDoc */
+    existsBySecondary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache, useNumericId, idSame } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary' });
+                }
+                else {
+                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary' });
+                }
+            }
+            if (!idSame) {
+                return this.existsByPrimary(this._keyToUrn(key));
+            }
+            if (cache.props.isConnected) {
+                try {
+                    const found = (yield cache.getBySecondary(key))[0];
+                    if (found) {
+                        return true;
+                    }
+                }
+                catch (e) {
+                    this.logger.warn(`existsBySecondary.cache.existsBySecondary <${e.name}> ${e.message}`);
+                }
+            }
+            return this.$existsBySecondary(key, p1, true);
+        });
+    }
+    // endregion exists
+    // region list
+    /** @inheritDoc */
+    list(keys, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ignoreCheck) {
+                (0, type_1.assertArray)(keys, { field: 'keys', where: 'DbRepo', method: 'list' });
+            }
+            const { conn, cache } = this._props;
+            const opt = conn.buildOpt(p1, 'list');
+            const result = this._checkKeys(keys);
+            if (result.ordered.length < 1) {
+                return [];
+            }
+            const docs = [];
+            let founds = [];
+            if (result.urns.length > 0) {
+                if (cache.props.isConnected) {
+                    try {
+                        founds = yield cache.getByPrimary(...result.urns);
+                    }
+                    catch (e) {
+                        this.logger.warn(`list.cache.getByPrimary <${e.name}> ${e.message}`);
+                    }
+                    founds.forEach(val => {
+                        const index = result.urns.indexOf(val._urn);
+                        if (index >= 0) {
+                            result.urns.splice(index, 1);
+                        }
+                    });
+                    docs.push(...founds);
+                }
+                if (result.urns.length > 0) {
+                    founds = yield this.$listByPrimary(result.urns, opt, true);
+                    if (founds.length > 0) {
+                        if (cache.props.isConnected) {
+                            founds.forEach(found => cache.ingestDoc(found)
+                                .then()
+                                .catch(e => this.logger.warn(`list.cache.ingestDoc <${e.name}> ${e.message}`)));
+                        }
+                        docs.push(...founds);
+                    }
+                }
+            }
+            if (result.ids.length > 0) {
+                if (cache.props.isConnected) {
+                    try {
+                        founds = yield cache.getBySecondary(...result.ids);
+                    }
+                    catch (e) {
+                        this.logger.warn(`list.cache.getBySecondary <${e.name}> ${e.message}`);
+                    }
+                    founds.forEach(val => {
+                        const index = result.ids.indexOf(val.id);
+                        if (index >= 0) {
+                            result.ids.splice(index, 1);
+                        }
+                    });
+                    docs.push(...founds);
+                }
+                if (result.ids.length > 0) {
+                    founds = yield this.$listBySecondary(result.ids, opt, true);
+                    if (founds.length > 0) {
+                        if (cache.props.isConnected) {
+                            founds.forEach(found => cache.ingestDoc(found)
+                                .then()
+                                .catch(e => this.logger.warn(`list.cache.ingestDoc <${e.name}> ${e.message}`)));
+                        }
+                        docs.push(...founds);
+                    }
+                }
+            }
+            return result.ordered.map(o => docs.find(d => d[o[1]] === o[0]));
+        });
+    }
+    // endregion list
+    // region filter
+    /** @inheritDoc */
+    filter(query, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'filter');
+            return this.$filter(query_1.queryParser.exec(query, [], opt.name), opt);
+        });
+    }
+    // endregion filter
+    // region insert
+    /** @inheritDoc */
+    insert(doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useCreatedAt, useNumericId, useCreatedBy, useUpdatedAt, useUpdatedBy } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'insert' });
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                }
+                else {
+                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                }
+                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'insert' });
+            }
+            if (!doc._trashId !== undefined) {
+                delete doc._trashId;
+            }
+            if (useCreatedAt) {
+                doc.createdAt = this._now;
+            }
+            if (useCreatedBy) {
+                // todo
+            }
+            if (useUpdatedAt) {
+                doc.updatedAt = this._now;
+            }
+            if (useUpdatedBy) {
+                // todo
+            }
+            return this.$insert(doc, p1);
+        });
+    }
+    /** @inheritDoc */
+    inserts(docs, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ignoreCheck) {
+                (0, type_1.assertArray)(docs, { field: 'docs', where: 'DbRepo', method: 'inserts' });
+            }
+            const insertedIds = [];
+            for (const doc of docs) {
+                insertedIds.push(yield this.insert(doc, p1, true));
+            }
+            return insertedIds;
+        });
+    }
+    // endregion insert
+    // region replace
+    /** @inheritDoc */
+    replace(doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'replace' });
+                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'replace' });
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                }
+                else {
+                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                }
+            }
+            if (doc._trashId !== undefined) {
+                delete doc._trashId;
+            }
+            if (useUpdatedAt) {
+                doc.updatedAt = this._now;
+            }
+            if (useUpdatedBy) {
+                // todo
+            }
+            const replacedId = yield this.$replace(doc, p1, true);
+            if (cache.props.isConnected) {
+                cache.clearDoc(replacedId)
+                    .then()
+                    .catch(e => this.logger.warn(`replace.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return replacedId;
+        });
+    }
+    // endregion replace
+    // region update
+    /** @inheritDoc */
+    update(k1, doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ignoreCheck) {
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'update' });
+            }
+            const [key, field] = this._checkKey(k1);
+            switch (field) {
+                case "_urn":
+                    return this.updateByPrimary(key, doc, p1, true);
+                case "id":
+                    return this.updateBySecondary(key, doc, p1, true);
+                default:
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'update' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    updateByPrimary(key, doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { forbiddenSet, cache, useUpdatedAt, useUpdatedBy } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'updateByPrimary' });
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'updateByPrimary' });
+            }
+            if (doc._trashId !== undefined) {
+                delete doc._trashId;
+            }
+            forbiddenSet.forEach(f => {
+                if (doc[f] !== undefined) {
+                    delete doc[f];
+                }
+            });
+            if (useUpdatedAt) {
+                doc.updatedAt = this._now;
+            }
+            if (useUpdatedBy) {
+                // todo
+            }
+            const updatedKey = yield this.$updateByPrimary(key, doc, p1, true);
+            if (updatedKey && cache.props.isConnected) {
+                cache.clearDoc(updatedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`updateByPrimary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return updatedKey;
+        });
+    }
+    /** @inheritDoc */
+    updateBySecondary(key, doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { forbiddenSet, cache, useNumericId, idSame, useUpdatedAt, useUpdatedBy } = this._props;
+            if (!ignoreCheck) {
+                if (useNumericId) {
+                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                }
+                else {
+                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                }
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'getBySecondary' });
+            }
+            if (idSame) {
+                return this.updateBySecondary(this._keyToUrn(key), doc, p1, true);
+            }
+            if (doc._trashId !== undefined) {
+                delete doc._trashId;
+            }
+            forbiddenSet.forEach(f => {
+                if (doc[f] !== undefined) {
+                    delete doc[f];
+                }
+            });
+            if (useUpdatedAt) {
+                doc.updatedAt = this._now;
+            }
+            if (useUpdatedBy) {
+                // todo
+            }
+            const updatedKey = yield this.$updateBySecondary(key, doc, p1, true);
+            if (updatedKey && cache.props.isConnected) {
+                cache.clearDoc(updatedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`updateBySecondary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return updatedKey;
+        });
+    }
+    // endregion update
+    // region set
+    /** @inheritDoc */
+    set(key, doc, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ignoreCheck) {
+                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'set' });
+            }
+            for (const [f, v] of Object.entries(doc)) {
+                if (v === undefined) { // dont allow undefined
+                    delete doc[f];
+                }
+            }
+            return this.update(key, doc, p1, false);
+        });
+    }
+    /** @inheritDoc */
+    unset(key, fields, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ignoreCheck) {
+                (0, type_1.assertArray)(fields, { field: 'fields', where: 'DbRepo', method: 'unset' });
+                fields.forEach((field, index) => {
+                    (0, type_1.assertText)(field, { field: field, where: 'DbRepo', method: 'unset', index });
+                });
+            }
+            const { forbiddenUnset } = this._props;
+            const doc = {};
+            fields.forEach(f => {
+                if (!forbiddenUnset.includes(f)) {
+                    doc[f] = undefined;
+                }
+            });
+            return this.update(key, doc, p1, false);
+        });
+    }
+    // endregion set
+    // region remove
+    /** @inheritDoc */
+    remove(k1, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [key, field] = this._checkKey(k1);
+            switch (field) {
+                case "_urn":
+                    return this.removeByPrimary(key, p1, true);
+                case "id":
+                    return this.removeBySecondary(key, p1, true);
+                default:
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'remove' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    removeByPrimary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache } = this._props;
+            if (!ignoreCheck) {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'removeByPrimary' });
+            }
+            const removedKey = yield this.$removeByPrimary(key, p1, true);
+            if (removedKey && cache.props.isConnected) {
+                cache.clearDoc(removedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`removeByPrimary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return removedKey;
+        });
+    }
+    /** @inheritDoc */
+    removeBySecondary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cache, useNumericId, idSame } = this._props;
+            if (useNumericId) {
+                (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'removeBySecondary' });
+            }
+            else {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'removeBySecondary' });
+            }
+            if (idSame) {
+                return this.removeByPrimary(this._keyToUrn(key), p1, ignoreCheck);
+            }
+            const removedKey = yield this.$removeBySecondary(key, p1, true);
+            if (removedKey && cache.props.isConnected) {
+                cache.clearDoc(removedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`removeBySecondary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return removedKey;
+        });
+    }
+    // endregion remove
+    // region trash
+    /** @inheritDoc */
+    trash(k1, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [key, field] = this._checkKey(k1);
+            switch (field) {
+                case "_urn":
+                    return this.trashByPrimary(key, p1, true);
+                case "id":
+                    return this.trashBySecondary(key, p1, true);
+                default:
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'trash' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    trashByPrimary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useSoftDelete, conn, cache } = this._props;
+            if (!useSoftDelete) {
+                throw new error_1.DbNotSupportedError('Soft delete', 'DbRepo', 'trashByPrimary');
+            }
+            if (!ignoreCheck) {
+                (0, type_1.assertText)(key, { field: 'urn', where: 'DbRepo', method: 'trashByPrimary' });
+            }
+            const opt = conn.buildOpt(p1, 'trashByPrimary');
+            if (!(0, type_1.isText)(opt.trashId)) {
+                opt.trashId = (0, node_crypto_1.randomUUID)();
+            }
+            const trashedKey = yield this.$trashByPrimary(key, opt, true);
+            if (trashedKey && cache.props.isConnected) {
+                cache.clearDoc(trashedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`trashByPrimary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return trashedKey;
+        });
+    }
+    /** @inheritDoc */
+    trashBySecondary(key, p1, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useSoftDelete, useNumericId, idSame, conn, cache } = this._props;
+            if (!useSoftDelete) {
+                throw new error_1.DbNotSupportedError('Soft delete', 'DbRepo', 'trashBySecondary');
+            }
+            if (useNumericId) {
+                (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'trashBySecondary' });
+            }
+            else {
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'trashBySecondary' });
+            }
+            if (idSame) {
+                return this.trashByPrimary(this._keyToUrn(key), p1, ignoreCheck);
+            }
+            const opt = conn.buildOpt(p1, 'trashBySecondary');
+            if (!(0, type_1.isText)(opt.trashId)) {
+                opt.trashId = (0, node_crypto_1.randomUUID)();
+            }
+            const trashedKey = yield this.$trashBySecondary(key, opt, true);
+            if (trashedKey && cache.props.isConnected) {
+                cache.clearDoc(trashedKey)
+                    .then()
+                    .catch(e => this.logger.warn(`trashBySecondary.cache.clearDoc <${e.name}> ${e.message}`));
+            }
+            return trashedKey;
+        });
+    }
+    // endregion trash
+    // region dim
+    /** @inheritDoc */
+    $toDim(doc, dim) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!doc) {
+                return undefined;
+            }
+            switch (dim) {
+                case "portion":
+                    return yield this.$toPortion(doc);
+                case "view":
+                    return yield this.$toView(doc);
+                case "pair":
+                    return yield this.$toPair(doc);
+                default:
+                    return yield this.$toPortion(doc);
+            }
+        });
+    }
+    /** @inheritDoc */
+    getDim(key, dim) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const doc = yield this.get(key, { name: `getDim/${dim !== null && dim !== void 0 ? dim : 'def'}` });
+            return doc ? this.$toDim(doc, dim) : undefined;
+        });
+    }
+    /** @inheritDoc */
+    listDims(keys, dim, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const docs = yield this.list(keys, { name: `listDims/${dim !== null && dim !== void 0 ? dim : 'def'}` }, ignoreCheck);
+            if (docs.length < 1) {
+                return [];
+            }
+            const items = [];
+            for (const doc of docs) {
+                items.push(yield this.$toDim(doc, dim));
+            }
+            return items;
+        });
+    }
+    // endregion dim
+    // region pair
+    /** @inheritDoc */
+    $toPair(doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!doc) {
+                return undefined;
+            }
+            return { id: doc === null || doc === void 0 ? void 0 : doc.id, name: doc === null || doc === void 0 ? void 0 : doc.name };
+        });
+    }
+    /** @inheritDoc */
+    getPair(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getDim(key, 'pair');
+        });
+    }
+    /** @inheritDoc */
+    listPairs(keys, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listDims(keys, 'pair', ignoreCheck);
+        });
+    }
+    // endregion pair
+    // region view
+    $toView(doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return doc;
+        });
+    }
+    /** @inheritDoc */
+    getView(identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getDim(identifier, 'view');
+        });
+    }
+    /** @inheritDoc */
+    listViews(identifiers, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listDims(identifiers, 'view', ignoreCheck);
+        });
+    }
+    // endregion view
+    // region portion
+    /** @inheritDoc */
+    $toPortion(doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!doc) {
+                return undefined;
+            }
+            return { id: doc === null || doc === void 0 ? void 0 : doc.id };
+        });
+    }
+    /** @inheritDoc */
+    getPortion(identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getDim(identifier, 'portion');
+        });
+    }
+    /** @inheritDoc */
+    listPortions(identifiers, ignoreCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listDims(identifiers, 'portion', ignoreCheck);
+        });
+    }
+}
+exports.DbRepo = DbRepo;