@samet-it/be-db-common 1.1.3 → 1.1.5

package/dist/connection/db.connection.js

@@ -106,7 +106,8 @@ class DbConnection {
     checkError(err, opt) {
         var _a, _b, _c;
         const size = be_base_common_1.errorHandler.addStat(err);
-        if ((_a = opt === null || opt === void 0 ? void 0 : opt.ignoredErrors) === null || _a === void 0 ? void 0 : _a.includes(err.name)) {
+        const ignoredErrors = (_a = opt === null || opt === void 0 ? void 0 : opt.ignoredErrors) !== null && _a !== void 0 ? _a : [];
+        if (ignoredErrors.includes(err) || ignoredErrors.includes(err.name)) {
             return;
         }
         if (opt === null || opt === void 0 ? void 0 : opt.silent) {
@@ -183,6 +184,9 @@ class DbConnection {
     /** {@inheritDoc} */
     exec(fn, p1) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this._props.enabled) {
+                return undefined;
+            }
             const opt = this.buildOpt(p1);
             try {
                 return yield fn;
@@ -199,6 +203,9 @@ class DbConnection {
      * */
     onModuleInit() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this._props.enabled) {
+                return;
+            }
             yield this.connect();
         });
     }

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

@@ -1,6 +1,5 @@
 import type { DbLines } from "../line";
-import type { DbErrorOmit } from "../error";
-import type { Opt } from "@leyyo/common";
+import type { OmitError, Opt } from "@leyyo/common";
 /**
  * DB query result
  * */
@@ -16,7 +15,7 @@ export interface DbQueryResult<META> {
     /**
      * [when success=false] Couchbase error
      */
-    error?: DbErrorOmit;
+    error?: OmitError;
 }
 /**
  * DB query result as a row
@@ -39,15 +38,23 @@ export interface DbQueryResultMore<E = any, META = unknown> extends DbQueryResul
 /**
  * DB query option
  * */
-export interface DbExecOpt {
+export interface DbExecOpt extends Opt {
     /**
      * Name of SQL
      * */
     name?: string;
+    /**
+     * do not use cache
+     * */
+    noCache?: boolean;
+    /**
+     * Ignore context cache
+     * */
+    ignoreContext?: string;
     /**
      * Ignored errors
      * */
-    ignoredErrors?: Array<string>;
+    ignoredErrors?: Array<OmitError | string>;
     /**
      * Print sql?
      * */
@@ -220,6 +227,12 @@ export interface DbMeta {
  * DB connection option
  * */
 export interface DbConnOpt {
+    /**
+     * Is enabled?
+     *
+     * @type {boolean}
+     * */
+    enabled?: boolean;
     /**
      * Protocol
      *

package/dist/error/db-invalid-value.error.d.ts

@@ -1,4 +1,4 @@
-import type { BasicType } from "@leyyo/common";
+import type { Opt } from "@leyyo/common";
 import { DbError } from "./db.error";
 /**
  * Cache validation error
@@ -6,9 +6,7 @@ import { DbError } from "./db.error";
 export declare class DbInvalidValueError extends DbError {
     /**
      * @param {string} field - invalid field
-     * @param {string} expected - expected type
-     * @param {string} where - class name
-     * @param {string} method - method name
+     * @param {Opt} params - parameters
      * */
-    constructor(field: string, expected: BasicType, where: string, method: string);
+    constructor(field: string, params: Opt);
 }

package/dist/error/db-invalid-value.error.js

@@ -9,12 +9,10 @@ const db_error_1 = require("./db.error");
 class DbInvalidValueError extends db_error_1.DbError {
     /**
      * @param {string} field - invalid field
-     * @param {string} expected - expected type
-     * @param {string} where - class name
-     * @param {string} method - method name
+     * @param {Opt} params - parameters
      * */
-    constructor(field, expected, where, method) {
-        super(`${field} value is not valid at ${where}#${method}`, { field, expected, where, method });
+    constructor(field, params) {
+        super(`${field} value is not valid`, Object.assign(Object.assign({}, params), { field }));
     }
 }
 exports.DbInvalidValueError = DbInvalidValueError;

package/dist/error/db-not-supported.error.d.ts

@@ -1,12 +1,14 @@
 import { DbError } from "./db.error";
+import type { Opt } from "@leyyo/common";
 /**
  * DB not-supported error
  * */
 export declare class DbNotSupportedError extends DbError {
     /**
+     * Constructor
+     *
      * @param {string} feature - feature name
-     * @param {string} where - class name
-     * @param {string} method - method name
+     * @param {Opt} params - parameters
      * */
-    constructor(feature: string, where: string, method: string);
+    constructor(feature: string, params: Opt);
 }

package/dist/error/db-not-supported.error.js

@@ -7,12 +7,13 @@ const db_error_1 = require("./db.error");
  * */
 class DbNotSupportedError extends db_error_1.DbError {
     /**
+     * Constructor
+     *
      * @param {string} feature - feature name
-     * @param {string} where - class name
-     * @param {string} method - method name
+     * @param {Opt} params - parameters
      * */
-    constructor(feature, where, method) {
-        super(`${feature} is not supported at ${where}#${method}`, { feature, where, method });
+    constructor(feature, params) {
+        super(`${feature} is not supported`, Object.assign(Object.assign({}, params), { feature }));
     }
 }
 exports.DbNotSupportedError = DbNotSupportedError;

package/dist/error/db.error.d.ts

@@ -1,7 +1,6 @@
 import { SametError } from "@samet-it/be-base-common";
-import type { DbErrorOmit } from "./index.types";
 /**
  * General database error
  * */
-export declare class DbError extends SametError implements DbErrorOmit {
+export declare class DbError extends SametError {
 }

package/dist/error/index.d.ts

@@ -1,4 +1,3 @@
-export * from './index.types';
 export * from './db.error';
 export * from './db-execute.error';
 export * from './db-invalid-value.error';

package/dist/error/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./index.types"), exports);
 __exportStar(require("./db.error"), exports);
 __exportStar(require("./db-execute.error"), exports);
 __exportStar(require("./db-invalid-value.error"), exports);

package/dist/repo/db.repo.js

@@ -45,7 +45,7 @@ class DbRepo {
          * */
         this._opt = {};
         if (!(0, type_1.isObjectFilled)(conn)) {
-            throw new error_1.DbInvalidValueError('Connection', typeof conn, 'DbRepo', 'constructor');
+            throw new error_1.DbInvalidValueError('Connection', { where: 'DbRepo', method: 'constructor', type: typeof conn });
         }
         if (!(0, type_1.isObjectBare)(this._opt)) {
             this._opt = {};
@@ -59,7 +59,7 @@ class DbRepo {
         }
         if (this._opt.useVersion) {
             if (typeof this._opt.version !== 'number') {
-                throw new error_1.DbInvalidValueError('Model version', typeof conn, 'DbRepo', 'constructor');
+                throw new error_1.DbInvalidValueError('Model version', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.version });
             }
         }
         else {
@@ -84,7 +84,7 @@ class DbRepo {
             }
         }
         if (!this._opt.urnPrefix) {
-            throw new error_1.DbInvalidValueError('Urn prefix', typeof conn, 'DbRepo', 'constructor');
+            throw new error_1.DbInvalidValueError('Urn prefix', { where: 'DbRepo', method: 'constructor', type: typeof this._opt.urnPrefix });
         }
         this._opt.forbiddenSet = this._checkForbiddenList(this._opt.forbiddenSet, ['id', '_urn', '_trashId', 'createdAt', 'createdBy']);
         this._opt.forbiddenUnset = this._checkForbiddenList(this._opt.forbiddenUnset, ['id', '_urn', '_trashId', 'createdAt', 'createdBy', 'updatedAt', 'updatedBy']);
@@ -155,14 +155,10 @@ class DbRepo {
      * */
     _urnFromDoc(doc, method) {
         const { path } = this._props;
-        (0, type_1.assertObject)(doc, () => {
-            return { field: 'doc', where: 'DbRepo', path, method };
-        });
-        const urn = doc._urn;
-        (0, type_1.assertObject)(urn, () => {
-            return { field: 'urn', where: 'DbRepo', path, method };
-        });
-        return urn;
+        const param = { where: 'DbRepo', path, method };
+        (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
+        (0, type_1.assertText)(doc._urn, Object.assign({ field: 'urn' }, param));
+        return doc._urn;
     }
     _checkKey(value) {
         const { useNumericId } = this._props;
@@ -274,28 +270,31 @@ class DbRepo {
     /** @inheritDoc */
     get(k1, p1) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'get');
             const [key, field] = this._checkKey(k1);
             switch (field) {
                 case "_urn":
-                    return this.getByPrimary(key, p1, true);
+                    return this.getByPrimary(key, opt, true);
                 case "id":
-                    return this.getBySecondary(key, p1, true);
+                    return this.getBySecondary(key, opt, true);
                 default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'get' });
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'get', queryName: opt.name });
             }
         });
     }
     /** @inheritDoc */
     getByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache } = this._props;
+            const { cache, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'getByPrimary');
             if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary' });
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary', queryName: opt.name });
             }
             let found;
-            if (cache.props.isConnected) {
+            if (!opt.noCache && cache.props.isConnected) {
                 try {
-                    found = (yield cache.getByPrimary(key))[0];
+                    found = yield cache.getByPrimary(key, opt);
                 }
                 catch (e) {
                     this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getByPrimary', 'cache', 'getByPrimary'));
@@ -304,9 +303,9 @@ class DbRepo {
                     return found;
                 }
             }
-            found = yield this.$getByPrimary(key, p1, true);
-            if (found && cache.props.isConnected) {
-                cache.ingestDoc(found)
+            found = yield this.$getByPrimary(key, opt, true);
+            if (!opt.noCache && found && cache.props.isConnected) {
+                cache.ingestDoc(found, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getByPrimary', 'cache', 'ingestDoc')));
             }
@@ -316,22 +315,23 @@ class DbRepo {
     /** @inheritDoc */
     getBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, useNumericId, idSame } = this._props;
+            const { cache, useNumericId, idSame, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'getBySecondary');
             if (!ignoreCheck) {
                 if (useNumericId) {
-                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                    (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' });
+                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
                 }
             }
             if (idSame) {
-                return this.getByPrimary(this._keyToUrn(key), p1, true);
+                return this.getByPrimary(this._keyToUrn(key), opt, true);
             }
             let found;
-            if (cache.props.isConnected) {
+            if (!opt.noCache && cache.props.isConnected) {
                 try {
-                    found = (yield cache.getBySecondary(key))[0];
+                    found = yield cache.getBySecondary(key, opt);
                     if (found) {
                         return found;
                     }
@@ -340,9 +340,9 @@ class DbRepo {
                     this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getBySecondary', 'cache', 'getBySecondary'));
                 }
             }
-            found = yield this.$getBySecondary(key, p1, true);
+            found = yield this.$getBySecondary(key, opt, true);
             if (found && cache.props.isConnected) {
-                cache.ingestDoc(found)
+                cache.ingestDoc(found, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getBySecondary', 'cache', 'ingestDoc')));
             }
@@ -354,14 +354,16 @@ class DbRepo {
     /** @inheritDoc */
     exists(k1, p1) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'exists');
             const [key, field] = this._checkKey(k1);
             switch (field) {
                 case "_urn":
-                    return this.existsByPrimary(key, p1, true);
+                    return this.existsByPrimary(key, opt, true);
                 case "id":
-                    return this.existsBySecondary(key, p1, true);
+                    return this.existsBySecondary(key, opt, true);
                 default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'exists' });
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'exists', queryName: opt.name });
                     break;
             }
         });
@@ -369,13 +371,14 @@ class DbRepo {
     /** @inheritDoc */
     existsByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache } = this._props;
+            const { cache, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'existsByPrimary');
             if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary' });
+                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary', queryName: opt.name });
             }
-            if (cache.props.isConnected) {
+            if (!opt.noCache && cache.props.isConnected) {
                 try {
-                    const found = (yield cache.getByPrimary(key))[0];
+                    const found = yield cache.getByPrimary(key, opt);
                     if (found) {
                         return true;
                     }
@@ -384,27 +387,28 @@ class DbRepo {
                     this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'existsByPrimary', 'cache', 'getByPrimary'));
                 }
             }
-            return this.$existsByPrimary(key, p1, true);
+            return this.$existsByPrimary(key, opt, true);
         });
     }
     /** @inheritDoc */
     existsBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, useNumericId, idSame } = this._props;
+            const { cache, useNumericId, idSame, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'existsBySecondary');
             if (!ignoreCheck) {
                 if (useNumericId) {
-                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary' });
+                    (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' });
+                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
                 }
             }
             if (!idSame) {
                 return this.existsByPrimary(this._keyToUrn(key));
             }
-            if (cache.props.isConnected) {
+            if (!opt.noCache && cache.props.isConnected) {
                 try {
-                    const found = (yield cache.getBySecondary(key))[0];
+                    const found = yield cache.getBySecondary(key, opt);
                     if (found) {
                         return true;
                     }
@@ -413,7 +417,7 @@ class DbRepo {
                     this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'existsBySecondary', 'cache', 'getBySecondary'));
                 }
             }
-            return this.$existsBySecondary(key, p1, true);
+            return this.$existsBySecondary(key, opt, true);
         });
     }
     // endregion exists
@@ -421,11 +425,11 @@ class DbRepo {
     /** @inheritDoc */
     list(keys, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ignoreCheck) {
-                (0, type_1.assertArray)(keys, { field: 'keys', where: 'DbRepo', method: 'list' });
-            }
             const { conn, cache } = this._props;
             const opt = conn.buildOpt(p1, 'list');
+            if (!ignoreCheck) {
+                (0, type_1.assertArray)(keys, { field: 'keys', where: 'DbRepo', method: 'list', queryName: opt.name });
+            }
             const result = this._checkKeys(keys);
             if (result.ordered.length < 1) {
                 return [];
@@ -433,9 +437,9 @@ class DbRepo {
             const docs = [];
             let founds = [];
             if (result.urns.length > 0) {
-                if (cache.props.isConnected) {
+                if (!opt.noCache && cache.props.isConnected) {
                     try {
-                        founds = yield cache.getByPrimary(...result.urns);
+                        founds = yield cache.getByPrimaryMore(result.urns, opt);
                     }
                     catch (e) {
                         this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'getByPrimary'));
@@ -451,8 +455,8 @@ class DbRepo {
                 if (result.urns.length > 0) {
                     founds = yield this.$listByPrimary(result.urns, opt, true);
                     if (founds.length > 0) {
-                        if (cache.props.isConnected) {
-                            founds.forEach(found => cache.ingestDoc(found)
+                        if (!opt.noCache && cache.props.isConnected) {
+                            founds.forEach(found => cache.ingestDoc(found, opt)
                                 .then()
                                 .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'ingestDoc'))));
                         }
@@ -461,9 +465,9 @@ class DbRepo {
                 }
             }
             if (result.ids.length > 0) {
-                if (cache.props.isConnected) {
+                if (!opt.noCache && cache.props.isConnected) {
                     try {
-                        founds = yield cache.getBySecondary(...result.ids);
+                        founds = yield cache.getBySecondaryMore(result.ids, opt);
                     }
                     catch (e) {
                         this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'getBySecondary'));
@@ -479,8 +483,8 @@ class DbRepo {
                 if (result.ids.length > 0) {
                     founds = yield this.$listBySecondary(result.ids, opt, true);
                     if (founds.length > 0) {
-                        if (cache.props.isConnected) {
-                            founds.forEach(found => cache.ingestDoc(found)
+                        if (!opt.noCache && cache.props.isConnected) {
+                            founds.forEach(found => cache.ingestDoc(found, opt)
                                 .then()
                                 .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'ingestDoc'))));
                         }
@@ -506,19 +510,21 @@ class DbRepo {
     /** @inheritDoc */
     insert(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { useCreatedAt, noInsert, useNumericId, useCreatedBy, useUpdatedAt, useUpdatedBy } = this._props;
+            const { useCreatedAt, conn, noInsert, useNumericId, useCreatedBy, useUpdatedAt, useUpdatedBy } = this._props;
+            const opt = conn.buildOpt(p1, 'insert');
+            const param = { where: 'DbRepo', method: 'insert', queryName: opt.name };
             if (noInsert) {
-                throw new error_1.DbNotSupportedError('Insert', 'DbRepo', 'insert');
+                throw new error_1.DbNotSupportedError('Insert', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'insert' });
+                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
                 if (useNumericId) {
-                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                    (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
                 else {
-                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'insert' });
+                    (0, type_1.assertText)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
-                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'insert' });
+                (0, type_1.assertText)(doc._urn, Object.assign({ field: 'doc._urn' }, param));
             }
             if (!doc._trashId !== undefined) {
                 delete doc._trashId;
@@ -535,22 +541,24 @@ class DbRepo {
             if (useUpdatedBy) {
                 // todo
             }
-            return this.$insert(doc, p1);
+            return this.$insert(doc, opt);
         });
     }
     /** @inheritDoc */
     inserts(docs, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noInsert } = this._props;
+            const { noInsert, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'inserts');
+            const param = { where: 'DbRepo', method: 'inserts', queryName: opt.name };
             if (noInsert) {
-                throw new error_1.DbNotSupportedError('Insert', 'DbRepo', 'inserts');
+                throw new error_1.DbNotSupportedError('Insert', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertArray)(docs, { field: 'docs', where: 'DbRepo', method: 'inserts' });
+                (0, type_1.assertArray)(docs, Object.assign({ field: 'docs' }, param));
             }
             const insertedIds = [];
             for (const doc of docs) {
-                insertedIds.push(yield this.insert(doc, p1, true));
+                insertedIds.push(yield this.insert(doc, opt, true));
             }
             return insertedIds;
         });
@@ -560,15 +568,16 @@ class DbRepo {
     /** @inheritDoc */
     replace(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
+            const { cache, conn, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
+            const opt = conn.buildOpt(p1, 'replace');
             if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'replace' });
-                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'replace' });
+                (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 (useNumericId) {
-                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace' });
+                    (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' });
+                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
                 }
             }
             if (doc._trashId !== undefined) {
@@ -580,9 +589,9 @@ class DbRepo {
             if (useUpdatedBy) {
                 // todo
             }
-            const replacedKey = yield this.$replace(doc, p1, true);
-            if (cache.props.isConnected) {
-                cache.clearDoc(replacedKey)
+            const replacedKey = yield this.$replace(doc, opt, true);
+            if (!opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(replacedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'replace', 'cache', 'clearDoc')));
             }
@@ -594,18 +603,20 @@ class DbRepo {
     /** @inheritDoc */
     upsert(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noInsert, noUpdate, cache, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
+            const { noInsert, conn, noUpdate, cache, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
+            const opt = conn.buildOpt(p1, 'upsert');
+            const param = { where: 'DbRepo', method: 'upsert', queryName: opt.name };
             if (noInsert || noUpdate) {
-                throw new error_1.DbNotSupportedError('Upsert', 'DbRepo', 'upsert');
+                throw new error_1.DbNotSupportedError('Upsert', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'upsert' });
-                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'upsert' });
+                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
+                (0, type_1.assertText)(doc._urn, Object.assign({ field: 'doc._urn' }, param));
                 if (useNumericId) {
-                    (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'upsert' });
+                    (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
                 else {
-                    (0, type_1.assertText)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'upsert' });
+                    (0, type_1.assertText)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
             }
             if (doc._trashId !== undefined) {
@@ -617,9 +628,9 @@ class DbRepo {
             if (useUpdatedBy) {
                 // todo
             }
-            const createdKey = yield this.$replace(doc, p1, true);
-            if (cache.props.isConnected) {
-                cache.clearDoc(createdKey)
+            const createdKey = yield this.$replace(doc, opt, true);
+            if (!opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(createdKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'upsert', 'cache', 'clearDoc')));
             }
@@ -631,30 +642,34 @@ class DbRepo {
     /** @inheritDoc */
     update(k1, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'update');
             if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'update' });
+                (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, p1, true);
+                    return this.updateByPrimary(key, doc, opt, true);
                 case "id":
-                    return this.updateBySecondary(key, doc, p1, true);
+                    return this.updateBySecondary(key, doc, opt, true);
                 default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'update' });
+                    (0, type_1.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 { noUpdate, forbiddenSet, cache, useUpdatedAt, useUpdatedBy } = this._props;
+            const { noUpdate, conn, forbiddenSet, cache, useUpdatedAt, useUpdatedBy } = this._props;
+            const opt = conn.buildOpt(p1, 'updateByPrimary');
+            const param = { where: 'DbRepo', method: 'updateByPrimary', queryName: opt.name };
             if (noUpdate) {
-                throw new error_1.DbNotSupportedError('Update', 'DbRepo', 'updateByPrimary');
+                throw new error_1.DbNotSupportedError('Update', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'updateByPrimary' });
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'updateByPrimary' });
+                (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;
@@ -670,9 +685,9 @@ class DbRepo {
             if (useUpdatedBy) {
                 // todo
             }
-            const updatedKey = yield this.$updateByPrimary(key, doc, p1, true);
-            if (updatedKey && cache.props.isConnected) {
-                cache.clearDoc(updatedKey)
+            const updatedKey = yield this.$updateByPrimary(key, doc, opt, true);
+            if (updatedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(updatedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'updateByPrimary', 'cache', 'clearDoc')));
             }
@@ -682,21 +697,23 @@ class DbRepo {
     /** @inheritDoc */
     updateBySecondary(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { forbiddenSet, noUpdate, cache, useNumericId, idSame, useUpdatedAt, useUpdatedBy } = this._props;
+            const { forbiddenSet, noUpdate, cache, useNumericId, idSame, useUpdatedAt, useUpdatedBy, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'updateBySecondary');
+            const param = { where: 'DbRepo', method: 'updateBySecondary', queryName: opt.name };
             if (noUpdate) {
-                throw new error_1.DbNotSupportedError('Update', 'DbRepo', 'updateBySecondary');
+                throw new error_1.DbNotSupportedError('Update', param);
             }
             if (!ignoreCheck) {
                 if (useNumericId) {
-                    (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                    (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
                 }
                 else {
-                    (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary' });
+                    (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
                 }
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'getBySecondary' });
+                (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
             }
             if (idSame) {
-                return this.updateBySecondary(this._keyToUrn(key), doc, p1, true);
+                return this.updateBySecondary(this._keyToUrn(key), doc, opt, true);
             }
             if (doc._trashId !== undefined) {
                 delete doc._trashId;
@@ -712,9 +729,9 @@ class DbRepo {
             if (useUpdatedBy) {
                 // todo
             }
-            const updatedKey = yield this.$updateBySecondary(key, doc, p1, true);
-            if (updatedKey && cache.props.isConnected) {
-                cache.clearDoc(updatedKey)
+            const updatedKey = yield this.$updateBySecondary(key, doc, opt, true);
+            if (updatedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(updatedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'updateBySecondary', 'cache', 'clearDoc')));
             }
@@ -726,24 +743,28 @@ class DbRepo {
     /** @inheritDoc */
     set(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'set');
             if (!ignoreCheck) {
-                (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'set' });
+                (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];
                 }
             }
-            return this.update(key, doc, p1, false);
+            return this.update(key, doc, opt, false);
         });
     }
     /** @inheritDoc */
     unset(key, fields, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'unset');
             if (!ignoreCheck) {
-                (0, type_1.assertArray)(fields, { field: 'fields', where: 'DbRepo', method: 'unset' });
+                (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 });
+                    (0, type_1.assertText)(field, { field: field, where: 'DbRepo', method: 'unset', index, queryName: opt.name });
                 });
             }
             const { forbiddenUnset } = this._props;
@@ -753,7 +774,7 @@ class DbRepo {
                     doc[f] = undefined;
                 }
             });
-            return this.update(key, doc, p1, false);
+            return this.update(key, doc, opt, false);
         });
     }
     // endregion set
@@ -761,30 +782,34 @@ class DbRepo {
     /** @inheritDoc */
     remove(k1, p1) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'remove');
             const [key, field] = this._checkKey(k1);
             switch (field) {
                 case "_urn":
-                    return this.removeByPrimary(key, p1, true);
+                    return this.removeByPrimary(key, opt, true);
                 case "id":
-                    return this.removeBySecondary(key, p1, true);
+                    return this.removeBySecondary(key, opt, true);
                 default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'remove' });
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'remove', queryName: opt.name });
             }
         });
     }
     /** @inheritDoc */
     removeByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, noRemove } = this._props;
+            const { cache, noRemove, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'removeByPrimary');
+            const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
             if (noRemove) {
-                throw new error_1.DbNotSupportedError('Remove', 'DbRepo', 'removeByPrimary');
+                throw new error_1.DbNotSupportedError('Remove', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'removeByPrimary' });
+                (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
             }
-            const removedKey = yield this.$removeByPrimary(key, p1, true);
-            if (removedKey && cache.props.isConnected) {
-                cache.clearDoc(removedKey)
+            const removedKey = yield this.$removeByPrimary(key, opt, true);
+            if (removedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(removedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'removeByPrimary', 'cache', 'clearDoc')));
             }
@@ -794,22 +819,24 @@ class DbRepo {
     /** @inheritDoc */
     removeBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, noRemove, useNumericId, idSame } = this._props;
+            const { cache, noRemove, useNumericId, idSame, conn } = this._props;
+            const opt = conn.buildOpt(p1, 'removeBySecondary');
+            const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
             if (noRemove) {
-                throw new error_1.DbNotSupportedError('Remove', 'DbRepo', 'removeByPrimary');
+                throw new error_1.DbNotSupportedError('Remove', param);
             }
             if (useNumericId) {
-                (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'removeBySecondary' });
+                (0, type_1.assertInteger)(key, { field: 'key', param });
             }
             else {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'removeBySecondary' });
+                (0, type_1.assertText)(key, { field: 'key', param });
             }
             if (idSame) {
-                return this.removeByPrimary(this._keyToUrn(key), p1, ignoreCheck);
+                return this.removeByPrimary(this._keyToUrn(key), opt, ignoreCheck);
             }
-            const removedKey = yield this.$removeBySecondary(key, p1, true);
-            if (removedKey && cache.props.isConnected) {
-                cache.clearDoc(removedKey)
+            const removedKey = yield this.$removeBySecondary(key, opt, true);
+            if (removedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(removedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'removeBySecondary', 'cache', 'clearDoc')));
             }
@@ -821,34 +848,40 @@ class DbRepo {
     /** @inheritDoc */
     trash(k1, p1) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { conn } = this._props;
+            const opt = conn.buildOpt(p1, 'trash');
             const [key, field] = this._checkKey(k1);
             switch (field) {
                 case "_urn":
-                    return this.trashByPrimary(key, p1, true);
+                    return this.trashByPrimary(key, opt, true);
                 case "id":
-                    return this.trashBySecondary(key, p1, true);
+                    return this.trashBySecondary(key, opt, true);
                 default:
-                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'trash' });
+                    (0, type_1.assertMessage)('Invalid key', { field: 'key', value: k1, where: 'DbRepo', method: 'trash', queryName: opt.name });
             }
         });
     }
     /** @inheritDoc */
     trashByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noTrash, conn, cache } = this._props;
+            const { noTrash, useSoftDelete, conn, cache } = this._props;
+            const opt = conn.buildOpt(p1, 'trashByPrimary');
+            const param = { where: 'DbRepo', method: 'trashByPrimary', queryName: opt.name };
+            if (!useSoftDelete) {
+                throw new error_1.DbNotSupportedError('Soft Delete', param);
+            }
             if (noTrash) {
-                throw new error_1.DbNotSupportedError('Trash', 'DbRepo', 'trashByPrimary');
+                throw new error_1.DbNotSupportedError('Trash', param);
             }
             if (!ignoreCheck) {
-                (0, type_1.assertText)(key, { field: 'urn', where: 'DbRepo', method: 'trashByPrimary' });
+                (0, type_1.assertText)(key, Object.assign({ field: 'urn' }, param));
             }
-            const opt = conn.buildOpt(p1, 'trashByPrimary');
             if (!(0, type_1.isText)(opt.trashId)) {
                 opt.trashId = (0, node_crypto_1.randomUUID)();
             }
             const trashedKey = yield this.$trashByPrimary(key, opt, true);
-            if (trashedKey && cache.props.isConnected) {
-                cache.clearDoc(trashedKey)
+            if (trashedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(trashedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'trashByPrimary', 'cache', 'clearDoc')));
             }
@@ -858,26 +891,30 @@ class DbRepo {
     /** @inheritDoc */
     trashBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noTrash, useNumericId, idSame, conn, cache } = this._props;
+            const { noTrash, useSoftDelete, useNumericId, idSame, conn, cache } = this._props;
+            const opt = conn.buildOpt(p1, 'trashBySecondary');
+            const param = { where: 'DbRepo', method: 'trashBySecondary', queryName: opt.name };
+            if (!useSoftDelete) {
+                throw new error_1.DbNotSupportedError('Soft Delete', param);
+            }
             if (noTrash) {
-                throw new error_1.DbNotSupportedError('Trash', 'DbRepo', 'trashBySecondary');
+                throw new error_1.DbNotSupportedError('Trash', param);
             }
             if (useNumericId) {
-                (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'trashBySecondary' });
+                (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
             }
             else {
-                (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'trashBySecondary' });
+                (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
             }
             if (idSame) {
-                return this.trashByPrimary(this._keyToUrn(key), p1, ignoreCheck);
+                return this.trashByPrimary(this._keyToUrn(key), opt, ignoreCheck);
             }
-            const opt = conn.buildOpt(p1, 'trashBySecondary');
             if (!(0, type_1.isText)(opt.trashId)) {
                 opt.trashId = (0, node_crypto_1.randomUUID)();
             }
             const trashedKey = yield this.$trashBySecondary(key, opt, true);
-            if (trashedKey && cache.props.isConnected) {
-                cache.clearDoc(trashedKey)
+            if (trashedKey && !opt.noCache && cache.props.isConnected) {
+                cache.clearDoc(trashedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'trashBySecondary', 'cache', 'clearDoc')));
             }

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

@@ -587,6 +587,15 @@ export interface DbRepoOpt<ENT extends Entity<ID>, ID extends KeyValue> {
      * @default false
      * */
     idSame?: boolean;
+    /**
+     * Ignores soft delete
+     * - if yes, it ignores trash case
+     * - if no, it validates trash case
+     *
+     * @fields `_trashId`
+     * @default false
+     * */
+    useSoftDelete?: boolean;
     /**
      * Manages `created at` case, as time by `useIsoDate`
      * - if yes, it builds `createdAt`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samet-it/be-db-common",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Backend DB Common",
   "repository": {
     "type": "git",
@@ -64,9 +64,9 @@
   },
   "dependencies": {
     "@leyyo/query": "^1.2.2",
-    "@leyyo/common": "^1.2.3",
+    "@leyyo/common": "^1.2.4",
     "@leyyo/type": "^1.1.1",
-    "@samet-it/be-base-common": "^1.1.3",
-    "@samet-it/be-cache-common": "^1.1.3"
+    "@samet-it/be-base-common": "^1.1.4",
+    "@samet-it/be-cache-common": "^1.1.6"
   }
 }

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

@@ -1 +0,0 @@
-export type DbErrorOmit = Omit<Error, 'message' | 'name' | 'stack'>;

package/dist/error/index.types.js

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