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

package/dist/repo/db.repo.js

@@ -15,28 +15,31 @@ const be_base_common_1 = require("@samet-it/be-base-common");
 const query_1 = require("@leyyo/query");
 const type_1 = require("@leyyo/type");
 const error_1 = require("../error");
+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
  *
  * Generics:
- * - 0-`CONN`: db connection {@link DbConnectionBase}
+ * - 0-`CONN`: db connection {@link DbConnectionLike}
  * - 1-`OPT`: db execution options {@link DbExecOpt}
- * - 2-`ENT`: entity {@link Entity}
- * - 3-`ID`: id type {@link KeyValue}
- * - 4-`URN`: urn interface {@link UrnDocLike}
- * - 5-`VIEW`: view interface for presentation layer {@link View}
- * - 6-`PAIR`: pair interface for presentation layer {@link Pair}
- * - 7-`PORTION`: portion interface for presentation layer {@link Portion}
- * - 8-`KEYS`: keys to autocomplete, def: keys of {@link Entity}
- * - 9-`DIMS`: dimensions for presentation layer {@link DefDims}
+ * - 2-`META`: query result metadata {@link DbMeta}
+ * - 3-`ENT`: entity {@link Entity}
+ * - 4-`ID`: id type {@link KeyValue}
+ * - 5-`URN`: urn interface {@link UrnDocLike}
+ * - 6-`VIEW`: view interface for presentation layer {@link View}
+ * - 7-`PAIR`: pair interface for presentation layer {@link Pair}
+ * - 8-`PORTION`: portion interface for presentation layer {@link Portion}
+ * - 9-`KEYS`: keys to autocomplete, def: keys of {@link Entity}
+ * - 10-`DIMS`: dimensions for presentation layer {@link DefDims}
  * */
 class DbRepo {
     // endregion protected-property
     /**
      * Constructor
      *
-     * @param {DbConnectionBase} conn - db connection
+     * @param {DbConnectionLike} conn - db connection
      * @param {DbRepoOpt} opt - options
      * */
     constructor(conn, opt) {
@@ -86,41 +89,22 @@ class DbRepo {
         if (!this._opt.urnPrefix) {
             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']);
-        this._props = Object.assign({ conn }, this._opt);
-        delete this._opt;
-    }
-    // region protected-method
-    _removeFieldForForbidden(fields, flag, field) {
-        if (this._opt[flag] !== true) {
-            const index = fields.indexOf(field);
-            if (index >= 0) {
-                fields.splice(index, 0);
-            }
-        }
-    }
-    _checkForbiddenList(given, def) {
-        if (!Array.isArray(given)) {
-            given = [];
+        if (!Array.isArray(this._opt.forbiddenSet)) {
+            this._opt.forbiddenSet = [...FORBIDDEN_KEYS];
         }
         else {
-            given = given.filter(v => (0, type_1.isText)(v));
-        }
-        if (given.length < 1) {
-            given.push(...def);
+            STRICT_KEYS.forEach(k => {
+                if (!this._opt.forbiddenSet.includes(k)) {
+                    this._opt.forbiddenSet.push(k);
+                }
+            });
         }
-        this._removeFieldForForbidden(given, 'useCreatedAt', 'createdAt');
-        this._removeFieldForForbidden(given, 'useCreatedBy', 'createdBy');
-        this._removeFieldForForbidden(given, 'useUpdatedAt', 'updatedAt');
-        this._removeFieldForForbidden(given, 'useUpdatedBy', 'updatedBy');
-        this._removeFieldForForbidden(given, 'useRevision', '_rev');
-        this._removeFieldForForbidden(given, 'useVersion', '_ver');
-        return given;
+        this._props = Object.assign({ conn }, this._opt);
+        delete this._opt;
     }
+    // region protected-method
     get _now() {
-        const { useIsoDate } = this._props;
-        return useIsoDate ? new Date().toISOString() : Date.now();
+        return this.hasIsoDate ? new Date().toISOString() : Date.now();
     }
     get _randomIndexName() {
         return 'idx_' + (0, node_crypto_1.randomUUID)().match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
@@ -151,27 +135,25 @@ class DbRepo {
         return name;
     }
     /**
-     * Fetch urn from doc as doc._urn
+     * Fetch urn from doc as doc.urn
      * */
     _urnFromDoc(doc, method) {
-        const { path } = this._props;
-        const param = { where: 'DbRepo', path, method };
+        const param = { where: 'DbRepo', path: this.path, method };
         (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-        (0, type_1.assertText)(doc._urn, Object.assign({ field: 'urn' }, param));
-        return doc._urn;
+        (0, type_1.assertText)(doc.urn, Object.assign({ field: 'urn' }, param));
+        return doc.urn;
     }
     _checkKey(value) {
-        const { useNumericId } = this._props;
         let id;
         switch (typeof value) {
             case "string":
                 const str = value.trim();
                 if (str) {
                     if (this._isUrn(str)) {
-                        return [str, '_urn'];
+                        return [str, 'urn'];
                     }
                     else {
-                        if (useNumericId) {
+                        if (this.hasNumericId) {
                             try {
                                 id = parseInt(str);
                             }
@@ -189,7 +171,7 @@ class DbRepo {
                 }
                 break;
             case "number":
-                if (useNumericId) {
+                if (this.hasNumericId) {
                     return [value, 'id'];
                 }
                 else {
@@ -206,9 +188,6 @@ class DbRepo {
                 if (obj.urn !== undefined) {
                     return this._checkKey(obj.urn);
                 }
-                if (obj._urn !== undefined) {
-                    return this._checkKey(obj._urn);
-                }
                 break;
         }
         return [undefined, undefined];
@@ -224,7 +203,7 @@ 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]);
                 }
@@ -237,12 +216,10 @@ class DbRepo {
         return result;
     }
     _isUrn(key) {
-        const { urnPrefix } = this._props;
-        return (typeof key === 'string') && key.startsWith(urnPrefix + ':');
+        return (typeof key === 'string') && key.startsWith(this.urnPrefix + ':');
     }
     _keyToUrn(key) {
-        const { urnPrefix } = this._props;
-        return `${urnPrefix}:${key}`;
+        return `${this.urnPrefix}:${key}`;
     }
     // endregion protected-method
     // region getter
@@ -254,12 +231,210 @@ class DbRepo {
     $cast() {
         return this;
     }
+    /** @inheritDoc */
+    get isEnabled() {
+        return this._props.conn.isEnabled;
+    }
+    /** @inheritDoc */
+    get userFetcher() {
+        return this._props.conn.props.userFetcher;
+    }
+    /** @inheritDoc */
+    get conn() {
+        return this._props.conn;
+    }
+    /** @inheritDoc */
+    get isConnected() {
+        return this._props.conn.isConnected;
+    }
+    /** @inheritDoc */
+    get cache() {
+        return this._props.cache;
+    }
+    /** @inheritDoc */
+    get modelVersion() {
+        return this._props.version;
+    }
+    /** @inheritDoc */
+    get urnDelimiter() {
+        return this._props.urnDelimiter;
+    }
+    /** @inheritDoc */
+    get urnPrefix() {
+        return this._props.urnPrefix;
+    }
+    /** @inheritDoc */
+    get hasNumericId() {
+        return this._props.useNumericId;
+    }
+    /** @inheritDoc */
+    get hasIsoDate() {
+        return this._props.useIsoDate;
+    }
+    /** @inheritDoc */
+    get isIdSame() {
+        return this._props.idSame;
+    }
+    /** @inheritDoc */
+    get hasSoftDelete() {
+        return this._props.useSoftDelete;
+    }
+    /** @inheritDoc */
+    get hasCreatedAt() {
+        return this._props.useCreatedAt;
+    }
+    /** @inheritDoc */
+    get hasCreatedBy() {
+        return this._props.useCreatedBy;
+    }
+    /** @inheritDoc */
+    get hasUpdatedAt() {
+        return this._props.useUpdatedAt;
+    }
+    /** @inheritDoc */
+    get hasUpdatedBy() {
+        return this._props.useUpdatedBy;
+    }
+    /** @inheritDoc */
+    get hasVersion() {
+        return this._props.useVersion;
+    }
+    /** @inheritDoc */
+    get hasRevision() {
+        return this._props.useRevision;
+    }
+    /** @inheritDoc */
+    get isNoInsert() {
+        return this._props.noInsert;
+    }
+    /** @inheritDoc */
+    get isNoUpdate() {
+        return this._props.noUpdate;
+    }
+    /** @inheritDoc */
+    get isNoTrash() {
+        return this._props.noTrash;
+    }
+    /** @inheritDoc */
+    get isNoRemove() {
+        return this._props.noRemove;
+    }
+    /** @inheritDoc */
+    get alphaFn() {
+        return this._props.alphaFn;
+    }
+    /** @inheritDoc */
+    get searchFn() {
+        return this._props.searchFn;
+    }
+    /** @inheritDoc */
+    get irregularFn() {
+        return this._props.irregularFn;
+    }
+    /** @inheritDoc */
+    get forbiddenSet() {
+        return [...this._props.forbiddenSet];
+    }
+    /** @inheritDoc */
+    get path() {
+        return this._props.path;
+    }
+    /** @inheritDoc */
+    get table() {
+        return this._props.table;
+    }
+    /** @inheritDoc */
+    get urnLength() {
+        return this._props.urnLength;
+    }
     // endregion getter
+    // region field-value
+    /** {@inheritDoc} */
+    checkError(err, opt) {
+        var _a, _b, _c;
+        const size = be_base_common_1.errorHandler.addStat(err);
+        const ignoredErrors = (_a = opt === null || opt === void 0 ? void 0 : opt.ignoredErrors) !== null && _a !== void 0 ? _a : [];
+        if (ignoredErrors.includes(err) || ignoredErrors.includes(err.name)) {
+            return;
+        }
+        if (opt === null || opt === void 0 ? void 0 : opt.silent) {
+            if (size < 100) {
+                this.logger.warn(be_base_common_1.errorHandler.common.logText(err, ((_b = opt.name) !== null && _b !== void 0 ? _b : 'Database error'), size));
+            }
+            return;
+        }
+        if (size < 100) {
+            this.logger.error(be_base_common_1.errorHandler.common.logText(err, ((_c = opt.name) !== null && _c !== void 0 ? _c : 'Database error'), size));
+        }
+        if (err instanceof error_1.DbError) {
+            throw err;
+        }
+        else {
+            throw be_base_common_1.errorHandler.common.castForClass(error_1.DbError, err, { queryName: opt.name });
+        }
+    }
+    /** {@inheritDoc} */
+    f(field) {
+        return this.field(field);
+    }
+    v(value) {
+        return this.value(value);
+    }
+    /** {@inheritDoc} */
+    rows(rows) {
+        if (rows && Array.isArray(rows) && (rows.length > 0)) {
+            return rows.filter(row => row['_trashId'] === undefined);
+        }
+        return [];
+    }
+    /** {@inheritDoc} */
+    row(row) {
+        if (row && row['_trashId'] === undefined) {
+            return row;
+        }
+        return undefined;
+    }
+    /** {@inheritDoc} */
+    first(rows) {
+        if (rows && Array.isArray(rows) && (rows.length > 0)) {
+            return rows[0];
+        }
+        return undefined;
+    }
+    // endregion field-value
+    // region option
+    /** {@inheritDoc} */
+    buildOpt(p1, name) {
+        const opt = (typeof p1 === 'string' ? { name: p1 } : Object.assign({}, p1));
+        if (typeof opt.name === undefined && typeof name !== undefined) {
+            opt.name = name;
+        }
+        opt.name = opt.name ? `[${opt.name}]` : '';
+        return opt;
+    }
+    // endregion option
+    // region query
+    /** {@inheritDoc} */
+    exec(fn, p1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled) {
+                return undefined;
+            }
+            const opt = this.buildOpt(p1);
+            try {
+                return yield fn;
+            }
+            catch (err) {
+                this.checkError(err, opt);
+                return undefined;
+            }
+        });
+    }
+    // endregion query
     // region urn
     /** @inheritDoc */
     toUrn(urnRec) {
-        const { urnPrefix, urnDelimiter } = this._props;
-        return `${urnPrefix}:${this.$toUrnTuple(urnRec).join(urnDelimiter)}`;
+        return `${this.urnPrefix}:${this.$toUrnTuple(urnRec).join(this.urnDelimiter)}`;
     }
     /** @inheritDoc */
     $toUrnTuple(urnRec) {
@@ -270,11 +445,10 @@ 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 opt = this.buildOpt(p1, 'get');
             const [key, field] = this._checkKey(k1);
             switch (field) {
-                case "_urn":
+                case "urn":
                     return this.getByPrimary(key, opt, true);
                 case "id":
                     return this.getBySecondary(key, opt, true);
@@ -286,15 +460,14 @@ class DbRepo {
     /** @inheritDoc */
     getByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'getByPrimary');
+            const opt = this.buildOpt(p1, 'getByPrimary');
             if (!ignoreCheck) {
                 (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getByPrimary', queryName: opt.name });
             }
             let found;
-            if (!opt.noCache && cache.props.isConnected) {
+            if (!opt.noCache && this.cache.isConnected) {
                 try {
-                    found = yield cache.getByPrimary(key, opt);
+                    found = yield this.cache.getByPrimary(key, opt);
                 }
                 catch (e) {
                     this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getByPrimary', 'cache', 'getByPrimary'));
@@ -304,8 +477,8 @@ class DbRepo {
                 }
             }
             found = yield this.$getByPrimary(key, opt, true);
-            if (!opt.noCache && found && cache.props.isConnected) {
-                cache.ingestDoc(found, opt)
+            if (!opt.noCache && found && this.cache.isConnected) {
+                this.cache.ingestDoc(found, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getByPrimary', 'cache', 'ingestDoc')));
             }
@@ -315,23 +488,22 @@ class DbRepo {
     /** @inheritDoc */
     getBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, useNumericId, idSame, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'getBySecondary');
+            const opt = this.buildOpt(p1, 'getBySecondary');
             if (!ignoreCheck) {
-                if (useNumericId) {
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
                 }
                 else {
                     (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'getBySecondary', queryName: opt.name });
                 }
             }
-            if (idSame) {
+            if (this.isIdSame) {
                 return this.getByPrimary(this._keyToUrn(key), opt, true);
             }
             let found;
-            if (!opt.noCache && cache.props.isConnected) {
+            if (!opt.noCache && this.cache.isConnected) {
                 try {
-                    found = yield cache.getBySecondary(key, opt);
+                    found = yield this.cache.getBySecondary(key, opt);
                     if (found) {
                         return found;
                     }
@@ -341,8 +513,8 @@ class DbRepo {
                 }
             }
             found = yield this.$getBySecondary(key, opt, true);
-            if (found && cache.props.isConnected) {
-                cache.ingestDoc(found, opt)
+            if (found && this.cache.isConnected) {
+                this.cache.ingestDoc(found, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'getBySecondary', 'cache', 'ingestDoc')));
             }
@@ -354,11 +526,10 @@ 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 opt = this.buildOpt(p1, 'exists');
             const [key, field] = this._checkKey(k1);
             switch (field) {
-                case "_urn":
+                case "urn":
                     return this.existsByPrimary(key, opt, true);
                 case "id":
                     return this.existsBySecondary(key, opt, true);
@@ -371,14 +542,13 @@ class DbRepo {
     /** @inheritDoc */
     existsByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'existsByPrimary');
+            const opt = this.buildOpt(p1, 'existsByPrimary');
             if (!ignoreCheck) {
                 (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsByPrimary', queryName: opt.name });
             }
-            if (!opt.noCache && cache.props.isConnected) {
+            if (!opt.noCache && this.cache.isConnected) {
                 try {
-                    const found = yield cache.getByPrimary(key, opt);
+                    const found = yield this.cache.getByPrimary(key, opt);
                     if (found) {
                         return true;
                     }
@@ -393,22 +563,21 @@ class DbRepo {
     /** @inheritDoc */
     existsBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, useNumericId, idSame, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'existsBySecondary');
+            const opt = this.buildOpt(p1, 'existsBySecondary');
             if (!ignoreCheck) {
-                if (useNumericId) {
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
                 }
                 else {
                     (0, type_1.assertText)(key, { field: 'key', where: 'DbRepo', method: 'existsBySecondary', queryName: opt.name });
                 }
             }
-            if (!idSame) {
+            if (!this.isIdSame) {
                 return this.existsByPrimary(this._keyToUrn(key));
             }
-            if (!opt.noCache && cache.props.isConnected) {
+            if (!opt.noCache && this.cache.isConnected) {
                 try {
-                    const found = yield cache.getBySecondary(key, opt);
+                    const found = yield this.cache.getBySecondary(key, opt);
                     if (found) {
                         return true;
                     }
@@ -425,8 +594,7 @@ class DbRepo {
     /** @inheritDoc */
     list(keys, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { conn, cache } = this._props;
-            const opt = conn.buildOpt(p1, 'list');
+            const opt = this.buildOpt(p1, 'list');
             if (!ignoreCheck) {
                 (0, type_1.assertArray)(keys, { field: 'keys', where: 'DbRepo', method: 'list', queryName: opt.name });
             }
@@ -437,15 +605,15 @@ class DbRepo {
             const docs = [];
             let founds = [];
             if (result.urns.length > 0) {
-                if (!opt.noCache && cache.props.isConnected) {
+                if (!opt.noCache && this.cache.isConnected) {
                     try {
-                        founds = yield cache.getByPrimaryMore(result.urns, opt);
+                        founds = yield this.cache.getByPrimaryMore(result.urns, opt);
                     }
                     catch (e) {
                         this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'getByPrimary'));
                     }
                     founds.forEach(val => {
-                        const index = result.urns.indexOf(val._urn);
+                        const index = result.urns.indexOf(val.urn);
                         if (index >= 0) {
                             result.urns.splice(index, 1);
                         }
@@ -455,8 +623,8 @@ class DbRepo {
                 if (result.urns.length > 0) {
                     founds = yield this.$listByPrimary(result.urns, opt, true);
                     if (founds.length > 0) {
-                        if (!opt.noCache && cache.props.isConnected) {
-                            founds.forEach(found => cache.ingestDoc(found, opt)
+                        if (!opt.noCache && this.cache.isConnected) {
+                            founds.forEach(found => this.cache.ingestDoc(found, opt)
                                 .then()
                                 .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'ingestDoc'))));
                         }
@@ -465,9 +633,9 @@ class DbRepo {
                 }
             }
             if (result.ids.length > 0) {
-                if (!opt.noCache && cache.props.isConnected) {
+                if (!opt.noCache && this.cache.isConnected) {
                     try {
-                        founds = yield cache.getBySecondaryMore(result.ids, opt);
+                        founds = yield this.cache.getBySecondaryMore(result.ids, opt);
                     }
                     catch (e) {
                         this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'getBySecondary'));
@@ -483,8 +651,8 @@ class DbRepo {
                 if (result.ids.length > 0) {
                     founds = yield this.$listBySecondary(result.ids, opt, true);
                     if (founds.length > 0) {
-                        if (!opt.noCache && cache.props.isConnected) {
-                            founds.forEach(found => cache.ingestDoc(found, opt)
+                        if (!opt.noCache && this.cache.isConnected) {
+                            founds.forEach(found => this.cache.ingestDoc(found, opt)
                                 .then()
                                 .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'list', 'cache', 'ingestDoc'))));
                         }
@@ -500,8 +668,7 @@ class DbRepo {
     /** @inheritDoc */
     filter(query, p1) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { conn } = this._props;
-            const opt = conn.buildOpt(p1, 'filter');
+            const opt = this.buildOpt(p1, 'filter');
             return this.$filter(query_1.queryParser.exec(query, [], opt.name), opt);
         });
     }
@@ -510,36 +677,42 @@ class DbRepo {
     /** @inheritDoc */
     insert(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { useCreatedAt, conn, noInsert, useNumericId, useCreatedBy, useUpdatedAt, useUpdatedBy } = this._props;
-            const opt = conn.buildOpt(p1, 'insert');
+            const opt = this.buildOpt(p1, 'insert');
             const param = { where: 'DbRepo', method: 'insert', queryName: opt.name };
-            if (noInsert) {
+            if (this.isNoInsert) {
                 throw new error_1.DbNotSupportedError('Insert', param);
             }
             if (!ignoreCheck) {
                 (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-                if (useNumericId) {
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
                 else {
                     (0, type_1.assertText)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
-                (0, type_1.assertText)(doc._urn, Object.assign({ field: 'doc._urn' }, param));
+                (0, type_1.assertText)(doc.urn, Object.assign({ field: 'doc.urn' }, param));
             }
             if (!doc._trashId !== undefined) {
                 delete doc._trashId;
             }
-            if (useCreatedAt) {
+            if (this.hasCreatedAt) {
                 doc.createdAt = this._now;
             }
-            if (useCreatedBy) {
-                // todo
+            let userId;
+            if (this.hasCreatedBy && this.userFetcher) {
+                doc.createdBy = (yield this.userFetcher());
+                userId = doc.createdBy;
             }
-            if (useUpdatedAt) {
+            if (this.hasUpdatedAt) {
                 doc.updatedAt = this._now;
             }
-            if (useUpdatedBy) {
-                // todo
+            if (this.hasUpdatedBy && this.userFetcher) {
+                if (userId) {
+                    doc.createdBy = userId;
+                }
+                else {
+                    doc.createdBy = (yield this.userFetcher());
+                }
             }
             return this.$insert(doc, opt);
         });
@@ -547,10 +720,9 @@ class DbRepo {
     /** @inheritDoc */
     inserts(docs, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noInsert, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'inserts');
+            const opt = this.buildOpt(p1, 'inserts');
             const param = { where: 'DbRepo', method: 'inserts', queryName: opt.name };
-            if (noInsert) {
+            if (this.isNoInsert) {
                 throw new error_1.DbNotSupportedError('Insert', param);
             }
             if (!ignoreCheck) {
@@ -568,12 +740,11 @@ class DbRepo {
     /** @inheritDoc */
     replace(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, conn, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
-            const opt = conn.buildOpt(p1, 'replace');
+            const opt = this.buildOpt(p1, 'replace');
             if (!ignoreCheck) {
                 (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                (0, type_1.assertText)(doc._urn, { field: 'doc._urn', where: 'DbRepo', method: 'replace', queryName: opt.name });
-                if (useNumericId) {
+                (0, type_1.assertText)(doc.urn, { field: 'doc.urn', where: 'DbRepo', method: 'replace', queryName: opt.name });
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(doc.id, { field: 'doc.id', where: 'DbRepo', method: 'replace', queryName: opt.name });
                 }
                 else {
@@ -583,15 +754,15 @@ class DbRepo {
             if (doc._trashId !== undefined) {
                 delete doc._trashId;
             }
-            if (useUpdatedAt) {
+            if (this.hasUpdatedAt) {
                 doc.updatedAt = this._now;
             }
-            if (useUpdatedBy) {
-                // todo
+            if (this.hasUpdatedBy && this.userFetcher) {
+                doc.createdBy = (yield this.userFetcher());
             }
             const replacedKey = yield this.$replace(doc, opt, true);
-            if (!opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(replacedKey, opt)
+            if (!opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(replacedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'replace', 'cache', 'clearDoc')));
             }
@@ -603,16 +774,15 @@ class DbRepo {
     /** @inheritDoc */
     upsert(doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noInsert, conn, noUpdate, cache, useNumericId, useUpdatedAt, useUpdatedBy } = this._props;
-            const opt = conn.buildOpt(p1, 'upsert');
+            const opt = this.buildOpt(p1, 'upsert');
             const param = { where: 'DbRepo', method: 'upsert', queryName: opt.name };
-            if (noInsert || noUpdate) {
+            if (this.isNoInsert || this.isNoUpdate) {
                 throw new error_1.DbNotSupportedError('Upsert', param);
             }
             if (!ignoreCheck) {
                 (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
-                (0, type_1.assertText)(doc._urn, Object.assign({ field: 'doc._urn' }, param));
-                if (useNumericId) {
+                (0, type_1.assertText)(doc.urn, Object.assign({ field: 'doc.urn' }, param));
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(doc.id, Object.assign({ field: 'doc.id' }, param));
                 }
                 else {
@@ -622,15 +792,15 @@ class DbRepo {
             if (doc._trashId !== undefined) {
                 delete doc._trashId;
             }
-            if (useUpdatedAt) {
+            if (this.hasUpdatedAt) {
                 doc.updatedAt = this._now;
             }
-            if (useUpdatedBy) {
-                // todo
+            if (this.hasUpdatedBy && this.userFetcher) {
+                doc.createdBy = (yield this.userFetcher());
             }
             const createdKey = yield this.$replace(doc, opt, true);
-            if (!opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(createdKey, opt)
+            if (!opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(createdKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'upsert', 'cache', 'clearDoc')));
             }
@@ -642,14 +812,13 @@ 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');
+            const opt = this.buildOpt(p1, 'update');
             if (!ignoreCheck) {
                 (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'update', queryName: opt.name });
             }
             const [key, field] = this._checkKey(k1);
             switch (field) {
-                case "_urn":
+                case "urn":
                     return this.updateByPrimary(key, doc, opt, true);
                 case "id":
                     return this.updateBySecondary(key, doc, opt, true);
@@ -661,10 +830,9 @@ class DbRepo {
     /** @inheritDoc */
     updateByPrimary(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noUpdate, conn, forbiddenSet, cache, useUpdatedAt, useUpdatedBy } = this._props;
-            const opt = conn.buildOpt(p1, 'updateByPrimary');
+            const opt = this.buildOpt(p1, 'updateByPrimary');
             const param = { where: 'DbRepo', method: 'updateByPrimary', queryName: opt.name };
-            if (noUpdate) {
+            if (this.isNoUpdate) {
                 throw new error_1.DbNotSupportedError('Update', param);
             }
             if (!ignoreCheck) {
@@ -674,20 +842,20 @@ class DbRepo {
             if (doc._trashId !== undefined) {
                 delete doc._trashId;
             }
-            forbiddenSet.forEach(f => {
+            this._props.forbiddenSet.forEach(f => {
                 if (doc[f] !== undefined) {
                     delete doc[f];
                 }
             });
-            if (useUpdatedAt) {
+            if (this.hasUpdatedAt) {
                 doc.updatedAt = this._now;
             }
-            if (useUpdatedBy) {
-                // todo
+            if (this.hasUpdatedBy && this.userFetcher) {
+                doc.createdBy = (yield this.userFetcher());
             }
             const updatedKey = yield this.$updateByPrimary(key, doc, opt, true);
-            if (updatedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(updatedKey, opt)
+            if (updatedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(updatedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'updateByPrimary', 'cache', 'clearDoc')));
             }
@@ -697,14 +865,13 @@ class DbRepo {
     /** @inheritDoc */
     updateBySecondary(key, doc, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { forbiddenSet, noUpdate, cache, useNumericId, idSame, useUpdatedAt, useUpdatedBy, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'updateBySecondary');
+            const opt = this.buildOpt(p1, 'updateBySecondary');
             const param = { where: 'DbRepo', method: 'updateBySecondary', queryName: opt.name };
-            if (noUpdate) {
+            if (this.isNoUpdate) {
                 throw new error_1.DbNotSupportedError('Update', param);
             }
             if (!ignoreCheck) {
-                if (useNumericId) {
+                if (this.hasNumericId) {
                     (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
                 }
                 else {
@@ -712,26 +879,26 @@ class DbRepo {
                 }
                 (0, type_1.assertObject)(doc, Object.assign({ field: 'doc' }, param));
             }
-            if (idSame) {
+            if (this.isIdSame) {
                 return this.updateBySecondary(this._keyToUrn(key), doc, opt, true);
             }
             if (doc._trashId !== undefined) {
                 delete doc._trashId;
             }
-            forbiddenSet.forEach(f => {
+            this._props.forbiddenSet.forEach(f => {
                 if (doc[f] !== undefined) {
                     delete doc[f];
                 }
             });
-            if (useUpdatedAt) {
+            if (this.hasUpdatedAt) {
                 doc.updatedAt = this._now;
             }
-            if (useUpdatedBy) {
-                // todo
+            if (this.hasUpdatedBy && this.userFetcher) {
+                doc.createdBy = (yield this.userFetcher());
             }
             const updatedKey = yield this.$updateBySecondary(key, doc, opt, true);
-            if (updatedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(updatedKey, opt)
+            if (updatedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(updatedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'updateBySecondary', 'cache', 'clearDoc')));
             }
@@ -743,8 +910,7 @@ 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');
+            const opt = this.buildOpt(p1, 'set');
             if (!ignoreCheck) {
                 (0, type_1.assertObject)(doc, { field: 'doc', where: 'DbRepo', method: 'set', queryName: opt.name });
             }
@@ -759,18 +925,16 @@ class DbRepo {
     /** @inheritDoc */
     unset(key, fields, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { conn } = this._props;
-            const opt = conn.buildOpt(p1, 'unset');
+            const opt = this.buildOpt(p1, 'unset');
             if (!ignoreCheck) {
                 (0, type_1.assertArray)(fields, { field: 'fields', where: 'DbRepo', method: 'unset', queryName: opt.name });
                 fields.forEach((field, index) => {
                     (0, type_1.assertText)(field, { field: field, where: 'DbRepo', method: 'unset', index, queryName: opt.name });
                 });
             }
-            const { forbiddenUnset } = this._props;
             const doc = {};
             fields.forEach(f => {
-                if (!forbiddenUnset.includes(f)) {
+                if (!this._props.forbiddenSet.includes(f)) {
                     doc[f] = undefined;
                 }
             });
@@ -782,11 +946,10 @@ 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 opt = this.buildOpt(p1, 'remove');
             const [key, field] = this._checkKey(k1);
             switch (field) {
-                case "_urn":
+                case "urn":
                     return this.removeByPrimary(key, opt, true);
                 case "id":
                     return this.removeBySecondary(key, opt, true);
@@ -798,18 +961,17 @@ class DbRepo {
     /** @inheritDoc */
     removeByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, noRemove, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'removeByPrimary');
+            const opt = this.buildOpt(p1, 'removeByPrimary');
             const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
-            if (noRemove) {
+            if (this.isNoRemove) {
                 throw new error_1.DbNotSupportedError('Remove', param);
             }
             if (!ignoreCheck) {
                 (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
             }
             const removedKey = yield this.$removeByPrimary(key, opt, true);
-            if (removedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(removedKey, opt)
+            if (removedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(removedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'removeByPrimary', 'cache', 'clearDoc')));
             }
@@ -819,24 +981,23 @@ class DbRepo {
     /** @inheritDoc */
     removeBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { cache, noRemove, useNumericId, idSame, conn } = this._props;
-            const opt = conn.buildOpt(p1, 'removeBySecondary');
+            const opt = this.buildOpt(p1, 'removeBySecondary');
             const param = { where: 'DbRepo', method: 'removeByPrimary', queryName: opt.name };
-            if (noRemove) {
+            if (this.isNoRemove) {
                 throw new error_1.DbNotSupportedError('Remove', param);
             }
-            if (useNumericId) {
+            if (this.hasNumericId) {
                 (0, type_1.assertInteger)(key, { field: 'key', param });
             }
             else {
                 (0, type_1.assertText)(key, { field: 'key', param });
             }
-            if (idSame) {
+            if (this.isIdSame) {
                 return this.removeByPrimary(this._keyToUrn(key), opt, ignoreCheck);
             }
             const removedKey = yield this.$removeBySecondary(key, opt, true);
-            if (removedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(removedKey, opt)
+            if (removedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(removedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'removeBySecondary', 'cache', 'clearDoc')));
             }
@@ -848,11 +1009,10 @@ 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 opt = this.buildOpt(p1, 'trash');
             const [key, field] = this._checkKey(k1);
             switch (field) {
-                case "_urn":
+                case "urn":
                     return this.trashByPrimary(key, opt, true);
                 case "id":
                     return this.trashBySecondary(key, opt, true);
@@ -864,13 +1024,12 @@ class DbRepo {
     /** @inheritDoc */
     trashByPrimary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noTrash, useSoftDelete, conn, cache } = this._props;
-            const opt = conn.buildOpt(p1, 'trashByPrimary');
+            const opt = this.buildOpt(p1, 'trashByPrimary');
             const param = { where: 'DbRepo', method: 'trashByPrimary', queryName: opt.name };
-            if (!useSoftDelete) {
+            if (!this.hasSoftDelete) {
                 throw new error_1.DbNotSupportedError('Soft Delete', param);
             }
-            if (noTrash) {
+            if (this.isNoTrash) {
                 throw new error_1.DbNotSupportedError('Trash', param);
             }
             if (!ignoreCheck) {
@@ -880,8 +1039,8 @@ class DbRepo {
                 opt.trashId = (0, node_crypto_1.randomUUID)();
             }
             const trashedKey = yield this.$trashByPrimary(key, opt, true);
-            if (trashedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(trashedKey, opt)
+            if (trashedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(trashedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'trashByPrimary', 'cache', 'clearDoc')));
             }
@@ -891,30 +1050,29 @@ class DbRepo {
     /** @inheritDoc */
     trashBySecondary(key, p1, ignoreCheck) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { noTrash, useSoftDelete, useNumericId, idSame, conn, cache } = this._props;
-            const opt = conn.buildOpt(p1, 'trashBySecondary');
+            const opt = this.buildOpt(p1, 'trashBySecondary');
             const param = { where: 'DbRepo', method: 'trashBySecondary', queryName: opt.name };
-            if (!useSoftDelete) {
+            if (!this.hasSoftDelete) {
                 throw new error_1.DbNotSupportedError('Soft Delete', param);
             }
-            if (noTrash) {
+            if (this.isNoTrash) {
                 throw new error_1.DbNotSupportedError('Trash', param);
             }
-            if (useNumericId) {
+            if (this.hasNumericId) {
                 (0, type_1.assertInteger)(key, Object.assign({ field: 'key' }, param));
             }
             else {
                 (0, type_1.assertText)(key, Object.assign({ field: 'key' }, param));
             }
-            if (idSame) {
+            if (this.isIdSame) {
                 return this.trashByPrimary(this._keyToUrn(key), opt, ignoreCheck);
             }
             if (!(0, type_1.isText)(opt.trashId)) {
                 opt.trashId = (0, node_crypto_1.randomUUID)();
             }
             const trashedKey = yield this.$trashBySecondary(key, opt, true);
-            if (trashedKey && !opt.noCache && cache.props.isConnected) {
-                cache.clearDoc(trashedKey, opt)
+            if (trashedKey && !opt.noCache && this.cache.isConnected) {
+                this.cache.clearDoc(trashedKey, opt)
                     .then()
                     .catch(e => this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'trashBySecondary', 'cache', 'clearDoc')));
             }