@naturalcycles/db-lib 9.4.2 → 9.6.0

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, UnixTimestampMillisNumber, Unsaved, 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 { CommonDBTransactionOptions, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
 import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveBatchOptions, CommonDaoSaveOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoStreamSaveOptions } from './common.dao.model';
 /**
@@ -12,9 +12,9 @@ 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>);
+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<BM | null>;
@@ -22,8 +22,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     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<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<BM[]>;
     getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<DBM[]>;
     requireById(id: string, opt?: CommonDaoOptions): Promise<BM>;
@@ -44,7 +42,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM, TM>;
+    query(table?: string): RunnableDBQuery<BM, DBM>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
@@ -56,8 +54,6 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     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>>;
-    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<BM, void>, opt?: CommonDaoStreamForEachOptions<BM>): Promise<void>;
     streamQueryAsDBMForEach(q: DBQuery<DBM>, mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
@@ -159,16 +155,13 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     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?: BM, opt?: CommonDaoOptions): TM;
-    bmsToTM(bms: BM[], opt?: CommonDaoOptions): TM[];
     /**
      * 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, 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<BM | null>;
-    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
-    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
-    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<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

@@ -4,7 +4,6 @@ exports.CommonDaoTransaction = exports.CommonDao = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const cnst_1 = require("../cnst");
-const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
 const common_dao_model_1 = require("./common.dao.model");
 const isGAE = !!process.env['GAE_INSTANCE'];
@@ -33,10 +32,6 @@ class CommonDao {
             hooks: {
                 parseNaturalId: () => ({}),
                 beforeCreate: bm => bm,
-                beforeDBMValidate: dbm => dbm,
-                beforeDBMToBM: dbm => dbm,
-                beforeBMToDBM: bm => bm,
-                beforeBMToTM: bm => bm,
                 anonymize: dbm => dbm,
                 onValidationError: err => err,
                 ...cfg.hooks,
@@ -54,7 +49,7 @@ class CommonDao {
         const bm = this.cfg.hooks.beforeCreate(part);
         // First assignIdCreatedUpdated, then validate!
         this.assignIdCreatedUpdated(bm, opt);
-        return this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
+        return this.validateAndConvert(bm, this.cfg.bmSchema, opt);
     }
     async getById(id, opt = {}) {
         if (!id)
@@ -63,10 +58,10 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
         let dbm = (await (opt.tx || this.cfg.db).getByIds(table, [id]))[0];
-        if (dbm && !opt.raw && this.cfg.hooks.afterLoad) {
+        if (dbm && this.cfg.hooks.afterLoad) {
             dbm = (await this.cfg.hooks.afterLoad(dbm)) || undefined;
         }
-        const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
+        const bm = await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
         return bm || null;
     }
@@ -90,34 +85,13 @@ class CommonDao {
         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) {
+        if (dbm && this.cfg.hooks.afterLoad) {
             dbm = (await this.cfg.hooks.afterLoad(dbm)) || undefined;
         }
-        if (!opt.raw) {
-            dbm = this.anyToDBM(dbm, opt);
-        }
+        dbm = this.anyToDBM(dbm, opt);
         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 [];
@@ -125,10 +99,10 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
         let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids);
-        if (!opt.raw && this.cfg.hooks.afterLoad && dbms.length) {
+        if (this.cfg.hooks.afterLoad && dbms.length) {
             dbms = (await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
         }
-        const bms = opt.raw ? dbms : await this.dbmsToBM(dbms, opt);
+        const bms = await this.dbmsToBM(dbms, opt);
         this.logResult(started, op, bms, table);
         return bms;
     }
@@ -139,7 +113,7 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
         let dbms = await (opt.tx || this.cfg.db).getByIds(table, ids);
-        if (!opt.raw && this.cfg.hooks.afterLoad && dbms.length) {
+        if (this.cfg.hooks.afterLoad && dbms.length) {
             dbms = (await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.cfg.hooks.afterLoad(dbm))).filter(js_lib_1._isTruthy);
         }
         this.logResult(started, op, dbms, table);
@@ -238,10 +212,10 @@ class CommonDao {
         const started = this.logStarted(op, q.table);
         let { rows, ...queryResult } = await this.cfg.db.runQuery(q, opt);
         const partialQuery = !!q._selectedFieldNames;
-        if (!opt.raw && this.cfg.hooks.afterLoad && rows.length) {
+        if (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 bms = partialQuery || opt.raw ? rows : await this.dbmsToBM(rows, opt);
+        const bms = partialQuery ? rows : await this.dbmsToBM(rows, opt);
         this.logResult(started, op, bms, q.table);
         return {
             rows: bms,
@@ -257,34 +231,14 @@ class CommonDao {
         const op = `runQueryAsDBM(${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) {
+        if (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 dbms = partialQuery || opt.raw ? rows : this.anyToDBMs(rows, opt);
+        const dbms = partialQuery ? rows : this.anyToDBMs(rows, opt);
         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()})`;
@@ -308,7 +262,7 @@ class CommonDao {
             this.cfg.db.streamQuery(q, opt),
             (0, nodejs_lib_1.transformMap)(async (dbm) => {
                 count++;
-                if (partialQuery || opt.raw)
+                if (partialQuery)
                     return dbm;
                 if (this.cfg.hooks.afterLoad) {
                     dbm = (await this.cfg.hooks.afterLoad(dbm));
@@ -347,7 +301,7 @@ class CommonDao {
             this.cfg.db.streamQuery(q, opt),
             (0, nodejs_lib_1.transformMap)(async (dbm) => {
                 count++;
-                if (partialQuery || opt.raw)
+                if (partialQuery)
                     return dbm;
                 if (this.cfg.hooks.afterLoad) {
                     dbm = (await this.cfg.hooks.afterLoad(dbm));
@@ -383,7 +337,7 @@ class CommonDao {
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
         const partialQuery = !!q._selectedFieldNames;
         const stream = this.cfg.db.streamQuery(q, opt);
-        if (partialQuery || opt.raw)
+        if (partialQuery)
             return stream;
         return stream
             .on('error', err => stream.emit('error', err))
@@ -414,7 +368,7 @@ class CommonDao {
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
         const stream = this.cfg.db.streamQuery(q, opt);
         const partialQuery = !!q._selectedFieldNames;
-        if (partialQuery || opt.raw)
+        if (partialQuery)
             return stream;
         return (stream
             // optimization: 1 validation is enough
@@ -509,7 +463,7 @@ class CommonDao {
         const idWasGenerated = !bm.id && this.cfg.generateId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
         (0, js_lib_1._typeCast)(bm);
-        let dbm = await this.bmToDBM(bm, opt);
+        let dbm = await this.bmToDBM(bm, opt); // validates BM
         if (this.cfg.hooks.beforeSave) {
             dbm = (await this.cfg.hooks.beforeSave(dbm));
             if (dbm === null)
@@ -636,14 +590,11 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         // assigning id in case it misses the id
         // will override/set `updated` field, unless opts.preserveUpdated is set
-        let row = dbm;
-        if (!opt.raw) {
-            const idWasGenerated = !dbm.id && this.cfg.generateId;
-            this.assignIdCreatedUpdated(dbm, opt); // mutates
-            row = this.anyToDBM(dbm, opt);
-            if (opt.ensureUniqueId && idWasGenerated)
-                await this.ensureUniqueId(table, row);
-        }
+        const idWasGenerated = !dbm.id && this.cfg.generateId;
+        this.assignIdCreatedUpdated(dbm, opt); // mutates
+        let row = this.anyToDBM(dbm, opt);
+        if (opt.ensureUniqueId && idWasGenerated)
+            await this.ensureUniqueId(table, row);
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
@@ -705,13 +656,10 @@ class CommonDao {
             return [];
         this.requireWriteAccess();
         const table = opt.table || this.cfg.table;
-        let rows = dbms;
-        if (!opt.raw) {
-            dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)); // mutates
-            rows = this.anyToDBMs(dbms, opt);
-            if (opt.ensureUniqueId)
-                throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
-        }
+        dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)); // mutates
+        let rows = this.anyToDBMs(dbms, opt);
+        if (opt.ensureUniqueId)
+            throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
@@ -882,9 +830,15 @@ class CommonDao {
             dbm = this.cfg.hooks.anonymize(dbm);
         }
         // DBM > BM
-        const bm = await this.cfg.hooks.beforeDBMToBM(dbm);
+        let bm;
+        if (this.cfg.hooks.beforeDBMToBM) {
+            bm = await this.cfg.hooks.beforeDBMToBM(dbm);
+        }
+        else {
+            bm = dbm;
+        }
         // Validate/convert BM
-        return this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
+        return this.validateAndConvert(bm, this.cfg.bmSchema, opt);
     }
     async dbmsToBM(dbms, opt = {}) {
         return await (0, js_lib_1.pMap)(dbms, async (dbm) => await this.dbmToBM(dbm, opt));
@@ -892,16 +846,21 @@ class CommonDao {
     async bmToDBM(bm, opt) {
         if (bm === undefined)
             return;
-        // optimization: no need to run the BM validation, since DBM will be validated anyway
-        // Validate/convert BM
-        // bm gets assigned to the new reference
-        // bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
         // should not do it on load, but only on save!
         // this.assignIdCreatedUpdated(bm, opt)
+        // bm gets assigned to the new reference
+        bm = this.validateAndConvert(bm, this.cfg.bmSchema, opt);
         // BM > DBM
-        const dbm = { ...(await this.cfg.hooks.beforeBMToDBM(bm)) };
+        let dbm;
+        if (this.cfg.hooks.beforeBMToDBM) {
+            dbm = { ...(await this.cfg.hooks.beforeBMToDBM(bm)) };
+        }
+        else {
+            dbm = bm;
+        }
         // Validate/convert DBM
-        return this.validateAndConvert(dbm, this.cfg.dbmSchema, db_model_1.DBModelType.DBM, opt);
+        // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
+        return dbm;
     }
     async bmsToDBM(bms, opt = {}) {
         // try/catch?
@@ -913,41 +872,25 @@ class CommonDao {
         // this shouldn't be happening on load! but should on save!
         // this.assignIdCreatedUpdated(dbm, opt)
         dbm = { ...dbm, ...this.cfg.hooks.parseNaturalId(dbm.id) };
+        // todo: is this the right place?
+        // todo: is anyToDBM even needed?
         if (opt.anonymize) {
             dbm = this.cfg.hooks.anonymize(dbm);
         }
         // Validate/convert DBM
-        return this.validateAndConvert(dbm, this.cfg.dbmSchema, db_model_1.DBModelType.DBM, opt);
+        // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
+        return dbm;
     }
     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).
      *
      * Does NOT mutate the object.
      */
-    validateAndConvert(obj, schema, modelType, opt = {}) {
-        // `raw` option completely bypasses any processing
-        if (opt.raw)
-            return obj;
+    validateAndConvert(obj, schema, opt = {}) {
         // Kirill 2021-10-18: I realized that there's little reason to keep removing null values
         // So, from now on we'll preserve them
         // "undefined" values, I believe, are/were not saved to/from DB anyway (due to e.g JSON.stringify removing them)
@@ -957,23 +900,14 @@ class CommonDao {
         // obj = _filterNullishValues(obj as any)
         // We still filter `undefined` values here, because `beforeDBMToBM` can return undefined values
         // and they can be annoying with snapshot tests
-        if (this.cfg.filterNullishValues) {
-            obj = (0, js_lib_1._filterNullishValues)(obj);
-        }
-        else {
-            obj = (0, js_lib_1._filterUndefinedValues)(obj);
-        }
-        // Pre-validation hooks
-        if (modelType === db_model_1.DBModelType.DBM) {
-            obj = this.cfg.hooks.beforeDBMValidate(obj);
-        }
+        obj = (0, js_lib_1._filterUndefinedValues)(obj);
         // Return as is if no schema is passed or if `skipConversion` is set
         if (!schema || opt.skipConversion) {
             return obj;
         }
         // This will Convert and Validate
         const table = opt.table || this.cfg.table;
-        const objectName = table + (modelType || '');
+        const objectName = table;
         let error;
         let convertedValue;
         if (schema instanceof js_lib_1.ZodSchema) {

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

@@ -1,8 +1,8 @@
-import { AnyObject, BaseDBEntity, CommonLogger, ErrorMode, Promisable, 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
@@ -28,19 +28,8 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
      * - patch, patchAsDBM
      */
     beforeCreate: (bm: Partial<BM>) => Partial<BM>;
-    /**
-     * Called when loading things "as DBM" and validation is not skipped.
-     * When loading things as BM/TM - other hooks get involved instead:
-     * - beforeDBMToBM
-     * - beforeBMToTM
-     *
-     * TODO: maybe rename those to `validateAs(model)`
-     * as it only validates "final state", not intermediate
-     */
-    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.
      *
@@ -104,15 +93,13 @@ 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;
     /**
      * Joi, AjvSchema or ZodSchema is supported.
      */
-    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 +128,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`.
@@ -163,16 +150,6 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Set to false to disable `updated` field management.
      */
     useUpdatedProperty?: boolean;
-    /**
-     * Default is false.
-     * If true - will run `_filterNullishValues` inside `validateAndConvert` function
-     * (instead of `_filterUndefinedValues`).
-     * This was the old db-lib behavior.
-     * This option allows to keep backwards-compatible behavior.
-     *
-     * @deprecated
-     */
-    filterNullishValues?: boolean;
     /**
      * Defaults to false.
      * If true - run patch operations (patch, patchById) in a Transaction.
@@ -200,15 +177,6 @@ export interface CommonDaoOptions extends CommonDBOptions {
      * @default false
      */
     skipConversion?: boolean;
-    /**
-     * If true - will SKIP ANY transformation/processing, will return DB objects as they are. Will also skip created/updated/id
-     * generation.
-     *
-     * Useful for performance/streaming/pipelines.
-     *
-     * @default false
-     */
-    raw?: boolean;
     /**
      * @default false
      */

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, 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,19 +84,17 @@ 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);
+    constructor(dao: CommonDao<BM, DBM>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
     runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
-    runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]>;
     runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<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<BM, void>, opt?: CommonDaoStreamForEachOptions<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,9 +13,7 @@ function runCommonDaoTest(db, quirks = {}) {
     const dao = new common_dao_1.CommonDao({
         table: test_model_1.TEST_TABLE,
         db,
-        dbmSchema: test_model_1.testItemDBMSchema,
         bmSchema: test_model_1.testItemBMSchema,
-        tmSchema: test_model_1.testItemTMSchema,
         logStarted: true,
         logLevel: __1.CommonDaoLogLevel.DATA_FULL,
     });
@@ -33,7 +31,7 @@ function runCommonDaoTest(db, quirks = {}) {
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await dao.createTable(test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
+            await dao.createTable(test_model_1.testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {

package/dist/testing/dbTest.js

@@ -20,7 +20,7 @@ function runCommonDBTest(db, quirks = {}) {
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
+            await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {

package/dist/testing/index.d.ts

@@ -1,6 +1,6 @@
 import { runCommonDaoTest } from './daoTest';
 import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest';
 import { runCommonKeyValueDBTest } from './keyValueDBTest';
-import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TestItemBM, testItemBMJsonSchema, testItemBMSchema, TestItemDBM, testItemDBMJsonSchema, testItemDBMSchema, TestItemTM, testItemTMSchema, TEST_TABLE } from './test.model';
+import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TestItemBM, testItemBMJsonSchema, testItemBMSchema, TestItemDBM, TestItemTM, testItemTMSchema, TEST_TABLE } from './test.model';
 export type { TestItemDBM, TestItemBM, TestItemTM, CommonDBImplementationQuirks };
-export { TEST_TABLE, createTestItemDBM, createTestItemBM, createTestItemsDBM, createTestItemsBM, testItemDBMSchema, testItemBMSchema, testItemTMSchema, testItemBMJsonSchema, testItemDBMJsonSchema, runCommonDBTest, runCommonDaoTest, runCommonKeyValueDBTest, };
+export { TEST_TABLE, createTestItemDBM, createTestItemBM, createTestItemsDBM, createTestItemsBM, testItemBMSchema, testItemTMSchema, testItemBMJsonSchema, runCommonDBTest, runCommonDaoTest, runCommonKeyValueDBTest, };

package/dist/testing/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommonKeyValueDBTest = exports.runCommonDaoTest = exports.runCommonDBTest = exports.testItemDBMJsonSchema = exports.testItemBMJsonSchema = exports.testItemTMSchema = exports.testItemBMSchema = exports.testItemDBMSchema = exports.createTestItemsBM = exports.createTestItemsDBM = exports.createTestItemBM = exports.createTestItemDBM = exports.TEST_TABLE = void 0;
+exports.runCommonKeyValueDBTest = exports.runCommonDaoTest = exports.runCommonDBTest = exports.testItemBMJsonSchema = exports.testItemTMSchema = exports.testItemBMSchema = exports.createTestItemsBM = exports.createTestItemsDBM = exports.createTestItemBM = exports.createTestItemDBM = exports.TEST_TABLE = void 0;
 const daoTest_1 = require("./daoTest");
 Object.defineProperty(exports, "runCommonDaoTest", { enumerable: true, get: function () { return daoTest_1.runCommonDaoTest; } });
 const dbTest_1 = require("./dbTest");
@@ -14,7 +14,5 @@ Object.defineProperty(exports, "createTestItemsBM", { enumerable: true, get: fun
 Object.defineProperty(exports, "createTestItemsDBM", { enumerable: true, get: function () { return test_model_1.createTestItemsDBM; } });
 Object.defineProperty(exports, "testItemBMJsonSchema", { enumerable: true, get: function () { return test_model_1.testItemBMJsonSchema; } });
 Object.defineProperty(exports, "testItemBMSchema", { enumerable: true, get: function () { return test_model_1.testItemBMSchema; } });
-Object.defineProperty(exports, "testItemDBMJsonSchema", { enumerable: true, get: function () { return test_model_1.testItemDBMJsonSchema; } });
-Object.defineProperty(exports, "testItemDBMSchema", { enumerable: true, get: function () { return test_model_1.testItemDBMSchema; } });
 Object.defineProperty(exports, "testItemTMSchema", { enumerable: true, get: function () { return test_model_1.testItemTMSchema; } });
 Object.defineProperty(exports, "TEST_TABLE", { enumerable: true, get: function () { return test_model_1.TEST_TABLE; } });