@samet-it/be-db-common 1.3.2 → 1.3.4

package/dist/repo/db.repo.js

@@ -1,21 +1,10 @@
-"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 be_base_common_1 = require("@samet-it/be-base-common");
-const common_1 = require("@leyyo/common");
-const query_1 = require("@leyyo/query");
-const type_1 = require("@leyyo/type");
-const error_1 = require("../error");
+import { randomUUID } from "node:crypto";
+import { errorHandler } from "@samet-it/be-base-common";
+import { errorCommon, isFilledObj, isText } from "@leyyo/common";
+import { queryParser } from "@leyyo/query";
+import { assertArray, assertInteger, assertMessage, assertObject, assertText } from "@leyyo/assert";
+import { DbError, DbInvalidValueError, DbNotSupportedError } from "../error/index.js";
+import { isBareObject } from "@leyyo/type";
 const FORBIDDEN_KEYS = ['id', 'urn', '_trashId', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy', "_rev", '_search', '_alpha', '_irregular'];
 const STRICT_KEYS = ['id', 'urn', '_trashId', "_rev", '_irregular'];
 // noinspection JSUnusedGlobalSymbols
@@ -35,7 +24,21 @@ const STRICT_KEYS = ['id', 'urn', '_trashId', "_rev", '_irregular'];
  * - 9-`KEYS`: keys to autocomplete, def: keys of {@link Entity}
  * - 10-`DIMS`: dimensions for presentation layer {@link DefDims}
  * */
-class DbRepo {
+export class DbRepo {
+    // region protected-property
+    /**
+     * Logger
+     * */
+    logger;
+    /**
+     * Option of in-body usage in place of constructor param
+     * */
+    _opt = {};
+    /**
+     * Produced setting from option
+     * @see _opt
+     * */
+    _props;
     // endregion protected-property
     /**
      * Constructor
@@ -44,21 +47,17 @@ class DbRepo {
      * @param {DbRepoOpt} opt - options
      * */
     constructor(conn, opt) {
-        /**
-         * Option of in-body usage in place of constructor param
-         * */
-        this._opt = {};
-        if (!(0, common_1.isFilledObj)(conn)) {
-            throw new error_1.DbInvalidValueError('Connection', { where: 'DbRepo', method: 'constructor', type: typeof conn });
-        }
-        if (!(0, type_1.isBareObject)(this._opt)) {
+        if (!isFilledObj(conn)) {
+            throw new DbInvalidValueError('Connection', { where: 'DbRepo', method: 'constructor', type: typeof conn });
+        }
+        if (!isBareObject(this._opt)) {
             this._opt = {};
         }
-        if ((0, type_1.isBareObject)(opt)) {
-            this._opt = Object.assign(Object.assign({}, this._opt), opt);
+        if (isBareObject(opt)) {
+            this._opt = { ...this._opt, ...opt };
         }
         this._checkOptions();
-        this._props = Object.assign({ conn }, this._opt);
+        this._props = { conn, ...this._opt };
         delete this._opt;
     }
     // region protected-method
@@ -72,7 +71,7 @@ class DbRepo {
         }
         if (this._opt.useVersion) {
             if (typeof this._opt.version !== 'number') {
-                throw new error_1.DbInvalidValueError('Model version', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.version });
+                throw new DbInvalidValueError('Model version', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.version });
             }
         }
         else {
@@ -97,7 +96,7 @@ class DbRepo {
             }
         }
         if (!this._opt.urnPrefix) {
-            throw new error_1.DbInvalidValueError('Urn prefix', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.urnPrefix });
+            throw new DbInvalidValueError('Urn prefix', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.urnPrefix });
         }
         if (!Array.isArray(this._opt.forbiddenSet)) {
             this._opt.forbiddenSet = [...FORBIDDEN_KEYS];
@@ -114,9 +113,9 @@ class DbRepo {
             this.$toUrnTuple = directOpt.$toUrnTuple;
         }
         if (typeof directOpt.$toDim === 'function') {
-            this.$toDim = (doc, dim) => __awaiter(this, void 0, void 0, function* () {
-                return (yield directOpt.$toDim(doc, dim));
-            });
+            this.$toDim = async (doc, dim) => {
+                return (await directOpt.$toDim(doc, dim));
+            };
         }
         if (!Array.isArray(directOpt.indexedFields)) {
             directOpt.indexedFields = [];
@@ -139,7 +138,7 @@ class DbRepo {
      * @return {string}
      * */
     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)
+        return 'idx_' + 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('_');
     }
@@ -177,8 +176,8 @@ class DbRepo {
      * */
     _urnFromDoc(doc, method) {
         const param = { where: 'DbRepo', path: this.path, method };
-        (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-        (0, type_1.assertText)(doc.urn, Object.assign({ field: 'urn' }, param));
+        assertObject(doc, { field: 'doc', ...param });
+        assertText(doc.urn, { field: 'urn', ...param });
         return doc.urn;
     }
     /**
@@ -404,9 +403,8 @@ class DbRepo {
     }
     /** @inheritDoc */
     get urnLength() {
-        var _a, _b;
         if (!this._props.urnLength) {
-            this._props.urnLength = (_b = (_a = this._props.urnPrefix) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+            this._props.urnLength = this._props.urnPrefix?.length ?? 0;
         }
         return this._props.urnLength;
     }
@@ -414,26 +412,25 @@ class DbRepo {
     // region field-value
     /** {@inheritDoc} */
     checkError(err, opt) {
-        var _a, _b, _c;
-        const size = be_base_common_1.errorHandler.addStat(err);
-        const ignoredErrors = (_a = opt === null || opt === void 0 ? void 0 : opt.ignoredErrors) !== null && _a !== void 0 ? _a : [];
+        const size = errorHandler.addStat(err);
+        const ignoredErrors = opt?.ignoredErrors ?? [];
         if (ignoredErrors.includes(err) || ignoredErrors.includes(err.name)) {
             return;
         }
-        if (opt === null || opt === void 0 ? void 0 : opt.silent) {
+        if (opt?.silent) {
             if (size < 100) {
-                this.logger.warn(common_1.errorCommon.text(err, ((_b = opt.name) !== null && _b !== void 0 ? _b : 'Database error'), size));
+                this.logger.warn(errorCommon.text(err, (opt.name ?? 'Database error'), size));
             }
             return;
         }
         if (size < 100) {
-            this.logger.error(common_1.errorCommon.text(err, ((_c = opt.name) !== null && _c !== void 0 ? _c : 'Database error'), size));
+            this.logger.error(errorCommon.text(err, (opt.name ?? 'Database error'), size));
         }
-        if (err instanceof error_1.DbError) {
+        if (err instanceof DbError) {
             throw err;
         }
         else {
-            throw common_1.errorCommon.forcedCast(error_1.DbError, err, { queryName: opt.name });
+            throw errorCommon.forcedCast(DbError, err, { queryName: opt.name });
         }
     }
     /** {@inheritDoc} */
@@ -468,7 +465,7 @@ class DbRepo {
     // region option
     /** {@inheritDoc} */
     buildOpt(p1, name) {
-        const opt = (typeof p1 === 'string' ? { name: p1 } : Object.assign({}, p1));
+        const opt = (typeof p1 === 'string' ? { name: p1 } : { ...p1 });
         if (typeof opt.name === undefined && typeof name !== undefined) {
             opt.name = name;
         }
@@ -478,26 +475,39 @@ class DbRepo {
     // endregion option
     // region query
     /** {@inheritDoc} */
-    exec(fn, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isEnabled) {
-                return undefined;
-            }
-            const opt = this.buildOpt(p1);
-            try {
-                return yield fn;
-            }
-            catch (err) {
-                this.checkError(err, opt);
-                return undefined;
-            }
-        });
+    async exec(fn, p1) {
+        if (!this.isEnabled) {
+            return undefined;
+        }
+        const opt = this.buildOpt(p1);
+        try {
+            return await fn;
+        }
+        catch (err) {
+            this.checkError(err, opt);
+            return undefined;
+        }
     }
     // endregion query
     // region urn
     /** @inheritDoc */
     toUrn(urnRec) {
-        return `${this.urnPrefix}:${this.$toUrnTuple(urnRec).join(this.urnDelimiter)}`;
+        let code = this.$toUrnTuple(urnRec).join(this.urnDelimiter);
+        if (code.includes(':')) {
+            code = code.split(':').join(';');
+        }
+        return `${this.urnPrefix}:${code}`;
+    }
+    /** @inheritDoc */
+    toUrnKey(p1) {
+        if (isText(p1)) {
+            return p1.split(':').pop();
+        }
+        const doc = p1;
+        if (isFilledObj(doc)) {
+            return this.toUrnKey(doc.urn);
+        }
+        return undefined;
     }
     /** @inheritDoc */
     $toUrnTuple(urnRec) {
@@ -506,743 +516,723 @@ class DbRepo {
     // endregion urn
     // region get
     /** @inheritDoc */
-    get(keyLike, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'get');
-            const [key, field] = this._checkKey(keyLike);
-            switch (field) {
-                case "urn":
-                    return this.getByPrimary(key, opt, true);
-                case "id":
-                    return this.getBySecondary(key, opt, true);
-                default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'get', queryName: opt.name });
-            }
-        });
+    async get(keyLike, p1) {
+        const opt = this.buildOpt(p1, 'get');
+        const [key, field] = this._checkKey(keyLike);
+        switch (field) {
+            case "urn":
+                return this.getByPrimary(key, opt, true);
+            case "id":
+                return this.getBySecondary(key, opt, true);
+            default:
+                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'get', queryName: opt.name });
+        }
     }
     /** @inheritDoc */
-    getByPrimary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'getByPrimary');
-            if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary', queryName: opt.name });
+    async getByPrimary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'getByPrimary');
+        if (!ignoreCheck) {
+            assertText(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary', queryName: opt.name });
+        }
+        let found;
+        if (!opt.noCache && this.cache.isConnected) {
+            try {
+                found = await this.cache.getByPrimary(key, opt);
             }
-            let found;
-            if (!opt.noCache && this.cache.isConnected) {
-                try {
-                    found = yield this.cache.getByPrimary(key, opt);
-                }
-                catch (e) {
-                    this.logger.warn(common_1.errorCommon.text(e, 'getByPrimary', 'cache', 'getByPrimary'));
-                }
-                if (found) {
-                    return found;
-                }
+            catch (e) {
+                this.logger.warn(errorCommon.text(e, 'getByPrimary', 'cache', 'getByPrimary'));
             }
-            found = yield this.$getByPrimary(key, opt, true);
-            if (!opt.noCache && found && this.cache.isConnected) {
-                this.cache.ingestDoc(found, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'getByPrimary', 'cache', 'ingestDoc')));
+            if (found) {
+                return found;
             }
-            return found;
-        });
+        }
+        found = await this.$getByPrimary(key, opt, true);
+        if (!opt.noCache && found && this.cache.isConnected) {
+            this.cache.ingestDoc(found, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'getByPrimary', 'cache', 'ingestDoc')));
+        }
+        return found;
     }
     /** @inheritDoc */
-    getBySecondary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'getBySecondary');
-            if (!ignoreCheck) {
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
-                }
-                else {
-                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
-                }
+    async getBySecondary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'getBySecondary');
+        if (!ignoreCheck) {
+            if (this.hasNumericId) {
+                assertInteger(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
             }
-            if (this.isIdSame) {
-                return this.getByPrimary(this._keyToUrn(key), opt, true);
+            else {
+                assertText(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
             }
-            let found;
-            if (!opt.noCache && this.cache.isConnected) {
-                try {
-                    found = yield this.cache.getBySecondary(key, opt);
-                    if (found) {
-                        return found;
-                    }
-                }
-                catch (e) {
-                    this.logger.warn(common_1.errorCommon.text(e, 'getBySecondary', 'cache', 'getBySecondary'));
+        }
+        if (this.isIdSame) {
+            return this.getByPrimary(this._keyToUrn(key), opt, true);
+        }
+        let found;
+        if (!opt.noCache && this.cache.isConnected) {
+            try {
+                found = await this.cache.getBySecondary(key, opt);
+                if (found) {
+                    return found;
                 }
             }
-            found = yield this.$getBySecondary(key, opt, true);
-            if (found && this.cache.isConnected) {
-                this.cache.ingestDoc(found, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'getBySecondary', 'cache', 'ingestDoc')));
+            catch (e) {
+                this.logger.warn(errorCommon.text(e, 'getBySecondary', 'cache', 'getBySecondary'));
             }
-            return found;
-        });
+        }
+        found = await this.$getBySecondary(key, opt, true);
+        if (found && this.cache.isConnected) {
+            this.cache.ingestDoc(found, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'getBySecondary', 'cache', 'ingestDoc')));
+        }
+        return found;
     }
     // endregion get
     // region exists
     /** @inheritDoc */
-    exists(keyLike, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'exists');
-            const [key, field] = this._checkKey(keyLike);
-            switch (field) {
-                case "urn":
-                    return this.existsByPrimary(key, opt, true);
-                case "id":
-                    return this.existsBySecondary(key, opt, true);
-                default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'exists', queryName: opt.name });
-                    break;
-            }
-        });
+    async exists(keyLike, p1) {
+        const opt = this.buildOpt(p1, 'exists');
+        const [key, field] = this._checkKey(keyLike);
+        switch (field) {
+            case "urn":
+                return this.existsByPrimary(key, opt, true);
+            case "id":
+                return this.existsBySecondary(key, opt, true);
+            default:
+                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'exists', queryName: opt.name });
+                break;
+        }
     }
     /** @inheritDoc */
-    existsByPrimary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'existsByPrimary');
-            if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary', queryName: opt.name });
-            }
-            if (!opt.noCache && this.cache.isConnected) {
-                try {
-                    const found = yield this.cache.getByPrimary(key, opt);
-                    if (found) {
-                        return true;
-                    }
-                }
-                catch (e) {
-                    this.logger.warn(common_1.errorCommon.text(e, 'existsByPrimary', 'cache', 'getByPrimary'));
+    async existsByPrimary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'existsByPrimary');
+        if (!ignoreCheck) {
+            assertText(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary', queryName: opt.name });
+        }
+        if (!opt.noCache && this.cache.isConnected) {
+            try {
+                const found = await this.cache.getByPrimary(key, opt);
+                if (found) {
+                    return true;
                 }
             }
-            return this.$existsByPrimary(key, opt, true);
-        });
+            catch (e) {
+                this.logger.warn(errorCommon.text(e, 'existsByPrimary', 'cache', 'getByPrimary'));
+            }
+        }
+        return this.$existsByPrimary(key, opt, true);
     }
     /** @inheritDoc */
-    existsBySecondary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'existsBySecondary');
-            if (!ignoreCheck) {
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
-                }
-                else {
-                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
-                }
+    async existsBySecondary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'existsBySecondary');
+        if (!ignoreCheck) {
+            if (this.hasNumericId) {
+                assertInteger(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
             }
-            if (!this.isIdSame) {
-                return this.existsByPrimary(this._keyToUrn(key));
+            else {
+                assertText(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
             }
-            if (!opt.noCache && this.cache.isConnected) {
-                try {
-                    const found = yield this.cache.getBySecondary(key, opt);
-                    if (found) {
-                        return true;
-                    }
-                }
-                catch (e) {
-                    this.logger.warn(common_1.errorCommon.text(e, 'existsBySecondary', 'cache', 'getBySecondary'));
+        }
+        if (!this.isIdSame) {
+            return this.existsByPrimary(this._keyToUrn(key));
+        }
+        if (!opt.noCache && this.cache.isConnected) {
+            try {
+                const found = await this.cache.getBySecondary(key, opt);
+                if (found) {
+                    return true;
                 }
             }
-            return this.$existsBySecondary(key, opt, true);
-        });
+            catch (e) {
+                this.logger.warn(errorCommon.text(e, 'existsBySecondary', 'cache', 'getBySecondary'));
+            }
+        }
+        return this.$existsBySecondary(key, opt, true);
     }
     // endregion exists
     // region list
     /** @inheritDoc */
-    list(keyLikes, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'list');
-            if (!ignoreCheck) {
-                (0, type_1.assertArray)(keyLikes, { field: 'keys', where: 'DbRepo', method: 'list', queryName: opt.name });
-            }
-            const result = this._checkKeys(keyLikes);
-            if (result.ordered.length < 1) {
-                return [];
+    async list(keyLikes, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'list');
+        if (!ignoreCheck) {
+            assertArray(keyLikes, { field: 'keys', where: 'DbRepo', method: 'list', queryName: opt.name });
+        }
+        const result = this._checkKeys(keyLikes);
+        if (result.ordered.length < 1) {
+            return [];
+        }
+        const docs = [];
+        let founds = [];
+        if (result.urns.length > 0) {
+            if (!opt.noCache && this.cache.isConnected) {
+                try {
+                    founds = await this.cache.getByPrimaryMore(result.urns, opt);
+                }
+                catch (e) {
+                    this.logger.warn(errorCommon.text(e, 'list', 'cache', 'getByPrimary'));
+                }
+                founds.forEach(val => {
+                    const index = result.urns.indexOf(val.urn);
+                    if (index >= 0) {
+                        result.urns.splice(index, 1);
+                    }
+                });
+                docs.push(...founds);
             }
-            const docs = [];
-            let founds = [];
             if (result.urns.length > 0) {
-                if (!opt.noCache && this.cache.isConnected) {
-                    try {
-                        founds = yield this.cache.getByPrimaryMore(result.urns, opt);
+                founds = await this.$listByPrimary(result.urns, opt, true);
+                if (founds.length > 0) {
+                    if (!opt.noCache && this.cache.isConnected) {
+                        founds.forEach(found => this.cache.ingestDoc(found, opt)
+                            .then()
+                            .catch(e => this.logger.warn(errorCommon.text(e, 'list', 'cache', 'ingestDoc'))));
                     }
-                    catch (e) {
-                        this.logger.warn(common_1.errorCommon.text(e, 'list', 'cache', 'getByPrimary'));
-                    }
-                    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 (!opt.noCache && this.cache.isConnected) {
-                            founds.forEach(found => this.cache.ingestDoc(found, opt)
-                                .then()
-                                .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'list', 'cache', 'ingestDoc'))));
-                        }
-                        docs.push(...founds);
-                    }
+            }
+        }
+        if (result.ids.length > 0) {
+            if (!opt.noCache && this.cache.isConnected) {
+                try {
+                    founds = await this.cache.getBySecondaryMore(result.ids, opt);
+                }
+                catch (e) {
+                    this.logger.warn(errorCommon.text(e, 'list', 'cache', 'getBySecondary'));
                 }
+                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) {
-                if (!opt.noCache && this.cache.isConnected) {
-                    try {
-                        founds = yield this.cache.getBySecondaryMore(result.ids, opt);
+                founds = await this.$listBySecondary(result.ids, opt, true);
+                if (founds.length > 0) {
+                    if (!opt.noCache && this.cache.isConnected) {
+                        founds.forEach(found => this.cache.ingestDoc(found, opt)
+                            .then()
+                            .catch(e => this.logger.warn(errorCommon.text(e, 'list', 'cache', 'ingestDoc'))));
                     }
-                    catch (e) {
-                        this.logger.warn(common_1.errorCommon.text(e, 'list', 'cache', 'getBySecondary'));
-                    }
-                    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 (!opt.noCache && this.cache.isConnected) {
-                            founds.forEach(found => this.cache.ingestDoc(found, opt)
-                                .then()
-                                .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'list', 'cache', 'ingestDoc'))));
-                        }
-                        docs.push(...founds);
-                    }
-                }
             }
-            return result.ordered.map(o => docs.find(d => d[o[1]] === o[0]));
-        });
+        }
+        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 opt = this.buildOpt(p1, 'filter');
-            return this.$filter(query_1.queryParser.exec(query, [], opt.name), opt);
-        });
+    async filter(query, p1) {
+        const opt = this.buildOpt(p1, 'filter');
+        return this.$filter(queryParser.exec(query, [], opt.name), opt);
     }
     // endregion filter
     // region insert
     /** @inheritDoc */
-    insert(doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'insert');
-            const param = { where: 'DbRepo', method: 'insert', queryName: opt.name };
-            if (this.isNoInsert) {
-                throw new error_1.DbNotSupportedError('Insert', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
-                }
-                else {
-                    (0, type_1.assertText)(doc.id, Object.assign({ field: 'doc.id' }, param));
-                }
-                (0, type_1.assertText)(doc.urn, Object.assign({ field: 'doc.urn' }, param));
-            }
-            if (!doc._trashId !== undefined) {
-                delete doc._trashId;
-            }
-            if (this.hasCreatedAt) {
-                doc.createdAt = this._now;
+    async insert(doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'insert');
+        const param = { where: 'DbRepo', method: 'insert', queryName: opt.name };
+        if (this.isNoInsert) {
+            throw new DbNotSupportedError('Insert', param);
+        }
+        if (!ignoreCheck) {
+            assertObject(doc, { field: 'doc', ...param });
+            if (this.hasNumericId) {
+                assertInteger(doc.id, { field: 'doc.id', ...param });
             }
-            let userId;
-            if (this.hasCreatedBy && this.userFetcher) {
-                doc.createdBy = (yield this.userFetcher());
-                userId = doc.createdBy;
+            else {
+                assertText(doc.id, { field: 'doc.id', ...param });
             }
-            if (this.hasUpdatedAt) {
-                doc.updatedAt = this._now;
+            assertText(doc.urn, { field: 'doc.urn', ...param });
+        }
+        if (!doc._trashId !== undefined) {
+            delete doc._trashId;
+        }
+        if (this.hasCreatedAt) {
+            doc.createdAt = this._now;
+        }
+        let userId;
+        if (this.hasCreatedBy && this.userFetcher) {
+            doc.createdBy = await this.userFetcher();
+            userId = doc.createdBy;
+        }
+        if (this.hasUpdatedAt) {
+            doc.updatedAt = this._now;
+        }
+        if (this.hasUpdatedBy && this.userFetcher) {
+            if (userId) {
+                doc.createdBy = userId;
             }
-            if (this.hasUpdatedBy && this.userFetcher) {
-                if (userId) {
-                    doc.createdBy = userId;
-                }
-                else {
-                    doc.createdBy = (yield this.userFetcher());
-                }
+            else {
+                doc.createdBy = await this.userFetcher();
             }
-            return this.$insert(doc, opt);
-        });
+        }
+        return this.$insert(doc, opt);
     }
     /** @inheritDoc */
-    inserts(docs, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'inserts');
-            const param = { where: 'DbRepo', method: 'inserts', queryName: opt.name };
-            if (this.isNoInsert) {
-                throw new error_1.DbNotSupportedError('Insert', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertArray)(docs, Object.assign({ field: 'docs' }, param));
-            }
-            const insertedIds = [];
-            for (const doc of docs) {
-                insertedIds.push(yield this.insert(doc, opt, true));
-            }
-            return insertedIds;
-        });
+    async inserts(docs, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'inserts');
+        const param = { where: 'DbRepo', method: 'inserts', queryName: opt.name };
+        if (this.isNoInsert) {
+            throw new DbNotSupportedError('Insert', param);
+        }
+        if (!ignoreCheck) {
+            assertArray(docs, { field: 'docs', ...param });
+        }
+        const insertedIds = [];
+        for (const doc of docs) {
+            insertedIds.push(await this.insert(doc, opt, true));
+        }
+        return insertedIds;
     }
     // endregion insert
     // region replace
     /** @inheritDoc */
-    replace(doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'replace');
-            if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                (0, type_1.assertText)(doc.urn, { field: 'doc.urn', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                }
-                else {
-                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                }
-            }
-            if (doc._trashId !== undefined) {
-                delete doc._trashId;
-            }
-            if (this.hasUpdatedAt) {
-                doc.updatedAt = this._now;
-            }
-            if (this.hasUpdatedBy && this.userFetcher) {
-                doc.createdBy = (yield this.userFetcher());
+    async replace(doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'replace');
+        if (!ignoreCheck) {
+            assertObject(doc, { field: 'doc', where: 'DbRepo', method: 'replace', queryName: opt.name });
+            assertText(doc.urn, { field: 'doc.urn', where: 'DbRepo', method: 'replace', queryName: opt.name });
+            if (this.hasNumericId) {
+                assertInteger(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
             }
-            const replacedKey = yield this.$replace(doc, opt, true);
-            if (!opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(replacedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'replace', 'cache', 'clearDoc')));
+            else {
+                assertText(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
             }
-            return replacedKey;
-        });
+        }
+        if (doc._trashId !== undefined) {
+            delete doc._trashId;
+        }
+        if (this.hasUpdatedAt) {
+            doc.updatedAt = this._now;
+        }
+        if (this.hasUpdatedBy && this.userFetcher) {
+            doc.createdBy = await this.userFetcher();
+        }
+        const replacedKey = await this.$replace(doc, opt, true);
+        if (!opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(replacedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'replace', 'cache', 'clearDoc')));
+        }
+        return replacedKey;
     }
     // endregion replace
     // region upsert
     /** @inheritDoc */
-    upsert(doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'upsert');
-            const param = { where: 'DbRepo', method: 'upsert', queryName: opt.name };
-            if (this.isNoInsert || this.isNoUpdate) {
-                throw new error_1.DbNotSupportedError('Upsert', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-                (0, type_1.assertText)(doc.urn, Object.assign({ field: 'doc.urn' }, param));
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
-                }
-                else {
-                    (0, type_1.assertText)(doc.id, Object.assign({ field: 'doc.id' }, param));
-                }
-            }
-            if (doc._trashId !== undefined) {
-                delete doc._trashId;
-            }
-            if (this.hasUpdatedAt) {
-                doc.updatedAt = this._now;
-            }
-            if (this.hasUpdatedBy && this.userFetcher) {
-                doc.createdBy = (yield this.userFetcher());
+    async upsert(doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'upsert');
+        const param = { where: 'DbRepo', method: 'upsert', queryName: opt.name };
+        if (this.isNoInsert || this.isNoUpdate) {
+            throw new DbNotSupportedError('Upsert', param);
+        }
+        if (!ignoreCheck) {
+            assertObject(doc, { field: 'doc', ...param });
+            assertText(doc.urn, { field: 'doc.urn', ...param });
+            if (this.hasNumericId) {
+                assertInteger(doc.id, { field: 'doc.id', ...param });
             }
-            const createdKey = yield this.$replace(doc, opt, true);
-            if (!opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(createdKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'upsert', 'cache', 'clearDoc')));
+            else {
+                assertText(doc.id, { field: 'doc.id', ...param });
             }
-            return createdKey;
-        });
+        }
+        if (doc._trashId !== undefined) {
+            delete doc._trashId;
+        }
+        if (this.hasUpdatedAt) {
+            doc.updatedAt = this._now;
+        }
+        if (this.hasUpdatedBy && this.userFetcher) {
+            doc.createdBy = await this.userFetcher();
+        }
+        const createdKey = await this.$replace(doc, opt, true);
+        if (!opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(createdKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'upsert', 'cache', 'clearDoc')));
+        }
+        return createdKey;
     }
     // endregion upsert
     // region update
     /** @inheritDoc */
-    update(k1, doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'update');
-            if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'update', queryName: opt.name });
-            }
-            const [key, field] = this._checkKey(k1);
-            switch (field) {
-                case "urn":
-                    return this.updateByPrimary(key, doc, opt, true);
-                case "id":
-                    return this.updateBySecondary(key, doc, opt, true);
-                default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'update', queryName: opt.name });
-            }
-        });
+    async update(k1, doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'update');
+        if (!ignoreCheck) {
+            assertObject(doc, { field: 'doc', where: 'DbRepo', method: 'update', queryName: opt.name });
+        }
+        const [key, field] = this._checkKey(k1);
+        switch (field) {
+            case "urn":
+                return this.updateByPrimary(key, doc, opt, true);
+            case "id":
+                return this.updateBySecondary(key, doc, opt, true);
+            default:
+                assertMessage('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'update', queryName: opt.name });
+        }
     }
     /** @inheritDoc */
-    updateByPrimary(key, doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'updateByPrimary');
-            const param = { where: 'DbRepo', method: 'updateByPrimary', queryName: opt.name };
-            if (this.isNoUpdate) {
-                throw new error_1.DbNotSupportedError('Update', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
-                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-            }
-            if (doc._trashId !== undefined) {
-                delete doc._trashId;
-            }
-            this._props.forbiddenSet.forEach(f => {
-                if (doc[f] !== undefined) {
-                    delete doc[f];
-                }
-            });
-            if (this.hasUpdatedAt) {
-                doc.updatedAt = this._now;
-            }
-            if (this.hasUpdatedBy && this.userFetcher) {
-                doc.createdBy = (yield this.userFetcher());
-            }
-            const updatedKey = yield this.$updateByPrimary(key, doc, opt, true);
-            if (updatedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(updatedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'updateByPrimary', 'cache', 'clearDoc')));
+    async updateByPrimary(key, doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'updateByPrimary');
+        const param = { where: 'DbRepo', method: 'updateByPrimary', queryName: opt.name };
+        if (this.isNoUpdate) {
+            throw new DbNotSupportedError('Update', param);
+        }
+        if (!ignoreCheck) {
+            assertText(key, { field: 'key', ...param });
+            assertObject(doc, { field: 'doc', ...param });
+        }
+        if (doc._trashId !== undefined) {
+            delete doc._trashId;
+        }
+        this._props.forbiddenSet.forEach(f => {
+            if (doc[f] !== undefined) {
+                delete doc[f];
             }
-            return updatedKey;
         });
+        if (this.hasUpdatedAt) {
+            doc.updatedAt = this._now;
+        }
+        if (this.hasUpdatedBy && this.userFetcher) {
+            doc.createdBy = await this.userFetcher();
+        }
+        const updatedKey = await this.$updateByPrimary(key, doc, opt, true);
+        if (updatedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(updatedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'updateByPrimary', 'cache', 'clearDoc')));
+        }
+        return updatedKey;
     }
     /** @inheritDoc */
-    updateBySecondary(key, doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'updateBySecondary');
-            const param = { where: 'DbRepo', method: 'updateBySecondary', queryName: opt.name };
-            if (this.isNoUpdate) {
-                throw new error_1.DbNotSupportedError('Update', param);
-            }
-            if (!ignoreCheck) {
-                if (this.hasNumericId) {
-                    (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
-                }
-                else {
-                    (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
-                }
-                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-            }
-            if (this.isIdSame) {
-                return this.updateBySecondary(this._keyToUrn(key), doc, opt, true);
-            }
-            if (doc._trashId !== undefined) {
-                delete doc._trashId;
-            }
-            this._props.forbiddenSet.forEach(f => {
-                if (doc[f] !== undefined) {
-                    delete doc[f];
-                }
-            });
-            if (this.hasUpdatedAt) {
-                doc.updatedAt = this._now;
+    async updateBySecondary(key, doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'updateBySecondary');
+        const param = { where: 'DbRepo', method: 'updateBySecondary', queryName: opt.name };
+        if (this.isNoUpdate) {
+            throw new DbNotSupportedError('Update', param);
+        }
+        if (!ignoreCheck) {
+            if (this.hasNumericId) {
+                assertInteger(key, { field: 'key', ...param });
             }
-            if (this.hasUpdatedBy && this.userFetcher) {
-                doc.createdBy = (yield this.userFetcher());
+            else {
+                assertText(key, { field: 'key', ...param });
             }
-            const updatedKey = yield this.$updateBySecondary(key, doc, opt, true);
-            if (updatedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(updatedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'updateBySecondary', 'cache', 'clearDoc')));
+            assertObject(doc, { field: 'doc', ...param });
+        }
+        if (this.isIdSame) {
+            return this.updateBySecondary(this._keyToUrn(key), doc, opt, true);
+        }
+        if (doc._trashId !== undefined) {
+            delete doc._trashId;
+        }
+        this._props.forbiddenSet.forEach(f => {
+            if (doc[f] !== undefined) {
+                delete doc[f];
             }
-            return updatedKey;
         });
+        if (this.hasUpdatedAt) {
+            doc.updatedAt = this._now;
+        }
+        if (this.hasUpdatedBy && this.userFetcher) {
+            doc.createdBy = await this.userFetcher();
+        }
+        const updatedKey = await this.$updateBySecondary(key, doc, opt, true);
+        if (updatedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(updatedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'updateBySecondary', 'cache', 'clearDoc')));
+        }
+        return updatedKey;
     }
     // endregion update
     // region set
     /** @inheritDoc */
-    set(key, doc, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'set');
-            if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'set', queryName: opt.name });
-            }
-            for (const [f, v] of Object.entries(doc)) {
-                if (v === undefined) { // dont allow undefined
-                    delete doc[f];
-                }
+    async set(key, doc, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'set');
+        if (!ignoreCheck) {
+            assertObject(doc, { field: 'doc', where: 'DbRepo', method: 'set', queryName: opt.name });
+        }
+        for (const [f, v] of Object.entries(doc)) {
+            if (v === undefined) { // dont allow undefined
+                delete doc[f];
             }
-            return this.update(key, doc, opt, false);
-        });
+        }
+        return this.update(key, doc, opt, false);
     }
     /** @inheritDoc */
-    unset(key, fields, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'unset');
-            if (!ignoreCheck) {
-                (0, type_1.assertArray)(fields, { field: 'fields', where: 'DbRepo', method: 'unset', queryName: opt.name });
-                fields.forEach((field, index) => {
-                    (0, type_1.assertText)(field, { field: field, where: 'DbRepo', method: 'unset', index, queryName: opt.name });
-                });
-            }
-            const doc = {};
-            fields.forEach(f => {
-                if (!this._props.forbiddenSet.includes(f)) {
-                    doc[f] = undefined;
-                }
+    async unset(key, fields, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'unset');
+        if (!ignoreCheck) {
+            assertArray(fields, { field: 'fields', where: 'DbRepo', method: 'unset', queryName: opt.name });
+            fields.forEach((field, index) => {
+                assertText(field, { field: field, where: 'DbRepo', method: 'unset', index, queryName: opt.name });
             });
-            return this.update(key, doc, opt, false);
+        }
+        const doc = {};
+        fields.forEach(f => {
+            if (!this._props.forbiddenSet.includes(f)) {
+                doc[f] = undefined;
+            }
         });
+        return this.update(key, doc, opt, false);
     }
     // endregion set
     // region remove
     /** @inheritDoc */
-    remove(keyLike, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'remove');
-            const [key, field] = this._checkKey(keyLike);
-            switch (field) {
-                case "urn":
-                    return this.removeByPrimary(key, opt, true);
-                case "id":
-                    return this.removeBySecondary(key, opt, true);
-                default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'remove', queryName: opt.name });
-            }
-        });
+    async remove(keyLike, p1) {
+        const opt = this.buildOpt(p1, 'remove');
+        const [key, field] = this._checkKey(keyLike);
+        switch (field) {
+            case "urn":
+                return this.removeByPrimary(key, opt, true);
+            case "id":
+                return this.removeBySecondary(key, opt, true);
+            default:
+                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'remove', queryName: opt.name });
+        }
     }
     /** @inheritDoc */
-    removeByPrimary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'removeByPrimary');
-            const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
-            if (this.isNoRemove) {
-                throw new error_1.DbNotSupportedError('Remove', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
-            }
-            const removedKey = yield this.$removeByPrimary(key, opt, true);
-            if (removedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(removedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'removeByPrimary', 'cache', 'clearDoc')));
-            }
-            return removedKey;
-        });
+    async removeByPrimary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'removeByPrimary');
+        const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
+        if (this.isNoRemove) {
+            throw new DbNotSupportedError('Remove', param);
+        }
+        if (!ignoreCheck) {
+            assertText(key, { field: 'key', ...param });
+        }
+        const removedKey = await this.$removeByPrimary(key, opt, true);
+        if (removedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(removedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'removeByPrimary', 'cache', 'clearDoc')));
+        }
+        return removedKey;
     }
     /** @inheritDoc */
-    removeBySecondary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'removeBySecondary');
-            const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
-            if (this.isNoRemove) {
-                throw new error_1.DbNotSupportedError('Remove', param);
-            }
-            if (this.hasNumericId) {
-                (0, type_1.assertInteger)(key, { field: 'key', param });
-            }
-            else {
-                (0, type_1.assertText)(key, { field: 'key', param });
-            }
-            if (this.isIdSame) {
-                return this.removeByPrimary(this._keyToUrn(key), opt, ignoreCheck);
-            }
-            const removedKey = yield this.$removeBySecondary(key, opt, true);
-            if (removedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(removedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'removeBySecondary', 'cache', 'clearDoc')));
-            }
-            return removedKey;
-        });
+    async removeBySecondary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'removeBySecondary');
+        const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
+        if (this.isNoRemove) {
+            throw new DbNotSupportedError('Remove', param);
+        }
+        if (this.hasNumericId) {
+            assertInteger(key, { field: 'key', param });
+        }
+        else {
+            assertText(key, { field: 'key', param });
+        }
+        if (this.isIdSame) {
+            return this.removeByPrimary(this._keyToUrn(key), opt, ignoreCheck);
+        }
+        const removedKey = await this.$removeBySecondary(key, opt, true);
+        if (removedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(removedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'removeBySecondary', 'cache', 'clearDoc')));
+        }
+        return removedKey;
     }
     // endregion remove
     // region trash
     /** @inheritDoc */
-    trash(keyLike, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'trash');
-            const [key, field] = this._checkKey(keyLike);
-            switch (field) {
-                case "urn":
-                    return this.trashByPrimary(key, opt, true);
-                case "id":
-                    return this.trashBySecondary(key, opt, true);
-                default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'trash', queryName: opt.name });
-            }
-        });
+    async trash(keyLike, p1) {
+        const opt = this.buildOpt(p1, 'trash');
+        const [key, field] = this._checkKey(keyLike);
+        switch (field) {
+            case "urn":
+                return this.trashByPrimary(key, opt, true);
+            case "id":
+                return this.trashBySecondary(key, opt, true);
+            default:
+                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'trash', queryName: opt.name });
+        }
     }
     /** @inheritDoc */
-    trashByPrimary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'trashByPrimary');
-            const param = { where: 'DbRepo', method: 'trashByPrimary', queryName: opt.name };
-            if (!this.hasSoftDelete) {
-                throw new error_1.DbNotSupportedError('Soft Delete', param);
-            }
-            if (this.isNoTrash) {
-                throw new error_1.DbNotSupportedError('Trash', param);
-            }
-            if (!ignoreCheck) {
-                (0, type_1.assertText)(key, Object.assign({ field: 'urn' }, param));
-            }
-            if (!(0, common_1.isText)(opt.trashId)) {
-                opt.trashId = (0, node_crypto_1.randomUUID)();
-            }
-            const trashedKey = yield this.$trashByPrimary(key, opt, true);
-            if (trashedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(trashedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'trashByPrimary', 'cache', 'clearDoc')));
-            }
-            return trashedKey;
-        });
+    async trashByPrimary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'trashByPrimary');
+        const param = { where: 'DbRepo', method: 'trashByPrimary', queryName: opt.name };
+        if (!this.hasSoftDelete) {
+            throw new DbNotSupportedError('Soft Delete', param);
+        }
+        if (this.isNoTrash) {
+            throw new DbNotSupportedError('Trash', param);
+        }
+        if (!ignoreCheck) {
+            assertText(key, { field: 'urn', ...param });
+        }
+        if (!isText(opt.trashId)) {
+            opt.trashId = randomUUID();
+        }
+        const trashedKey = await this.$trashByPrimary(key, opt, true);
+        if (trashedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(trashedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'trashByPrimary', 'cache', 'clearDoc')));
+        }
+        return trashedKey;
     }
     /** @inheritDoc */
-    trashBySecondary(key, p1, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1, 'trashBySecondary');
-            const param = { where: 'DbRepo', method: 'trashBySecondary', queryName: opt.name };
-            if (!this.hasSoftDelete) {
-                throw new error_1.DbNotSupportedError('Soft Delete', param);
-            }
-            if (this.isNoTrash) {
-                throw new error_1.DbNotSupportedError('Trash', param);
-            }
-            if (this.hasNumericId) {
-                (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
-            }
-            else {
-                (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
-            }
-            if (this.isIdSame) {
-                return this.trashByPrimary(this._keyToUrn(key), opt, ignoreCheck);
-            }
-            if (!(0, common_1.isText)(opt.trashId)) {
-                opt.trashId = (0, node_crypto_1.randomUUID)();
-            }
-            const trashedKey = yield this.$trashBySecondary(key, opt, true);
-            if (trashedKey && !opt.noCache && this.cache.isConnected) {
-                this.cache.clearDoc(trashedKey, opt)
-                    .then()
-                    .catch(e => this.logger.warn(common_1.errorCommon.text(e, 'trashBySecondary', 'cache', 'clearDoc')));
-            }
-            return trashedKey;
-        });
+    async trashBySecondary(key, p1, ignoreCheck) {
+        const opt = this.buildOpt(p1, 'trashBySecondary');
+        const param = { where: 'DbRepo', method: 'trashBySecondary', queryName: opt.name };
+        if (!this.hasSoftDelete) {
+            throw new DbNotSupportedError('Soft Delete', param);
+        }
+        if (this.isNoTrash) {
+            throw new DbNotSupportedError('Trash', param);
+        }
+        if (this.hasNumericId) {
+            assertInteger(key, { field: 'key', ...param });
+        }
+        else {
+            assertText(key, { field: 'key', ...param });
+        }
+        if (this.isIdSame) {
+            return this.trashByPrimary(this._keyToUrn(key), opt, ignoreCheck);
+        }
+        if (!isText(opt.trashId)) {
+            opt.trashId = randomUUID();
+        }
+        const trashedKey = await this.$trashBySecondary(key, opt, true);
+        if (trashedKey && !opt.noCache && this.cache.isConnected) {
+            this.cache.clearDoc(trashedKey, opt)
+                .then()
+                .catch(e => this.logger.warn(errorCommon.text(e, 'trashBySecondary', 'cache', 'clearDoc')));
+        }
+        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 "view":
-                    return doc;
-                case "pair":
-                    return { id: doc.id, name: doc.name };
-                default: // portion
-                    if (this.isIdSame) {
-                        return { id: doc.id };
-                    }
-                    else {
-                        return { id: doc.id, urn: doc.urn };
-                    }
-            }
-        });
+    async $toDim(doc, dim) {
+        if (!doc) {
+            return undefined;
+        }
+        switch (dim) {
+            case "view":
+                return await this.toView(doc);
+            case "pair":
+                return await this.toPair(doc);
+            case "portion":
+                return await this.toPortion(doc);
+            default: // portion
+                if (this.isIdSame) {
+                    return { id: doc.id };
+                }
+                else {
+                    return { id: doc.id, urn: doc.urn };
+                }
+        }
     }
     /** @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;
-        });
+    async getDim(key, dim) {
+        const doc = await this.get(key, { name: `getDim/${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;
-        });
+    async listDims(keys, dim, ignoreCheck) {
+        const docs = await this.list(keys, { name: `listDims/${dim ?? 'def'}` }, ignoreCheck);
+        if (docs.length < 1) {
+            return [];
+        }
+        const items = [];
+        for (const doc of docs) {
+            items.push(await this.$toDim(doc, dim));
+        }
+        return items;
     }
     // endregion dim
     // region pair
-    toPair(doc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$toDim(doc, 'pair');
-        });
+    async toPair(doc) {
+        return { id: doc.id, name: doc.name ?? doc.id };
     }
     /** @inheritDoc */
-    getPair(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getDim(key, 'pair');
-        });
+    async getPair(key) {
+        const doc = await this.get(key, { name: `getPair` });
+        return this.toPair(doc);
     }
     /** @inheritDoc */
-    listPairs(keys, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.listDims(keys, 'pair', ignoreCheck);
-        });
+    async listPairs(keys, ignoreCheck) {
+        const docs = await this.list(keys, { name: `listPairs` }, ignoreCheck);
+        if (docs.length < 1) {
+            return [];
+        }
+        const items = [];
+        for (const doc of docs) {
+            items.push(await this.toPair(doc));
+        }
+        return items;
     }
     // endregion pair
     // region view
-    toView(doc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$toDim(doc, 'view');
-        });
+    async toView(doc) {
+        return doc;
     }
     /** @inheritDoc */
-    getView(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getDim(key, 'view');
-        });
+    async getView(key) {
+        const doc = await this.get(key, { name: `getView` });
+        return this.toView(doc);
     }
     /** @inheritDoc */
-    listViews(keys, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.listDims(keys, 'view', ignoreCheck);
-        });
+    async listViews(keys, ignoreCheck) {
+        const docs = await this.list(keys, { name: `listViews` }, ignoreCheck);
+        if (docs.length < 1) {
+            return [];
+        }
+        const items = [];
+        for (const doc of docs) {
+            items.push(await this.toView(doc));
+        }
+        return items;
     }
     // endregion view
     // region portion
     /** @inheritDoc */
-    toPortion(doc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$toDim(doc, 'portion');
-        });
+    async toPortion(doc) {
+        if (this.isIdSame) {
+            return { id: doc.id };
+        }
+        else {
+            return { id: doc.id, urn: doc.urn };
+        }
     }
     /** @inheritDoc */
-    getPortion(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getDim(key, 'portion');
-        });
+    async getPortion(key) {
+        if (this.isIdSame) {
+            const [identifier, field] = this._checkKey(key);
+            if (field === 'id') {
+                return { id: identifier };
+            }
+        }
+        const doc = await this.get(key, { name: `getPortion` });
+        return this.toPortion(doc);
     }
     /** @inheritDoc */
-    listPortions(keys, ignoreCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.listDims(keys, 'portion', ignoreCheck);
-        });
+    async listPortions(keys, ignoreCheck) {
+        if (this.isIdSame) {
+            const idResult = this._checkKeys(keys);
+            if (!idResult?.urns?.length) {
+                if (Array.isArray(idResult?.ids)) {
+                    return idResult.ids.map(id => {
+                        return { id };
+                    });
+                }
+                return [];
+            }
+        }
+        const docs = await this.list(keys, { name: `listPortions` }, ignoreCheck);
+        if (docs.length < 1) {
+            return [];
+        }
+        const items = [];
+        for (const doc of docs) {
+            items.push(await this.toPortion(doc));
+        }
+        return items;
     }
 }
-exports.DbRepo = DbRepo;