@naturalcycles/db-lib 9.4.1 → 9.5.0

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, Saved, UnixTimestampMillisNumber, UnsavedId, ZodSchema } from '@naturalcycles/js-lib';
+import { AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBTransactionOptions, DBModelType, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -12,22 +12,20 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveBa
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
-    cfg: CommonDaoCfg<BM, DBM, TM>;
-    constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
-    create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
+export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
+    cfg: CommonDaoCfg<BM, DBM>;
+    constructor(cfg: CommonDaoCfg<BM, DBM>);
+    create(part?: Partial<BM>, opt?: CommonDaoOptions): BM;
     getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getById(id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
+    getById(id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
+    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
+    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<Saved<DBM> | null>;
-    getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsTM(id?: string | null, opt?: CommonDaoOptions): Promise<TM | null>;
-    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
-    requireById(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
+    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
+    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    requireById(id: string, opt?: CommonDaoOptions): Promise<BM>;
+    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<DBM>;
     private throwRequiredError;
     /**
      * Throws if readOnly is true
@@ -38,33 +36,31 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      */
     private requireObjectMutability;
     private ensureUniqueId;
-    getBy(by: keyof DBM, value: any, limit?: number, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    getOneBy(by: keyof DBM, value: any, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getAll(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    getBy(by: keyof DBM, value: any, limit?: number, opt?: CommonDaoOptions): Promise<BM[]>;
+    getOneBy(by: keyof DBM, value: any, opt?: CommonDaoOptions): Promise<BM | null>;
+    getAll(opt?: CommonDaoOptions): Promise<BM[]>;
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM, TM>;
-    runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    query(table?: string): RunnableDBQuery<BM, DBM>;
+    runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
      * Convenience method that runs multiple queries in parallel and then merges their results together.
      * Does deduplication by id.
      * Order is not guaranteed, as queries run in parallel.
      */
-    runUnionQueries(queries: DBQuery<DBM>[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    runQueryExtended(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
-    runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
-    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<DBM>>>;
-    runQueryAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<TM[]>;
-    runQueryExtendedAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
+    runUnionQueries(queries: DBQuery<DBM>[], opt?: CommonDaoOptions): Promise<BM[]>;
+    runQueryExtended(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<BM>>;
+    runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<DBM[]>;
+    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
     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<Saved<DBM>, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
+    streamQueryForEach(q: DBQuery<DBM>, mapper: AsyncMapper<BM, void>, opt?: CommonDaoStreamForEachOptions<BM>): Promise<void>;
+    streamQueryAsDBMForEach(q: DBQuery<DBM>, mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     /**
      * Stream as Readable, to be able to .pipe() it further with support of backpressure.
      */
-    streamQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<Saved<DBM>>;
+    streamQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM>;
     /**
      * Stream as Readable, to be able to .pipe() it further with support of backpressure.
      *
@@ -74,7 +70,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      *
      * You can do `.pipe(transformNoOp)` to make it "valid again".
      */
-    streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<Saved<BM>>): ReadableTyped<Saved<BM>>;
+    streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;
     queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<string[]>;
     streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<string>): ReadableTyped<string>;
     streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
@@ -86,7 +82,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     /**
      * Mutates with id, created, updated
      */
-    save(bm: UnsavedId<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
+    save(bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -95,7 +91,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Similar to `save` with skipIfEquals.
      * Similar to `patch`, but doesn't load the object from the Database.
      */
-    savePatch(bm: BM, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    savePatch(bm: BM, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Convenience method to replace 3 operations (loading+patching+saving) with one:
      *
@@ -105,25 +101,25 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * 2. Applies the patch on top of loaded data.
      * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
-    patchById(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patchById(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Like patchById, but runs all operations within a Transaction.
      */
-    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Same as patchById, but takes the whole object as input.
      * This "whole object" is mutated with the patch and returned.
      * Otherwise, similar behavior as patchById.
      * It still loads the row from the DB.
      */
-    patch(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patch(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Like patch, but runs all operations within a Transaction.
      */
-    patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveAsDBM(dbm: UnsavedId<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>>;
-    saveBatch(bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
-    saveBatchAsDBM(dbms: UnsavedId<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>[]>;
+    patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
+    saveAsDBM(dbm: Unsaved<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM>;
+    saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
+    saveBatchAsDBM(dbms: Unsaved<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM[]>;
     /**
      * "Streaming" is implemented by buffering incoming rows into **batches**
      * (of size opt.batchSize, which defaults to 500),
@@ -147,28 +143,25 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     updateByIds(ids: string[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(q: DBQuery<DBM>, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
-    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<BM>;
+    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<BM[]>;
     /**
      * Mutates object with properties: id, created, updated.
      * Returns DBM (new reference).
      */
     bmToDBM(bm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
-    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
-    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
+    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM>;
+    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<DBM[]>;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
-    anyToDBM(dbm?: any, opt?: CommonDaoOptions): Saved<DBM>;
-    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): Saved<DBM>[];
-    bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined;
-    bmToTM(bm?: BM, opt?: CommonDaoOptions): TM;
-    bmsToTM(bms: BM[], opt?: CommonDaoOptions): TM[];
+    anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
+    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): DBM[];
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).
      *
      * Does NOT mutate the object.
      */
-    validateAndConvert<T>(obj: Partial<T>, schema: ObjectSchema<T> | AjvSchema<T> | ZodSchema<T> | undefined, modelType: DBModelType, opt?: CommonDaoOptions): any;
+    validateAndConvert<T>(obj: Partial<T>, schema: ObjectSchema<T> | AjvSchema<T> | ZodSchema<T> | undefined, modelType?: DBModelType, opt?: CommonDaoOptions): any;
     getTableSchema(): Promise<JsonSchemaRootObject<DBM>>;
     createTable(schema: JsonSchemaObject<DBM>, opt?: CommonDaoCreateOptions): Promise<void>;
     /**
@@ -199,10 +192,10 @@ export declare class CommonDaoTransaction {
      * Perform a graceful rollback without throwing/re-throwing any error.
      */
     rollback(): Promise<void>;
-    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bm: UnsavedId<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
+    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
+    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
     deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
 }

package/dist/commondao/common.dao.js

@@ -36,7 +36,6 @@ class CommonDao {
                 beforeDBMValidate: dbm => dbm,
                 beforeDBMToBM: dbm => dbm,
                 beforeBMToDBM: bm => bm,
-                beforeBMToTM: bm => bm,
                 anonymize: dbm => dbm,
                 onValidationError: err => err,
                 ...cfg.hooks,
@@ -99,25 +98,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);
-        let [dbm] = await (opt.tx || this.cfg.db).getByIds(table, [id]);
-        if (dbm && !opt.raw && this.cfg.hooks.afterLoad) {
-            dbm = (await this.cfg.hooks.afterLoad(dbm)) || undefined;
-        }
-        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 = {}) {
         if (!ids.length)
             return [];
@@ -265,26 +245,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);
-        let { rows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
-        if (!opt.raw && this.cfg.hooks.afterLoad && rows.length) {
-            rows = (await (0, js_lib_1.pMap)(rows, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
-        }
-        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()})`;
@@ -419,7 +379,7 @@ class CommonDao {
         return (stream
             // optimization: 1 validation is enough
             // .pipe(transformMap<any, DBM>(dbm => this.anyToDBM(dbm, opt), safeOpt))
-            // .pipe(transformMap<DBM, Saved<BM>>(dbm => this.dbmToBM(dbm, opt), safeOpt))
+            // .pipe(transformMap<DBM, BM>(dbm => this.dbmToBM(dbm, opt), safeOpt))
             .on('error', err => stream.emit('error', err))
             .pipe((0, nodejs_lib_1.transformMap)(async (dbm) => {
             if (this.cfg.hooks.afterLoad) {
@@ -922,22 +882,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));
-    }
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).
@@ -1117,7 +1061,7 @@ class CommonDaoTransaction {
     //   dao: CommonDao<BM, DBM, any>,
     //   q: DBQuery<DBM>,
     //   opt?: CommonDaoOptions,
-    // ): Promise<Saved<BM>[]> {
+    // ): Promise<BM[]> {
     //   try {
     //     return await dao.runQuery(q, { ...opt, tx: this.tx })
     //   } catch (err) {

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

@@ -1,8 +1,8 @@
-import { AnyObject, BaseDBEntity, CommonLogger, ErrorMode, Promisable, Saved, ZodError, ZodSchema } from '@naturalcycles/js-lib';
+import { BaseDBEntity, CommonLogger, ErrorMode, Promisable, ZodError, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchema, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, TM> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity> {
     /**
      * Allows to override the id generation function.
      * By default it uses `stringId` from nodejs-lib
@@ -40,7 +40,6 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
     beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>;
     beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
     beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
-    beforeBMToTM: (bm: BM) => Partial<TM>;
     /**
      * Allows to access the DBM just after it has been loaded from the DB.
      *
@@ -53,7 +52,7 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    afterLoad?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>;
+    afterLoad?: (dbm: DBM) => Promisable<DBM | null>;
     /**
      * Allows to access the DBM just before it's supposed to be saved to the DB.
      *
@@ -67,7 +66,7 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    beforeSave?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>;
+    beforeSave?: (dbm: DBM) => Promisable<DBM | null>;
     /**
      * Called in:
      * - dbmToBM (applied before DBM becomes BM)
@@ -104,7 +103,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
+export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     db: CommonDB;
     table: string;
     /**
@@ -112,7 +111,6 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
      */
     dbmSchema?: ObjectSchema<DBM> | AjvSchema<DBM> | ZodSchema<DBM>;
     bmSchema?: ObjectSchema<BM> | AjvSchema<BM> | ZodSchema<BM>;
-    tmSchema?: ObjectSchema<TM> | AjvSchema<TM> | ZodSchema<TM>;
     excludeFromIndexes?: (keyof DBM)[];
     /**
      * Defaults to false.
@@ -141,7 +139,7 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * @default false
      */
     logStarted?: boolean;
-    hooks?: Partial<CommonDaoHooks<BM, DBM, TM>>;
+    hooks?: Partial<CommonDaoHooks<BM, DBM>>;
     /**
      * Defaults to true.
      * Set to false to disable auto-generation of `id`.

package/dist/db.model.d.ts

@@ -94,8 +94,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 = DBModelType = {}));
 /**
  * Allows to construct a query similar to:

package/dist/query/dbQuery.d.ts

@@ -1,4 +1,4 @@
-import { AsyncMapper, Saved, AnyObject, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib';
+import { AsyncMapper, BaseDBEntity, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
 import { CommonDao } from '../commondao/common.dao';
@@ -84,25 +84,23 @@ export declare class DBQuery<ROW extends ObjectWithId> {
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> extends DBQuery<DBM> {
-    dao: CommonDao<BM, DBM, TM>;
+export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> extends DBQuery<DBM> {
+    dao: CommonDao<BM, DBM>;
     /**
      * Pass `table` to override table.
      */
-    constructor(dao: CommonDao<BM, DBM, TM>, table?: string);
-    runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    constructor(dao: CommonDao<BM, DBM>, table?: string);
+    runQuery(opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
-    runQueryAsDBM(opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
-    runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]>;
-    runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
-    runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<DBM>>>;
-    runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
+    runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
+    runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<BM>>;
+    runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
     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>;
-    streamQueryAsDBMForEach(mapper: AsyncMapper<Saved<DBM>, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
-    streamQuery(opt?: CommonDaoStreamOptions<Saved<BM>>): ReadableTyped<Saved<BM>>;
-    streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<Saved<DBM>>;
+    streamQueryForEach(mapper: AsyncMapper<BM, void>, opt?: CommonDaoStreamForEachOptions<BM>): Promise<void>;
+    streamQueryAsDBMForEach(mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
+    streamQuery(opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;
+    streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM>;
     queryIds(opt?: CommonDaoOptions): Promise<string[]>;
     streamQueryIds(opt?: CommonDaoStreamOptions<string>): ReadableTyped<string>;
     streamQueryIdsForEach(mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): 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

@@ -15,7 +15,6 @@ function runCommonDaoTest(db, 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/dist/testing/test.model.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { BaseDBEntity, Saved, JsonSchemaObject } from '@naturalcycles/js-lib';
+import { BaseDBEntity, JsonSchemaObject } from '@naturalcycles/js-lib';
 export declare const TEST_TABLE = "TEST_TABLE";
 export interface TestItemBM extends BaseDBEntity {
     k1: string;
@@ -19,7 +19,7 @@ export declare const testItemDBMSchema: import("joi").ObjectSchema<TestItemDBM>;
 export declare const testItemTMSchema: import("joi").ObjectSchema<TestItemTM>;
 export declare const testItemBMJsonSchema: JsonSchemaObject<TestItemBM>;
 export declare const testItemDBMJsonSchema: JsonSchemaObject<TestItemDBM>;
-export declare function createTestItemDBM(num?: number): Saved<TestItemDBM>;
-export declare function createTestItemBM(num?: number): Saved<TestItemBM>;
-export declare function createTestItemsDBM(count?: number): Saved<TestItemDBM>[];
-export declare function createTestItemsBM(count?: number): Saved<TestItemBM>[];
+export declare function createTestItemDBM(num?: number): TestItemDBM;
+export declare function createTestItemBM(num?: number): TestItemBM;
+export declare function createTestItemsDBM(count?: number): TestItemDBM[];
+export declare function createTestItemsBM(count?: number): TestItemBM[];

package/dist/testing/test.model.js

@@ -25,7 +25,10 @@ exports.testItemTMSchema = (0, nodejs_lib_1.objectSchema)({
 });
 exports.testItemBMJsonSchema = js_lib_1.jsonSchema
     .rootObject({
+    // todo: figure out how to not copy-paste these 3 fields
     id: js_lib_1.jsonSchema.string(), // todo: not strictly needed here
+    created: js_lib_1.jsonSchema.unixTimestamp(),
+    updated: js_lib_1.jsonSchema.unixTimestamp(),
     k1: js_lib_1.jsonSchema.string(),
     k2: js_lib_1.jsonSchema.oneOf([js_lib_1.jsonSchema.string(), js_lib_1.jsonSchema.null()]).optional(),
     k3: js_lib_1.jsonSchema.number().optional(),

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "9.4.1",
+  "version": "9.5.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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

@@ -1,10 +1,8 @@
 import {
-  AnyObject,
   BaseDBEntity,
   CommonLogger,
   ErrorMode,
   Promisable,
-  Saved,
   ZodError,
   ZodSchema,
 } from '@naturalcycles/js-lib'
@@ -19,7 +17,7 @@ import {
 import { CommonDB } from '../common.db'
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model'
 
-export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, TM> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity> {
   /**
    * Allows to override the id generation function.
    * By default it uses `stringId` from nodejs-lib
@@ -62,7 +60,6 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
 
   beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
   beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>
-  beforeBMToTM: (bm: BM) => Partial<TM>
 
   /**
    * Allows to access the DBM just after it has been loaded from the DB.
@@ -76,7 +73,7 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
    *
    * You can do validations as needed here and throw errors, they will be propagated.
    */
-  afterLoad?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>
+  afterLoad?: (dbm: DBM) => Promisable<DBM | null>
 
   /**
    * Allows to access the DBM just before it's supposed to be saved to the DB.
@@ -91,7 +88,7 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
    *
    * You can do validations as needed here and throw errors, they will be propagated.
    */
-  beforeSave?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>
+  beforeSave?: (dbm: DBM) => Promisable<DBM | null>
 
   /**
    * Called in:
@@ -132,11 +129,7 @@ export enum CommonDaoLogLevel {
   DATA_FULL = 30,
 }
 
-export interface CommonDaoCfg<
-  BM extends BaseDBEntity,
-  DBM extends BaseDBEntity = BM,
-  TM extends AnyObject = BM,
-> {
+export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   db: CommonDB
   table: string
 
@@ -145,7 +138,6 @@ export interface CommonDaoCfg<
    */
   dbmSchema?: ObjectSchema<DBM> | AjvSchema<DBM> | ZodSchema<DBM>
   bmSchema?: ObjectSchema<BM> | AjvSchema<BM> | ZodSchema<BM>
-  tmSchema?: ObjectSchema<TM> | AjvSchema<TM> | ZodSchema<TM>
 
   excludeFromIndexes?: (keyof DBM)[]
 
@@ -182,7 +174,7 @@ export interface CommonDaoCfg<
   logStarted?: boolean
 
   // Hooks are designed with inspiration from got/ky interface
-  hooks?: Partial<CommonDaoHooks<BM, DBM, TM>>
+  hooks?: Partial<CommonDaoHooks<BM, DBM>>
 
   /**
    * Defaults to true.