@naturalcycles/db-lib 8.34.2 → 8.36.1

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

@@ -45,7 +45,7 @@ export interface CacheDBCfg {
   logger?: CommonLogger
 }
 
-export interface CacheDBOptions<ROW extends ObjectWithId> extends CommonDBSaveOptions<ROW> {
+export interface CacheDBOptions {
   /**
    * @default false
    */
@@ -57,9 +57,10 @@ export interface CacheDBOptions<ROW extends ObjectWithId> extends CommonDBSaveOp
   onlyCache?: boolean
 }
 
-export interface CacheDBStreamOptions<ROW extends ObjectWithId>
-  extends CacheDBOptions<ROW>,
-    CommonDBStreamOptions {}
-export interface CacheDBCreateOptions<ROW extends ObjectWithId>
-  extends CacheDBOptions<ROW>,
-    CommonDBCreateOptions {}
+export interface CacheDBSaveOptions<ROW extends ObjectWithId>
+  extends CacheDBOptions,
+    CommonDBSaveOptions<ROW> {}
+
+export interface CacheDBStreamOptions extends CacheDBOptions, CommonDBStreamOptions {}
+
+export interface CacheDBCreateOptions extends CacheDBOptions, CommonDBCreateOptions {}

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

@@ -13,6 +13,7 @@ import {
   CacheDBCfg,
   CacheDBCreateOptions,
   CacheDBOptions,
+  CacheDBSaveOptions,
   CacheDBStreamOptions,
 } from './cache.db.model'
 
@@ -59,7 +60,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
   override async createTable<ROW extends ObjectWithId>(
     table: string,
     schema: JsonSchemaObject<ROW>,
-    opt: CacheDBCreateOptions<ROW> = {},
+    opt: CacheDBCreateOptions = {},
   ): Promise<void> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       await this.cfg.downstreamDB.createTable(table, schema, opt)
@@ -72,11 +73,11 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
-    ids: string[],
-    opt: CacheDBOptions<ROW> = {},
+    ids: ROW['id'][],
+    opt: CacheDBSaveOptions<ROW> = {},
   ): Promise<ROW[]> {
     const resultMap: StringMap<ROW> = {}
-    const missingIds: string[] = []
+    const missingIds: ROW['id'][] = []
 
     if (!opt.skipCache && !this.cfg.skipCache) {
       const results = await this.cfg.cacheDB.getByIds<ROW>(table, ids, opt)
@@ -118,13 +119,13 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async deleteByIds<ROW extends ObjectWithId>(
     table: string,
-    ids: string[],
-    opt: CacheDBOptions<ROW> = {},
+    ids: ROW['id'][],
+    opt: CacheDBOptions = {},
   ): Promise<number> {
     let deletedIds = 0
 
     if (!opt.onlyCache && !this.cfg.onlyCache) {
-      deletedIds = await this.cfg.downstreamDB.deleteByIds(table, ids, opt)
+      deletedIds = await this.cfg.downstreamDB.deleteByIds<ROW>(table, ids, opt)
 
       if (this.cfg.logDownstream) {
         this.cfg.logger?.log(`${table}.deleteByIds ${deletedIds} rows from downstream`)
@@ -132,11 +133,13 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
 
     if (!opt.skipCache && !this.cfg.skipCache) {
-      const cacheResult = this.cfg.cacheDB.deleteByIds(table, ids, opt).then(deletedFromCache => {
-        if (this.cfg.logCached) {
-          this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`)
-        }
-      })
+      const cacheResult = this.cfg.cacheDB
+        .deleteByIds<ROW>(table, ids, opt)
+        .then(deletedFromCache => {
+          if (this.cfg.logCached) {
+            this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`)
+          }
+        })
       if (this.cfg.awaitCache) await cacheResult
     }
 
@@ -146,7 +149,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
   override async saveBatch<ROW extends ObjectWithId>(
     table: string,
     rows: ROW[],
-    opt: CacheDBOptions<ROW> = {},
+    opt: CacheDBSaveOptions<ROW> = {},
   ): Promise<void> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       await this.cfg.downstreamDB.saveBatch(table, rows, opt)
@@ -174,7 +177,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async runQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions<ROW> = {},
+    opt: CacheDBSaveOptions<ROW> = {},
   ): Promise<RunQueryResult<ROW>> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const { rows, ...queryResult } = await this.cfg.downstreamDB.runQuery(q, opt)
@@ -204,7 +207,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async runQueryCount<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions<ROW> = {},
+    opt: CacheDBOptions = {},
   ): Promise<number> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       return await this.cfg.downstreamDB.runQueryCount(q, opt)
@@ -221,7 +224,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override streamQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBStreamOptions<ROW> = {},
+    opt: CacheDBStreamOptions = {},
   ): Readable {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const stream = this.cfg.downstreamDB.streamQuery<ROW>(q, opt)
@@ -260,7 +263,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions<ROW> = {},
+    opt: CacheDBOptions = {},
   ): Promise<number> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const deletedIds = await this.cfg.downstreamDB.deleteByQuery(q, opt)

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

@@ -64,7 +64,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
 
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
-    ids: string[],
+    ids: ROW['id'][],
     _opt?: CommonDBOptions,
   ): Promise<ROW[]> {
     const byId = _by(await this.loadFile<ROW>(table), r => r.id)
@@ -173,7 +173,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
 
   override async deleteByIds<ROW extends ObjectWithId>(
     table: string,
-    ids: string[],
+    ids: ROW['id'][],
     _opt?: CommonDBOptions,
   ): Promise<number> {
     if (!ids.length) return 0

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

@@ -137,17 +137,17 @@ export class InMemoryDB implements CommonDB {
     if (opt.dropIfExists) {
       this.data[table] = {}
     } else {
-      this.data[table] = this.data[table] || {}
+      this.data[table] ||= {}
     }
   }
 
   async getByIds<ROW extends ObjectWithId>(
     _table: string,
-    ids: string[],
+    ids: ROW['id'][],
     _opt?: CommonDBOptions,
   ): Promise<ROW[]> {
     const table = this.cfg.tablesPrefix + _table
-    this.data[table] = this.data[table] || {}
+    this.data[table] ||= {}
     return ids.map(id => this.data[table]![id]).filter(Boolean) as ROW[]
   }
 
@@ -157,7 +157,7 @@ export class InMemoryDB implements CommonDB {
     _opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
     const table = this.cfg.tablesPrefix + _table
-    this.data[table] = this.data[table] || {}
+    this.data[table] ||= {}
 
     rows.forEach(r => {
       if (!r.id) {
@@ -179,7 +179,11 @@ export class InMemoryDB implements CommonDB {
     })
   }
 
-  async deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number> {
+  async deleteByIds<ROW extends ObjectWithId>(
+    _table: string,
+    ids: ROW['id'][],
+    _opt?: CommonDBOptions,
+  ): Promise<number> {
     const table = this.cfg.tablesPrefix + _table
     this.data[table] = this.data[table] || {}
 

package/src/base.common.db.ts

@@ -35,7 +35,7 @@ export class BaseCommonDB implements CommonDB {
     _schema: JsonSchemaObject<ROW>,
   ): Promise<void> {}
 
-  async deleteByIds(_table: string, _ids: string[]): Promise<number> {
+  async deleteByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<number> {
     return 0
   }
 
@@ -43,7 +43,7 @@ export class BaseCommonDB implements CommonDB {
     return 0
   }
 
-  async getByIds<ROW extends ObjectWithId>(_table: string, _ids: string[]): Promise<ROW[]> {
+  async getByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<ROW[]> {
     return []
   }
 

package/src/common.db.ts

@@ -49,7 +49,7 @@ export interface CommonDB {
    */
   getByIds<ROW extends ObjectWithId>(
     table: string,
-    ids: string[],
+    ids: ROW['id'][],
     opt?: CommonDBOptions,
   ): Promise<ROW[]>
 
@@ -78,10 +78,14 @@ export interface CommonDB {
 
   // DELETE
   /**
-   * @returns number of deleted items.
+   * Returns number of deleted items.
    * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
    */
-  deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>
+  deleteByIds<ROW extends ObjectWithId>(
+    table: string,
+    ids: ROW['id'][],
+    opt?: CommonDBOptions,
+  ): Promise<number>
 
   deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>
 

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

@@ -10,27 +10,21 @@ import {
 import { CommonDB } from '../common.db'
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model'
 
-// Hook DBM, BM, TM types should follow this exact order
-export type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string
-export type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>
-export type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>
-export type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>
-export type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
-export type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>
-export type CommonDaoBeforeTMToBMHook<BM, TM> = (tm: TM) => Partial<BM>
-export type CommonDaoBeforeBMToTMHook<BM, TM> = (bm: BM) => Partial<TM>
-export type CommonDaoAnonymizeHook<DBM> = (dbm: DBM) => DBM
-
-interface CommonDaoHooks<BM, DBM, TM> {
-  createId: CommonDaoCreateIdHook<BM, DBM>
-  parseNaturalId: CommonDaoParseNaturalIdHook<DBM>
-  beforeCreate: CommonDaoBeforeCreateHook<BM>
-  beforeDBMValidate: CommonDaoBeforeDBMValidateHook<DBM>
-  beforeDBMToBM: CommonDaoBeforeDBMToBMHook<BM, DBM>
-  beforeBMToDBM: CommonDaoBeforeBMToDBMHook<BM, DBM>
-  beforeTMToBM: CommonDaoBeforeTMToBMHook<BM, TM>
-  beforeBMToTM: CommonDaoBeforeBMToTMHook<BM, TM>
-  anonymize: CommonDaoAnonymizeHook<DBM>
+export interface CommonDaoHooks<
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID>,
+  TM,
+  ID extends string | number,
+> {
+  createId: (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.
@@ -61,9 +55,10 @@ export enum CommonDaoLogLevel {
 }
 
 export interface CommonDaoCfg<
-  BM extends Partial<ObjectWithId>,
-  DBM extends ObjectWithId = Saved<BM>,
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID> = Saved<BM>,
   TM = BM,
+  ID extends string | number = DBM['id'],
 > {
   db: CommonDB
   table: string
@@ -109,7 +104,19 @@ 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, TM, ID>>
+
+  /**
+   * Defaults to 'string'
+   */
+  idType?: 'string' | 'number'
+
+  /**
+   * Defaults to true.
+   * Set to false to disable auto-generation of `id`.
+   * Useful e.g when your DB is generating ids by itself (e.g mysql auto_increment).
+   */
+  createId?: boolean
 
   /**
    * Defaults to true

package/src/commondao/common.dao.ts

@@ -59,49 +59,60 @@ const isCI = !!process.env['CI']
  * TM = Transport model (optimized to be sent over the wire)
  */
 export class CommonDao<
-  BM extends Partial<ObjectWithId>,
-  DBM extends ObjectWithId = Saved<BM>,
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID> = Saved<BM>,
   TM = BM,
+  ID extends string | number = DBM['id'],
 > {
-  constructor(public cfg: CommonDaoCfg<BM, DBM, TM>) {
+  constructor(public cfg: CommonDaoCfg<BM, DBM, TM, ID>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
       // e.g in Dev (local machine), Test - it will log operations (useful for debugging)
       logLevel: isGAE || isCI ? CommonDaoLogLevel.NONE : CommonDaoLogLevel.OPERATIONS,
+      idType: 'string',
+      createId: true,
       created: true,
       updated: true,
       logger: console,
       ...cfg,
       hooks: {
-        createId: () => stringId(),
         parseNaturalId: () => ({}),
         beforeCreate: bm => bm as BM,
         beforeDBMValidate: dbm => dbm,
         beforeDBMToBM: dbm => dbm as any,
         beforeBMToDBM: bm => bm as any,
-        beforeTMToBM: tm => tm as any,
+        beforeTMToBM: tm => tm,
         beforeBMToTM: bm => bm as any,
         anonymize: dbm => dbm,
         onValidationError: err => err,
         ...cfg.hooks,
       },
     }
+
+    if (this.cfg.createId) {
+      _assert(
+        this.cfg.idType === 'string',
+        'db-lib: automatic generation of non-string ids is not supported',
+      )
+
+      this.cfg.hooks!.createId ||= () => stringId() as ID
+    } else {
+      delete this.cfg.hooks!.createId
+    }
   }
 
   // CREATE
   create(part: Partial<BM> = {}, opt: CommonDaoOptions = {}): Saved<BM> {
     let bm = this.cfg.hooks!.beforeCreate!(part) as BM
     bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
-
-    // If no SCHEMA - return as is
     return this.assignIdCreatedUpdated(bm, opt)
   }
 
   // GET
   async getById(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getById(id?: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
-  async getById(id?: string, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
+  async getById(id?: ID, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
+  async getById(id?: ID, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
     if (!id) return null
     const op = `getById(${id})`
     const table = opt.table || this.cfg.table
@@ -126,22 +137,14 @@ export class CommonDao<
     return bm || null
   }
 
-  async getByIdOrEmpty(
-    id: string,
-    part: Partial<BM> = {},
-    opt?: CommonDaoOptions,
-  ): Promise<Saved<BM>> {
+  async getByIdOrEmpty(id: ID, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<Saved<BM>> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
     return this.create({ ...part, id }, opt)
   }
 
-  async getByIdAsDBMOrEmpty(
-    id: string,
-    part: Partial<BM> = {},
-    opt?: CommonDaoOptions,
-  ): Promise<DBM> {
+  async getByIdAsDBMOrEmpty(id: ID, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<DBM> {
     const dbm = await this.getByIdAsDBM(id, opt)
     if (dbm) return dbm
 
@@ -150,8 +153,8 @@ export class CommonDao<
   }
 
   async getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsDBM(id?: string, opt?: CommonDaoOptions): Promise<DBM | null>
-  async getByIdAsDBM(id?: string, opt: CommonDaoOptions = {}): Promise<DBM | null> {
+  async getByIdAsDBM(id?: ID, opt?: CommonDaoOptions): Promise<DBM | null>
+  async getByIdAsDBM(id?: ID, opt: CommonDaoOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const op = `getByIdAsDBM(${id})`
     const table = opt.table || this.cfg.table
@@ -165,8 +168,8 @@ export class CommonDao<
   }
 
   async getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsTM(id?: string, opt?: CommonDaoOptions): Promise<TM | null>
-  async getByIdAsTM(id?: string, opt: CommonDaoOptions = {}): Promise<TM | null> {
+  async getByIdAsTM(id?: ID, opt?: CommonDaoOptions): Promise<TM | null>
+  async getByIdAsTM(id?: ID, opt: CommonDaoOptions = {}): Promise<TM | null> {
     if (!id) return null
     const op = `getByIdAsTM(${id})`
     const table = opt.table || this.cfg.table
@@ -182,7 +185,7 @@ export class CommonDao<
     return tm || null
   }
 
-  async getByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<Saved<BM>[]> {
+  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
     const started = this.logStarted(op, table)
@@ -192,7 +195,7 @@ export class CommonDao<
     return bms
   }
 
-  async getByIdsAsDBM(ids: string[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
+  async getByIdsAsDBM(ids: ID[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
     const op = `getByIdsAsDBM ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
@@ -201,7 +204,7 @@ export class CommonDao<
     return dbms
   }
 
-  async requireById(id: string, opt: CommonDaoOptions = {}): Promise<Saved<BM>> {
+  async requireById(id: ID, opt: CommonDaoOptions = {}): Promise<Saved<BM>> {
     const r = await this.getById(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -209,7 +212,7 @@ export class CommonDao<
     return r
   }
 
-  async requireByIdAsDBM(id: string, opt: CommonDaoOptions = {}): Promise<DBM> {
+  async requireByIdAsDBM(id: ID, opt: CommonDaoOptions = {}): Promise<DBM> {
     const r = await this.getByIdAsDBM(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -217,7 +220,7 @@ export class CommonDao<
     return r
   }
 
-  private throwRequiredError(id: string, opt: CommonDaoOptions): never {
+  private throwRequiredError(id: ID, opt: CommonDaoOptions): never {
     const table = opt.table || this.cfg.table
     throw new AppError(`DB row required, but not found: ${table}.${id}`, {
       code: DBLibError.DB_ROW_REQUIRED,
@@ -267,8 +270,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, TM, ID> {
+    return new RunnableDBQuery<BM, DBM, TM, ID>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
@@ -514,18 +517,18 @@ export class CommonDao<
     )
   }
 
-  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<string[]> {
+  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<ID[]> {
     q.table = opt.table || q.table
     const { rows } = await this.cfg.db.runQuery(q.select(['id']), opt)
     return rows.map(r => r.id)
   }
 
-  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions = {}): ReadableTyped<string> {
+  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions = {}): ReadableTyped<ID> {
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
     return this.cfg.db.streamQuery<DBM>(q.select(['id']), opt).pipe(
-      transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id, {
+      transformMapSimple<DBM, ID>(objectWithId => objectWithId.id, {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
       }),
     )
@@ -533,8 +536,8 @@ export class CommonDao<
 
   async streamQueryIdsForEach(
     q: DBQuery<DBM>,
-    mapper: AsyncMapper<string, void>,
-    opt: CommonDaoStreamForEachOptions<string> = {},
+    mapper: AsyncMapper<ID, void>,
+    opt: CommonDaoStreamForEachOptions<ID> = {},
   ): Promise<void> {
     q.table = opt.table || q.table
     opt.errorMode = opt.errorMode || ErrorMode.SUPPRESS
@@ -545,9 +548,9 @@ export class CommonDao<
 
     await _pipeline([
       this.cfg.db.streamQuery<DBM>(q.select(['id']), opt),
-      transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id),
+      transformMapSimple<DBM, ID>(objectWithId => objectWithId.id),
       transformTap(() => count++),
-      transformMap<string, void>(mapper, {
+      transformMap<ID, void>(mapper, {
         ...opt,
         predicate: _passthroughPredicate,
       }),
@@ -573,18 +576,14 @@ export class CommonDao<
   assignIdCreatedUpdated(obj: DBM | BM, opt: CommonDaoOptions = {}): DBM | Saved<BM> {
     const now = Math.floor(Date.now() / 1000)
 
-    obj.id = obj.id || this.cfg.hooks!.createId!(obj)
+    obj.id ||= this.cfg.hooks!.createId?.(obj)
 
     if (this.cfg.created) {
-      Object.assign(obj, {
-        created: (obj as any).created || (obj as any).updated || now,
-      })
+      obj['created'] ||= obj['updated'] || now
     }
 
     if (this.cfg.updated) {
-      Object.assign(obj, {
-        updated: opt.preserveUpdatedCreated && (obj as any).updated ? (obj as any).updated : now,
-      })
+      obj['updated'] = opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now
     }
 
     return obj as any
@@ -613,7 +612,7 @@ export class CommonDao<
     return bm as any
   }
 
-  private async ensureImmutableDontExist(table: string, ids: string[]): Promise<void> {
+  private async ensureImmutableDontExist(table: string, ids: ID[]): Promise<void> {
     await this.throwIfObjectExists(table, ids, [
       DBLibError.OBJECT_IS_IMMUTABLE,
       {
@@ -640,7 +639,7 @@ export class CommonDao<
 
   private async throwIfObjectExists(
     table: string,
-    ids: string[],
+    ids: ID[],
     errorMeta: [DBLibError, any],
   ): Promise<void> {
     const existing = await this.cfg.db.getByIds<DBM>(table, ids)
@@ -656,11 +655,7 @@ export class CommonDao<
    *
    * Convenience method to replace 3 operations (loading+patching+saving) with one.
    */
-  async patch(
-    id: string,
-    patch: Partial<BM>,
-    opt: CommonDaoSaveOptions<DBM> = {},
-  ): Promise<Saved<BM>> {
+  async patch(id: ID, patch: Partial<BM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
     return await this.save(
       {
         ...(await this.getByIdOrEmpty(id, patch, opt)),
@@ -670,11 +665,7 @@ export class CommonDao<
     )
   }
 
-  async patchAsDBM(
-    id: string,
-    patch: Partial<DBM>,
-    opt: CommonDaoSaveOptions<DBM> = {},
-  ): Promise<DBM> {
+  async patchAsDBM(id: ID, patch: Partial<DBM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<DBM> {
     const dbm =
       (await this.getByIdAsDBM(id, opt)) ||
       (this.create({ ...patch, id } as Partial<BM>, opt) as any as DBM)
@@ -778,8 +769,8 @@ export class CommonDao<
    * @returns number of deleted items
    */
   async deleteById(id: undefined, opt?: CommonDaoOptions): Promise<0>
-  async deleteById(id?: string, opt?: CommonDaoOptions): Promise<number>
-  async deleteById(id?: string, opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteById(id?: ID, opt?: CommonDaoOptions): Promise<number>
+  async deleteById(id?: ID, opt: CommonDaoOptions = {}): Promise<number> {
     if (!id) return 0
     this.requireWriteAccess()
     if (!opt.allowMutability) this.requireObjectMutability()
@@ -791,7 +782,7 @@ export class CommonDao<
     return ids
   }
 
-  async deleteByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<number> {
     this.requireWriteAccess()
     if (!opt.allowMutability) this.requireObjectMutability()
     const op = `deleteByIds(${ids.join(', ')})`
@@ -823,7 +814,7 @@ export class CommonDao<
 
       await _pipeline([
         this.cfg.db.streamQuery<DBM>(q.select(['id']), opt),
-        transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id, {
+        transformMapSimple<DBM, ID>(objectWithId => objectWithId.id, {
           errorMode: ErrorMode.SUPPRESS,
         }),
         transformBuffer<string>({ batchSize }),

package/src/db.model.ts

@@ -1,5 +1,4 @@
 import { AnyObjectWithId, ObjectWithId } from '@naturalcycles/js-lib'
-import { CommonDB } from './common.db'
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface CommonDBOptions {}
@@ -16,8 +15,9 @@ export type CommonDBStreamOptions = CommonDBOptions
 
 export interface CommonDBCreateOptions extends CommonDBOptions {
   /**
-   * @default false
    * Caution! If set to true - will actually DROP the table!
+   *
+   * @default false
    */
   dropIfExists?: boolean
 }
@@ -51,19 +51,3 @@ export enum DBModelType {
   BM = 'BM',
   TM = 'TM',
 }
-
-/**
- * Interface for a module (lib) that implements CommonDB.
- *
- * Example:
- *
- * const lib: CommonDBModule = require('mysql-lib')
- * const db = lib.getDB()
- */
-export interface CommonDBAdapter {
-  /**
-   * @param cfg was read from SECRET_DB${i} by secret('SECRET_DB${i}') method and passed there.
-   * It's a string that can contain e.g JSON.stringified configuration object (depends on the adapter).
-   */
-  getDBAdapter(cfg?: string): CommonDB
-}