@naturalcycles/db-lib 9.4.2 → 9.6.0

package/dist/testing/test.model.d.ts

@@ -15,10 +15,8 @@ export interface TestItemTM {
     even?: boolean;
 }
 export declare const testItemBMSchema: import("joi").ObjectSchema<TestItemBM>;
-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): TestItemDBM;
 export declare function createTestItemBM(num?: number): TestItemBM;
 export declare function createTestItemsDBM(count?: number): TestItemDBM[];

package/dist/testing/test.model.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTestItemsBM = exports.createTestItemsDBM = exports.createTestItemBM = exports.createTestItemDBM = exports.testItemDBMJsonSchema = exports.testItemBMJsonSchema = exports.testItemTMSchema = exports.testItemDBMSchema = exports.testItemBMSchema = exports.TEST_TABLE = void 0;
+exports.createTestItemsBM = exports.createTestItemsDBM = exports.createTestItemBM = exports.createTestItemDBM = exports.testItemBMJsonSchema = exports.testItemTMSchema = exports.testItemBMSchema = exports.TEST_TABLE = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const MOCK_TS_2018_06_21 = 1529539200;
@@ -12,13 +12,6 @@ exports.testItemBMSchema = (0, nodejs_lib_1.objectSchema)({
     even: nodejs_lib_1.booleanSchema.optional(),
     b1: nodejs_lib_1.binarySchema.optional(),
 }).concat(nodejs_lib_1.baseDBEntitySchema);
-exports.testItemDBMSchema = (0, nodejs_lib_1.objectSchema)({
-    k1: nodejs_lib_1.stringSchema,
-    k2: nodejs_lib_1.stringSchema.allow(null).optional(),
-    k3: nodejs_lib_1.numberSchema.optional(),
-    even: nodejs_lib_1.booleanSchema.optional(),
-    b1: nodejs_lib_1.binarySchema.optional(),
-}).concat(nodejs_lib_1.baseDBEntitySchema);
 exports.testItemTMSchema = (0, nodejs_lib_1.objectSchema)({
     k1: nodejs_lib_1.stringSchema,
     even: nodejs_lib_1.booleanSchema.optional(),
@@ -37,19 +30,6 @@ exports.testItemBMJsonSchema = js_lib_1.jsonSchema
 })
     .baseDBEntity()
     .build();
-exports.testItemDBMJsonSchema = js_lib_1.jsonSchema
-    .rootObject({
-    // todo: figure out how to not copy-paste these 3 fields
-    id: js_lib_1.jsonSchema.string(),
-    created: js_lib_1.jsonSchema.unixTimestamp(),
-    updated: js_lib_1.jsonSchema.unixTimestamp(),
-    k1: js_lib_1.jsonSchema.string(),
-    k2: js_lib_1.jsonSchema.string().optional(),
-    k3: js_lib_1.jsonSchema.number().optional(),
-    even: js_lib_1.jsonSchema.boolean().optional(),
-    b1: js_lib_1.jsonSchema.buffer().optional(),
-})
-    .build();
 function createTestItemDBM(num = 1) {
     return {
         id: `id${num}`,

package/package.json

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

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

@@ -1,5 +1,4 @@
 import {
-  AnyObject,
   BaseDBEntity,
   CommonLogger,
   ErrorMode,
@@ -18,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
@@ -48,20 +47,8 @@ export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntit
    */
   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.
@@ -131,20 +118,14 @@ 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
 
   /**
    * 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)[]
 
@@ -181,7 +162,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.
@@ -208,17 +189,6 @@ export interface CommonDaoCfg<
    */
   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.
@@ -249,16 +219,6 @@ export interface CommonDaoOptions extends CommonDBOptions {
    */
   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/src/commondao/common.dao.ts

@@ -2,7 +2,6 @@ import { Transform } from 'node:stream'
 import {
   _assert,
   _deepJsonEquals,
-  _filterNullishValues,
   _filterUndefinedValues,
   _isTruthy,
   _objectAssignExact,
@@ -11,7 +10,6 @@ import {
   _truncate,
   _typeCast,
   _uniqBy,
-  AnyObject,
   AppError,
   AsyncMapper,
   BaseDBEntity,
@@ -44,13 +42,7 @@ import {
   writableVoid,
 } from '@naturalcycles/nodejs-lib'
 import { DBLibError } from '../cnst'
-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,
@@ -76,12 +68,8 @@ const isCI = !!process.env['CI']
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export class CommonDao<
-  BM extends BaseDBEntity,
-  DBM extends BaseDBEntity = BM,
-  TM extends AnyObject = BM,
-> {
-  constructor(public cfg: CommonDaoCfg<BM, DBM, TM>) {
+export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
+  constructor(public cfg: CommonDaoCfg<BM, DBM>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
@@ -96,14 +84,10 @@ export class CommonDao<
       hooks: {
         parseNaturalId: () => ({}),
         beforeCreate: bm => bm as BM,
-        beforeDBMValidate: dbm => dbm,
-        beforeDBMToBM: dbm => dbm as any,
-        beforeBMToDBM: bm => bm as any,
-        beforeBMToTM: bm => bm as any,
         anonymize: dbm => dbm,
         onValidationError: err => err,
         ...cfg.hooks,
-      } satisfies Partial<CommonDaoHooks<BM, DBM, TM>>,
+      } satisfies Partial<CommonDaoHooks<BM, DBM>>,
     }
 
     if (this.cfg.generateId) {
@@ -118,7 +102,7 @@ export class CommonDao<
     const bm = this.cfg.hooks!.beforeCreate!(part)
     // First assignIdCreatedUpdated, then validate!
     this.assignIdCreatedUpdated(bm, opt)
-    return this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
+    return this.validateAndConvert(bm, this.cfg.bmSchema, opt)
   }
 
   // GET
@@ -131,11 +115,11 @@ export class CommonDao<
     const started = this.logStarted(op, table)
 
     let dbm = (await (opt.tx || this.cfg.db).getByIds<DBM>(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 as any) : await this.dbmToBM(dbm, opt)
+    const bm = await this.dbmToBM(dbm, opt)
     this.logResult(started, op, bm, table)
     return bm || null
   }
@@ -167,52 +151,28 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
     let [dbm] = await (opt.tx || this.cfg.db).getByIds<DBM>(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: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsTM(id?: string | null, opt?: CommonDaoOptions): Promise<TM | null>
-  async getByIdAsTM(id?: string | 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)
-    let [dbm] = await (opt.tx || this.cfg.db).getByIds<DBM>(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 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: string[], opt: CommonDaoOptions = {}): Promise<BM[]> {
     if (!ids.length) return []
     const op = `getByIds ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
     let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids)
-    if (!opt.raw && this.cfg.hooks!.afterLoad && dbms.length) {
+    if (this.cfg.hooks!.afterLoad && dbms.length) {
       dbms = (await pMap(dbms, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _isTruthy,
       )
     }
 
-    const bms = opt.raw ? (dbms as any) : await this.dbmsToBM(dbms, opt)
+    const bms = await this.dbmsToBM(dbms, opt)
     this.logResult(started, op, bms, table)
     return bms
   }
@@ -223,7 +183,7 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
     let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids)
-    if (!opt.raw && this.cfg.hooks!.afterLoad && dbms.length) {
+    if (this.cfg.hooks!.afterLoad && dbms.length) {
       dbms = (await pMap(dbms, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _isTruthy,
       )
@@ -307,8 +267,8 @@ export class CommonDao<
   /**
    * Pass `table` to override table
    */
-  query(table?: string): RunnableDBQuery<BM, DBM, TM> {
-    return new RunnableDBQuery<BM, DBM, TM>(this, table)
+  query(table?: string): RunnableDBQuery<BM, DBM> {
+    return new RunnableDBQuery<BM, DBM>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]> {
@@ -346,13 +306,13 @@ export class CommonDao<
     const started = this.logStarted(op, q.table)
     let { rows, ...queryResult } = await this.cfg.db.runQuery<DBM>(q, opt)
     const partialQuery = !!q._selectedFieldNames
-    if (!opt.raw && this.cfg.hooks!.afterLoad && rows.length) {
+    if (this.cfg.hooks!.afterLoad && rows.length) {
       rows = (await pMap(rows, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _isTruthy,
       )
     }
 
-    const bms = partialQuery || opt.raw ? (rows as any[]) : await this.dbmsToBM(rows, opt)
+    const bms = partialQuery ? (rows as any[]) : await this.dbmsToBM(rows, opt)
     this.logResult(started, op, bms, q.table)
     return {
       rows: bms,
@@ -373,47 +333,18 @@ export class CommonDao<
     const op = `runQueryAsDBM(${q.pretty()})`
     const started = this.logStarted(op, q.table)
     let { rows, ...queryResult } = await this.cfg.db.runQuery<DBM>(q, opt)
-    if (!opt.raw && this.cfg.hooks!.afterLoad && rows.length) {
+    if (this.cfg.hooks!.afterLoad && rows.length) {
       rows = (await pMap(rows, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _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: 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)
-    let { rows, ...queryResult } = await this.cfg.db.runQuery<DBM>(q, opt)
-    if (!opt.raw && this.cfg.hooks!.afterLoad && rows.length) {
-      rows = (await pMap(rows, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
-        _isTruthy,
-      )
-    }
-
-    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()})`
@@ -445,7 +376,7 @@ export class CommonDao<
       transformMap<DBM, BM>(
         async dbm => {
           count++
-          if (partialQuery || opt.raw) return dbm as any
+          if (partialQuery) return dbm as any
 
           if (this.cfg.hooks!.afterLoad) {
             dbm = (await this.cfg.hooks!.afterLoad(dbm))!
@@ -495,7 +426,7 @@ export class CommonDao<
       transformMap<any, DBM>(
         async dbm => {
           count++
-          if (partialQuery || opt.raw) return dbm
+          if (partialQuery) return dbm
 
           if (this.cfg.hooks!.afterLoad) {
             dbm = (await this.cfg.hooks!.afterLoad(dbm))!
@@ -537,7 +468,7 @@ export class CommonDao<
     const partialQuery = !!q._selectedFieldNames
 
     const stream = this.cfg.db.streamQuery<DBM>(q, opt)
-    if (partialQuery || opt.raw) return stream
+    if (partialQuery) return stream
 
     return stream
       .on('error', err => stream.emit('error', err))
@@ -575,7 +506,7 @@ export class CommonDao<
 
     const stream = this.cfg.db.streamQuery<DBM>(q, opt)
     const partialQuery = !!q._selectedFieldNames
-    if (partialQuery || opt.raw) return stream
+    if (partialQuery) return stream
 
     return (
       stream
@@ -698,7 +629,7 @@ export class CommonDao<
     const idWasGenerated = !bm.id && this.cfg.generateId
     this.assignIdCreatedUpdated(bm, opt) // mutates
     _typeCast<BM>(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))!
@@ -857,13 +788,11 @@ export class CommonDao<
 
     // assigning id in case it misses the id
     // will override/set `updated` field, unless opts.preserveUpdated is set
-    let row = dbm as 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' }
     }
@@ -942,12 +871,10 @@ export class CommonDao<
     if (!dbms.length) return []
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
-    let rows = dbms as DBM[]
-    if (!opt.raw) {
-      dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)) // mutates
-      rows = this.anyToDBMs(dbms as DBM[], opt)
-      if (opt.ensureUniqueId) throw new AppError('ensureUniqueId is not supported in saveBatch')
-    }
+    dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)) // mutates
+    let rows = this.anyToDBMs(dbms as DBM[], opt)
+    if (opt.ensureUniqueId) throw new AppError('ensureUniqueId is not supported in saveBatch')
+
     if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
       opt = { ...opt, saveMethod: 'insert' }
     }
@@ -1176,11 +1103,16 @@ export class CommonDao<
     }
 
     // DBM > BM
-    const bm = await this.cfg.hooks!.beforeDBMToBM!(dbm)
+    let bm: Partial<BM>
+    if (this.cfg.hooks!.beforeDBMToBM) {
+      bm = await this.cfg.hooks!.beforeDBMToBM(dbm)
+    } else {
+      bm = dbm as any
+    }
 
     // Validate/convert BM
 
-    return this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
+    return this.validateAndConvert(bm, this.cfg.bmSchema, opt)
   }
 
   async dbmsToBM(dbms: DBM[], opt: CommonDaoOptions = {}): Promise<BM[]> {
@@ -1196,20 +1128,23 @@ export class CommonDao<
   async bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM | undefined> {
     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: DBM
+    if (this.cfg.hooks!.beforeBMToDBM) {
+      dbm = { ...((await this.cfg.hooks!.beforeBMToDBM(bm!)) as DBM) }
+    } else {
+      dbm = bm as any
+    }
 
     // Validate/convert DBM
-
-    return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
+    // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
+    return dbm
   }
 
   async bmsToDBM(bms: BM[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
@@ -1227,40 +1162,21 @@ export class CommonDao<
 
     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, DBModelType.DBM, opt)
+    // return this.validateAndConvert(dbm, this.cfg.dbmSchema, DBModelType.DBM, opt)
+    return dbm
   }
 
   anyToDBMs(entities: DBM[], opt: CommonDaoOptions = {}): DBM[] {
     return entities.map(entity => this.anyToDBM(entity, opt))
   }
 
-  bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined
-  bmToTM(bm?: BM, opt?: CommonDaoOptions): TM
-  bmToTM(bm?: 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)
-
-    // Validate/convert DBM
-    return this.validateAndConvert(tm, this.cfg.tmSchema, DBModelType.TM, opt)
-  }
-
-  bmsToTM(bms: BM[], opt: CommonDaoOptions = {}): TM[] {
-    // try/catch?
-    return bms.map(bm => this.bmToTM(bm, opt))
-  }
-
   /**
    * Returns *converted value*.
    * Validates (unless `skipValidation=true` passed).
@@ -1270,12 +1186,8 @@ export class CommonDao<
   validateAndConvert<T>(
     obj: Partial<T>,
     schema: ObjectSchema<T> | AjvSchema<T> | ZodSchema<T> | undefined,
-    modelType: DBModelType,
     opt: CommonDaoOptions = {},
   ): any {
-    // `raw` option completely bypasses any processing
-    if (opt.raw) return obj as any
-
     // 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)
@@ -1285,16 +1197,7 @@ export 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 = _filterNullishValues(obj)
-    } else {
-      obj = _filterUndefinedValues(obj)
-    }
-
-    // Pre-validation hooks
-    if (modelType === DBModelType.DBM) {
-      obj = this.cfg.hooks!.beforeDBMValidate!(obj as any) as T
-    }
+    obj = _filterUndefinedValues(obj)
 
     // Return as is if no schema is passed or if `skipConversion` is set
     if (!schema || opt.skipConversion) {
@@ -1303,7 +1206,7 @@ export class CommonDao<
 
     // This will Convert and Validate
     const table = opt.table || this.cfg.table
-    const objectName = table + (modelType || '')
+    const objectName = table
 
     let error: JoiValidationError | AjvValidationError | ZodValidationError<T> | undefined
     let convertedValue: any
@@ -1460,7 +1363,7 @@ export class CommonDaoTransaction {
   }
 
   async getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM, any>,
+    dao: CommonDao<BM, DBM>,
     id?: string | null,
     opt?: CommonDaoOptions,
   ): Promise<BM | null> {
@@ -1468,7 +1371,7 @@ export class CommonDaoTransaction {
   }
 
   async getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM, any>,
+    dao: CommonDao<BM, DBM>,
     ids: string[],
     opt?: CommonDaoOptions,
   ): Promise<BM[]> {
@@ -1490,7 +1393,7 @@ export class CommonDaoTransaction {
   // }
 
   async save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM, any>,
+    dao: CommonDao<BM, DBM>,
     bm: Unsaved<BM>,
     opt?: CommonDaoSaveBatchOptions<DBM>,
   ): Promise<BM> {
@@ -1498,7 +1401,7 @@ export class CommonDaoTransaction {
   }
 
   async saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM, any>,
+    dao: CommonDao<BM, DBM>,
     bms: Unsaved<BM>[],
     opt?: CommonDaoSaveBatchOptions<DBM>,
   ): Promise<BM[]> {

package/src/db.model.ts

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

package/src/query/dbQuery.ts

@@ -1,7 +1,6 @@
 import {
   AsyncMapper,
   _truncate,
-  AnyObject,
   _objectAssign,
   BaseDBEntity,
   ObjectWithId,
@@ -238,13 +237,12 @@ export class DBQuery<ROW extends ObjectWithId> {
 export class RunnableDBQuery<
   BM extends BaseDBEntity,
   DBM extends BaseDBEntity = BM,
-  TM extends AnyObject = BM,
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.
    */
   constructor(
-    public dao: CommonDao<BM, DBM, TM>,
+    public dao: CommonDao<BM, DBM>,
     table?: string,
   ) {
     super(table || dao.cfg.table)
@@ -262,10 +260,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<BM>> {
     return await this.dao.runQueryExtended(this, opt)
   }
@@ -274,10 +268,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)
   }