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

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

@@ -1,15 +1,16 @@
-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";
+import type { DbConnectionLike, DbConnOpt, DbOnAfter, DbConnProps, DbEvent } from "./index.types";
+import type { Logger } from "@leyyo/common";
 /**
  * DB connection abstract class
+ *
+ * Generics:
+ * - 0-`OPT`: db execution options {@link DbExecOpt}
  * */
-export declare abstract class DbConnection<LINK extends DbRepoLink, META extends DbMeta, OPT extends DbExecOpt> implements DbConnectionLike<LINK, META, OPT> {
+export declare abstract class DbConnection implements DbConnectionLike {
     /**
      * Logger
      * */
-    protected logger: LoggerLike;
+    protected logger: Logger;
     /**
      * On connected callbacks
      * */
@@ -54,36 +55,27 @@ export declare abstract class DbConnection<LINK extends DbRepoLink, META extends
      * @param {boolean} throwable - throwable? yes: throw the error
      * */
     protected _triggerOnCase(name: DbEvent, items: Array<DbOnAfter>, throwable: boolean): void;
+    /**
+     * Generate next delay time with exponential & randomized manner
+     *
+     * @param {number} count - try count
+     * @param {number} baseDelay - starting delay interval
+     * @param {number} maxDelay - maximum delay interval
+     * @return {number}
+     * */
+    protected _delayWithJitter(count: number, baseDelay: number, maxDelay: number): number;
     /** {@inheritDoc} */
     get props(): Readonly<DbConnProps>;
     /** {@inheritDoc} */
-    checkError(err: Error, opt: DbExecOpt | Opt): void;
-    /** {@inheritDoc} */
-    f(field: string): string;
-    /** {@inheritDoc} */
-    abstract field(field: string): string;
-    v(value: unknown): string;
-    abstract value(value: unknown): string;
-    /** {@inheritDoc} */
-    rows<T>(rows: Array<T>): Array<T>;
+    get isEnabled(): boolean;
     /** {@inheritDoc} */
-    row<T>(row: T): T | undefined;
-    /** {@inheritDoc} */
-    first<T>(rows: Array<T>): T | undefined;
-    /** {@inheritDoc} */
-    buildOpt(p1?: Partial<OPT> | string, name?: string): OPT;
+    get isConnected(): boolean;
     /** {@inheritDoc} */
     onConnected(fn: DbOnAfter): void;
     /** {@inheritDoc} */
     onDisconnected(fn: DbOnAfter): void;
     /** {@inheritDoc} */
     onFirstConnected(fn: DbOnAfter): void;
-    /** {@inheritDoc} */
-    exec<T>(fn: Promise<T>, p1?: string | Omit<OPT, 'printSql'>): Promise<T>;
-    /** {@inheritDoc} */
-    abstract more<T>(link: LINK, sql: string | DbLines, name?: string | DbExecOpt): Promise<DbQueryResultMore<T, META>>;
-    /** {@inheritDoc} */
-    abstract one<T>(link: LINK, sql: string | DbLines, name?: string | DbExecOpt): Promise<DbQueryResultOne<T, META>>;
     /**
      * It will be called during module based systems
      * */

package/dist/connection/db.connection.js

@@ -12,10 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbConnection = void 0;
 const be_base_common_1 = require("@samet-it/be-base-common");
 const type_1 = require("@leyyo/type");
-const error_1 = require("../error");
 // noinspection JSUnusedGlobalSymbols
 /**
  * DB connection abstract class
+ *
+ * Generics:
+ * - 0-`OPT`: db execution options {@link DbExecOpt}
  * */
 class DbConnection {
     // endregion protected-property
@@ -47,7 +49,7 @@ class DbConnection {
         if ((0, type_1.isObjectBare)(opt)) {
             this._opt = Object.assign(Object.assign({}, this._opt), opt);
         }
-        this._props = Object.assign({}, this._opt);
+        this._props = Object.assign(Object.assign({}, this._opt), { connectTryCount: 0, pingTryCount: 0 });
         delete this._opt;
     }
     // region protected-method
@@ -94,77 +96,33 @@ class DbConnection {
             });
         }
     }
+    /**
+     * Generate next delay time with exponential & randomized manner
+     *
+     * @param {number} count - try count
+     * @param {number} baseDelay - starting delay interval
+     * @param {number} maxDelay - maximum delay interval
+     * @return {number}
+     * */
+    _delayWithJitter(count, baseDelay, maxDelay) {
+        const exp = Math.min(baseDelay * Math.pow(2, count), maxDelay);
+        return exp / 2 + Math.random() * (exp / 2);
+    }
     // endregion protected-method
     // region getter
     /** {@inheritDoc} */
     get props() {
         return this._props;
     }
-    // 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);
-    }
-    v(value) {
-        return this.value(value);
+    get isEnabled() {
+        return this._props.isEnabled;
     }
     /** {@inheritDoc} */
-    rows(rows) {
-        if (rows && Array.isArray(rows) && (rows.length > 0)) {
-            return rows.filter(row => row['_trashId'] === undefined);
-        }
-        return [];
+    get isConnected() {
+        return this._props.isConnected;
     }
-    /** {@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
+    // endregion getter
     // region callback
     /** {@inheritDoc} */
     onConnected(fn) {
@@ -179,26 +137,14 @@ class DbConnection {
         this._on('first-connected', this._onFirstConnected, fn, true);
     }
     // endregion callback
-    // region query
-    /** {@inheritDoc} */
-    exec(fn, p1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opt = this.buildOpt(p1);
-            try {
-                return yield fn;
-            }
-            catch (err) {
-                this.checkError(err, opt);
-                return undefined;
-            }
-        });
-    }
-    // endregion query
     /**
      * It will be called during module based systems
      * */
     onModuleInit() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled) {
+                return;
+            }
             yield this.connect();
         });
     }

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

@@ -1,142 +1,20 @@
-import type { DbLines } from "../line";
-import type { DbErrorOmit } from "../error";
-import type { Opt } from "@leyyo/common";
+import { KeyValue } from "@leyyo/common";
 /**
- * DB query result
- * */
-export interface DbQueryResult<META> {
-    /**
-     * Success or failure
-     */
-    success: boolean;
-    /**
-     * [when success=true] The meta-data which has been returned by the query.
-     */
-    meta?: META;
-    /**
-     * [when success=false] Couchbase error
-     */
-    error?: DbErrorOmit;
-}
-/**
- * DB query result as a row
- * */
-export interface DbQueryResultOne<E = any, META = unknown> extends DbQueryResult<META> {
-    /**
-     * The rows which have been returned by the query.
-     */
-    row: E | undefined;
-}
-/**
- * DB query result as rows
- * */
-export interface DbQueryResultMore<E = any, META = unknown> extends DbQueryResult<META> {
-    /**
-     * The rows which have been returned by the query.
-     */
-    rows: E[];
-}
-/**
- * DB query option
- * */
-export interface DbExecOpt {
-    /**
-     * Name of SQL
-     * */
-    name?: string;
-    /**
-     * do not use cache
-     * */
-    noCache?: boolean;
-    /**
-     * Ignored errors
-     * */
-    ignoredErrors?: Array<string>;
-    /**
-     * Print sql?
-     * */
-    printSql?: boolean;
-    /**
-     * Ignore any error
-     * */
-    silent?: boolean;
-    /**
-     * Trash id for only trash case
-     * */
-    trashId?: string;
-}
-/**
- * DB connection
+ * DB connection interface
  * */
-export interface DbConnectionBase<OPT extends DbExecOpt = DbExecOpt> {
-    /**
-     * Field name
-     *
-     * @param {string} field - raw field name
-     * @return {string} - formatted field name
-     * */
-    field(field: string): string;
+export interface DbConnectionLike {
     /**
-     * Field name
-     * @alias #field
-     *
-     * @param {string} field - raw field name
-     * @return {string} - formatted field name
-     * */
-    f(field: string): string;
-    /**
-     * Format value
-     *
-     * @param {string} value - raw value
-     * @return {string} - formatted value
-     * */
-    value(value: unknown): string;
-    /**
-     * Format value
-     * @alias #value
-     *
-     * @param {string} value - raw value
-     * @return {string} - formatted value
-     * */
-    v(value: unknown): string;
-    /**
-     * Check rows and discard trashed
-     *
-     * @param {Array<any>} rows - rows
-     * @return {Array<any>} - checked rows
-     * */
-    rows<T>(rows: Array<T>): Array<T>;
-    /**
-     * Check row and discard trashed
-     *
-     * @param {any} row - row
-     * @return {any} - checked row
-     * */
-    row<T>(row: T): T | undefined;
-    /**
-     * Return first row of rows
-     *
-     * @param {Array<any>} rows - rows
-     * @return {any} - first row if exists
+     * Props on connection
      * */
-    first<T>(rows: Array<T>): T | undefined;
+    get props(): Readonly<DbConnProps>;
     /**
-     * Build option
-     *
-     * @param {(DbExecOpt|string)?} opt - option or query name
-     * @param {string?} name - query name, if first param is option
-     * @return {DbExecOpt} - formatted option
+     * Shortcut to {@link DbConnOpt#isEnabled}
      * */
-    buildOpt(opt?: Partial<OPT> | string, name?: string): OPT;
-}
-/**
- * DB connection interface
- * */
-export interface DbConnectionLike<LINK extends DbRepoLink, META extends DbMeta, OPT extends DbExecOpt> extends DbConnectionBase {
+    get isEnabled(): boolean;
     /**
-     * Props on connection
+     * Shortcut to {@link DbConnProps#isConnected}
      * */
-    get props(): Readonly<DbConnProps>;
+    get isConnected(): boolean;
     /**
      * Add an async function into queue
      *
@@ -155,42 +33,6 @@ export interface DbConnectionLike<LINK extends DbRepoLink, META extends DbMeta,
      * @param {function} fn - callback
      * */
     onDisconnected(fn: DbOnAfter): void;
-    /**
-     * Check error
-     *
-     * @param {Error} err - error
-     * @param {DbExecOpt} opt - option
-     * */
-    checkError(err: Error, opt: DbExecOpt | Opt): void;
-    /**
-     * Execute a lambda
-     *
-     * @param {function} fn - promise callback
-     * @param {(DbExecOpt|string)?} opt - option or query name
-     * @return {Promise} - generic type
-     * @async
-     * */
-    exec<T>(fn: Promise<T>, opt?: string | Omit<OPT, 'printSql'>): Promise<T>;
-    /**
-     * Execute a sql and return rows
-     *
-     * @param {DbRepoLink} link - repository link
-     * @param {(string|DbLines)} sql - sql or sql lines
-     * @param {(DbExecOpt|string)?} opt - option or query name
-     * @return {Promise<DbQueryResultMore>} - rows
-     * @async
-     * */
-    more<T>(link: LINK, sql: string | DbLines, opt?: string | OPT): Promise<DbQueryResultMore<T, META>>;
-    /**
-     * Execute a sql and return a row
-     *
-     * @param {DbRepoLink} link - repository link
-     * @param {(string|DbLines)} sql - sql or sql lines
-     * @param {(DbExecOpt|string)?} opt - option or query name
-     * @return {Promise<DbQueryResultOne>} - row
-     * @async
-     * */
-    one<T>(link: LINK, sql: string | DbLines, opt?: string | OPT): Promise<DbQueryResultOne<T, META>>;
     /**
      * It will be called during module based systems
      *
@@ -215,15 +57,16 @@ export interface DbConnectionLike<LINK extends DbRepoLink, META extends DbMeta,
      * */
     ping(next?: boolean): Promise<boolean>;
 }
-/**
- * DB meta
- * */
-export interface DbMeta {
-}
 /**
  * DB connection option
  * */
 export interface DbConnOpt {
+    /**
+     * Is enabled?
+     *
+     * @type {boolean}
+     * */
+    isEnabled?: boolean;
     /**
      * Protocol
      *
@@ -267,7 +110,7 @@ export interface DbConnOpt {
      * @default `undefined`
      * @type {function}
      * */
-    userFetcher?: () => Promise<string>;
+    userFetcher?: UserFetcherLambda;
 }
 /**
  * DB connection props
@@ -285,6 +128,20 @@ export interface DbConnProps extends DbConnOpt {
      * @type {boolean}
      * */
     isFirst: boolean;
+    /**
+     * Consecutive attempts for connection
+     * - It is cleared (zero) when it connected
+     *
+     * @type {number}
+     * */
+    connectTryCount: number;
+    /**
+     * Consecutive attempts for ping
+     * - It is cleared (zero) when it pinged
+     *
+     * @type {number}
+     * */
+    pingTryCount: number;
 }
 /**
  * DB on after lambda
@@ -295,7 +152,8 @@ export type DbOnAfter = () => Promise<void>;
  * DB connection events
  * */
 export type DbEvent = 'connected' | 'disconnected' | 'first-connected';
-/** Repository Link */
-export interface DbRepoLink {
-    path: string;
-}
+/**
+ * User fetcher lambda
+ * - It uses ASL
+ * */
+export type UserFetcherLambda = () => Promise<KeyValue>;

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.d.ts

@@ -1,28 +1,31 @@
-import type { DbCheckKeysResult, DbRepoProps, DbRepoLike, DbRepoOpt, DbCheckKeysTuple } from "./index.types";
-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 { DbCheckKeysResult, DbRepoProps, DbRepoLike, DbRepoOpt, UrnDelimiter, DbCheckKeysTuple, DbExecOpt, DbMeta, DbRepoExtensionLambda, DbQueryResultOne, DbQueryResultMore } from "./index.types";
+import { DefDims, Entity, IdDocLike, Pair, Portion, UrnDocLike, UrnTuple, View } from "@samet-it/be-base-common";
+import { DbConnectionLike, UserFetcherLambda } from "../connection";
+import type { KeyValue, Logger, Opt, StrKey } from "@leyyo/common";
 import { type QueryAny, type QueryRegular } from "@leyyo/query";
+import type { CacheConnectionLike, CacheChannelLike, CacheExecOpt } from "@samet-it/be-cache-common";
+import type { DbLines } from "../line";
 /**
  * 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}
  * */
-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> {
+export declare abstract class DbRepo<CONN extends DbConnectionLike, OPT extends DbExecOpt, META extends DbMeta, 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, META, ENT, ID, URN, VIEW, PAIR, PORTION, KEYS, DIMS> {
     /**
      * Logger
      * */
-    protected logger: LoggerLike;
+    protected logger: Logger;
     /**
      * Option of in-body usage in place of constructor param
      * */
@@ -35,17 +38,15 @@ export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends
     /**
      * Constructor
      *
-     * @param {DbConnectionBase} conn - db connection
+     * @param {DbConnectionLike} 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
+     * Fetch urn from doc as doc.urn
      * */
     protected _urnFromDoc(doc: Partial<ENT>, method: string): string;
     protected _checkKey(value: unknown): DbCheckKeysTuple<ID>;
@@ -60,6 +61,86 @@ export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends
     /** @inheritDoc */
     $cast<T>(): T;
     /** @inheritDoc */
+    get isEnabled(): boolean;
+    /** @inheritDoc */
+    get userFetcher(): UserFetcherLambda;
+    /** @inheritDoc */
+    get conn(): CONN;
+    /** @inheritDoc */
+    get isConnected(): boolean;
+    /** @inheritDoc */
+    get cache(): CacheChannelLike<CacheConnectionLike, CacheExecOpt, ENT, ID>;
+    /** @inheritDoc */
+    get modelVersion(): number;
+    /** @inheritDoc */
+    get urnDelimiter(): UrnDelimiter;
+    /** @inheritDoc */
+    get urnPrefix(): string;
+    /** @inheritDoc */
+    get hasNumericId(): boolean;
+    /** @inheritDoc */
+    get hasIsoDate(): boolean;
+    /** @inheritDoc */
+    get isIdSame(): boolean;
+    /** @inheritDoc */
+    get hasSoftDelete(): boolean;
+    /** @inheritDoc */
+    get hasCreatedAt(): boolean;
+    /** @inheritDoc */
+    get hasCreatedBy(): boolean;
+    /** @inheritDoc */
+    get hasUpdatedAt(): boolean;
+    /** @inheritDoc */
+    get hasUpdatedBy(): boolean;
+    /** @inheritDoc */
+    get hasVersion(): boolean;
+    /** @inheritDoc */
+    get hasRevision(): boolean;
+    /** @inheritDoc */
+    get isNoInsert(): boolean;
+    /** @inheritDoc */
+    get isNoUpdate(): boolean;
+    /** @inheritDoc */
+    get isNoTrash(): boolean;
+    /** @inheritDoc */
+    get isNoRemove(): boolean;
+    /** @inheritDoc */
+    get alphaFn(): DbRepoExtensionLambda<ENT, ID>;
+    /** @inheritDoc */
+    get searchFn(): DbRepoExtensionLambda<ENT, ID>;
+    /** @inheritDoc */
+    get irregularFn(): DbRepoExtensionLambda<ENT, ID>;
+    /** @inheritDoc */
+    get forbiddenSet(): Array<keyof ENT>;
+    /** @inheritDoc */
+    get path(): string;
+    /** @inheritDoc */
+    get table(): string;
+    /** @inheritDoc */
+    get urnLength(): number;
+    /** {@inheritDoc} */
+    checkError(err: Error, opt: DbExecOpt | Opt): void;
+    /** {@inheritDoc} */
+    f(field: string): string;
+    /** {@inheritDoc} */
+    abstract field(field: string): string;
+    v(value: unknown): string;
+    abstract value(value: unknown): string;
+    /** {@inheritDoc} */
+    rows<T>(rows: Array<T>): Array<T>;
+    /** {@inheritDoc} */
+    row<T>(row: T): T | undefined;
+    /** {@inheritDoc} */
+    first<T>(rows: Array<T>): T | undefined;
+    /** {@inheritDoc} */
+    buildOpt(p1?: Partial<OPT> | string, name?: string): OPT;
+    /** {@inheritDoc} */
+    exec<T>(fn: Promise<T>, p1?: string | Omit<OPT, 'printSql'>): Promise<T>;
+    /** {@inheritDoc} */
+    abstract more<T>(sql: string | DbLines, name?: string | DbExecOpt): Promise<DbQueryResultMore<T, META>>;
+    /** {@inheritDoc} */
+    abstract one<T>(sql: string | DbLines, name?: string | DbExecOpt): Promise<DbQueryResultOne<T, META>>;
+    /** @inheritDoc */
     toUrn(urnRec: URN): string;
     /** @inheritDoc */
     $toUrnTuple(urnRec: URN): UrnTuple;