@samet-it/be-db-common 1.3.5 → 1.3.7

package/dist/repo/db.repo.js

@@ -1,13 +1,25 @@
 import { randomUUID } from "node:crypto";
-import { errorHandler, setFqn } from "@samet-it/be-base-common";
-import { errorCommon, isFilledObj, isText } from "@samet-it/be-base-common";
+import { setFqn, } from "@samet-it/be-base-common";
+import { errorCommon, isFilledObj, isText, } from "@samet-it/be-base-common";
 import { queryParser } from "@leyyo/query";
-import { assertArray, assertInteger, assertMessage, assertObject, assertText } from "@samet-it/be-base-common";
+import { assertArray, assertInteger, assertMessage, assertObject, assertText, } from "@samet-it/be-base-common";
 import { DbError, DbInvalidValueError, DbNotSupportedError } from "../error/index.js";
 import { isBareObject } from "@samet-it/be-base-common";
 import { FQN } from "../internal.js";
-const FORBIDDEN_KEYS = ['id', 'urn', '_trashId', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy', "_rev", '_search', '_alpha', '_irregular'];
-const STRICT_KEYS = ['id', 'urn', '_trashId', "_rev", '_irregular'];
+const FORBIDDEN_KEYS = [
+    "id",
+    "urn",
+    "_trashId",
+    "createdAt",
+    "createdBy",
+    "updatedAt",
+    "updatedBy",
+    "_rev",
+    "_search",
+    "_alpha",
+    "_irregular",
+];
+const STRICT_KEYS = ["id", "urn", "_trashId", "_rev", "_irregular"];
 // noinspection JSUnusedGlobalSymbols
 /**
  * DB repository abstract class
@@ -49,7 +61,11 @@ export class DbRepo {
      * */
     constructor(conn, opt) {
         if (!isFilledObj(conn)) {
-            throw new DbInvalidValueError('Connection', { where: 'DbRepo', method: 'constructor', type: typeof conn });
+            throw new DbInvalidValueError("Connection", {
+                where: "DbRepo",
+                method: "constructor",
+                type: typeof conn,
+            });
         }
         if (!isBareObject(this._opt)) {
             this._opt = {};
@@ -71,23 +87,27 @@ export class DbRepo {
             this._opt.cache = { isEnabled: false, isConnected: false };
         }
         if (this._opt.useVersion) {
-            if (typeof this._opt.version !== 'number') {
-                throw new DbInvalidValueError('Model version', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.version });
+            if (typeof this._opt.version !== "number") {
+                throw new DbInvalidValueError("Model version", {
+                    where: "DbRepo",
+                    method: "constructor",
+                    type: typeof this._opt.version,
+                });
             }
         }
         else {
             this._opt.version = undefined;
         }
-        if (typeof this._opt.urnDelimiter !== 'string') {
-            this._opt.urnDelimiter = ',';
+        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 (![",", "|", ";", "/"].includes(this._opt.urnDelimiter)) {
+                this._opt.urnDelimiter = ",";
             }
         }
-        if (typeof this._opt.urnPrefix !== 'string') {
+        if (typeof this._opt.urnPrefix !== "string") {
             this._opt.urnPrefix = undefined;
         }
         else {
@@ -97,23 +117,27 @@ export class DbRepo {
             }
         }
         if (!this._opt.urnPrefix) {
-            throw new 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];
         }
         else {
-            STRICT_KEYS.forEach(k => {
+            STRICT_KEYS.forEach((k) => {
                 if (!this._opt.forbiddenSet.includes(k)) {
                     this._opt.forbiddenSet.push(k);
                 }
             });
         }
         const directOpt = this._opt;
-        if (typeof directOpt.$toUrnTuple === 'function') {
+        if (typeof directOpt.$toUrnTuple === "function") {
             this.$toUrnTuple = directOpt.$toUrnTuple;
         }
-        if (typeof directOpt.$toDim === 'function') {
+        if (typeof directOpt.$toDim === "function") {
             this.$toDim = async (doc, dim) => {
                 return (await directOpt.$toDim(doc, dim));
             };
@@ -139,9 +163,11 @@ export class DbRepo {
      * @return {string}
      * */
     get _randomIndexName() {
-        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('_');
+        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("_"));
     }
     /**
      * Check & validate index name
@@ -150,22 +176,23 @@ export class DbRepo {
      * @return {string} - validated index name
      * */
     _indexName(name) {
-        if (typeof name !== 'string') {
+        if (typeof name !== "string") {
             return this._randomIndexName;
         }
         name = name.trim();
-        if (name === '') {
+        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 === '') {
+        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.startsWith("idx_")) {
+            name = "idx_" + name;
         }
         if (name.length > 30) {
             name = name.substring(0, 30);
@@ -176,9 +203,9 @@ export class DbRepo {
      * Fetch urn from doc as doc.urn
      * */
     _urnFromDoc(doc, method) {
-        const param = { where: 'DbRepo', path: this.path, method };
-        assertObject(doc, { field: 'doc', ...param });
-        assertText(doc.urn, { field: 'urn', ...param });
+        const param = { where: "DbRepo", path: this.path, method };
+        assertObject(doc, { field: "doc", ...param });
+        assertText(doc.urn, { field: "urn", ...param });
         return doc.urn;
     }
     /**
@@ -189,12 +216,14 @@ export class DbRepo {
      * */
     _checkKey(value) {
         let id;
+        let str;
+        let obj;
         switch (typeof value) {
             case "string":
-                const str = value.trim();
+                str = value.trim();
                 if (str) {
                     if (this._isUrn(str)) {
-                        return [str, 'urn'];
+                        return [str, "urn"];
                     }
                     else {
                         if (this.hasNumericId) {
@@ -205,27 +234,27 @@ export class DbRepo {
                                 // nothing
                             }
                             if (id !== undefined) {
-                                return [id, 'id'];
+                                return [id, "id"];
                             }
                         }
                         else {
-                            return [str, 'id'];
+                            return [str, "id"];
                         }
                     }
                 }
                 break;
             case "number":
                 if (this.hasNumericId) {
-                    return [value, 'id'];
+                    return [value, "id"];
                 }
                 else {
-                    return [value.toString(10), 'id'];
+                    return [value.toString(10), "id"];
                 }
             case "object":
                 if (!value) {
                     return [undefined, undefined];
                 }
-                const obj = value;
+                obj = value;
                 if (obj.urn !== undefined) {
                     return this._checkKey(obj.urn);
                 }
@@ -250,11 +279,11 @@ export class DbRepo {
         for (const item of keys) {
             const [key, field] = this._checkKey(item);
             if (field) {
-                if ((field === 'urn') && !result.urns.includes(key)) {
+                if (field === "urn" && !result.urns.includes(key)) {
                     result.urns.push(key);
                     result.ordered.push([key, field]);
                 }
-                else if ((field === 'id') && !result.ids.includes(key)) {
+                else if (field === "id" && !result.ids.includes(key)) {
                     result.ids.push(key);
                     result.ordered.push([key, field]);
                 }
@@ -269,7 +298,7 @@ export class DbRepo {
      * @return boolean - is urn or not
      * */
     _isUrn(key) {
-        return (typeof key === 'string') && key.startsWith(this.urnPrefix + ':');
+        return typeof key === "string" && key.startsWith(this.urnPrefix + ":");
     }
     /**
      * Build key to urn value with prefix
@@ -413,19 +442,19 @@ export class DbRepo {
     // region field-value
     /** {@inheritDoc} */
     checkError(err, opt) {
-        const size = errorHandler.addStat(err);
+        const size = errorCommon.addStat(err);
         const ignoredErrors = opt?.ignoredErrors ?? [];
         if (ignoredErrors.includes(err) || ignoredErrors.includes(err.name)) {
             return;
         }
         if (opt?.silent) {
             if (size < 100) {
-                this.logger.warn(errorCommon.text(err, (opt.name ?? 'Database error'), size));
+                this.logger.warn(errorCommon.text(err, (opt.name ?? "Database error"), size));
             }
             return;
         }
         if (size < 100) {
-            this.logger.error(errorCommon.text(err, (opt.name ?? 'Database error'), size));
+            this.logger.error(errorCommon.text(err, (opt.name ?? "Database error"), size));
         }
         if (err instanceof DbError) {
             throw err;
@@ -443,21 +472,21 @@ export class DbRepo {
     }
     /** {@inheritDoc} */
     rows(rows) {
-        if (rows && Array.isArray(rows) && (rows.length > 0)) {
-            return rows.filter(row => row['_trashId'] === undefined);
+        if (rows && Array.isArray(rows) && rows.length > 0) {
+            return rows.filter((row) => row["_trashId"] === undefined);
         }
         return [];
     }
     /** {@inheritDoc} */
     row(row) {
-        if (row && row['_trashId'] === undefined) {
+        if (row && row["_trashId"] === undefined) {
             return row;
         }
         return undefined;
     }
     /** {@inheritDoc} */
     first(rows) {
-        if (rows && Array.isArray(rows) && (rows.length > 0)) {
+        if (rows && Array.isArray(rows) && rows.length > 0) {
             return rows[0];
         }
         return undefined;
@@ -466,11 +495,11 @@ export class DbRepo {
     // region option
     /** {@inheritDoc} */
     buildOpt(p1, name) {
-        const opt = (typeof p1 === 'string' ? { name: p1 } : { ...p1 });
-        if (typeof opt.name === undefined && typeof name !== undefined) {
+        const opt = (typeof p1 === "string" ? { name: p1 } : { ...p1 });
+        if (opt.name === undefined && name !== undefined) {
             opt.name = name;
         }
-        opt.name = opt.name ? `[${opt.name}]` : '';
+        opt.name = opt.name ? `[${opt.name}]` : "";
         return opt;
     }
     // endregion option
@@ -494,15 +523,15 @@ export class DbRepo {
     /** @inheritDoc */
     toUrn(urnRec) {
         let code = this.$toUrnTuple(urnRec).join(this.urnDelimiter);
-        if (code.includes(':')) {
-            code = code.split(':').join(';');
+        if (code.includes(":")) {
+            code = code.split(":").join(";");
         }
         return `${this.urnPrefix}:${code}`;
     }
     /** @inheritDoc */
     toUrnKey(p1) {
         if (isText(p1)) {
-            return p1.split(':').pop();
+            return p1.split(":").pop();
         }
         const doc = p1;
         if (isFilledObj(doc)) {
@@ -512,13 +541,13 @@ export class DbRepo {
     }
     /** @inheritDoc */
     $toUrnTuple(urnRec) {
-        return [urnRec['id']];
+        return [urnRec["id"]];
     }
     // endregion urn
     // region get
     /** @inheritDoc */
     async get(keyLike, p1) {
-        const opt = this.buildOpt(p1, 'get');
+        const opt = this.buildOpt(p1, "get");
         const [key, field] = this._checkKey(keyLike);
         switch (field) {
             case "urn":
@@ -526,14 +555,25 @@ export class DbRepo {
             case "id":
                 return this.getBySecondary(key, opt, true);
             default:
-                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'get', queryName: opt.name });
+                assertMessage("Invalid key", {
+                    field: "key",
+                    value: keyLike,
+                    where: "DbRepo",
+                    method: "get",
+                    queryName: opt.name,
+                });
         }
     }
     /** @inheritDoc */
     async getByPrimary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'getByPrimary');
+        const opt = this.buildOpt(p1, "getByPrimary");
         if (!ignoreCheck) {
-            assertText(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary', queryName: opt.name });
+            assertText(key, {
+                field: "key",
+                where: "DbRepo",
+                method: "getByPrimary",
+                queryName: opt.name,
+            });
         }
         let found;
         if (!opt.noCache && this.cache.isConnected) {
@@ -541,7 +581,7 @@ export class DbRepo {
                 found = await this.cache.getByPrimary(key, opt);
             }
             catch (e) {
-                this.logger.warn(errorCommon.text(e, 'getByPrimary', 'cache', 'getByPrimary'));
+                this.logger.warn(errorCommon.text(e, "getByPrimary", "cache", "getByPrimary"));
             }
             if (found) {
                 return found;
@@ -549,21 +589,32 @@ export class DbRepo {
         }
         found = await this.$getByPrimary(key, opt, true);
         if (!opt.noCache && found && this.cache.isConnected) {
-            this.cache.ingestDoc(found, opt)
+            this.cache
+                .ingestDoc(found, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'getByPrimary', 'cache', 'ingestDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "getByPrimary", "cache", "ingestDoc")));
         }
         return found;
     }
     /** @inheritDoc */
     async getBySecondary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'getBySecondary');
+        const opt = this.buildOpt(p1, "getBySecondary");
         if (!ignoreCheck) {
             if (this.hasNumericId) {
-                assertInteger(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
+                assertInteger(key, {
+                    field: "key",
+                    where: "DbRepo",
+                    method: "getBySecondary",
+                    queryName: opt.name,
+                });
             }
             else {
-                assertText(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
+                assertText(key, {
+                    field: "key",
+                    where: "DbRepo",
+                    method: "getBySecondary",
+                    queryName: opt.name,
+                });
             }
         }
         if (this.isIdSame) {
@@ -578,14 +629,15 @@ export class DbRepo {
                 }
             }
             catch (e) {
-                this.logger.warn(errorCommon.text(e, 'getBySecondary', 'cache', 'getBySecondary'));
+                this.logger.warn(errorCommon.text(e, "getBySecondary", "cache", "getBySecondary"));
             }
         }
         found = await this.$getBySecondary(key, opt, true);
         if (found && this.cache.isConnected) {
-            this.cache.ingestDoc(found, opt)
+            this.cache
+                .ingestDoc(found, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'getBySecondary', 'cache', 'ingestDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "getBySecondary", "cache", "ingestDoc")));
         }
         return found;
     }
@@ -593,7 +645,7 @@ export class DbRepo {
     // region exists
     /** @inheritDoc */
     async exists(keyLike, p1) {
-        const opt = this.buildOpt(p1, 'exists');
+        const opt = this.buildOpt(p1, "exists");
         const [key, field] = this._checkKey(keyLike);
         switch (field) {
             case "urn":
@@ -601,15 +653,26 @@ export class DbRepo {
             case "id":
                 return this.existsBySecondary(key, opt, true);
             default:
-                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'exists', queryName: opt.name });
+                assertMessage("Invalid key", {
+                    field: "key",
+                    value: keyLike,
+                    where: "DbRepo",
+                    method: "exists",
+                    queryName: opt.name,
+                });
                 break;
         }
     }
     /** @inheritDoc */
     async existsByPrimary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'existsByPrimary');
+        const opt = this.buildOpt(p1, "existsByPrimary");
         if (!ignoreCheck) {
-            assertText(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary', queryName: opt.name });
+            assertText(key, {
+                field: "key",
+                where: "DbRepo",
+                method: "existsByPrimary",
+                queryName: opt.name,
+            });
         }
         if (!opt.noCache && this.cache.isConnected) {
             try {
@@ -619,20 +682,30 @@ export class DbRepo {
                 }
             }
             catch (e) {
-                this.logger.warn(errorCommon.text(e, 'existsByPrimary', 'cache', 'getByPrimary'));
+                this.logger.warn(errorCommon.text(e, "existsByPrimary", "cache", "getByPrimary"));
             }
         }
         return this.$existsByPrimary(key, opt, true);
     }
     /** @inheritDoc */
     async existsBySecondary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'existsBySecondary');
+        const opt = this.buildOpt(p1, "existsBySecondary");
         if (!ignoreCheck) {
             if (this.hasNumericId) {
-                assertInteger(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
+                assertInteger(key, {
+                    field: "key",
+                    where: "DbRepo",
+                    method: "existsBySecondary",
+                    queryName: opt.name,
+                });
             }
             else {
-                assertText(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
+                assertText(key, {
+                    field: "key",
+                    where: "DbRepo",
+                    method: "existsBySecondary",
+                    queryName: opt.name,
+                });
             }
         }
         if (!this.isIdSame) {
@@ -646,7 +719,7 @@ export class DbRepo {
                 }
             }
             catch (e) {
-                this.logger.warn(errorCommon.text(e, 'existsBySecondary', 'cache', 'getBySecondary'));
+                this.logger.warn(errorCommon.text(e, "existsBySecondary", "cache", "getBySecondary"));
             }
         }
         return this.$existsBySecondary(key, opt, true);
@@ -655,9 +728,14 @@ export class DbRepo {
     // region list
     /** @inheritDoc */
     async list(keyLikes, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'list');
+        const opt = this.buildOpt(p1, "list");
         if (!ignoreCheck) {
-            assertArray(keyLikes, { field: 'keys', where: 'DbRepo', method: 'list', queryName: opt.name });
+            assertArray(keyLikes, {
+                field: "keys",
+                where: "DbRepo",
+                method: "list",
+                queryName: opt.name,
+            });
         }
         const result = this._checkKeys(keyLikes);
         if (result.ordered.length < 1) {
@@ -671,9 +749,9 @@ export class DbRepo {
                     founds = await this.cache.getByPrimaryMore(result.urns, opt);
                 }
                 catch (e) {
-                    this.logger.warn(errorCommon.text(e, 'list', 'cache', 'getByPrimary'));
+                    this.logger.warn(errorCommon.text(e, "list", "cache", "getByPrimary"));
                 }
-                founds.forEach(val => {
+                founds.forEach((val) => {
                     const index = result.urns.indexOf(val.urn);
                     if (index >= 0) {
                         result.urns.splice(index, 1);
@@ -685,9 +763,10 @@ export class DbRepo {
                 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)
+                        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(errorCommon.text(e, "list", "cache", "ingestDoc"))));
                     }
                     docs.push(...founds);
                 }
@@ -699,9 +778,9 @@ export class DbRepo {
                     founds = await this.cache.getBySecondaryMore(result.ids, opt);
                 }
                 catch (e) {
-                    this.logger.warn(errorCommon.text(e, 'list', 'cache', 'getBySecondary'));
+                    this.logger.warn(errorCommon.text(e, "list", "cache", "getBySecondary"));
                 }
-                founds.forEach(val => {
+                founds.forEach((val) => {
                     const index = result.ids.indexOf(val.id);
                     if (index >= 0) {
                         result.ids.splice(index, 1);
@@ -713,43 +792,44 @@ export class DbRepo {
                 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)
+                        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(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 */
     async filter(query, p1) {
-        const opt = this.buildOpt(p1, 'filter');
+        const opt = this.buildOpt(p1, "filter");
         return this.$filter(queryParser.exec(query, [], opt.name), opt);
     }
     // endregion filter
     // region insert
     /** @inheritDoc */
     async insert(doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'insert');
-        const param = { where: 'DbRepo', method: 'insert', queryName: opt.name };
+        const opt = this.buildOpt(p1, "insert");
+        const param = { where: "DbRepo", method: "insert", queryName: opt.name };
         if (this.isNoInsert) {
-            throw new DbNotSupportedError('Insert', param);
+            throw new DbNotSupportedError("Insert", param);
         }
         if (!ignoreCheck) {
-            assertObject(doc, { field: 'doc', ...param });
+            assertObject(doc, { field: "doc", ...param });
             if (this.hasNumericId) {
-                assertInteger(doc.id, { field: 'doc.id', ...param });
+                assertInteger(doc.id, { field: "doc.id", ...param });
             }
             else {
-                assertText(doc.id, { field: 'doc.id', ...param });
+                assertText(doc.id, { field: "doc.id", ...param });
             }
-            assertText(doc.urn, { field: 'doc.urn', ...param });
+            assertText(doc.urn, { field: "doc.urn", ...param });
         }
-        if (!doc._trashId !== undefined) {
+        if (doc._trashId !== undefined) {
             delete doc._trashId;
         }
         if (this.hasCreatedAt) {
@@ -757,7 +837,7 @@ export class DbRepo {
         }
         let userId;
         if (this.hasCreatedBy && this.userFetcher) {
-            doc.createdBy = await this.userFetcher();
+            doc.createdBy = (await this.userFetcher());
             userId = doc.createdBy;
         }
         if (this.hasUpdatedAt) {
@@ -768,20 +848,20 @@ export class DbRepo {
                 doc.createdBy = userId;
             }
             else {
-                doc.createdBy = await this.userFetcher();
+                doc.createdBy = (await this.userFetcher());
             }
         }
         return this.$insert(doc, opt);
     }
     /** @inheritDoc */
     async inserts(docs, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'inserts');
-        const param = { where: 'DbRepo', method: 'inserts', queryName: opt.name };
+        const opt = this.buildOpt(p1, "inserts");
+        const param = { where: "DbRepo", method: "inserts", queryName: opt.name };
         if (this.isNoInsert) {
-            throw new DbNotSupportedError('Insert', param);
+            throw new DbNotSupportedError("Insert", param);
         }
         if (!ignoreCheck) {
-            assertArray(docs, { field: 'docs', ...param });
+            assertArray(docs, { field: "docs", ...param });
         }
         const insertedIds = [];
         for (const doc of docs) {
@@ -793,15 +873,30 @@ export class DbRepo {
     // region replace
     /** @inheritDoc */
     async replace(doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'replace');
+        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 });
+            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 });
+                assertInteger(doc.id, {
+                    field: "doc.id",
+                    where: "DbRepo",
+                    method: "replace",
+                    queryName: opt.name,
+                });
             }
             else {
-                assertText(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
+                assertText(doc.id, {
+                    field: "doc.id",
+                    where: "DbRepo",
+                    method: "replace",
+                    queryName: opt.name,
+                });
             }
         }
         if (doc._trashId !== undefined) {
@@ -811,13 +906,14 @@ export class DbRepo {
             doc.updatedAt = this._now;
         }
         if (this.hasUpdatedBy && this.userFetcher) {
-            doc.createdBy = await 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)
+            this.cache
+                .clearDoc(replacedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'replace', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "replace", "cache", "clearDoc")));
         }
         return replacedKey;
     }
@@ -825,19 +921,19 @@ export class DbRepo {
     // region upsert
     /** @inheritDoc */
     async upsert(doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'upsert');
-        const param = { where: 'DbRepo', method: 'upsert', queryName: opt.name };
+        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);
+            throw new DbNotSupportedError("Upsert", param);
         }
         if (!ignoreCheck) {
-            assertObject(doc, { field: 'doc', ...param });
-            assertText(doc.urn, { field: 'doc.urn', ...param });
+            assertObject(doc, { field: "doc", ...param });
+            assertText(doc.urn, { field: "doc.urn", ...param });
             if (this.hasNumericId) {
-                assertInteger(doc.id, { field: 'doc.id', ...param });
+                assertInteger(doc.id, { field: "doc.id", ...param });
             }
             else {
-                assertText(doc.id, { field: 'doc.id', ...param });
+                assertText(doc.id, { field: "doc.id", ...param });
             }
         }
         if (doc._trashId !== undefined) {
@@ -847,13 +943,14 @@ export class DbRepo {
             doc.updatedAt = this._now;
         }
         if (this.hasUpdatedBy && this.userFetcher) {
-            doc.createdBy = await 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)
+            this.cache
+                .clearDoc(createdKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'upsert', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "upsert", "cache", "clearDoc")));
         }
         return createdKey;
     }
@@ -861,9 +958,9 @@ export class DbRepo {
     // region update
     /** @inheritDoc */
     async update(k1, doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'update');
+        const opt = this.buildOpt(p1, "update");
         if (!ignoreCheck) {
-            assertObject(doc, { field: 'doc', where: 'DbRepo', method: 'update', queryName: opt.name });
+            assertObject(doc, { field: "doc", where: "DbRepo", method: "update", queryName: opt.name });
         }
         const [key, field] = this._checkKey(k1);
         switch (field) {
@@ -872,24 +969,30 @@ export class DbRepo {
             case "id":
                 return this.updateBySecondary(key, doc, opt, true);
             default:
-                assertMessage('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'update', queryName: opt.name });
+                assertMessage("Invalid key", {
+                    field: "key",
+                    value: k1,
+                    where: "DbRepo",
+                    method: "update",
+                    queryName: opt.name,
+                });
         }
     }
     /** @inheritDoc */
     async updateByPrimary(key, doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'updateByPrimary');
-        const param = { where: 'DbRepo', method: 'updateByPrimary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "updateByPrimary");
+        const param = { where: "DbRepo", method: "updateByPrimary", queryName: opt.name };
         if (this.isNoUpdate) {
-            throw new DbNotSupportedError('Update', param);
+            throw new DbNotSupportedError("Update", param);
         }
         if (!ignoreCheck) {
-            assertText(key, { field: 'key', ...param });
-            assertObject(doc, { field: 'doc', ...param });
+            assertText(key, { field: "key", ...param });
+            assertObject(doc, { field: "doc", ...param });
         }
         if (doc._trashId !== undefined) {
             delete doc._trashId;
         }
-        this._props.forbiddenSet.forEach(f => {
+        this._props.forbiddenSet.forEach((f) => {
             if (doc[f] !== undefined) {
                 delete doc[f];
             }
@@ -898,31 +1001,32 @@ export class DbRepo {
             doc.updatedAt = this._now;
         }
         if (this.hasUpdatedBy && this.userFetcher) {
-            doc.createdBy = await 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)
+            this.cache
+                .clearDoc(updatedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'updateByPrimary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "updateByPrimary", "cache", "clearDoc")));
         }
         return updatedKey;
     }
     /** @inheritDoc */
     async updateBySecondary(key, doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'updateBySecondary');
-        const param = { where: 'DbRepo', method: 'updateBySecondary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "updateBySecondary");
+        const param = { where: "DbRepo", method: "updateBySecondary", queryName: opt.name };
         if (this.isNoUpdate) {
-            throw new DbNotSupportedError('Update', param);
+            throw new DbNotSupportedError("Update", param);
         }
         if (!ignoreCheck) {
             if (this.hasNumericId) {
-                assertInteger(key, { field: 'key', ...param });
+                assertInteger(key, { field: "key", ...param });
             }
             else {
-                assertText(key, { field: 'key', ...param });
+                assertText(key, { field: "key", ...param });
             }
-            assertObject(doc, { field: 'doc', ...param });
+            assertObject(doc, { field: "doc", ...param });
         }
         if (this.isIdSame) {
             return this.updateBySecondary(this._keyToUrn(key), doc, opt, true);
@@ -930,7 +1034,7 @@ export class DbRepo {
         if (doc._trashId !== undefined) {
             delete doc._trashId;
         }
-        this._props.forbiddenSet.forEach(f => {
+        this._props.forbiddenSet.forEach((f) => {
             if (doc[f] !== undefined) {
                 delete doc[f];
             }
@@ -939,13 +1043,14 @@ export class DbRepo {
             doc.updatedAt = this._now;
         }
         if (this.hasUpdatedBy && this.userFetcher) {
-            doc.createdBy = await 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)
+            this.cache
+                .clearDoc(updatedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'updateBySecondary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "updateBySecondary", "cache", "clearDoc")));
         }
         return updatedKey;
     }
@@ -953,12 +1058,13 @@ export class DbRepo {
     // region set
     /** @inheritDoc */
     async set(key, doc, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'set');
+        const opt = this.buildOpt(p1, "set");
         if (!ignoreCheck) {
-            assertObject(doc, { field: 'doc', where: 'DbRepo', method: 'set', queryName: opt.name });
+            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
+            if (v === undefined) {
+                // dont allow undefined
                 delete doc[f];
             }
         }
@@ -966,15 +1072,26 @@ export class DbRepo {
     }
     /** @inheritDoc */
     async unset(key, fields, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'unset');
+        const opt = this.buildOpt(p1, "unset");
         if (!ignoreCheck) {
-            assertArray(fields, { field: 'fields', where: 'DbRepo', method: 'unset', queryName: opt.name });
+            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 });
+                assertText(field, {
+                    field: field,
+                    where: "DbRepo",
+                    method: "unset",
+                    index,
+                    queryName: opt.name,
+                });
             });
         }
         const doc = {};
-        fields.forEach(f => {
+        fields.forEach((f) => {
             if (!this._props.forbiddenSet.includes(f)) {
                 doc[f] = undefined;
             }
@@ -985,7 +1102,7 @@ export class DbRepo {
     // region remove
     /** @inheritDoc */
     async remove(keyLike, p1) {
-        const opt = this.buildOpt(p1, 'remove');
+        const opt = this.buildOpt(p1, "remove");
         const [key, field] = this._checkKey(keyLike);
         switch (field) {
             case "urn":
@@ -993,48 +1110,56 @@ export class DbRepo {
             case "id":
                 return this.removeBySecondary(key, opt, true);
             default:
-                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'remove', queryName: opt.name });
+                assertMessage("Invalid key", {
+                    field: "key",
+                    value: keyLike,
+                    where: "DbRepo",
+                    method: "remove",
+                    queryName: opt.name,
+                });
         }
     }
     /** @inheritDoc */
     async removeByPrimary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'removeByPrimary');
-        const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "removeByPrimary");
+        const param = { where: "DbRepo", method: "removeByPrimary", queryName: opt.name };
         if (this.isNoRemove) {
-            throw new DbNotSupportedError('Remove', param);
+            throw new DbNotSupportedError("Remove", param);
         }
         if (!ignoreCheck) {
-            assertText(key, { field: 'key', ...param });
+            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)
+            this.cache
+                .clearDoc(removedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'removeByPrimary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "removeByPrimary", "cache", "clearDoc")));
         }
         return removedKey;
     }
     /** @inheritDoc */
     async removeBySecondary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'removeBySecondary');
-        const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "removeBySecondary");
+        const param = { where: "DbRepo", method: "removeByPrimary", queryName: opt.name };
         if (this.isNoRemove) {
-            throw new DbNotSupportedError('Remove', param);
+            throw new DbNotSupportedError("Remove", param);
         }
         if (this.hasNumericId) {
-            assertInteger(key, { field: 'key', param });
+            assertInteger(key, { field: "key", param });
         }
         else {
-            assertText(key, { field: 'key', param });
+            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)
+            this.cache
+                .clearDoc(removedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'removeBySecondary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "removeBySecondary", "cache", "clearDoc")));
         }
         return removedKey;
     }
@@ -1042,7 +1167,7 @@ export class DbRepo {
     // region trash
     /** @inheritDoc */
     async trash(keyLike, p1) {
-        const opt = this.buildOpt(p1, 'trash');
+        const opt = this.buildOpt(p1, "trash");
         const [key, field] = this._checkKey(keyLike);
         switch (field) {
             case "urn":
@@ -1050,48 +1175,55 @@ export class DbRepo {
             case "id":
                 return this.trashBySecondary(key, opt, true);
             default:
-                assertMessage('Invalid key', { field: 'key', value: keyLike, where: 'DbRepo', method: 'trash', queryName: opt.name });
+                assertMessage("Invalid key", {
+                    field: "key",
+                    value: keyLike,
+                    where: "DbRepo",
+                    method: "trash",
+                    queryName: opt.name,
+                });
         }
     }
     /** @inheritDoc */
     async trashByPrimary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'trashByPrimary');
-        const param = { where: 'DbRepo', method: 'trashByPrimary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "trashByPrimary");
+        const param = { where: "DbRepo", method: "trashByPrimary", queryName: opt.name };
         if (!this.hasSoftDelete) {
-            throw new DbNotSupportedError('Soft Delete', param);
+            throw new DbNotSupportedError("Soft Delete", param);
         }
         if (this.isNoTrash) {
-            throw new DbNotSupportedError('Trash', param);
+            throw new DbNotSupportedError("Trash", param);
         }
         if (!ignoreCheck) {
-            assertText(key, { field: 'urn', ...param });
+            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)
+            this.cache
+                .clearDoc(trashedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'trashByPrimary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "trashByPrimary", "cache", "clearDoc")));
         }
         return trashedKey;
     }
     /** @inheritDoc */
     async trashBySecondary(key, p1, ignoreCheck) {
-        const opt = this.buildOpt(p1, 'trashBySecondary');
-        const param = { where: 'DbRepo', method: 'trashBySecondary', queryName: opt.name };
+        const opt = this.buildOpt(p1, "trashBySecondary");
+        const param = { where: "DbRepo", method: "trashBySecondary", queryName: opt.name };
         if (!this.hasSoftDelete) {
-            throw new DbNotSupportedError('Soft Delete', param);
+            throw new DbNotSupportedError("Soft Delete", param);
         }
         if (this.isNoTrash) {
-            throw new DbNotSupportedError('Trash', param);
+            throw new DbNotSupportedError("Trash", param);
         }
         if (this.hasNumericId) {
-            assertInteger(key, { field: 'key', ...param });
+            assertInteger(key, { field: "key", ...param });
         }
         else {
-            assertText(key, { field: 'key', ...param });
+            assertText(key, { field: "key", ...param });
         }
         if (this.isIdSame) {
             return this.trashByPrimary(this._keyToUrn(key), opt, ignoreCheck);
@@ -1101,9 +1233,10 @@ export class DbRepo {
         }
         const trashedKey = await this.$trashBySecondary(key, opt, true);
         if (trashedKey && !opt.noCache && this.cache.isConnected) {
-            this.cache.clearDoc(trashedKey, opt)
+            this.cache
+                .clearDoc(trashedKey, opt)
                 .then()
-                .catch(e => this.logger.warn(errorCommon.text(e, 'trashBySecondary', 'cache', 'clearDoc')));
+                .catch((e) => this.logger.warn(errorCommon.text(e, "trashBySecondary", "cache", "clearDoc")));
         }
         return trashedKey;
     }
@@ -1116,11 +1249,11 @@ export class DbRepo {
         }
         switch (dim) {
             case "view":
-                return await this.toView(doc);
+                return (await this.toView(doc));
             case "pair":
-                return await this.toPair(doc);
+                return (await this.toPair(doc));
             case "portion":
-                return await this.toPortion(doc);
+                return (await this.toPortion(doc));
             default: // portion
                 if (this.isIdSame) {
                     return { id: doc.id };
@@ -1132,12 +1265,12 @@ export class DbRepo {
     }
     /** @inheritDoc */
     async getDim(key, dim) {
-        const doc = await this.get(key, { name: `getDim/${dim ?? 'def'}` });
+        const doc = await this.get(key, { name: `getDim/${dim ?? "def"}` });
         return doc ? this.$toDim(doc, dim) : undefined;
     }
     /** @inheritDoc */
     async listDims(keys, dim, ignoreCheck) {
-        const docs = await this.list(keys, { name: `listDims/${dim ?? 'def'}` }, ignoreCheck);
+        const docs = await this.list(keys, { name: `listDims/${dim ?? "def"}` }, ignoreCheck);
         if (docs.length < 1) {
             return [];
         }
@@ -1206,7 +1339,7 @@ export class DbRepo {
     async getPortion(key) {
         if (this.isIdSame) {
             const [identifier, field] = this._checkKey(key);
-            if (field === 'id') {
+            if (field === "id") {
                 return { id: identifier };
             }
         }
@@ -1219,7 +1352,7 @@ export class DbRepo {
             const idResult = this._checkKeys(keys);
             if (!idResult?.urns?.length) {
                 if (Array.isArray(idResult?.ids)) {
-                    return idResult.ids.map(id => {
+                    return idResult.ids.map((id) => {
                         return { id };
                     });
                 }