@naturalcycles/db-lib 8.50.1 → 8.50.3

package/dist/adapter/file/file.db.d.ts

@@ -21,19 +21,19 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getByIds<ROW extends Partial<ObjectWithId>>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
      * Implementation is optimized for loading/saving _whole files_.
      */
     commitTransaction(tx: DBTransaction, _opt?: CommonDBOptions): Promise<void>;
-    runQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    deleteByQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    getTableSchema<ROW extends Partial<ObjectWithId>>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]>;
-    saveFile<ROW extends Partial<ObjectWithId>>(table: string, _rows: ROW[]): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
+    saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
     saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
     private sortRows;
     private logStarted;

package/dist/adapter/file/file.db.model.d.ts

@@ -2,10 +2,10 @@ import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import type { DBQueryOrder } from '../../query/dbQuery';
 export interface FileDBPersistencePlugin {
-    ping(): Promise<void>;
-    getTables(): Promise<string[]>;
-    loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]>;
-    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
+    ping: () => Promise<void>;
+    getTables: () => Promise<string[]>;
+    loadFile: <ROW extends ObjectWithId>(table: string) => Promise<ROW[]>;
+    saveFiles: (ops: DBSaveBatchOperation<any>[]) => Promise<void>;
 }
 export interface FileDBCfg {
     plugin: FileDBPersistencePlugin;

package/dist/adapter/file/inMemory.persistence.plugin.d.ts

@@ -8,6 +8,6 @@ export declare class InMemoryPersistencePlugin implements FileDBPersistencePlugi
     data: StringMap<StringMap<ObjectWithId>>;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
 }

package/dist/adapter/file/localFile.persistence.plugin.d.ts

@@ -19,7 +19,7 @@ export declare class LocalFilePersistencePlugin implements FileDBPersistencePlug
     cfg: LocalFilePersistencePluginCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
     saveFile<ROW extends ObjectWithId>(table: string, rows: ROW[]): Promise<void>;
 }

package/dist/adapter/file/noop.persistence.plugin.d.ts

@@ -4,6 +4,6 @@ import { FileDBPersistencePlugin } from './file.db.model';
 export declare class NoopPersistencePlugin implements FileDBPersistencePlugin {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends Partial<ObjectWithId>>(_table: string): Promise<ROW[]>;
+    loadFile<ROW extends ObjectWithId>(_table: string): Promise<ROW[]>;
     saveFiles(_ops: DBSaveBatchOperation[]): Promise<void>;
 }

package/dist/adapter/inmemory/inMemory.db.d.ts

@@ -50,15 +50,15 @@ export declare class InMemoryDB implements CommonDB {
      */
     resetCache(_table?: string): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends Partial<ObjectWithId>>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends Partial<ObjectWithId>>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds<ROW extends Partial<ObjectWithId>>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
+    getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    updateByQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
-    runQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
     commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.

package/dist/adapter/inmemory/queryInMemory.d.ts

@@ -1,3 +1,3 @@
 import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBQuery } from '../../query/dbQuery';
-export declare function queryInMemory<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];
+export declare function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];

package/dist/common.db.d.ts

@@ -10,43 +10,43 @@ export interface CommonDB {
      * It SHOULD fail if DB setup is wrong (e.g on wrong credentials).
      * It SHOULD succeed if e.g getByIds(['nonExistingKey']) doesn't throw.
      */
-    ping(): Promise<void>;
+    ping: () => Promise<void>;
     /**
      * Return all tables (table names) available in this DB.
      */
-    getTables(): Promise<string[]>;
+    getTables: () => Promise<string[]>;
     /**
      * $id of the schema SHOULD be like this:
      * `${tableName}.schema.json`
      *
      * This is important for the code to rely on it, and it's verified by dbTest
      */
-    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    getTableSchema: <ROW extends ObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
     /**
      * Will do like `create table ...` for mysql.
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
-    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
+    createTable: <ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions) => Promise<void>;
     /**
      * Order of items returned is not guaranteed to match order of ids.
      * (Such limitation exists because Datastore doesn't support it).
      */
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds: <ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions) => Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
-    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
+    runQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<RunQueryResult<ROW>>;
+    runQueryCount: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    streamQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions) => ReadableTyped<ROW>;
     /**
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
-    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    saveBatch: <ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
     /**
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
      */
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
+    deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Applies patch to the rows returned by the query.
      *
@@ -65,10 +65,10 @@ export interface CommonDB {
      *
      * Returns number of rows affected.
      */
-    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
+    updateByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
      */
-    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
+    commitTransaction: (tx: DBTransaction, opt?: CommonDBOptions) => Promise<void>;
 }

package/dist/commondao/common.dao.d.ts

@@ -1,4 +1,4 @@
-import { AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchemaTyped, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DBDeleteByIdsOperation, DBModelType, DBOperation, DBPatch, DBSaveBatchOperation, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -8,10 +8,11 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOp
  *
  * DBM = Database model (how it's stored in DB)
  * BM = Backend model (optimized for API access)
+ * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends ObjectWithId<ID>, DBM extends ObjectWithId<ID> = BM, ID extends string | number = BM['id']> {
-    cfg: CommonDaoCfg<BM, DBM, ID>;
-    constructor(cfg: CommonDaoCfg<BM, DBM, ID>);
+export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM extends AnyObject = BM, ID extends string | number = NonNullable<BM['id']>> {
+    cfg: CommonDaoCfg<BM, DBM, TM, ID>;
+    constructor(cfg: CommonDaoCfg<BM, DBM, TM, ID>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
     getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getById(id?: ID | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
@@ -19,6 +20,8 @@ export declare class CommonDao<BM extends ObjectWithId<ID>, DBM extends ObjectWi
     getByIdAsDBMOrEmpty(id: ID, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
+    getByIdAsTM(id?: ID | null, opt?: CommonDaoOptions): Promise<TM | null>;
     getByIds(ids: ID[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     getByIdsAsDBM(ids: ID[], opt?: CommonDaoOptions): Promise<DBM[]>;
     requireById(id: ID, opt?: CommonDaoOptions): Promise<Saved<BM>>;
@@ -39,7 +42,7 @@ export declare class CommonDao<BM extends ObjectWithId<ID>, DBM extends ObjectWi
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM, ID>;
+    query(table?: string): RunnableDBQuery<BM, DBM, TM, ID>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
@@ -51,6 +54,8 @@ export declare class CommonDao<BM extends ObjectWithId<ID>, DBM extends ObjectWi
     runQueryExtended(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
     runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<DBM[]>;
     runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
+    runQueryAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<TM[]>;
+    runQueryExtendedAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
     runQueryCount(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<number>;
     streamQueryForEach(q: DBQuery<DBM>, mapper: AsyncMapper<Saved<BM>, void>, opt?: CommonDaoStreamForEachOptions<Saved<BM>>): Promise<void>;
     streamQueryAsDBMForEach(q: DBQuery<DBM>, mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
@@ -131,6 +136,12 @@ export declare class CommonDao<BM extends ObjectWithId<ID>, DBM extends ObjectWi
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
     anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
     anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): DBM[];
+    bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined;
+    bmToTM(bm?: Saved<BM>, opt?: CommonDaoOptions): TM;
+    bmsToTM(bms: Saved<BM>[], opt?: CommonDaoOptions): TM[];
+    tmToBM(tm: undefined, opt?: CommonDaoOptions): undefined;
+    tmToBM(tm?: TM, opt?: CommonDaoOptions): BM;
+    tmsToBM(tms: TM[], opt?: CommonDaoOptions): BM[];
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).

package/dist/commondao/common.dao.js

@@ -15,6 +15,7 @@ const isCI = !!process.env['CI'];
  *
  * DBM = Database model (how it's stored in DB)
  * BM = Backend model (optimized for API access)
+ * TM = Transport model (optimized to be sent over the wire)
  */
 class CommonDao {
     constructor(cfg) {
@@ -79,6 +80,8 @@ class CommonDao {
                 beforeDBMValidate: dbm => dbm,
                 beforeDBMToBM: dbm => dbm,
                 beforeBMToDBM: bm => bm,
+                beforeTMToBM: tm => tm,
+                beforeBMToTM: bm => bm,
                 anonymize: dbm => dbm,
                 onValidationError: err => err,
                 ...cfg.hooks,
@@ -136,6 +139,22 @@ class CommonDao {
         this.logResult(started, op, dbm, table);
         return dbm || null;
     }
+    async getByIdAsTM(id, opt = {}) {
+        if (!id)
+            return null;
+        const op = `getByIdAsTM(${id})`;
+        const table = opt.table || this.cfg.table;
+        const started = this.logStarted(op, table);
+        const [dbm] = await this.cfg.db.getByIds(table, [id]);
+        if (opt.raw) {
+            this.logResult(started, op, dbm, table);
+            return dbm || null;
+        }
+        const bm = await this.dbmToBM(dbm, opt);
+        const tm = this.bmToTM(bm, opt);
+        this.logResult(started, op, tm, table);
+        return tm || null;
+    }
     async getByIds(ids, opt = {}) {
         const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
@@ -271,6 +290,23 @@ class CommonDao {
         this.logResult(started, op, dbms, q.table);
         return { rows: dbms, ...queryResult };
     }
+    async runQueryAsTM(q, opt) {
+        const { rows } = await this.runQueryExtendedAsTM(q, opt);
+        return rows;
+    }
+    async runQueryExtendedAsTM(q, opt = {}) {
+        q.table = opt.table || q.table;
+        const op = `runQueryAsTM(${q.pretty()})`;
+        const started = this.logStarted(op, q.table);
+        const { rows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
+        const partialQuery = !!q._selectedFieldNames;
+        const tms = partialQuery || opt.raw ? rows : this.bmsToTM(await this.dbmsToBM(rows, opt), opt);
+        this.logResult(started, op, tms, q.table);
+        return {
+            rows: tms,
+            ...queryResult,
+        };
+    }
     async runQueryCount(q, opt = {}) {
         q.table = opt.table || q.table;
         const op = `runQueryCount(${q.pretty()})`;
@@ -732,6 +768,38 @@ class CommonDao {
     anyToDBMs(entities, opt = {}) {
         return entities.map(entity => this.anyToDBM(entity, opt));
     }
+    bmToTM(bm, opt) {
+        if (bm === undefined)
+            return;
+        // optimization: 1 validation is enough
+        // Validate/convert BM
+        // bm gets assigned to the new reference
+        // bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
+        // BM > TM
+        const tm = this.cfg.hooks.beforeBMToTM(bm);
+        // Validate/convert DBM
+        return this.validateAndConvert(tm, this.cfg.tmSchema, db_model_1.DBModelType.TM, opt);
+    }
+    bmsToTM(bms, opt = {}) {
+        // try/catch?
+        return bms.map(bm => this.bmToTM(bm, opt));
+    }
+    tmToBM(tm, opt = {}) {
+        if (!tm)
+            return;
+        // optimization: 1 validation is enough
+        // Validate/convert TM
+        // bm gets assigned to the new reference
+        // tm = this.validateAndConvert(tm, this.cfg.tmSchema, DBModelType.TM, opt)
+        // TM > BM
+        const bm = this.cfg.hooks.beforeTMToBM(tm);
+        // Validate/convert BM
+        return this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
+    }
+    tmsToBM(tms, opt = {}) {
+        // try/catch?
+        return tms.map(tm => this.tmToBM(tm, opt));
+    }
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).

package/dist/commondao/common.dao.model.d.ts

@@ -1,30 +1,29 @@
-import { CommonLogger, ErrorMode, ObjectWithId } from '@naturalcycles/js-lib';
+import { CommonLogger, ErrorMode, ObjectWithId, Saved } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchemaTyped, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export interface CommonDaoHooks<BM extends Partial<ObjectWithId<ID>>, DBM extends Partial<ObjectWithId<ID>> = BM, ID extends string | number = NonNullable<BM['id']>> {
-    createRandomId(): ID;
+export interface CommonDaoHooks<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID>, TM, ID extends string | number> {
+    createRandomId: () => ID;
     /**
      * createNaturalId hook is called (tried) first.
      * If it doesn't exist - createRandomId is called.
      */
-    createNaturalId(obj: DBM | BM): ID;
-    parseNaturalId(id: ID): Partial<DBM>;
-    beforeCreate(bm: Partial<BM>): Partial<BM>;
-    beforeDBMValidate(dbm: Partial<DBM>): Partial<DBM>;
-    beforeDBMToBM(dbm: DBM): Partial<BM> | Promise<Partial<BM>>;
-    beforeBMToDBM(bm: BM): Partial<DBM> | Promise<Partial<DBM>>;
-    /**
-     * Applicable to **read** operations, never to **save** operations.
-     */
-    anonymize(dbm: DBM): DBM;
+    createNaturalId: (obj: DBM | BM) => ID;
+    parseNaturalId: (id: ID) => Partial<DBM>;
+    beforeCreate: (bm: Partial<BM>) => Partial<BM>;
+    beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>;
+    beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
+    beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
+    beforeTMToBM: (tm: TM) => Partial<BM>;
+    beforeBMToTM: (bm: BM) => Partial<TM>;
+    anonymize: (dbm: DBM) => DBM;
     /**
      * If hook is defined - allows to prevent or modify the error thrown.
      * Return `false` to prevent throwing an error.
      * Return original `err` to pass the error through (will be thrown in CommonDao).
      * Return modified/new `Error` if needed.
      */
-    onValidationError(err: JoiValidationError | AjvValidationError): Error | false;
+    onValidationError: (err: JoiValidationError | AjvValidationError) => Error | false;
 }
 export declare enum CommonDaoLogLevel {
     /**
@@ -44,7 +43,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWithId<ID> = BM, ID extends string | number = BM['id']> {
+export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM = BM, ID extends string | number = string> {
     db: CommonDB;
     table: string;
     /**
@@ -52,6 +51,7 @@ export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWit
      */
     dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM>;
     bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>;
+    tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM>;
     excludeFromIndexes?: (keyof DBM)[];
     /**
      * Defaults to false.
@@ -61,8 +61,6 @@ export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWit
      * `delete*` and `patch` will throw.
      *
      * You can still override saveMethod, or set opt.allowMutability to allow deletion.
-     *
-     * todo: consider merging it with readOnly, as it's almost the same
      */
     immutable?: boolean;
     /**
@@ -82,7 +80,7 @@ export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWit
      * @default false
      */
     logStarted?: boolean;
-    hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>;
+    hooks?: Partial<CommonDaoHooks<BM, DBM, TM, ID>>;
     /**
      * Defaults to 'string'
      */
@@ -96,7 +94,6 @@ export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWit
     /**
      * See the same option in CommonDB.
      * Defaults to false normally.
-     * "Generated" means "generated by the underlying DB" (e.g MySQL autoincrement).
      */
     assignGeneratedIds?: boolean;
     /**
@@ -182,7 +179,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions<DBM extends Partial<ObjectWithId>> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveOptions<DBM extends ObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *

package/dist/db.model.d.ts

@@ -59,7 +59,8 @@ export declare enum DBRelation {
 }
 export declare enum DBModelType {
     DBM = "DBM",
-    BM = "BM"
+    BM = "BM",
+    TM = "TM"
 }
 /**
  * Allows to construct a query similar to:

package/dist/db.model.js

@@ -10,6 +10,7 @@ var DBModelType;
 (function (DBModelType) {
     DBModelType["DBM"] = "DBM";
     DBModelType["BM"] = "BM";
+    DBModelType["TM"] = "TM";
 })(DBModelType = exports.DBModelType || (exports.DBModelType = {}));
 /**
  * Allows to construct a query similar to:

package/dist/kv/commonKeyValueDB.d.ts

@@ -11,22 +11,22 @@ export interface CommonKeyValueDB {
     /**
      * Check that DB connection is working properly.
      */
-    ping(): Promise<void>;
+    ping: () => Promise<void>;
     /**
      * Will do like `create table ...` for mysql.
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
-    createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
+    createTable: (table: string, opt?: CommonDBCreateOptions) => Promise<void>;
     /**
      * Returns an array of tuples [key, value]. Not found values are not returned (no error is thrown).
      *
      * Currently it is NOT required to maintain the same order as input `ids`.
      */
-    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
-    deleteByIds(table: string, ids: string[]): Promise<void>;
-    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
-    streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
-    count(table: string): Promise<number>;
+    getByIds: (table: string, ids: string[]) => Promise<KeyValueDBTuple[]>;
+    deleteByIds: (table: string, ids: string[]) => Promise<void>;
+    saveBatch: (table: string, entries: KeyValueDBTuple[]) => Promise<void>;
+    streamIds: (table: string, limit?: number) => ReadableTyped<string>;
+    streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>;
+    streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>;
+    count: (table: string) => Promise<number>;
 }

package/dist/kv/commonKeyValueDao.d.ts

@@ -21,9 +21,9 @@ export interface CommonKeyValueDaoCfg<T> {
      */
     logStarted?: boolean;
     hooks?: {
-        mapValueToBuffer?(v: T): Promise<Buffer>;
-        mapBufferToValue?(b: Buffer): Promise<T>;
-        beforeCreate?(v: Partial<T>): Partial<T>;
+        mapValueToBuffer?: (v: T) => Promise<Buffer>;
+        mapBufferToValue?: (b: Buffer) => Promise<T>;
+        beforeCreate?: (v: Partial<T>) => Partial<T>;
     };
     /**
      * Set to `true` to conveniently enable zipping+JSON.stringify

package/dist/query/dbQuery.d.ts

@@ -1,4 +1,4 @@
-import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved } from '@naturalcycles/js-lib';
+import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved, AnyObject } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
 import { CommonDao } from '../commondao/common.dao';
@@ -24,12 +24,12 @@ import { RunQueryResult } from '../db.model';
  */
 export type DBQueryFilterOperator = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'in' | 'not-in' | 'array-contains' | 'array-contains-any';
 export declare const dbQueryFilterOperatorValues: DBQueryFilterOperator[];
-export interface DBQueryFilter<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
+export interface DBQueryFilter<ROW extends ObjectWithId = AnyObjectWithId> {
     name: keyof ROW;
     op: DBQueryFilterOperator;
     val: any;
 }
-export interface DBQueryOrder<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
+export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
     name: keyof ROW;
     descending?: boolean;
 }
@@ -43,14 +43,14 @@ export interface DBQueryOrder<ROW extends Partial<ObjectWithId> = AnyObjectWithI
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-export declare class DBQuery<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
+export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     table: string;
     constructor(table: string);
     /**
      * Convenience method.
      */
     static create<ROW extends ObjectWithId = AnyObjectWithId>(table: string): DBQuery<ROW>;
-    static fromPlainObject<ROW extends Partial<ObjectWithId> = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
+    static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
         table: string;
     }): DBQuery<ROW>;
     _filters: DBQueryFilter<ROW>[];
@@ -84,17 +84,19 @@ export declare class DBQuery<ROW extends Partial<ObjectWithId> = AnyObjectWithId
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends ObjectWithId<ID>, DBM extends ObjectWithId<ID> = BM, ID extends string | number = BM['id']> extends DBQuery<DBM> {
-    dao: CommonDao<BM, DBM, ID>;
+export declare class RunnableDBQuery<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM extends AnyObject = BM, ID extends string | number = string> extends DBQuery<DBM> {
+    dao: CommonDao<BM, DBM, TM, ID>;
     /**
      * Pass `table` to override table.
      */
-    constructor(dao: CommonDao<BM, DBM, ID>, table?: string);
+    constructor(dao: CommonDao<BM, DBM, TM, ID>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
     runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
+    runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]>;
     runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
     runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
+    runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
     runQueryCount(opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     streamQueryForEach(mapper: AsyncMapper<Saved<BM>, void>, opt?: CommonDaoStreamForEachOptions<Saved<BM>>): Promise<void>;

package/dist/query/dbQuery.js

@@ -153,12 +153,18 @@ class RunnableDBQuery extends DBQuery {
     async runQueryAsDBM(opt) {
         return await this.dao.runQueryAsDBM(this, opt);
     }
+    async runQueryAsTM(opt) {
+        return await this.dao.runQueryAsTM(this, opt);
+    }
     async runQueryExtended(opt) {
         return await this.dao.runQueryExtended(this, opt);
     }
     async runQueryExtendedAsDBM(opt) {
         return await this.dao.runQueryExtendedAsDBM(this, opt);
     }
+    async runQueryExtendedAsTM(opt) {
+        return await this.dao.runQueryExtendedAsTM(this, opt);
+    }
     async runQueryCount(opt) {
         return await this.dao.runQueryCount(this, opt);
     }

package/dist/testing/daoTest.js

@@ -13,6 +13,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         db,
         dbmSchema: test_model_1.testItemDBMSchema,
         bmSchema: test_model_1.testItemBMSchema,
+        tmSchema: test_model_1.testItemTMSchema,
         logStarted: true,
         logLevel: __1.CommonDaoLogLevel.DATA_FULL,
     });

package/package.json

@@ -41,7 +41,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.50.1",
+  "version": "8.50.3",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/file/file.db.model.ts

@@ -3,10 +3,10 @@ import { DBSaveBatchOperation } from '../../db.model'
 import type { DBQueryOrder } from '../../query/dbQuery'
 
 export interface FileDBPersistencePlugin {
-  ping(): Promise<void>
-  getTables(): Promise<string[]>
-  loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]>
-  saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>
+  ping: () => Promise<void>
+  getTables: () => Promise<string[]>
+  loadFile: <ROW extends ObjectWithId>(table: string) => Promise<ROW[]>
+  saveFiles: (ops: DBSaveBatchOperation<any>[]) => Promise<void>
 }
 
 export interface FileDBCfg {