@naturalcycles/db-lib 8.35.0 → 8.37.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 Partial<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 Partial<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,8 +21,8 @@ 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[]>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<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/file/file.db.js

@@ -46,6 +46,7 @@ class FileDB extends __1.BaseCommonDB {
         // 2. Merge with new data (using ids)
         let saved = 0;
         rows.forEach(r => {
+            (0, js_lib_1._assert)(r.id, 'FileDB: row.id is required');
             if (!(0, js_lib_1._deepEquals)(byId[r.id], r)) {
                 byId[r.id] = r;
                 saved++;

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[]>;
-    saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
+    getByIds<ROW extends ObjectWithId>(_table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    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,37 +58,40 @@ 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) {
+    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 });
-                throw new Error(`InMemoryDB: id doesn't exist for row`);
+                throw new Error(`InMemoryDB doesn't support id auto-generation in saveBatch, row without id was given`);
+            }
+            if (opt.saveMethod === 'insert' && this.data[table][r.id]) {
+                throw new Error(`InMemoryDB: INSERT failed, entity exists: ${table}.${r.id}`);
+            }
+            if (opt.saveMethod === 'update' && !this.data[table][r.id]) {
+                throw new Error(`InMemoryDB: UPDATE failed, entity doesn't exist: ${table}.${r.id}`);
             }
             // JSON parse/stringify (deep clone) is to:
             // 1. Not store values "by reference" (avoid mutation bugs)
             // 2. Simulate real DB that would do something like that in a transport layer anyway
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
-            // special treatment for Buffers (assign them raw, without JSON parse/stringify)
-            // Object.entries(r).forEach(([k, v]) => {
-            //   if (Buffer.isBuffer(v)) {
-            //     this.data[table]![r.id]![k] = v
-            //   }
-            // })
         });
     }
     async deleteByIds(_table, ids, _opt) {

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

@@ -13,12 +13,12 @@ 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>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, _rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW>;
     /**
      * Naive implementation.

package/dist/common.db.d.ts

@@ -31,19 +31,22 @@ 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).
      */
     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>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
-     * @returns number of deleted items.
+     * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
+     */
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    /**
+     * 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

@@ -1,4 +1,4 @@
-import { AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { AsyncMapper, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, Unsaved } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchemaTyped, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DBModelType, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -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,19 +72,20 @@ 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"
      */
     assignIdCreatedUpdated(obj: DBM, opt?: CommonDaoOptions): DBM;
     assignIdCreatedUpdated(obj: BM, opt?: CommonDaoOptions): Saved<BM>;
+    assignIdCreatedUpdated(obj: Unsaved<BM>, opt?: CommonDaoOptions): Saved<BM>;
     /**
      * Mutates with id, created, updated
      */
-    save(bm: BM, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
+    save(bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
     private ensureImmutableDontExist;
     private ensureUniqueId;
     private throwIfObjectExists;
@@ -96,17 +97,17 @@ 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>[]>;
+    saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>[]>;
     saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveOptions<DBM>): Promise<DBM[]>;
     /**
      * @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.
@@ -164,7 +165,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions<DBM extends ObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveOptions<DBM extends Partial<ObjectWithId>> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *
@@ -194,4 +195,3 @@ export interface CommonDaoStreamOptions extends CommonDaoOptions {
     errorMode?: ErrorMode;
 }
 export declare type CommonDaoCreateOptions = CommonDBCreateOptions;
-export {};

package/dist/db.model.d.ts

@@ -1,18 +1,31 @@
 import { AnyObjectWithId, ObjectWithId } from '@naturalcycles/js-lib';
-import { CommonDB } from './common.db';
+/**
+ * Similar to SQL INSERT, UPDATE.
+ * Insert will fail if row already exists.
+ * Update will fail if row is missing.
+ * Upsert will auto-detect and use Insert or Update to not fail.
+ *
+ * Default is Upsert.
+ */
+export declare type CommonDBSaveMethod = 'upsert' | 'insert' | 'update';
 export interface CommonDBOptions {
 }
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId> extends CommonDBOptions {
+export interface CommonDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyObjectWithId> extends CommonDBOptions {
     excludeFromIndexes?: (keyof ROW)[];
+    /**
+     * Default is `upsert`
+     */
+    saveMethod?: CommonDBSaveMethod;
 }
 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 +53,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, CommonDBSaveMethod, 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, CommonDBSaveMethod, 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/model.util.d.ts

@@ -1,6 +1,5 @@
-import { CreatedUpdated, CreatedUpdatedId, ObjectWithId } from '@naturalcycles/js-lib';
+import { CreatedUpdated, CreatedUpdatedId } from '@naturalcycles/js-lib';
 export declare function createdUpdatedFields(existingObject?: Partial<CreatedUpdated> | null): CreatedUpdated;
-export declare function createdUpdatedIdFields(existingObject?: Partial<CreatedUpdatedId> | null): CreatedUpdatedId;
-export declare function idField(existingObject?: Partial<CreatedUpdatedId> | null): ObjectWithId;
+export declare function createdUpdatedIdFields(existingObject?: Partial<CreatedUpdatedId<string>> | null): CreatedUpdatedId<string>;
 export declare function deserializeJsonField<T = any>(f?: string): T;
 export declare function serializeJsonField(f: any): string | undefined;

package/dist/model.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeJsonField = exports.deserializeJsonField = exports.idField = exports.createdUpdatedIdFields = exports.createdUpdatedFields = void 0;
+exports.serializeJsonField = exports.deserializeJsonField = exports.createdUpdatedIdFields = exports.createdUpdatedFields = void 0;
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 function createdUpdatedFields(existingObject) {
     const now = Math.floor(Date.now() / 1000);
@@ -19,12 +19,6 @@ function createdUpdatedIdFields(existingObject) {
     };
 }
 exports.createdUpdatedIdFields = createdUpdatedIdFields;
-function idField(existingObject) {
-    return {
-        id: existingObject?.id || (0, nodejs_lib_1.stringId)(),
-    };
-}
-exports.idField = idField;
 function deserializeJsonField(f) {
     return JSON.parse(f || '{}');
 }

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/testing/dbTest.d.ts

@@ -8,6 +8,8 @@ export interface CommonDBImplementationFeatures {
     dbQueryFilterIn?: boolean;
     dbQueryOrder?: boolean;
     dbQuerySelectFields?: boolean;
+    insert?: boolean;
+    update?: boolean;
     createTable?: boolean;
     tableSchemas?: boolean;
     /**

package/dist/testing/dbTest.js

@@ -12,7 +12,7 @@ const test_util_1 = require("./test.util");
 function runCommonDBTest(db, features = {}, quirks = {}) {
     const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -87,9 +87,24 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(Object.keys(item3Loaded)).not.toContain('k2');
         });
     }
+    if (update) {
+        test('saveBatch UPDATE method should throw', async () => {
+            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
+        });
+    }
     test('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });
+    if (insert) {
+        test('saveBatch INSERT method should throw', async () => {
+            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
+        });
+    }
+    if (update) {
+        test('saveBatch UPDATE method should pass', async () => {
+            await db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' });
+        });
+    }
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));