@naturalcycles/db-lib 8.50.2 → 8.51.0

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

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

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 Partial<ObjectWithId>>(
+  override async getByIds<ROW extends 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: ObjectWithId[] = await this.loadFile(table)
+        const rows = 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 Partial<ObjectWithId>>(
+  override async runQuery<ROW extends 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 Partial<ObjectWithId>>(
+  override async runQueryCount<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
     return (await this.loadFile(q.table)).length
   }
 
-  override streamQuery<ROW extends Partial<ObjectWithId>>(
+  override streamQuery<ROW extends 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 Partial<ObjectWithId>>(
+  override async deleteByQuery<ROW extends 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 Partial<ObjectWithId>>(
+  override async getTableSchema<ROW extends 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 Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends 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 Partial<ObjectWithId>>(table: string, _rows: ROW[]): Promise<void> {
+  async saveFile<ROW extends 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 Partial<ObjectWithId>>(rows: ROW[]): ROW[] {
+  private sortRows<ROW extends 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 Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends 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 Partial<ObjectWithId>>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends 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 Partial<ObjectWithId>>(_table: string): Promise<ROW[]> {
+  async loadFile<ROW extends 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 Partial<ObjectWithId>>(
+  async getTableSchema<ROW extends 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 Partial<ObjectWithId>>(
+  async createTable<ROW extends ObjectWithId>(
     _table: string,
     _schema: JsonSchemaObject<ROW>,
     opt: CommonDBCreateOptions = {},
@@ -143,14 +143,14 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async getByIds<ROW extends Partial<ObjectWithId>>(
+  async getByIds<ROW extends 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 Partial<ObjectWithId>>(
+  async deleteByQuery<ROW extends 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 Partial<ObjectWithId>>(
+  async updateByQuery<ROW extends 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 Partial<ObjectWithId>>(
+  async runQuery<ROW extends 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 Partial<ObjectWithId>>(
+  async runQueryCount<ROW extends 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 Partial<ObjectWithId>>(
+  streamQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): ReadableTyped<ROW> {

package/src/adapter/inmemory/queryInMemory.ts

@@ -18,10 +18,7 @@ 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 Partial<ObjectWithId>>(
-  q: DBQuery<ROW>,
-  rows: ROW[] = [],
-): ROW[] {
+export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: ROW[] = []): ROW[] {
   // .filter
   // eslint-disable-next-line unicorn/no-array-reduce
   rows = q._filters.reduce((rows, filter) => {

package/src/common.db.ts

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

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

@@ -1,4 +1,11 @@
-import { CommonLogger, ErrorMode, ObjectWithId } from '@naturalcycles/js-lib'
+import {
+  CommonLogger,
+  ErrorMode,
+  ObjectWithId,
+  Saved,
+  ZodError,
+  ZodSchema,
+} from '@naturalcycles/js-lib'
 import {
   AjvSchema,
   AjvValidationError,
@@ -12,25 +19,24 @@ import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../
 
 export interface CommonDaoHooks<
   BM extends Partial<ObjectWithId<ID>>,
-  DBM extends Partial<ObjectWithId<ID>> = BM,
-  ID extends string | number = NonNullable<BM['id']>,
+  DBM extends ObjectWithId<ID>,
+  TM,
+  ID extends string | number,
 > {
-  createRandomId(): ID
+  createRandomId: () => ID
   /**
    * createNaturalId hook is called (tried) first.
    * If it doesn't exist - createRandomId is called.
    */
-  createNaturalId(obj: DBM | BM): ID
-  parseNaturalId(id: ID): Partial<DBM>
-  beforeCreate(bm: Partial<BM>): Partial<BM>
-  beforeDBMValidate(dbm: Partial<DBM>): Partial<DBM>
-  beforeDBMToBM(dbm: DBM): Partial<BM> | Promise<Partial<BM>>
-  beforeBMToDBM(bm: BM): Partial<DBM> | Promise<Partial<DBM>>
-
-  /**
-   * Applicable to **read** operations, never to **save** operations.
-   */
-  anonymize(dbm: DBM): DBM
+  createNaturalId: (obj: DBM | BM) => ID
+  parseNaturalId: (id: ID) => Partial<DBM>
+  beforeCreate: (bm: Partial<BM>) => Partial<BM>
+  beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>
+  beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
+  beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>
+  beforeTMToBM: (tm: TM) => Partial<BM>
+  beforeBMToTM: (bm: BM) => Partial<TM>
+  anonymize: (dbm: DBM) => DBM
 
   /**
    * If hook is defined - allows to prevent or modify the error thrown.
@@ -38,7 +44,7 @@ export interface CommonDaoHooks<
    * Return original `err` to pass the error through (will be thrown in CommonDao).
    * Return modified/new `Error` if needed.
    */
-  onValidationError(err: JoiValidationError | AjvValidationError): Error | false
+  onValidationError: (err: JoiValidationError | AjvValidationError | ZodError) => Error | false
 }
 
 export enum CommonDaoLogLevel {
@@ -61,18 +67,20 @@ export enum CommonDaoLogLevel {
 }
 
 export interface CommonDaoCfg<
-  BM extends ObjectWithId<ID>,
-  DBM extends ObjectWithId<ID> = BM,
-  ID extends string | number = BM['id'],
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID> = Saved<BM>,
+  TM = BM,
+  ID extends string | number = string,
 > {
   db: CommonDB
   table: string
 
   /**
-   * Joi or AjvSchema are supported.
+   * Joi, AjvSchema or ZodSchema is supported.
    */
-  dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM>
-  bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>
+  dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM> | ZodSchema<DBM>
+  bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM> | ZodSchema<BM>
+  tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM> | ZodSchema<TM>
 
   excludeFromIndexes?: (keyof DBM)[]
 
@@ -84,8 +92,6 @@ 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
 
@@ -111,7 +117,7 @@ export interface CommonDaoCfg<
   logStarted?: boolean
 
   // Hooks are designed with inspiration from got/ky interface
-  hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>
+  hooks?: Partial<CommonDaoHooks<BM, DBM, TM, ID>>
 
   /**
    * Defaults to 'string'
@@ -128,7 +134,6 @@ 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
 
@@ -226,7 +231,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions<DBM extends Partial<ObjectWithId>>
+export interface CommonDaoSaveOptions<DBM extends ObjectWithId>
   extends CommonDaoOptions,
     CommonDBSaveOptions<DBM> {
   /**

package/src/commondao/common.dao.ts

@@ -6,6 +6,7 @@ import {
   _since,
   _truncate,
   _uniqBy,
+  AnyObject,
   AppError,
   AsyncMapper,
   ErrorMode,
@@ -15,6 +16,9 @@ import {
   pMap,
   Saved,
   Unsaved,
+  ZodSchema,
+  ZodValidationError,
+  zSafeValidate,
 } from '@naturalcycles/js-lib'
 import {
   _pipeline,
@@ -62,13 +66,15 @@ 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 ObjectWithId<ID>,
-  DBM extends ObjectWithId<ID> = BM,
-  ID extends string | number = BM['id'],
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID> = Saved<BM>,
+  TM extends AnyObject = BM,
+  ID extends string | number = NonNullable<BM['id']>,
 > {
-  constructor(public cfg: CommonDaoCfg<BM, DBM, ID>) {
+  constructor(public cfg: CommonDaoCfg<BM, DBM, TM, ID>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
@@ -87,6 +93,8 @@ 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,
@@ -159,6 +167,24 @@ 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
@@ -256,8 +282,8 @@ export class CommonDao<
   /**
    * Pass `table` to override table
    */
-  query(table?: string): RunnableDBQuery<BM, DBM, ID> {
-    return new RunnableDBQuery<BM, DBM, ID>(this, table)
+  query(table?: string): RunnableDBQuery<BM, DBM, TM, ID> {
+    return new RunnableDBQuery<BM, DBM, TM, ID>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
@@ -325,6 +351,29 @@ 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()})`
@@ -979,6 +1028,50 @@ 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).
@@ -987,8 +1080,8 @@ export class CommonDao<
    */
   validateAndConvert<IN, OUT = IN>(
     obj: Partial<IN>,
-    schema: ObjectSchemaTyped<IN> | AjvSchema<IN> | undefined,
-    modelType?: DBModelType | string,
+    schema: ObjectSchemaTyped<IN> | AjvSchema<IN> | ZodSchema<IN> | undefined,
+    modelType: DBModelType,
     opt: CommonDaoOptions = {},
   ): OUT {
     // `raw` option completely bypasses any processing
@@ -1023,10 +1116,15 @@ export class CommonDao<
     const table = opt.table || this.cfg.table
     const objectName = table + (modelType || '')
 
-    let error: JoiValidationError | AjvValidationError | undefined
+    let error: JoiValidationError | AjvValidationError | ZodValidationError<IN> | undefined
     let convertedValue: any
 
-    if (schema instanceof AjvSchema) {
+    if (schema instanceof ZodSchema) {
+      // Zod schema
+      const vr = zSafeValidate(obj as IN, schema)
+      error = vr.error
+      convertedValue = vr.data
+    } else if (schema instanceof AjvSchema) {
       // Ajv schema
       convertedValue = obj // because Ajv mutates original object