@naturalcycles/db-lib 8.35.0 → 8.36.0

package/dist/adapter/cachedb/cache.db.d.ts

@@ -5,7 +5,7 @@ import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB } from '../../common.db';
 import { RunQueryResult } from '../../db.model';
 import { DBQuery } from '../../query/dbQuery';
-import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBStreamOptions } from './cache.db.model';
+import { CacheDBCfg, CacheDBCreateOptions, CacheDBOptions, CacheDBSaveOptions, CacheDBStreamOptions } from './cache.db.model';
 /**
  * CommonDB implementation that proxies requests to downstream CommonDB
  * and does in-memory caching.
@@ -21,12 +21,12 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
      */
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions<ROW>): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBOptions<ROW>): Promise<ROW[]>;
-    deleteByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBOptions<ROW>): Promise<number>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBOptions<ROW>): Promise<void>;
-    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<number>;
-    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions<ROW>): Readable;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<number>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CacheDBSaveOptions<ROW>): Promise<ROW[]>;
+    deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CacheDBOptions): Promise<number>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): Readable;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
 }

package/dist/adapter/cachedb/cache.db.js

@@ -81,7 +81,9 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
             }
         }
         if (!opt.skipCache && !this.cfg.skipCache) {
-            const cacheResult = this.cfg.cacheDB.deleteByIds(table, ids, opt).then(deletedFromCache => {
+            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`);
                 }

package/dist/adapter/cachedb/cache.db.model.d.ts

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

package/dist/adapter/file/file.db.d.ts

@@ -21,7 +21,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
      * Implementation is optimized for loading/saving _whole files_.
@@ -30,7 +30,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    deleteByIds<ROW extends ObjectWithId>(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>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;

package/dist/adapter/inmemory/inMemory.db.d.ts

@@ -52,9 +52,9 @@ export declare class InMemoryDB implements CommonDB {
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    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>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;

package/dist/adapter/inmemory/inMemory.db.js

@@ -58,22 +58,25 @@ class InMemoryDB {
         };
     }
     async createTable(_table, _schema, opt = {}) {
+        var _a;
         const table = this.cfg.tablesPrefix + _table;
         if (opt.dropIfExists) {
             this.data[table] = {};
         }
         else {
-            this.data[table] = this.data[table] || {};
+            (_a = this.data)[table] || (_a[table] = {});
         }
     }
     async getByIds(_table, ids, _opt) {
+        var _a;
         const table = this.cfg.tablesPrefix + _table;
-        this.data[table] = this.data[table] || {};
+        (_a = this.data)[table] || (_a[table] = {});
         return ids.map(id => this.data[table][id]).filter(Boolean);
     }
     async saveBatch(_table, rows, _opt) {
+        var _a;
         const table = this.cfg.tablesPrefix + _table;
-        this.data[table] = this.data[table] || {};
+        (_a = this.data)[table] || (_a[table] = {});
         rows.forEach(r => {
             if (!r.id) {
                 this.cfg.logger?.warn({ rows });

package/dist/base.common.db.d.ts

@@ -13,9 +13,9 @@ export declare class BaseCommonDB implements CommonDB {
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>): Promise<void>;
-    deleteByIds(_table: string, _ids: string[]): Promise<number>;
+    deleteByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
-    getByIds<ROW extends ObjectWithId>(_table: string, _ids: string[]): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<ROW[]>;
     runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
     saveBatch<ROW extends ObjectWithId>(_table: string, _rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;

package/dist/common.db.d.ts

@@ -31,7 +31,7 @@ export interface CommonDB {
      * 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>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions): Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
@@ -40,10 +40,10 @@ export interface CommonDB {
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
     saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
-     * @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>;
     /**
      * Should be implemented as a Transaction (best effort), which means that

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

@@ -10,22 +10,22 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOp
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM = BM> {
-    cfg: CommonDaoCfg<BM, DBM, TM>;
-    constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
+export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM = BM, ID extends string | number = DBM['id']> {
+    cfg: CommonDaoCfg<BM, DBM, TM, ID>;
+    constructor(cfg: CommonDaoCfg<BM, DBM, TM, ID>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
     getById(id: undefined, opt?: CommonDaoOptions): Promise<null>;
-    getById(id?: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
+    getById(id?: ID, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getByIdOrEmpty(id: ID, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    getByIdAsDBMOrEmpty(id: ID, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsDBM(id?: string, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIdAsDBM(id?: ID, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsTM(id?: string, opt?: CommonDaoOptions): Promise<TM | null>;
-    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<DBM[]>;
-    requireById(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<DBM>;
+    getByIdAsTM(id?: ID, opt?: CommonDaoOptions): Promise<TM | null>;
+    getByIds(ids: ID[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    getByIdsAsDBM(ids: ID[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    requireById(id: ID, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    requireByIdAsDBM(id: ID, opt?: CommonDaoOptions): Promise<DBM>;
     private throwRequiredError;
     /**
      * Throws if readOnly is true
@@ -41,7 +41,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM, TM>;
+    query(table?: string): RunnableDBQuery<BM, DBM, TM, ID>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
@@ -72,9 +72,9 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * You can do `.pipe(transformNoOp)` to make it "valid again".
      */
     streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions): ReadableTyped<Saved<BM>>;
-    queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<string[]>;
-    streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions): ReadableTyped<string>;
-    streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
+    queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<ID[]>;
+    streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions): ReadableTyped<ID>;
+    streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<ID, void>, opt?: CommonDaoStreamForEachOptions<ID>): Promise<void>;
     /**
      * Mutates!
      * "Returns", just to have a type of "Saved"
@@ -96,8 +96,8 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      *
      * Convenience method to replace 3 operations (loading+patching+saving) with one.
      */
-    patch(id: string, patch: Partial<BM>, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
-    patchAsDBM(id: string, patch: Partial<DBM>, opt?: CommonDaoSaveOptions<DBM>): Promise<DBM>;
+    patch(id: ID, patch: Partial<BM>, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
+    patchAsDBM(id: ID, patch: Partial<DBM>, opt?: CommonDaoSaveOptions<DBM>): Promise<DBM>;
     saveAsDBM(dbm: DBM, opt?: CommonDaoSaveOptions<DBM>): Promise<DBM>;
     saveBatch(bms: BM[], opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>[]>;
     saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveOptions<DBM>): Promise<DBM[]>;
@@ -105,8 +105,8 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * @returns number of deleted items
      */
     deleteById(id: undefined, opt?: CommonDaoOptions): Promise<0>;
-    deleteById(id?: string, opt?: CommonDaoOptions): Promise<number>;
-    deleteByIds(ids: string[], opt?: CommonDaoOptions): Promise<number>;
+    deleteById(id?: ID, opt?: CommonDaoOptions): Promise<number>;
+    deleteByIds(ids: ID[], opt?: CommonDaoOptions): Promise<number>;
     /**
      * Pass `stream: true` option to use Streaming: it will Stream the query, batch by 500, and execute
      * `deleteByIds` for each batch concurrently (infinite concurrency).

package/dist/commondao/common.dao.js

@@ -19,18 +19,20 @@ const isCI = !!process.env['CI'];
  */
 class CommonDao {
     constructor(cfg) {
+        var _a;
         this.cfg = cfg;
         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 ? common_dao_model_1.CommonDaoLogLevel.NONE : common_dao_model_1.CommonDaoLogLevel.OPERATIONS,
+            idType: 'string',
+            createId: true,
             created: true,
             updated: true,
             logger: console,
             ...cfg,
             hooks: {
-                createId: () => (0, nodejs_lib_1.stringId)(),
                 parseNaturalId: () => ({}),
                 beforeCreate: bm => bm,
                 beforeDBMValidate: dbm => dbm,
@@ -43,12 +45,18 @@ class CommonDao {
                 ...cfg.hooks,
             },
         };
+        if (this.cfg.createId) {
+            (0, js_lib_1._assert)(this.cfg.idType === 'string', 'db-lib: automatic generation of non-string ids is not supported');
+            (_a = this.cfg.hooks).createId || (_a.createId = () => (0, nodejs_lib_1.stringId)());
+        }
+        else {
+            delete this.cfg.hooks.createId;
+        }
     }
     // CREATE
     create(part = {}, opt = {}) {
         let bm = this.cfg.hooks.beforeCreate(part);
         bm = this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
-        // If no SCHEMA - return as is
         return this.assignIdCreatedUpdated(bm, opt);
     }
     async getById(id, opt = {}) {
@@ -416,16 +424,12 @@ class CommonDao {
     }
     assignIdCreatedUpdated(obj, opt = {}) {
         const now = Math.floor(Date.now() / 1000);
-        obj.id = obj.id || this.cfg.hooks.createId(obj);
+        obj.id || (obj.id = this.cfg.hooks.createId?.(obj));
         if (this.cfg.created) {
-            Object.assign(obj, {
-                created: obj.created || obj.updated || now,
-            });
+            obj['created'] || (obj['created'] = obj['updated'] || now);
         }
         if (this.cfg.updated) {
-            Object.assign(obj, {
-                updated: opt.preserveUpdatedCreated && obj.updated ? obj.updated : now,
-            });
+            obj['updated'] = opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now;
         }
         return obj;
     }

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

@@ -2,25 +2,16 @@ import { CommonLogger, ErrorMode, ObjectWithId, Saved } from '@naturalcycles/js-
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchemaTyped, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export declare type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string;
-export declare type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>;
-export declare type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>;
-export declare type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>;
-export declare type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
-export declare type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
-export declare type CommonDaoBeforeTMToBMHook<BM, TM> = (tm: TM) => Partial<BM>;
-export declare type CommonDaoBeforeBMToTMHook<BM, TM> = (bm: BM) => Partial<TM>;
-export declare 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.
      * Return `false` to prevent throwing an error.
@@ -47,7 +38,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM = BM> {
+export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID> = Saved<BM>, TM = BM, ID extends string | number = DBM['id']> {
     db: CommonDB;
     table: string;
     /**
@@ -83,7 +74,17 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends Obje
      * @default false
      */
     logStarted?: boolean;
-    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
      * Set to false to disable `created` field management.
@@ -194,4 +195,3 @@ export interface CommonDaoStreamOptions extends CommonDaoOptions {
     errorMode?: ErrorMode;
 }
 export declare type CommonDaoCreateOptions = CommonDBCreateOptions;
-export {};

package/dist/db.model.d.ts

@@ -1,5 +1,4 @@
 import { AnyObjectWithId, ObjectWithId } from '@naturalcycles/js-lib';
-import { CommonDB } from './common.db';
 export interface CommonDBOptions {
 }
 /**
@@ -11,8 +10,9 @@ export interface CommonDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId>
 export declare type CommonDBStreamOptions = CommonDBOptions;
 export interface CommonDBCreateOptions extends CommonDBOptions {
     /**
-     * @default false
      * Caution! If set to true - will actually DROP the table!
+     *
+     * @default false
      */
     dropIfExists?: boolean;
 }
@@ -40,18 +40,3 @@ export declare 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;
-}

package/dist/index.d.ts

@@ -5,8 +5,8 @@ import { BaseCommonDB } from './base.common.db';
 import { DBLibError } from './cnst';
 import { CommonDB } from './common.db';
 import { CommonDao } from './commondao/common.dao';
-import { CommonDaoAnonymizeHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeBMToTMHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeTMToBMHook, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoCreateOptions, CommonDaoLogLevel, CommonDaoOptions, CommonDaoParseNaturalIdHook, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from './commondao/common.dao.model';
-import { CommonDBAdapter, CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBDeleteByIdsOperation, DBModelType, DBOperation, DBRelation, DBSaveBatchOperation, RunQueryResult } from './db.model';
+import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoLogLevel, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoHooks } from './commondao/common.dao.model';
+import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, DBDeleteByIdsOperation, DBModelType, DBOperation, DBRelation, DBSaveBatchOperation, RunQueryResult } from './db.model';
 import { CommonKeyValueDao, CommonKeyValueDaoCfg } from './kv/commonKeyValueDao';
 import { CommonKeyValueDB, KeyValueDBTuple } from './kv/commonKeyValueDB';
 import { createdUpdatedFields, createdUpdatedIdFields, deserializeJsonField, serializeJsonField } from './model.util';
@@ -17,5 +17,5 @@ import { DBQuery, DBQueryFilter, DBQueryFilterOperator, dbQueryFilterOperatorVal
 import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction';
 import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util';
 export * from './kv/commonKeyValueDaoMemoCache';
-export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoParseNaturalIdHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeTMToBMHook, CommonDaoBeforeBMToTMHook, CommonDaoAnonymizeHook, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, CommonDBAdapter, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
+export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDaoHooks, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CommonDaoCfg, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
 export { DBQuery, dbQueryFilterOperatorValues, RunnableDBQuery, CommonDaoLogLevel, DBRelation, DBModelType, CommonDao, createdUpdatedFields, createdUpdatedIdFields, InMemoryDB, InMemoryKeyValueDB, queryInMemory, serializeJsonField, deserializeJsonField, dbPipelineBackup, dbPipelineRestore, dbPipelineCopy, DBLibError, BaseCommonDB, DBTransaction, RunnableDBTransaction, mergeDBOperations, commitDBTransactionSimple, CommonKeyValueDao, };

package/dist/query/dbQuery.d.ts

@@ -83,12 +83,12 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId, TM> extends DBQuery<DBM> {
-    dao: CommonDao<BM, DBM, TM>;
+export declare class RunnableDBQuery<BM extends Partial<ObjectWithId<ID>>, DBM extends ObjectWithId<ID>, TM, ID extends string | number> extends DBQuery<DBM> {
+    dao: CommonDao<BM, DBM, TM, ID>;
     /**
      * Pass `table` to override table.
      */
-    constructor(dao: CommonDao<BM, DBM, TM>, table?: string);
+    constructor(dao: CommonDao<BM, DBM, TM, ID>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
     runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
@@ -101,9 +101,9 @@ export declare class RunnableDBQuery<BM extends Partial<ObjectWithId>, DBM exten
     streamQueryAsDBMForEach(mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     streamQuery(opt?: CommonDaoStreamOptions): ReadableTyped<Saved<BM>>;
     streamQueryAsDBM(opt?: CommonDaoStreamOptions): ReadableTyped<DBM>;
-    queryIds(opt?: CommonDaoOptions): Promise<string[]>;
-    streamQueryIds(opt?: CommonDaoStreamOptions): ReadableTyped<string>;
-    streamQueryIdsForEach(mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
+    queryIds(opt?: CommonDaoOptions): Promise<ID[]>;
+    streamQueryIds(opt?: CommonDaoStreamOptions): ReadableTyped<ID>;
+    streamQueryIdsForEach(mapper: AsyncMapper<ID, void>, opt?: CommonDaoStreamForEachOptions<ID>): Promise<void>;
     deleteByQuery(opt?: CommonDaoStreamForEachOptions<DBM> & {
         stream?: boolean;
     }): Promise<number>;

package/dist/validation/index.d.ts

@@ -1,8 +1,8 @@
 import { CommonDBOptions, CommonDBSaveOptions } from '../db.model';
 import { DBQuery, DBQueryFilter, DBQueryOrder } from '../query/dbQuery';
 export declare const commonDBOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBOptions, CommonDBOptions>;
-export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
+export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>, CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>>;
 export declare const dbQueryFilterOperatorSchema: import("@naturalcycles/nodejs-lib/dist/validation/joi/string.extensions").ExtendedStringSchema;
-export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
-export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
+export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>, DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>>;
+export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>, DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string | number>>>;
 export declare const dbQuerySchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQuery<any>, DBQuery<any>>;

package/package.json

@@ -42,7 +42,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.35.0",
+  "version": "8.36.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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)