@naturalcycles/db-lib 8.49.1 → 8.50.1

package/dist/adapter/cachedb/cache.db.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheDB = void 0;
 const node_stream_1 = require("node:stream");
+const js_lib_1 = require("@naturalcycles/js-lib");
 const base_common_db_1 = require("../../base.common.db");
 /**
  * CommonDB implementation that proxies requests to downstream CommonDB
@@ -70,7 +71,7 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
             }
         }
         // return in right order
-        return ids.map(id => resultMap[id]).filter(Boolean);
+        return ids.map(id => resultMap[id]).filter(js_lib_1._isTruthy);
     }
     async saveBatch(table, rows, opt = {}) {
         if (!opt.onlyCache && !this.cfg.onlyCache) {

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 ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends Partial<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 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>;
+    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>;
     saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
     private sortRows;
     private logStarted;

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

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

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 ObjectWithId>(table: string): Promise<ROW[]>;
+    loadFile<ROW extends Partial<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 ObjectWithId>(table: string): Promise<ROW[]>;
+    loadFile<ROW extends Partial<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 ObjectWithId>(_table: string): Promise<ROW[]>;
+    loadFile<ROW extends Partial<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 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[]>;
+    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[]>;
     saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    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>;
+    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>;
     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 ObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];
+export declare function queryInMemory<ROW extends Partial<ObjectWithId>>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];

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

@@ -1,4 +1,4 @@
-import { AnyObject, AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
+import { 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,11 +8,10 @@ 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 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>);
+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>);
     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>;
@@ -20,8 +19,6 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     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>>;
@@ -42,7 +39,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM, TM, ID>;
+    query(table?: string): RunnableDBQuery<BM, DBM, ID>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
@@ -54,8 +51,6 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     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>;
@@ -136,12 +131,6 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     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,7 +15,6 @@ 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) {
@@ -80,8 +79,6 @@ 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,
@@ -108,19 +105,7 @@ class CommonDao {
         const op = `getById(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        let dbm;
-        if (opt.timeout) {
-            // todo: possibly remove it after debugging is done
-            dbm = await (0, js_lib_1.pTimeout)(async () => {
-                return (await this.cfg.db.getByIds(table, [id]))[0];
-            }, {
-                timeout: opt.timeout,
-                name: `getById(${table})`,
-            });
-        }
-        else {
-            dbm = (await this.cfg.db.getByIds(table, [id]))[0];
-        }
+        const dbm = (await this.cfg.db.getByIds(table, [id]))[0];
         const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
         return bm || null;
@@ -151,22 +136,6 @@ 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;
@@ -302,23 +271,6 @@ 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()})`;
@@ -780,38 +732,6 @@ 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,8 +1,8 @@
-import { CommonLogger, ErrorMode, ObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { CommonLogger, ErrorMode, ObjectWithId } 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 ObjectWithId<ID>, TM, ID extends string | number> {
+export interface CommonDaoHooks<BM extends Partial<ObjectWithId<ID>>, DBM extends Partial<ObjectWithId<ID>> = BM, ID extends string | number = NonNullable<BM['id']>> {
     createRandomId(): ID;
     /**
      * createNaturalId hook is called (tried) first.
@@ -14,8 +14,9 @@ export interface CommonDaoHooks<BM extends Partial<ObjectWithId<ID>>, DBM extend
     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>;
+    /**
+     * Applicable to **read** operations, never to **save** operations.
+     */
     anonymize(dbm: DBM): DBM;
     /**
      * If hook is defined - allows to prevent or modify the error thrown.
@@ -43,7 +44,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM = BM, ID extends string | number = string> {
+export interface CommonDaoCfg<BM extends ObjectWithId<ID>, DBM extends ObjectWithId<ID> = BM, ID extends string | number = BM['id']> {
     db: CommonDB;
     table: string;
     /**
@@ -51,7 +52,6 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends
      */
     dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM>;
     bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>;
-    tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM>;
     excludeFromIndexes?: (keyof DBM)[];
     /**
      * Defaults to false.
@@ -61,6 +61,8 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends
      * `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;
     /**
@@ -80,7 +82,7 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends
      * @default false
      */
     logStarted?: boolean;
-    hooks?: Partial<CommonDaoHooks<BM, DBM, TM, ID>>;
+    hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>;
     /**
      * Defaults to 'string'
      */
@@ -94,6 +96,7 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends
     /**
      * See the same option in CommonDB.
      * Defaults to false normally.
+     * "Generated" means "generated by the underlying DB" (e.g MySQL autoincrement).
      */
     assignGeneratedIds?: boolean;
     /**
@@ -165,13 +168,6 @@ export interface CommonDaoOptions extends CommonDBOptions {
      * Useful e.g in AirtableDB where you can have one Dao to control multiple tables.
      */
     table?: string;
-    /**
-     * If set - wraps the method in `pTimeout` with a timeout of given number of milliseconds.
-     * Currently, it is only used to debug an ongoing GCP infra issue.
-     *
-     * @experimental
-     */
-    timeout?: number;
     /**
      * If passed - operation will not be performed immediately, but instead "added" to the transaction.
      * In the end - transaction needs to be committed (by calling `commit`).
@@ -186,7 +182,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions<DBM extends ObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveOptions<DBM extends Partial<ObjectWithId>> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *

package/dist/db.model.d.ts

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

package/dist/db.model.js

@@ -10,7 +10,6 @@ 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/query/dbQuery.d.ts

@@ -1,4 +1,4 @@
-import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved, AnyObject } from '@naturalcycles/js-lib';
+import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved } 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 ObjectWithId = AnyObjectWithId> {
+export interface DBQueryFilter<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
     name: keyof ROW;
     op: DBQueryFilterOperator;
     val: any;
 }
-export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
+export interface DBQueryOrder<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
     name: keyof ROW;
     descending?: boolean;
 }
@@ -43,14 +43,14 @@ export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
  *
  * <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 ObjectWithId = AnyObjectWithId> {
+export declare class DBQuery<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
     table: string;
     constructor(table: string);
     /**
      * Convenience method.
      */
     static create<ROW extends ObjectWithId = AnyObjectWithId>(table: string): DBQuery<ROW>;
-    static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
+    static fromPlainObject<ROW extends Partial<ObjectWithId> = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
         table: string;
     }): DBQuery<ROW>;
     _filters: DBQueryFilter<ROW>[];
@@ -84,19 +84,17 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-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>;
+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>;
     /**
      * Pass `table` to override table.
      */
-    constructor(dao: CommonDao<BM, DBM, TM, ID>, table?: string);
+    constructor(dao: CommonDao<BM, DBM, 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,18 +153,12 @@ 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,7 +13,6 @@ 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.49.1",
+  "version": "8.50.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/cachedb/cache.db.ts

@@ -1,5 +1,6 @@
 import { Readable } from 'node:stream'
 import {
+  _isTruthy,
   JsonSchemaObject,
   JsonSchemaRootObject,
   ObjectWithId,
@@ -115,7 +116,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
 
     // return in right order
-    return ids.map(id => resultMap[id]!).filter(Boolean)
+    return ids.map(id => resultMap[id]).filter(_isTruthy)
   }
 
   override async saveBatch<ROW extends Partial<ObjectWithId>>(

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

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

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

@@ -65,13 +65,13 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return tables
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
+  override async getByIds<ROW extends Partial<ObjectWithId>>(
     table: string,
     ids: ROW['id'][],
     _opt?: CommonDBOptions,
   ): Promise<ROW[]> {
     const byId = _by(await this.loadFile<ROW>(table), r => r.id)
-    return ids.map(id => byId[id]!).filter(Boolean)
+    return ids.map(id => byId[id!]!).filter(Boolean)
   }
 
   override async saveBatch<ROW extends Partial<ObjectWithId>>(
@@ -115,7 +115,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     await pMap(
       tables,
       async table => {
-        const rows = await this.loadFile(table)
+        const rows: ObjectWithId[] = await this.loadFile(table)
         data[table] = _by(rows, r => r.id)
       },
       { concurrency: 16 },
@@ -168,7 +168,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async runQuery<ROW extends ObjectWithId>(
+  override async runQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<RunQueryResult<ROW>> {
@@ -177,14 +177,14 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async runQueryCount<ROW extends ObjectWithId>(
+  override async runQueryCount<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
     return (await this.loadFile(q.table)).length
   }
 
-  override streamQuery<ROW extends ObjectWithId>(
+  override streamQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     opt?: CommonDBStreamOptions,
   ): ReadableTyped<ROW> {
@@ -198,7 +198,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return readable
   }
 
-  override async deleteByQuery<ROW extends ObjectWithId>(
+  override async deleteByQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
@@ -206,7 +206,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
 
     let deleted = 0
     queryInMemory(q, _stringMapValues(byId)).forEach(r => {
-      delete byId[r.id]
+      delete byId[r.id!]
       deleted++
     })
 
@@ -217,7 +217,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return deleted
   }
 
-  override async getTableSchema<ROW extends ObjectWithId>(
+  override async getTableSchema<ROW extends Partial<ObjectWithId>>(
     table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     const rows = await this.loadFile(table)
@@ -228,7 +228,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   }
 
   // wrapper, to handle logging
-  async loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
     const started = this.logStarted(`loadFile(${table})`)
     const rows = await this.cfg.plugin.loadFile<ROW>(table)
     this.logFinished(started, `loadFile(${table}) ${rows.length} row(s)`)
@@ -236,7 +236,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   }
 
   // wrapper, to handle logging, sorting rows before saving
-  async saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void> {
+  async saveFile<ROW extends Partial<ObjectWithId>>(table: string, _rows: ROW[]): Promise<void> {
     // if (!_rows.length) return // NO, it should be able to save file with 0 rows!
 
     // Sort the rows, if needed
@@ -257,7 +257,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     this.logFinished(started, op)
   }
 
-  private sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[] {
+  private sortRows<ROW extends Partial<ObjectWithId>>(rows: ROW[]): ROW[] {
     rows = rows.map(r => _filterUndefinedValues(r))
 
     if (this.cfg.sortOnSave) {

package/src/adapter/file/inMemory.persistence.plugin.ts

@@ -14,7 +14,7 @@ export class InMemoryPersistencePlugin implements FileDBPersistencePlugin {
     return Object.keys(this.data)
   }
 
-  async loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
     return Object.values(this.data[table] || ({} as any))
   }
 

package/src/adapter/file/localFile.persistence.plugin.ts

@@ -46,7 +46,7 @@ export class LocalFilePersistencePlugin implements FileDBPersistencePlugin {
       .map(f => f.split('.ndjson')[0]!)
   }
 
-  async loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
     await fs.ensureDir(this.cfg.storagePath)
     const ext = `ndjson${this.cfg.gzip ? '.gz' : ''}`
     const filePath = `${this.cfg.storagePath}/${table}.${ext}`

package/src/adapter/file/noop.persistence.plugin.ts

@@ -9,7 +9,7 @@ export class NoopPersistencePlugin implements FileDBPersistencePlugin {
     return []
   }
 
-  async loadFile<ROW extends ObjectWithId>(_table: string): Promise<ROW[]> {
+  async loadFile<ROW extends Partial<ObjectWithId>>(_table: string): Promise<ROW[]> {
     return []
   }
 

package/src/adapter/inmemory/inMemory.db.ts

@@ -120,7 +120,7 @@ export class InMemoryDB implements CommonDB {
     return Object.keys(this.data).filter(t => t.startsWith(this.cfg.tablesPrefix))
   }
 
-  async getTableSchema<ROW extends ObjectWithId>(
+  async getTableSchema<ROW extends Partial<ObjectWithId>>(
     _table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     const table = this.cfg.tablesPrefix + _table
@@ -130,7 +130,7 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async createTable<ROW extends ObjectWithId>(
+  async createTable<ROW extends Partial<ObjectWithId>>(
     _table: string,
     _schema: JsonSchemaObject<ROW>,
     opt: CommonDBCreateOptions = {},
@@ -143,14 +143,14 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async getByIds<ROW extends ObjectWithId>(
+  async getByIds<ROW extends Partial<ObjectWithId>>(
     _table: string,
     ids: ROW['id'][],
     _opt?: CommonDBOptions,
   ): Promise<ROW[]> {
     const table = this.cfg.tablesPrefix + _table
     this.data[table] ||= {}
-    return ids.map(id => this.data[table]![id] as ROW).filter(Boolean)
+    return ids.map(id => this.data[table]![id!] as ROW).filter(Boolean)
   }
 
   async saveBatch<ROW extends Partial<ObjectWithId>>(
@@ -184,7 +184,7 @@ export class InMemoryDB implements CommonDB {
     })
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(
+  async deleteByQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
@@ -192,14 +192,14 @@ export class InMemoryDB implements CommonDB {
     this.data[table] ||= {}
     let count = 0
     queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]).forEach(r => {
-      if (!this.data[table]![r.id]) return
-      delete this.data[table]![r.id]
+      if (!this.data[table]![r.id!]) return
+      delete this.data[table]![r.id!]
       count++
     })
     return count
   }
 
-  async updateByQuery<ROW extends ObjectWithId>(
+  async updateByQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     patch: DBPatch<ROW>,
   ): Promise<number> {
@@ -221,7 +221,7 @@ export class InMemoryDB implements CommonDB {
     return rows.length
   }
 
-  async runQuery<ROW extends ObjectWithId>(
+  async runQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<RunQueryResult<ROW>> {
@@ -229,7 +229,7 @@ export class InMemoryDB implements CommonDB {
     return { rows: queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]) }
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(
+  async runQueryCount<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
@@ -237,7 +237,7 @@ export class InMemoryDB implements CommonDB {
     return queryInMemory<any>(q, Object.values(this.data[table] || {})).length
   }
 
-  streamQuery<ROW extends ObjectWithId>(
+  streamQuery<ROW extends Partial<ObjectWithId>>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): ReadableTyped<ROW> {

package/src/adapter/inmemory/queryInMemory.ts

@@ -18,7 +18,10 @@ const FILTER_FNS: Record<DBQueryFilterOperator, FilterFn> = {
 
 // Important: q.table is not used in this function, so tablesPrefix is not needed.
 // But should be careful here..
-export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: ROW[] = []): ROW[] {
+export function queryInMemory<ROW extends Partial<ObjectWithId>>(
+  q: DBQuery<ROW>,
+  rows: ROW[] = [],
+): ROW[] {
   // .filter
   // eslint-disable-next-line unicorn/no-array-reduce
   rows = q._filters.reduce((rows, filter) => {

package/src/commondao/common.dao.model.ts

@@ -1,4 +1,4 @@
-import { CommonLogger, ErrorMode, ObjectWithId, Saved } from '@naturalcycles/js-lib'
+import { CommonLogger, ErrorMode, ObjectWithId } from '@naturalcycles/js-lib'
 import {
   AjvSchema,
   AjvValidationError,
@@ -12,9 +12,8 @@ import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../
 
 export interface CommonDaoHooks<
   BM extends Partial<ObjectWithId<ID>>,
-  DBM extends ObjectWithId<ID>,
-  TM,
-  ID extends string | number,
+  DBM extends Partial<ObjectWithId<ID>> = BM,
+  ID extends string | number = NonNullable<BM['id']>,
 > {
   createRandomId(): ID
   /**
@@ -27,8 +26,10 @@ export interface CommonDaoHooks<
   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>
+
+  /**
+   * Applicable to **read** operations, never to **save** operations.
+   */
   anonymize(dbm: DBM): DBM
 
   /**
@@ -60,10 +61,9 @@ export enum CommonDaoLogLevel {
 }
 
 export interface CommonDaoCfg<
-  BM extends Partial<ObjectWithId<ID>>,
-  DBM extends ObjectWithId<ID> = Saved<BM>,
-  TM = BM,
-  ID extends string | number = string,
+  BM extends ObjectWithId<ID>,
+  DBM extends ObjectWithId<ID> = BM,
+  ID extends string | number = BM['id'],
 > {
   db: CommonDB
   table: string
@@ -73,7 +73,6 @@ export interface CommonDaoCfg<
    */
   dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM>
   bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>
-  tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM>
 
   excludeFromIndexes?: (keyof DBM)[]
 
@@ -85,6 +84,8 @@ export interface CommonDaoCfg<
    * `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
 
@@ -110,7 +111,7 @@ export interface CommonDaoCfg<
   logStarted?: boolean
 
   // Hooks are designed with inspiration from got/ky interface
-  hooks?: Partial<CommonDaoHooks<BM, DBM, TM, ID>>
+  hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>
 
   /**
    * Defaults to 'string'
@@ -127,6 +128,7 @@ export interface CommonDaoCfg<
   /**
    * See the same option in CommonDB.
    * Defaults to false normally.
+   * "Generated" means "generated by the underlying DB" (e.g MySQL autoincrement).
    */
   assignGeneratedIds?: boolean
 
@@ -209,14 +211,6 @@ export interface CommonDaoOptions extends CommonDBOptions {
    */
   table?: string
 
-  /**
-   * If set - wraps the method in `pTimeout` with a timeout of given number of milliseconds.
-   * Currently, it is only used to debug an ongoing GCP infra issue.
-   *
-   * @experimental
-   */
-  timeout?: number
-
   /**
    * If passed - operation will not be performed immediately, but instead "added" to the transaction.
    * In the end - transaction needs to be committed (by calling `commit`).
@@ -232,7 +226,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions<DBM extends ObjectWithId>
+export interface CommonDaoSaveOptions<DBM extends Partial<ObjectWithId>>
   extends CommonDaoOptions,
     CommonDBSaveOptions<DBM> {
   /**

package/src/commondao/common.dao.ts

@@ -6,7 +6,6 @@ import {
   _since,
   _truncate,
   _uniqBy,
-  AnyObject,
   AppError,
   AsyncMapper,
   ErrorMode,
@@ -14,7 +13,6 @@ import {
   JsonSchemaRootObject,
   ObjectWithId,
   pMap,
-  pTimeout,
   Saved,
   Unsaved,
 } from '@naturalcycles/js-lib'
@@ -64,15 +62,13 @@ 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)
  */
 export class CommonDao<
-  BM extends Partial<ObjectWithId<ID>>,
-  DBM extends ObjectWithId<ID> = Saved<BM>,
-  TM extends AnyObject = BM,
-  ID extends string | number = NonNullable<BM['id']>,
+  BM extends ObjectWithId<ID>,
+  DBM extends ObjectWithId<ID> = BM,
+  ID extends string | number = BM['id'],
 > {
-  constructor(public cfg: CommonDaoCfg<BM, DBM, TM, ID>) {
+  constructor(public cfg: CommonDaoCfg<BM, DBM, ID>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
@@ -91,8 +87,6 @@ export class CommonDao<
         beforeDBMValidate: dbm => dbm,
         beforeDBMToBM: dbm => dbm as any,
         beforeBMToDBM: bm => bm as any,
-        beforeTMToBM: tm => tm as any,
-        beforeBMToTM: bm => bm as any,
         anonymize: dbm => dbm,
         onValidationError: err => err,
         ...cfg.hooks,
@@ -128,22 +122,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
 
-    let dbm: DBM | undefined
-
-    if (opt.timeout) {
-      // todo: possibly remove it after debugging is done
-      dbm = await pTimeout(
-        async () => {
-          return (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
-        },
-        {
-          timeout: opt.timeout,
-          name: `getById(${table})`,
-        },
-      )
-    } else {
-      dbm = (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
-    }
+    const dbm = (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
 
     const bm = opt.raw ? (dbm as any) : await this.dbmToBM(dbm, opt)
     this.logResult(started, op, bm, table)
@@ -180,24 +159,6 @@ export class CommonDao<
     return dbm || null
   }
 
-  async getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsTM(id?: ID | null, opt?: CommonDaoOptions): Promise<TM | null>
-  async getByIdAsTM(id?: ID | null, opt: CommonDaoOptions = {}): Promise<TM | null> {
-    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<DBM>(table, [id])
-    if (opt.raw) {
-      this.logResult(started, op, dbm, table)
-      return (dbm as any) || 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: ID[], opt: CommonDaoOptions = {}): Promise<Saved<BM>[]> {
     const op = `getByIds ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
@@ -295,8 +256,8 @@ export class CommonDao<
   /**
    * Pass `table` to override table
    */
-  query(table?: string): RunnableDBQuery<BM, DBM, TM, ID> {
-    return new RunnableDBQuery<BM, DBM, TM, ID>(this, table)
+  query(table?: string): RunnableDBQuery<BM, DBM, ID> {
+    return new RunnableDBQuery<BM, DBM, ID>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
@@ -364,29 +325,6 @@ export class CommonDao<
     return { rows: dbms, ...queryResult }
   }
 
-  async runQueryAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<TM[]> {
-    const { rows } = await this.runQueryExtendedAsTM(q, opt)
-    return rows
-  }
-
-  async runQueryExtendedAsTM(
-    q: DBQuery<DBM>,
-    opt: CommonDaoOptions = {},
-  ): Promise<RunQueryResult<TM>> {
-    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<DBM>(q, opt)
-    const partialQuery = !!q._selectedFieldNames
-    const tms =
-      partialQuery || opt.raw ? (rows as any[]) : this.bmsToTM(await this.dbmsToBM(rows, opt), opt)
-    this.logResult(started, op, tms, q.table)
-    return {
-      rows: tms,
-      ...queryResult,
-    }
-  }
-
   async runQueryCount(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
     q.table = opt.table || q.table
     const op = `runQueryCount(${q.pretty()})`
@@ -1041,50 +979,6 @@ export class CommonDao<
     return entities.map(entity => this.anyToDBM(entity, opt))
   }
 
-  bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined
-  bmToTM(bm?: Saved<BM>, opt?: CommonDaoOptions): TM
-  bmToTM(bm?: Saved<BM>, opt?: CommonDaoOptions): TM | undefined {
-    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 as any)
-
-    // Validate/convert DBM
-    return this.validateAndConvert(tm, this.cfg.tmSchema, DBModelType.TM, opt)
-  }
-
-  bmsToTM(bms: Saved<BM>[], opt: CommonDaoOptions = {}): TM[] {
-    // try/catch?
-    return bms.map(bm => this.bmToTM(bm, opt))
-  }
-
-  tmToBM(tm: undefined, opt?: CommonDaoOptions): undefined
-  tmToBM(tm?: TM, opt?: CommonDaoOptions): BM
-  tmToBM(tm?: TM, opt: CommonDaoOptions = {}): BM | undefined {
-    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) as BM
-
-    // Validate/convert BM
-    return this.validateAndConvert<BM>(bm, this.cfg.bmSchema, DBModelType.BM, opt)
-  }
-
-  tmsToBM(tms: TM[], opt: CommonDaoOptions = {}): BM[] {
-    // try/catch?
-    return tms.map(tm => this.tmToBM(tm, opt))
-  }
-
   /**
    * Returns *converted value*.
    * Validates (unless `skipValidation=true` passed).

package/src/db.model.ts

@@ -74,7 +74,6 @@ export enum DBRelation {
 export enum DBModelType {
   DBM = 'DBM',
   BM = 'BM',
-  TM = 'TM',
 }
 
 /**

package/src/query/dbQuery.ts

@@ -4,7 +4,6 @@ import {
   AsyncMapper,
   _truncate,
   Saved,
-  AnyObject,
   _objectAssign,
 } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
@@ -61,13 +60,13 @@ export const dbQueryFilterOperatorValues: DBQueryFilterOperator[] = [
   'array-contains-any',
 ]
 
-export interface DBQueryFilter<ROW extends ObjectWithId = AnyObjectWithId> {
+export interface DBQueryFilter<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
   name: keyof ROW
   op: DBQueryFilterOperator
   val: any
 }
 
-export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
+export interface DBQueryOrder<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
   name: keyof ROW
   descending?: boolean
 }
@@ -82,7 +81,7 @@ export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
+export class DBQuery<ROW extends Partial<ObjectWithId> = AnyObjectWithId> {
   constructor(public table: string) {}
 
   /**
@@ -92,7 +91,7 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     return new DBQuery(table)
   }
 
-  static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(
+  static fromPlainObject<ROW extends Partial<ObjectWithId> = AnyObjectWithId>(
     obj: Partial<DBQuery<ROW>> & { table: string },
   ): DBQuery<ROW> {
     return Object.assign(new DBQuery<ROW>(obj.table), obj)
@@ -236,15 +235,14 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
  * DBQuery that has additional method to support Fluent API style.
  */
 export class RunnableDBQuery<
-  BM extends Partial<ObjectWithId<ID>>,
-  DBM extends ObjectWithId<ID> = Saved<BM>,
-  TM extends AnyObject = BM,
-  ID extends string | number = string,
+  BM extends ObjectWithId<ID>,
+  DBM extends ObjectWithId<ID> = BM,
+  ID extends string | number = BM['id'],
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.
    */
-  constructor(public dao: CommonDao<BM, DBM, TM, ID>, table?: string) {
+  constructor(public dao: CommonDao<BM, DBM, ID>, table?: string) {
     super(table || dao.cfg.table)
   }
 
@@ -260,10 +258,6 @@ export class RunnableDBQuery<
     return await this.dao.runQueryAsDBM(this, opt)
   }
 
-  async runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]> {
-    return await this.dao.runQueryAsTM(this, opt)
-  }
-
   async runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>> {
     return await this.dao.runQueryExtended(this, opt)
   }
@@ -272,10 +266,6 @@ export class RunnableDBQuery<
     return await this.dao.runQueryExtendedAsDBM(this, opt)
   }
 
-  async runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>> {
-    return await this.dao.runQueryExtendedAsTM(this, opt)
-  }
-
   async runQueryCount(opt?: CommonDaoOptions): Promise<number> {
     return await this.dao.runQueryCount(this, opt)
   }

package/src/testing/daoTest.ts

@@ -8,7 +8,6 @@ import {
   createTestItemsBM,
   testItemBMSchema,
   testItemDBMSchema,
-  testItemTMSchema,
   TEST_TABLE,
   createTestItemBM,
   testItemDBMJsonSchema,
@@ -25,7 +24,6 @@ export function runCommonDaoTest(
     db,
     dbmSchema: testItemDBMSchema,
     bmSchema: testItemBMSchema,
-    tmSchema: testItemTMSchema,
     logStarted: true,
     logLevel: CommonDaoLogLevel.DATA_FULL,
   })