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

package/dist/connection/db.connection.d.ts

@@ -1,4 +1,4 @@
-import { DbConnectionLike, DbExecOpt, DbQueryResultMore, DbQueryResultOne, DbConnOpt, DbMeta, DbOnAfter, DbConnProps, DbRepoLink } from "./index.types";
+import { DbConnectionLike, DbExecOpt, DbQueryResultMore, DbQueryResultOne, DbConnOpt, DbMeta, DbOnAfter, DbConnProps, DbRepoLink, DbEvent } from "./index.types";
 import { LoggerLike } from "@samet-it/be-base-common";
 import type { DbLines } from "../line";
 import type { Opt } from "@leyyo/common";
@@ -31,12 +31,34 @@ export declare abstract class DbConnection<LINK extends DbRepoLink, META extends
      * @see _opt
      * */
     protected _props: DbConnProps;
+    /**
+     * Constructor
+     *
+     * @param {DbConnOpt} opt - options
+     * */
     protected constructor(opt?: DbConnOpt);
-    checkError(err: Error, opt: DbExecOpt | Opt): void;
-    protected _on(items: Array<DbOnAfter>, fn: DbOnAfter, throwable: boolean): void;
+    /**
+     * Add or instantly trigger new lambda
+     *
+     * @param {DbEvent} name - event name
+     * @param {Array<function>} items - existing callback function array
+     * @param {function} fn - callback function
+     * @param {boolean?} throwable - throw an error if it fails
+     * */
+    protected _on(name: DbEvent, items: Array<DbOnAfter>, fn: DbOnAfter, throwable: boolean): void;
+    /**
+     * Trigger after on case
+     *
+     * @param {DbEvent} name - event name
+     * @param {Array<DbOnAfter>} items - callback functions
+     * @param {boolean} throwable - throwable? yes: throw the error
+     * */
+    protected _triggerOnCase(name: DbEvent, items: Array<DbOnAfter>, throwable: boolean): void;
     /** {@inheritDoc} */
     get props(): Readonly<DbConnProps>;
     /** {@inheritDoc} */
+    checkError(err: Error, opt: DbExecOpt | Opt): void;
+    /** {@inheritDoc} */
     f(field: string): string;
     /** {@inheritDoc} */
     abstract field(field: string): string;

package/dist/connection/db.connection.js

@@ -19,6 +19,11 @@ const error_1 = require("../error");
  * */
 class DbConnection {
     // endregion protected-property
+    /**
+     * Constructor
+     *
+     * @param {DbConnOpt} opt - options
+     * */
     constructor(opt) {
         /**
          * On connected callbacks
@@ -46,29 +51,15 @@ class DbConnection {
         delete this._opt;
     }
     // region protected-method
-    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)) {
-            return;
-        }
-        if (opt === null || opt === void 0 ? void 0 : opt.silent) {
-            if (size < 100) {
-                this.logger.warn(`[${size}] ${(_b = opt.name) !== null && _b !== void 0 ? _b : 'Database error'} <${err.name}> ${err.message}`, err);
-            }
-            return;
-        }
-        if (size < 100) {
-            this.logger.error(`[${size}] ${(_c = opt.name) !== null && _c !== void 0 ? _c : 'Database error'} <${err.name}> ${err.message}`, err);
-        }
-        if (err instanceof error_1.DbError) {
-            throw err;
-        }
-        else {
-            throw be_base_common_1.errorHandler.common.castForClass(error_1.DbError, err, { queryName: opt.name });
-        }
-    }
-    _on(items, fn, throwable) {
+    /**
+     * Add or instantly trigger new lambda
+     *
+     * @param {DbEvent} name - event name
+     * @param {Array<function>} items - existing callback function array
+     * @param {function} fn - callback function
+     * @param {boolean?} throwable - throw an error if it fails
+     * */
+    _on(name, items, fn, throwable) {
         if (typeof fn !== 'function') {
             return;
         }
@@ -77,13 +68,32 @@ class DbConnection {
         }
         else {
             fn().then().catch(e => {
-                this.logger.error(`[${e.name}] => ${e.message}`, e);
+                this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'on', name));
                 if (throwable) {
                     throw e;
                 }
             });
         }
     }
+    /**
+     * Trigger after on case
+     *
+     * @param {DbEvent} name - event name
+     * @param {Array<DbOnAfter>} items - callback functions
+     * @param {boolean} throwable - throwable? yes: throw the error
+     * */
+    _triggerOnCase(name, items, throwable) {
+        if (items.length > 0) {
+            items.forEach(fn => {
+                fn().then().catch(e => {
+                    this.logger.warn(be_base_common_1.errorHandler.common.logText(e, 'trigger', 'on', name));
+                    if (throwable) {
+                        throw e;
+                    }
+                });
+            });
+        }
+    }
     // endregion protected-method
     // region getter
     /** {@inheritDoc} */
@@ -93,6 +103,29 @@ class DbConnection {
     // endregion getter
     // region field-value
     /** {@inheritDoc} */
+    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)) {
+            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);
     }
@@ -135,15 +168,15 @@ class DbConnection {
     // region callback
     /** {@inheritDoc} */
     onConnected(fn) {
-        this._on(this._onConnected, fn, false);
+        this._on('connected', this._onConnected, fn, false);
     }
     /** {@inheritDoc} */
     onDisconnected(fn) {
-        this._on(this._onDisconnected, fn, false);
+        this._on('disconnected', this._onDisconnected, fn, false);
     }
     /** {@inheritDoc} */
     onFirstConnected(fn) {
-        this._on(this._onFirstConnected, fn, true);
+        this._on('first-connected', this._onFirstConnected, fn, true);
     }
     // endregion callback
     // region query

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

@@ -1,5 +1,14 @@
 import type { Opt } from "@leyyo/common";
 import { DbError } from "./db.error";
+/**
+ * DB execute error during run sql
+ * */
 export declare class DbExecuteError extends DbError {
-    constructor(err: Error, name: string, sql: string, opt?: Opt);
+    /**
+     * @param {Error} err - error instance
+     * @param {string} name - query name
+     * @param {string} sql - sql script
+     * @param {Opt} params - parameters
+     * */
+    constructor(err: Error, name: string, sql: string, params?: Opt);
 }

package/dist/error/db-execute.error.js

@@ -2,9 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbExecuteError = void 0;
 const db_error_1 = require("./db.error");
+// noinspection JSUnusedGlobalSymbols
+/**
+ * DB execute error during run sql
+ * */
 class DbExecuteError extends db_error_1.DbError {
-    constructor(err, name, sql, opt) {
-        super(`${name ? name + ' : ' : ''}<${err.name}> ${err.message}`, Object.assign(Object.assign({}, opt), { sql, sqlName: name }));
+    /**
+     * @param {Error} err - error instance
+     * @param {string} name - query name
+     * @param {string} sql - sql script
+     * @param {Opt} params - parameters
+     * */
+    constructor(err, name, sql, params) {
+        super(`${name ? name + ' : ' : ''}<${err.name}> ${err.message}`, Object.assign(Object.assign({}, params), { sql, queryName: name }));
     }
 }
 exports.DbExecuteError = DbExecuteError;

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

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

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

@@ -2,9 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbInvalidValueError = void 0;
 const db_error_1 = require("./db.error");
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Cache validation error
+ * */
 class DbInvalidValueError extends db_error_1.DbError {
-    constructor(field, type, where, method) {
-        super(`${field} value is not valid at ${where}#${method}`, { field, type, where, method });
+    /**
+     * @param {string} field - invalid field
+     * @param {string} expected - expected type
+     * @param {string} where - class name
+     * @param {string} method - method name
+     * */
+    constructor(field, expected, where, method) {
+        super(`${field} value is not valid at ${where}#${method}`, { field, expected, where, method });
     }
 }
 exports.DbInvalidValueError = DbInvalidValueError;

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

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

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

@@ -2,7 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbNotSupportedError = void 0;
 const db_error_1 = require("./db.error");
+/**
+ * DB not-supported error
+ * */
 class DbNotSupportedError extends db_error_1.DbError {
+    /**
+     * @param {string} feature - feature name
+     * @param {string} where - class name
+     * @param {string} method - method name
+     * */
     constructor(feature, where, method) {
         super(`${feature} is not supported at ${where}#${method}`, { feature, where, method });
     }

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

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

package/dist/error/db.error.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbError = void 0;
 const be_base_common_1 = require("@samet-it/be-base-common");
 /**
- * Generic database error
+ * General database error
  * */
 class DbError extends be_base_common_1.SametError {
 }

package/dist/repo/db.repo.d.ts

@@ -1,12 +1,24 @@
 import type { DbCheckKeysResult, DbRepoProps, DbRepoLike, DbRepoOpt, DbCheckKeysTuple } from "./index.types";
-import type { DefDims, Entity, IdDocLike, LoggerLike, Pair, Portion, UrnDocLike, UrnTuple, View } from "@samet-it/be-base-common";
+import { DefDims, Entity, IdDocLike, LoggerLike, Pair, Portion, UrnDocLike, UrnTuple, View } from "@samet-it/be-base-common";
 import type { DbConnectionBase, DbExecOpt } from "../connection";
 import type { KeyValue, StrKey } from "@leyyo/common";
 import { type QueryAny, type QueryRegular } from "@leyyo/query";
 /**
  * DB repository abstract class
+ *
+ * Generics:
+ * - 0-`CONN`: db connection {@link DbConnectionBase}
+ * - 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}
  * */
-export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends DbExecOpt, ID extends KeyValue, ENTITY extends Entity<ID>, URN extends UrnDocLike, KEYS extends string, DIMS extends DefDims, PAIR extends Pair<ID>, VIEW extends View<ID>, PORTION extends Portion<ID>> implements DbRepoLike<CONN, OPT, ID, ENTITY, URN, KEYS, DIMS, PAIR, VIEW, PORTION> {
+export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends DbExecOpt, ENT extends Entity<ID>, ID extends KeyValue, URN extends UrnDocLike, VIEW extends View<ID>, PAIR extends Pair<ID>, PORTION extends Portion<ID>, KEYS extends string, DIMS extends DefDims> implements DbRepoLike<CONN, OPT, ENT, ID, URN, VIEW, PAIR, PORTION, KEYS, DIMS> {
     /**
      * Logger
      * */
@@ -14,47 +26,53 @@ export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends
     /**
      * Option of in-body usage in place of constructor param
      * */
-    protected _opt: DbRepoOpt<ID, ENTITY>;
+    protected _opt: DbRepoOpt<ENT, ID>;
     /**
      * Produced setting from option
      * @see _opt
      * */
-    protected _props: DbRepoProps<CONN, ID, ENTITY>;
-    protected constructor(conn: CONN, opt?: DbRepoOpt<ID, ENTITY>);
-    protected _removeFieldForForbidden(fields: Array<keyof ENTITY>, flag: keyof DbRepoOpt<ID, ENTITY>, field: keyof ENTITY): void;
-    protected _checkForbiddenList(given: Array<keyof ENTITY>, def: Array<keyof ENTITY>): Array<keyof ENTITY>;
+    protected _props: DbRepoProps<CONN, ENT, ID>;
+    /**
+     * Constructor
+     *
+     * @param {DbConnectionBase} conn - db connection
+     * @param {DbRepoOpt} opt - options
+     * */
+    protected constructor(conn: CONN, opt?: DbRepoOpt<ENT, ID>);
+    protected _removeFieldForForbidden(fields: Array<keyof ENT>, flag: keyof DbRepoOpt<ENT, ID>, field: keyof ENT): void;
+    protected _checkForbiddenList(given: Array<keyof ENT>, def: Array<keyof ENT>): Array<keyof ENT>;
     protected get _now(): string | number;
     protected get _randomIndexName(): string;
     protected _indexName(name: string): string;
     /**
      * Fetch urn from doc as doc._urn
      * */
-    protected _urnFromDoc(doc: Partial<ENTITY>, method: string): string;
+    protected _urnFromDoc(doc: Partial<ENT>, method: string): string;
     protected _checkKey(value: unknown): DbCheckKeysTuple<ID>;
     /**
      * Check array keys as id list or urn list
      * */
     protected _checkKeys(keys: Array<KeyValue>): DbCheckKeysResult<ID>;
     protected _isUrn(key: KeyValue): boolean;
+    protected _keyToUrn(key: KeyValue): string;
     /** @inheritDoc */
-    get props(): Readonly<DbRepoProps<CONN, ID, ENTITY>>;
+    get props(): Readonly<DbRepoProps<CONN, ENT, ID>>;
     /** @inheritDoc */
     $cast<T>(): T;
-    protected _keyToUrn(key: KeyValue): string;
     /** @inheritDoc */
     toUrn(urnRec: URN): string;
     /** @inheritDoc */
     $toUrnTuple(urnRec: URN): UrnTuple;
     /** @inheritDoc */
-    get(k1: KeyValue, p1?: OPT | string): Promise<ENTITY | undefined>;
+    get(k1: KeyValue, p1?: OPT | string): Promise<ENT | undefined>;
     /** @inheritDoc */
-    getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENT | undefined>;
     /** @inheritDoc */
-    abstract $getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    abstract $getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENT | undefined>;
     /** @inheritDoc */
-    getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENT | undefined>;
     /** @inheritDoc */
-    abstract $getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    abstract $getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENT | undefined>;
     /** @inheritDoc */
     exists(k1: KeyValue, p1?: OPT | string): Promise<boolean>;
     /** @inheritDoc */
@@ -66,39 +84,43 @@ export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends
     /** @inheritDoc */
     abstract $existsBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<boolean>;
     /** @inheritDoc */
-    list(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    list(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENT>>;
+    /** @inheritDoc */
+    abstract $listByPrimary(keys: string[], p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENT>>;
+    /** @inheritDoc */
+    abstract $listBySecondary(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENT>>;
     /** @inheritDoc */
-    abstract $listByPrimary(keys: string[], p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    filter<R = ENT, K2 extends string = StrKey<R>>(query: QueryAny<K2 | KEYS | StrKey<ENT>>, p1?: OPT | string): Promise<Array<R>>;
     /** @inheritDoc */
-    abstract $listBySecondary(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    abstract $filter<R = ENT, K2 extends string = StrKey<R>>(query: QueryRegular<K2 | KEYS | StrKey<ENT>>, p1?: OPT | string): Promise<Array<R>>;
     /** @inheritDoc */
-    filter<R = ENTITY, K2 extends string = StrKey<R>>(query: QueryAny<K2 | KEYS | StrKey<ENTITY>>, p1?: OPT | string): Promise<Array<R>>;
+    insert(doc: ENT, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    abstract $filter<R = ENTITY, K2 extends string = StrKey<R>>(query: QueryRegular<K2 | KEYS | StrKey<ENTITY>>, p1?: OPT | string): Promise<Array<R>>;
+    inserts(docs: Array<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<string>>;
     /** @inheritDoc */
-    insert(doc: ENTITY, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    abstract $insert(doc: ENT, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    inserts(docs: Array<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<string>>;
+    replace(doc: ENT, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    abstract $insert(doc: ENTITY, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    abstract $replace(doc: ENT, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    replace(doc: ENTITY, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    upsert(doc: ENT, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    abstract $replace(doc: ENTITY, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    abstract $upsert(doc: ENT, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    update(k1: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    update(k1: KeyValue, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    updateByPrimary(key: string, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    updateByPrimary(key: string, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    abstract $updateByPrimary(key: string, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    abstract $updateByPrimary(key: string, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    updateBySecondary(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    updateBySecondary(key: KeyValue, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    abstract $updateBySecondary(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    abstract $updateBySecondary(key: KeyValue, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    set(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    set(key: KeyValue, doc: Partial<ENT>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    unset(key: KeyValue, fields: Array<keyof ENTITY | string>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    unset(key: KeyValue, fields: Array<keyof ENT | KEYS | string>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
     remove(k1: KeyValue, p1?: OPT | string): Promise<string>;
     /** @inheritDoc */
@@ -120,24 +142,24 @@ export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends
     /** @inheritDoc */
     abstract $trashBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
     /** @inheritDoc */
-    $toDim<R extends IdDocLike<ID>>(doc: ENTITY, dim?: DIMS): Promise<R>;
+    $toDim<R extends IdDocLike<ID>>(doc: ENT, dim?: DIMS): Promise<R>;
     /** @inheritDoc */
     getDim<R extends IdDocLike<ID>>(key: KeyValue, dim?: DIMS): Promise<R>;
     /** @inheritDoc */
     listDims<R extends IdDocLike<ID>>(keys: Array<KeyValue>, dim?: DIMS, ignoreCheck?: boolean): Promise<Array<R>>;
     /** @inheritDoc */
-    $toPair(doc: ENTITY): Promise<PAIR>;
+    $toPair(doc: ENT): Promise<PAIR>;
     /** @inheritDoc */
     getPair(key: KeyValue): Promise<PAIR>;
     /** @inheritDoc */
     listPairs(keys: Array<KeyValue>, ignoreCheck?: boolean): Promise<Array<PAIR>>;
-    $toView(doc: ENTITY): Promise<VIEW>;
+    $toView(doc: ENT): Promise<VIEW>;
     /** @inheritDoc */
     getView(identifier: string): Promise<VIEW>;
     /** @inheritDoc */
     listViews(identifiers: Array<string>, ignoreCheck?: boolean): Promise<Array<VIEW>>;
     /** @inheritDoc */
-    $toPortion(doc: ENTITY): Promise<PORTION>;
+    $toPortion(doc: ENT): Promise<PORTION>;
     /** @inheritDoc */
     getPortion(identifier: string): Promise<PORTION>;
     /** @inheritDoc */