@naturalcycles/db-lib 8.34.1 → 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"
@@ -85,7 +85,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * Mutates with id, created, updated
      */
     save(bm: BM, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
-    private ensureImmutableDoesntExist;
+    private ensureImmutableDontExist;
     private ensureUniqueId;
     private throwIfObjectExists;
     /**
@@ -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;
     }
@@ -442,7 +446,7 @@ class CommonDao {
         if (opt.ensureUniqueId && idWasGenerated)
             await this.ensureUniqueId(table, dbm);
         if (this.cfg.immutable)
-            await this.ensureImmutableDoesntExist(table, dbm);
+            await this.ensureImmutableDontExist(table, [dbm.id]);
         const op = `save(${dbm.id})`;
         const started = this.logSaveStarted(op, bm, table);
         await this.cfg.db.saveBatch(table, [dbm], {
@@ -452,31 +456,29 @@ class CommonDao {
         this.logSaveResult(started, op, table);
         return bm;
     }
-    async ensureImmutableDoesntExist(table, dbm) {
-        await this.throwIfObjectExists(table, dbm, [
+    async ensureImmutableDontExist(table, ids) {
+        await this.throwIfObjectExists(table, ids, [
             cnst_1.DBLibError.OBJECT_IS_IMMUTABLE,
             {
                 code: cnst_1.DBLibError.OBJECT_IS_IMMUTABLE,
-                id: dbm.id,
                 table,
             },
         ]);
     }
     async ensureUniqueId(table, dbm) {
         // todo: retry N times
-        await this.throwIfObjectExists(table, dbm, [
+        await this.throwIfObjectExists(table, [dbm.id], [
             cnst_1.DBLibError.OBJECT_IS_IMMUTABLE,
             {
                 code: cnst_1.DBLibError.OBJECT_IS_IMMUTABLE,
-                id: dbm.id,
                 table,
             },
         ]);
     }
-    async throwIfObjectExists(table, dbm, errorMeta) {
-        const [existing] = await this.cfg.db.getByIds(table, [dbm.id]);
-        if (existing)
-            throw new js_lib_1.AppError(errorMeta[0], errorMeta[1]);
+    async throwIfObjectExists(table, ids, errorMeta) {
+        const existing = await this.cfg.db.getByIds(table, ids);
+        if (existing.length > 0)
+            throw new js_lib_1.AppError(errorMeta[0], { ...errorMeta[1], ids: existing.map(i => i.id) });
     }
     /**
      * Loads the row by id.
@@ -512,7 +514,7 @@ class CommonDao {
             if (opt.ensureUniqueId && idWasGenerated)
                 await this.ensureUniqueId(table, dbm);
             if (this.cfg.immutable)
-                await this.ensureImmutableDoesntExist(table, dbm);
+                await this.ensureImmutableDontExist(table, [dbm.id]);
         }
         const op = `saveAsDBM(${dbm.id})`;
         const started = this.logSaveStarted(op, dbm, table);
@@ -531,7 +533,7 @@ class CommonDao {
         if (opt.ensureUniqueId)
             throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
         if (this.cfg.immutable)
-            throw new js_lib_1.AppError('immutable DB entries are not supported in saveBatch');
+            await this.ensureImmutableDontExist(table, dbms.map(dbm => dbm.id));
         const op = `saveBatch ${dbms.length} row(s) (${(0, js_lib_1._truncate)(dbms
             .slice(0, 10)
             .map(bm => bm.id)
@@ -553,7 +555,7 @@ class CommonDao {
             if (opt.ensureUniqueId)
                 throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
             if (this.cfg.immutable)
-                throw new js_lib_1.AppError('immutable objects are not supported in saveBatch');
+                await this.ensureImmutableDontExist(table, dbms.map(dbm => dbm.id));
         }
         const op = `saveBatchAsDBM ${dbms.length} row(s) (${(0, js_lib_1._truncate)(dbms
             .slice(0, 10)

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,9 +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 { getDB } from './getDB';
+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';
@@ -18,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 { DBQuery, dbQueryFilterOperatorValues, RunnableDBQuery, CommonDaoLogLevel, DBRelation, DBModelType, CommonDao, createdUpdatedFields, createdUpdatedIdFields, InMemoryDB, InMemoryKeyValueDB, queryInMemory, serializeJsonField, deserializeJsonField, dbPipelineBackup, dbPipelineRestore, dbPipelineCopy, getDB, DBLibError, BaseCommonDB, DBTransaction, RunnableDBTransaction, mergeDBOperations, commitDBTransactionSimple, CommonKeyValueDao, };
+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/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonKeyValueDao = exports.commitDBTransactionSimple = exports.mergeDBOperations = exports.RunnableDBTransaction = exports.DBTransaction = exports.BaseCommonDB = exports.DBLibError = exports.getDB = exports.dbPipelineCopy = exports.dbPipelineRestore = exports.dbPipelineBackup = exports.deserializeJsonField = exports.serializeJsonField = exports.queryInMemory = exports.InMemoryKeyValueDB = exports.InMemoryDB = exports.createdUpdatedIdFields = exports.createdUpdatedFields = exports.CommonDao = exports.DBModelType = exports.DBRelation = exports.CommonDaoLogLevel = exports.RunnableDBQuery = exports.dbQueryFilterOperatorValues = exports.DBQuery = void 0;
+exports.CommonKeyValueDao = exports.commitDBTransactionSimple = exports.mergeDBOperations = exports.RunnableDBTransaction = exports.DBTransaction = exports.BaseCommonDB = exports.DBLibError = exports.dbPipelineCopy = exports.dbPipelineRestore = exports.dbPipelineBackup = exports.deserializeJsonField = exports.serializeJsonField = exports.queryInMemory = exports.InMemoryKeyValueDB = exports.InMemoryDB = exports.createdUpdatedIdFields = exports.createdUpdatedFields = exports.CommonDao = exports.DBModelType = exports.DBRelation = exports.CommonDaoLogLevel = exports.RunnableDBQuery = exports.dbQueryFilterOperatorValues = exports.DBQuery = void 0;
 const tslib_1 = require("tslib");
 const inMemory_db_1 = require("./adapter/inmemory/inMemory.db");
 Object.defineProperty(exports, "InMemoryDB", { enumerable: true, get: function () { return inMemory_db_1.InMemoryDB; } });
@@ -19,8 +19,6 @@ Object.defineProperty(exports, "CommonDaoLogLevel", { enumerable: true, get: fun
 const db_model_1 = require("./db.model");
 Object.defineProperty(exports, "DBModelType", { enumerable: true, get: function () { return db_model_1.DBModelType; } });
 Object.defineProperty(exports, "DBRelation", { enumerable: true, get: function () { return db_model_1.DBRelation; } });
-const getDB_1 = require("./getDB");
-Object.defineProperty(exports, "getDB", { enumerable: true, get: function () { return getDB_1.getDB; } });
 const commonKeyValueDao_1 = require("./kv/commonKeyValueDao");
 Object.defineProperty(exports, "CommonKeyValueDao", { enumerable: true, get: function () { return commonKeyValueDao_1.CommonKeyValueDao; } });
 const model_util_1 = require("./model.util");
@@ -44,4 +42,4 @@ Object.defineProperty(exports, "RunnableDBTransaction", { enumerable: true, get:
 const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
 Object.defineProperty(exports, "commitDBTransactionSimple", { enumerable: true, get: function () { return dbTransaction_util_1.commitDBTransactionSimple; } });
 Object.defineProperty(exports, "mergeDBOperations", { enumerable: true, get: function () { return dbTransaction_util_1.mergeDBOperations; } });
-(0, tslib_1.__exportStar)(require("./kv/commonKeyValueDaoMemoCache"), exports);
+tslib_1.__exportStar(require("./kv/commonKeyValueDaoMemoCache"), exports);

package/dist/pipeline/dbPipelineBackup.js

@@ -5,7 +5,6 @@ const zlib_1 = require("zlib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
-const time_lib_1 = require("@naturalcycles/time-lib");
 const fs = require("fs-extra");
 const index_1 = require("../index");
 /**
@@ -22,7 +21,7 @@ async function dbPipelineBackup(opt) {
     const strict = errorMode !== js_lib_1.ErrorMode.SUPPRESS;
     const gzip = opt.gzip !== false; // default to true
     let { tables } = opt;
-    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)(time_lib_1.dayjs.unix(sinceUpdated).toPretty()) : '';
+    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty()) : '';
     console.log(`>> ${(0, colors_1.dimWhite)('dbPipelineBackup')} started in ${(0, colors_1.grey)(outputDirPath)}...${sinceUpdatedStr}`);
     fs.ensureDirSync(outputDirPath);
     if (!tables) {

package/dist/pipeline/dbPipelineCopy.js

@@ -4,7 +4,6 @@ exports.dbPipelineCopy = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
-const time_lib_1 = require("@naturalcycles/time-lib");
 const dbQuery_1 = require("../query/dbQuery");
 /**
  * Pipeline from input stream(s) to CommonDB .saveBatch().
@@ -15,7 +14,7 @@ const dbQuery_1 = require("../query/dbQuery");
 async function dbPipelineCopy(opt) {
     const { batchSize = 100, dbInput, dbOutput, concurrency = 16, limit = 0, sinceUpdated, mapperPerTable = {}, saveOptionsPerTable = {}, transformMapOptions, errorMode = js_lib_1.ErrorMode.SUPPRESS, } = opt;
     let { tables } = opt;
-    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)(time_lib_1.dayjs.unix(sinceUpdated).toPretty()) : '';
+    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty()) : '';
     console.log(`>> ${(0, colors_1.dimWhite)('dbPipelineCopy')} started...${sinceUpdatedStr}`);
     if (!tables) {
         tables = await dbInput.getTables();

package/dist/pipeline/dbPipelineRestore.js

@@ -5,7 +5,6 @@ const zlib_1 = require("zlib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
-const time_lib_1 = require("@naturalcycles/time-lib");
 const fs = require("fs-extra");
 /**
  * Pipeline from NDJSON files in a folder (optionally gzipped) to CommonDB.
@@ -18,7 +17,7 @@ async function dbPipelineRestore(opt) {
     const { db, concurrency = 16, batchSize = 100, limit, sinceUpdated, inputDirPath, mapperPerTable = {}, saveOptionsPerTable = {}, transformMapOptions, errorMode = js_lib_1.ErrorMode.SUPPRESS, recreateTables = false, } = opt;
     const strict = errorMode !== js_lib_1.ErrorMode.SUPPRESS;
     const onlyTables = opt.tables && new Set(opt.tables);
-    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)(time_lib_1.dayjs.unix(sinceUpdated).toPretty()) : '';
+    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, colors_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty()) : '';
     console.log(`>> ${(0, colors_1.dimWhite)('dbPipelineRestore')} started in ${(0, colors_1.grey)(inputDirPath)}...${sinceUpdatedStr}`);
     fs.ensureDirSync(inputDirPath);
     const tablesToGzip = new Set();

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>;