@naturalcycles/db-lib 8.39.0 → 8.41.0

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

@@ -36,7 +36,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
     saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
-    sortRows<ROW>(rows: ROW[]): ROW[];
+    private sortRows;
     private logStarted;
     private logFinished;
 }

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

@@ -14,14 +14,14 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     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?: ID, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
+    getById(id?: ID | null, 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?: ID, opt?: CommonDaoOptions): Promise<DBM | null>;
-    getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsTM(id?: ID, opt?: CommonDaoOptions): Promise<TM | null>;
+    getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
+    getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
+    getByIdAsTM(id?: ID | null, 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>>;
@@ -103,8 +103,8 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
     /**
      * @returns number of deleted items
      */
-    deleteById(id: undefined, opt?: CommonDaoOptions): Promise<0>;
-    deleteById(id?: ID, opt?: CommonDaoOptions): Promise<number>;
+    deleteById(id: undefined | null, opt?: CommonDaoOptions): Promise<0>;
+    deleteById(id?: ID | null, 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

package/dist/commondao/common.dao.js

@@ -28,6 +28,7 @@ class CommonDao {
             logLevel: isGAE || isCI ? common_dao_model_1.CommonDaoLogLevel.NONE : common_dao_model_1.CommonDaoLogLevel.OPERATIONS,
             idType: 'string',
             createId: true,
+            assignGeneratedIds: false,
             created: true,
             updated: true,
             logger: console,
@@ -219,7 +220,7 @@ class CommonDao {
         (0, js_lib_1._assert)(q._selectedFieldNames?.length === 1, `runQuerySingleColumn requires exactly 1 column to be selected: ${q.pretty()}`);
         const col = q._selectedFieldNames[0];
         const { rows } = await this.runQueryExtended(q, opt);
-        return rows.map(r => r[col]);
+        return rows.map((r) => r[col]);
     }
     /**
      * Convenience method that runs multiple queries in parallel and then merges their results together.
@@ -434,13 +435,17 @@ class CommonDao {
         }
     }
     assignIdCreatedUpdated(obj, opt = {}) {
+        var _a;
         const now = Math.floor(Date.now() / 1000);
         obj.id || (obj.id = this.cfg.hooks.createId?.(obj));
         if (this.cfg.created) {
-            obj['created'] || (obj['created'] = obj['updated'] || now);
+            ;
+            (_a = obj)['created'] || (_a['created'] = obj['updated'] || now);
         }
         if (this.cfg.updated) {
-            obj['updated'] = opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now;
+            ;
+            obj['updated'] =
+                opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now;
         }
         return obj;
     }
@@ -450,7 +455,7 @@ class CommonDao {
      */
     async save(bm, opt = {}) {
         this.requireWriteAccess();
-        const idWasGenerated = !bm.id;
+        const idWasGenerated = !bm.id && this.cfg.createId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
         const dbm = await this.bmToDBM(bm, opt);
         const table = opt.table || this.cfg.table;
@@ -461,10 +466,16 @@ class CommonDao {
         }
         const op = `save(${dbm.id})`;
         const started = this.logSaveStarted(op, bm, table);
+        const { excludeFromIndexes } = this.cfg;
+        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
         await this.cfg.db.saveBatch(table, [dbm], {
-            excludeFromIndexes: this.cfg.excludeFromIndexes,
+            excludeFromIndexes,
+            assignGeneratedIds,
             ...opt,
         });
+        if (assignGeneratedIds) {
+            bm.id = dbm.id;
+        }
         this.logSaveResult(started, op, table);
         return bm;
     }
@@ -495,24 +506,31 @@ class CommonDao {
         const table = opt.table || this.cfg.table;
         // assigning id in case it misses the id
         // will override/set `updated` field, unless opts.preserveUpdated is set
+        let row = dbm;
         if (!opt.raw) {
-            const idWasGenerated = !dbm.id;
+            const idWasGenerated = !dbm.id && this.cfg.createId;
             this.assignIdCreatedUpdated(dbm, opt); // mutates
-            dbm = this.anyToDBM(dbm, opt);
+            row = this.anyToDBM(dbm, opt);
             if (opt.ensureUniqueId && idWasGenerated)
-                await this.ensureUniqueId(table, dbm);
+                await this.ensureUniqueId(table, row);
         }
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
-        const op = `saveAsDBM(${dbm.id})`;
-        const started = this.logSaveStarted(op, dbm, table);
-        await this.cfg.db.saveBatch(table, [dbm], {
-            excludeFromIndexes: this.cfg.excludeFromIndexes,
+        const op = `saveAsDBM(${row.id})`;
+        const started = this.logSaveStarted(op, row, table);
+        const { excludeFromIndexes } = this.cfg;
+        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
+        await this.cfg.db.saveBatch(table, [row], {
+            excludeFromIndexes,
+            assignGeneratedIds,
             ...opt,
         });
+        if (assignGeneratedIds) {
+            dbm.id = row.id;
+        }
         this.logSaveResult(started, op, table);
-        return dbm;
+        return row;
     }
     async saveBatch(bms, opt = {}) {
         this.requireWriteAccess();
@@ -529,36 +547,49 @@ class CommonDao {
             .map(bm => bm.id)
             .join(', '), 50)})`;
         const started = this.logSaveStarted(op, bms, table);
+        const { excludeFromIndexes } = this.cfg;
+        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
         await this.cfg.db.saveBatch(table, dbms, {
-            excludeFromIndexes: this.cfg.excludeFromIndexes,
+            excludeFromIndexes,
+            assignGeneratedIds,
             ...opt,
         });
+        if (assignGeneratedIds) {
+            dbms.forEach((dbm, i) => (bms[i].id = dbm.id));
+        }
         this.logSaveResult(started, op, table);
         return bms;
     }
     async saveBatchAsDBM(dbms, opt = {}) {
         this.requireWriteAccess();
         const table = opt.table || this.cfg.table;
+        let rows = dbms;
         if (!opt.raw) {
             dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)); // mutates
-            dbms = this.anyToDBMs(dbms, opt);
+            rows = this.anyToDBMs(dbms, opt);
             if (opt.ensureUniqueId)
                 throw new js_lib_1.AppError('ensureUniqueId is not supported in saveBatch');
         }
         if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
             opt = { ...opt, saveMethod: 'insert' };
         }
-        const op = `saveBatchAsDBM ${dbms.length} row(s) (${(0, js_lib_1._truncate)(dbms
+        const op = `saveBatchAsDBM ${rows.length} row(s) (${(0, js_lib_1._truncate)(rows
             .slice(0, 10)
             .map(bm => bm.id)
             .join(', '), 50)})`;
-        const started = this.logSaveStarted(op, dbms, table);
-        await this.cfg.db.saveBatch(table, dbms, {
-            excludeFromIndexes: this.cfg.excludeFromIndexes,
+        const started = this.logSaveStarted(op, rows, table);
+        const { excludeFromIndexes } = this.cfg;
+        const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds;
+        await this.cfg.db.saveBatch(table, rows, {
+            excludeFromIndexes,
+            assignGeneratedIds,
             ...opt,
         });
+        if (assignGeneratedIds) {
+            rows.forEach((row, i) => (dbms[i].id = row.id));
+        }
         this.logSaveResult(started, op, table);
-        return dbms;
+        return rows;
     }
     async deleteById(id, opt = {}) {
         if (!id)

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

@@ -86,6 +86,11 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId<ID>>, DBM extends
      * Useful e.g when your DB is generating ids by itself (e.g mysql auto_increment).
      */
     createId?: boolean;
+    /**
+     * See the same option in CommonDB.
+     * Defaults to false normally.
+     */
+    assignGeneratedIds?: boolean;
     /**
      * Defaults to true
      * Set to false to disable `created` field management.

package/dist/db.model.d.ts

@@ -19,6 +19,13 @@ export interface CommonDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyObje
      * Default is `upsert`
      */
     saveMethod?: CommonDBSaveMethod;
+    /**
+     * Only applicable to tables where id is "auto-generated by DB", e.g `auto_increment` in MySQL.
+     * By default it's false, so, auto-generated id will NOT be assigned/returned.
+     * Setting it to true will assign and return auto-generated id (on all rows, one by one).
+     * It's not true by default, because getting auto-generated id incurs an overhead of doing extra call (e.g LAST_INSERT_ID() in MySQL).
+     */
+    assignGeneratedIds?: boolean;
 }
 export declare type CommonDBStreamOptions = CommonDBOptions;
 export interface CommonDBCreateOptions extends CommonDBOptions {

package/dist/testing/daoTest.js

@@ -41,7 +41,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
     // CREATE TABLE, DROP
     if (createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await dao.createTable(test_model_1.testItemDBMJsonSchema.build(), { dropIfExists: true });
+            await dao.createTable(test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
         });
     }
     if (querying) {
@@ -55,7 +55,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
             if (eventualConsistencyDelay)
                 await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect(await dao.query().runQuery()).toEqual([]);
-            expect(await dao.query().runQueryCount()).toEqual(0);
+            expect(await dao.query().runQueryCount()).toBe(0);
         });
     }
     // GET empty
@@ -81,7 +81,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
             await dao.save(item3);
             const item3Loaded = await dao.requireById(item3.id);
             (0, dbTest_1.expectMatch)([item3], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBe(null);
+            expect(item3Loaded.k2).toBeNull();
             expect(Object.keys(item3)).toContain('k2');
             expect(item3.k2).toBeNull();
         });
@@ -98,7 +98,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         expected.updated = item3.updated; // as it's mutated
         const item3Loaded = await dao.requireById(item3.id);
         (0, dbTest_1.expectMatch)([expected], [item3Loaded], quirks);
-        expect(item3Loaded.k2).toBe(undefined);
+        expect(item3Loaded.k2).toBeUndefined();
         expect(Object.keys(item3Loaded)).not.toContain('k2');
         expect(Object.keys(item3)).toContain('k2');
         expect(item3.k2).toBeUndefined();

package/dist/testing/dbTest.js

@@ -28,7 +28,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     // CREATE TABLE, DROP
     if (createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemDBMJsonSchema.build(), { dropIfExists: true });
+            await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemDBMJsonSchema, { dropIfExists: true });
         });
     }
     if (querying) {
@@ -42,7 +42,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             if (eventualConsistencyDelay)
                 await (0, js_lib_1.pDelay)(eventualConsistencyDelay);
             expect((await db.runQuery(queryAll())).rows).toEqual([]);
-            expect(await db.runQueryCount(queryAll())).toEqual(0);
+            expect(await db.runQueryCount(queryAll())).toBe(0);
         });
     }
     // GET empty
@@ -68,7 +68,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
             const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([item3], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBe(null);
+            expect(item3Loaded.k2).toBeNull();
         });
     }
     if (documentDB) {
@@ -83,7 +83,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
             const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([expected], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBe(undefined);
+            expect(item3Loaded.k2).toBeUndefined();
             expect(Object.keys(item3Loaded)).not.toContain('k2');
         });
     }

package/dist/testing/test.model.d.ts

@@ -17,8 +17,8 @@ export interface TestItemTM {
 export declare const testItemBMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemBM, TestItemBM>;
 export declare const testItemDBMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemDBM, TestItemDBM>;
 export declare const testItemTMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemTM, TestItemTM>;
-export declare const testItemBMJsonSchema: import("@naturalcycles/js-lib/dist/json-schema/jsonSchemaBuilder").JsonSchemaObjectBuilder<TestItemBM & Partial<import("@naturalcycles/js-lib").SavedDBEntity<string>>>;
-export declare const testItemDBMJsonSchema: import("@naturalcycles/js-lib/dist/json-schema/jsonSchemaBuilder").JsonSchemaObjectBuilder<TestItemDBM>;
+export declare const testItemBMJsonSchema: import("@naturalcycles/js-lib").JsonSchemaObject<TestItemBM & Partial<import("@naturalcycles/js-lib").SavedDBEntity<string>>>;
+export declare const testItemDBMJsonSchema: import("@naturalcycles/js-lib").JsonSchemaObject<TestItemDBM>;
 export declare function createTestItemDBM(num?: number): TestItemDBM;
 export declare function createTestItemBM(num?: number): Saved<TestItemBM>;
 export declare function createTestItemsDBM(count?: number): TestItemDBM[];

package/dist/testing/test.model.js

@@ -31,8 +31,10 @@ exports.testItemBMJsonSchema = js_lib_1.jsonSchema
     even: js_lib_1.jsonSchema.boolean().optional(),
     b1: js_lib_1.jsonSchema.buffer().optional(),
 })
-    .baseDBEntity();
-exports.testItemDBMJsonSchema = js_lib_1.jsonSchema.rootObject({
+    .baseDBEntity()
+    .build();
+exports.testItemDBMJsonSchema = js_lib_1.jsonSchema
+    .rootObject({
     // todo: figure out how to not copy-paste these 3 fields
     id: js_lib_1.jsonSchema.string(),
     created: js_lib_1.jsonSchema.unixTimestamp(),
@@ -42,7 +44,8 @@ exports.testItemDBMJsonSchema = js_lib_1.jsonSchema.rootObject({
     k3: js_lib_1.jsonSchema.number().optional(),
     even: js_lib_1.jsonSchema.boolean().optional(),
     b1: js_lib_1.jsonSchema.buffer().optional(),
-});
+})
+    .build();
 function createTestItemDBM(num = 1) {
     return {
         id: `id${num}`,

package/package.json

@@ -10,9 +10,9 @@
   },
   "devDependencies": {
     "@naturalcycles/bench-lib": "^1.0.0",
-    "@naturalcycles/dev-lib": "^12.0.1",
-    "@types/node": "^17.0.0",
-    "jest": "^28.0.3",
+    "@naturalcycles/dev-lib": "^13.0.0",
+    "@types/node": "^18.0.3",
+    "jest": "^29.0.0",
     "weak-napi": "^2.0.2"
   },
   "files": [
@@ -42,7 +42,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.39.0",
+  "version": "8.41.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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

@@ -256,11 +256,11 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     this.logFinished(started, op)
   }
 
-  sortRows<ROW>(rows: ROW[]): ROW[] {
+  private sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[] {
     rows = rows.map(r => _filterUndefinedValues(r))
 
     if (this.cfg.sortOnSave) {
-      _sortBy(rows, r => r[this.cfg.sortOnSave!.name], true)
+      _sortBy(rows, r => r[this.cfg.sortOnSave!.name as keyof ROW], true)
       if (this.cfg.sortOnSave.descending) rows.reverse() // mutates
     }
 

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

@@ -119,6 +119,12 @@ export interface CommonDaoCfg<
    */
   createId?: boolean
 
+  /**
+   * See the same option in CommonDB.
+   * Defaults to false normally.
+   */
+  assignGeneratedIds?: boolean
+
   /**
    * Defaults to true
    * Set to false to disable `created` field management.

package/src/commondao/common.dao.ts

@@ -73,6 +73,7 @@ export class CommonDao<
       logLevel: isGAE || isCI ? CommonDaoLogLevel.NONE : CommonDaoLogLevel.OPERATIONS,
       idType: 'string',
       createId: true,
+      assignGeneratedIds: false,
       created: true,
       updated: true,
       logger: console,
@@ -83,7 +84,7 @@ export class CommonDao<
         beforeDBMValidate: dbm => dbm,
         beforeDBMToBM: dbm => dbm as any,
         beforeBMToDBM: bm => bm as any,
-        beforeTMToBM: tm => tm,
+        beforeTMToBM: tm => tm as any,
         beforeBMToTM: bm => bm as any,
         anonymize: dbm => dbm,
         onValidationError: err => err,
@@ -111,9 +112,9 @@ export class CommonDao<
   }
 
   // GET
-  async getById(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getById(id?: ID, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
-  async getById(id?: ID, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
+  async getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+  async getById(id?: ID | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
+  async getById(id?: ID | null, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
     if (!id) return null
     const op = `getById(${id})`
     const table = opt.table || this.cfg.table
@@ -153,9 +154,9 @@ export class CommonDao<
     return await this.bmToDBM(bm, opt)
   }
 
-  async getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsDBM(id?: ID, opt?: CommonDaoOptions): Promise<DBM | null>
-  async getByIdAsDBM(id?: ID, opt: CommonDaoOptions = {}): Promise<DBM | null> {
+  async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+  async getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>
+  async getByIdAsDBM(id?: ID | null, opt: CommonDaoOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const op = `getByIdAsDBM(${id})`
     const table = opt.table || this.cfg.table
@@ -168,9 +169,9 @@ export class CommonDao<
     return dbm || null
   }
 
-  async getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsTM(id?: ID, opt?: CommonDaoOptions): Promise<TM | null>
-  async getByIdAsTM(id?: ID, opt: CommonDaoOptions = {}): Promise<TM | null> {
+  async getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+  async getByIdAsTM(id?: ID | null, opt?: CommonDaoOptions): Promise<TM | null>
+  async getByIdAsTM(id?: ID | null, opt: CommonDaoOptions = {}): Promise<TM | null> {
     if (!id) return null
     const op = `getByIdAsTM(${id})`
     const table = opt.table || this.cfg.table
@@ -301,7 +302,7 @@ export class CommonDao<
     const col = q._selectedFieldNames[0]!
 
     const { rows } = await this.runQueryExtended(q, opt)
-    return rows.map(r => r[col as any])
+    return rows.map((r: any) => r[col])
   }
 
   /**
@@ -593,11 +594,12 @@ export class CommonDao<
     obj.id ||= this.cfg.hooks!.createId?.(obj as BM)
 
     if (this.cfg.created) {
-      obj['created'] ||= obj['updated'] || now
+      ;(obj as any)['created'] ||= (obj as any)['updated'] || now
     }
 
     if (this.cfg.updated) {
-      obj['updated'] = opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now
+      ;(obj as any)['updated'] =
+        opt.preserveUpdatedCreated && (obj as any)['updated'] ? (obj as any)['updated'] : now
     }
 
     return obj as any
@@ -609,7 +611,7 @@ export class CommonDao<
    */
   async save(bm: Unsaved<BM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
     this.requireWriteAccess()
-    const idWasGenerated = !bm.id
+    const idWasGenerated = !bm.id && this.cfg.createId
     this.assignIdCreatedUpdated(bm, opt) // mutates
     const dbm = await this.bmToDBM(bm as BM, opt)
     const table = opt.table || this.cfg.table
@@ -619,11 +621,18 @@ export class CommonDao<
     }
     const op = `save(${dbm.id})`
     const started = this.logSaveStarted(op, bm, table)
+    const { excludeFromIndexes } = this.cfg
+    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
     await this.cfg.db.saveBatch(table, [dbm], {
-      excludeFromIndexes: this.cfg.excludeFromIndexes,
+      excludeFromIndexes,
+      assignGeneratedIds,
       ...opt,
     })
 
+    if (assignGeneratedIds) {
+      bm.id = dbm.id as any
+    }
+
     this.logSaveResult(started, op, table)
     return bm as any
   }
@@ -666,23 +675,32 @@ export class CommonDao<
 
     // assigning id in case it misses the id
     // will override/set `updated` field, unless opts.preserveUpdated is set
+    let row = dbm
     if (!opt.raw) {
-      const idWasGenerated = !dbm.id
+      const idWasGenerated = !dbm.id && this.cfg.createId
       this.assignIdCreatedUpdated(dbm, opt) // mutates
-      dbm = this.anyToDBM(dbm, opt)
-      if (opt.ensureUniqueId && idWasGenerated) await this.ensureUniqueId(table, dbm)
+      row = this.anyToDBM(dbm, opt)
+      if (opt.ensureUniqueId && idWasGenerated) await this.ensureUniqueId(table, row)
     }
     if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
       opt = { ...opt, saveMethod: 'insert' }
     }
-    const op = `saveAsDBM(${dbm.id})`
-    const started = this.logSaveStarted(op, dbm, table)
-    await this.cfg.db.saveBatch(table, [dbm], {
-      excludeFromIndexes: this.cfg.excludeFromIndexes,
+    const op = `saveAsDBM(${row.id})`
+    const started = this.logSaveStarted(op, row, table)
+    const { excludeFromIndexes } = this.cfg
+    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
+    await this.cfg.db.saveBatch(table, [row], {
+      excludeFromIndexes,
+      assignGeneratedIds,
       ...opt,
     })
+
+    if (assignGeneratedIds) {
+      dbm.id = row.id
+    }
+
     this.logSaveResult(started, op, table)
-    return dbm
+    return row
   }
 
   async saveBatch(bms: Unsaved<BM>[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>[]> {
@@ -703,12 +721,19 @@ export class CommonDao<
       50,
     )})`
     const started = this.logSaveStarted(op, bms, table)
+    const { excludeFromIndexes } = this.cfg
+    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
 
     await this.cfg.db.saveBatch(table, dbms, {
-      excludeFromIndexes: this.cfg.excludeFromIndexes,
+      excludeFromIndexes,
+      assignGeneratedIds,
       ...opt,
     })
 
+    if (assignGeneratedIds) {
+      dbms.forEach((dbm, i) => (bms[i]!.id = dbm.id as any))
+    }
+
     this.logSaveResult(started, op, table)
 
     return bms as any[]
@@ -717,39 +742,47 @@ export class CommonDao<
   async saveBatchAsDBM(dbms: DBM[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<DBM[]> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
+    let rows = dbms
     if (!opt.raw) {
       dbms.forEach(dbm => this.assignIdCreatedUpdated(dbm, opt)) // mutates
-      dbms = this.anyToDBMs(dbms, opt)
+      rows = this.anyToDBMs(dbms, opt)
       if (opt.ensureUniqueId) throw new AppError('ensureUniqueId is not supported in saveBatch')
     }
     if (this.cfg.immutable && !opt.allowMutability && !opt.saveMethod) {
       opt = { ...opt, saveMethod: 'insert' }
     }
-    const op = `saveBatchAsDBM ${dbms.length} row(s) (${_truncate(
-      dbms
+    const op = `saveBatchAsDBM ${rows.length} row(s) (${_truncate(
+      rows
         .slice(0, 10)
         .map(bm => bm.id)
         .join(', '),
       50,
     )})`
-    const started = this.logSaveStarted(op, dbms, table)
+    const started = this.logSaveStarted(op, rows, table)
+    const { excludeFromIndexes } = this.cfg
+    const assignGeneratedIds = opt.assignGeneratedIds || this.cfg.assignGeneratedIds
 
-    await this.cfg.db.saveBatch(table, dbms, {
-      excludeFromIndexes: this.cfg.excludeFromIndexes,
+    await this.cfg.db.saveBatch(table, rows, {
+      excludeFromIndexes,
+      assignGeneratedIds,
       ...opt,
     })
 
+    if (assignGeneratedIds) {
+      rows.forEach((row, i) => (dbms[i]!.id = row.id))
+    }
+
     this.logSaveResult(started, op, table)
-    return dbms
+    return rows
   }
 
   // DELETE
   /**
    * @returns number of deleted items
    */
-  async deleteById(id: undefined, opt?: CommonDaoOptions): Promise<0>
-  async deleteById(id?: ID, opt?: CommonDaoOptions): Promise<number>
-  async deleteById(id?: ID, opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteById(id: undefined | null, opt?: CommonDaoOptions): Promise<0>
+  async deleteById(id?: ID | null, opt?: CommonDaoOptions): Promise<number>
+  async deleteById(id?: ID | null, opt: CommonDaoOptions = {}): Promise<number> {
     if (!id) return 0
     this.requireWriteAccess()
     this.requireObjectMutability(opt)

package/src/db.model.ts

@@ -24,6 +24,14 @@ export interface CommonDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyObje
    * Default is `upsert`
    */
   saveMethod?: CommonDBSaveMethod
+
+  /**
+   * Only applicable to tables where id is "auto-generated by DB", e.g `auto_increment` in MySQL.
+   * By default it's false, so, auto-generated id will NOT be assigned/returned.
+   * Setting it to true will assign and return auto-generated id (on all rows, one by one).
+   * It's not true by default, because getting auto-generated id incurs an overhead of doing extra call (e.g LAST_INSERT_ID() in MySQL).
+   */
+  assignGeneratedIds?: boolean
 }
 
 export type CommonDBStreamOptions = CommonDBOptions

package/src/query/dbQuery.ts

@@ -186,8 +186,8 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     }
 
     tokens.push(
-      ...this._filters.map(f => `${f.name}${f.op}${f.val}`),
-      ...this._orders.map(o => `order by ${o.name}${o.descending ? ' desc' : ''}`),
+      ...this._filters.map(f => `${f.name as string}${f.op}${f.val}`),
+      ...this._orders.map(o => `order by ${o.name as string}${o.descending ? ' desc' : ''}`),
     )
 
     if (this._groupByFieldNames) {

package/src/testing/daoTest.ts

@@ -66,7 +66,7 @@ export function runCommonDaoTest(
   // CREATE TABLE, DROP
   if (createTable) {
     test('createTable, dropIfExists=true', async () => {
-      await dao.createTable(testItemDBMJsonSchema.build(), { dropIfExists: true })
+      await dao.createTable(testItemDBMJsonSchema, { dropIfExists: true })
     })
   }
 
@@ -84,7 +84,7 @@ export function runCommonDaoTest(
     test('runQuery(all), runQueryCount should return empty', async () => {
       if (eventualConsistencyDelay) await pDelay(eventualConsistencyDelay)
       expect(await dao.query().runQuery()).toEqual([])
-      expect(await dao.query().runQueryCount()).toEqual(0)
+      expect(await dao.query().runQueryCount()).toBe(0)
     })
   }
 
@@ -114,7 +114,7 @@ export function runCommonDaoTest(
       await dao.save(item3)
       const item3Loaded = await dao.requireById(item3.id)
       expectMatch([item3], [item3Loaded], quirks)
-      expect(item3Loaded.k2).toBe(null)
+      expect(item3Loaded.k2).toBeNull()
       expect(Object.keys(item3)).toContain('k2')
       expect(item3.k2).toBeNull()
     })
@@ -135,7 +135,7 @@ export function runCommonDaoTest(
 
     const item3Loaded = await dao.requireById(item3.id)
     expectMatch([expected], [item3Loaded], quirks)
-    expect(item3Loaded.k2).toBe(undefined)
+    expect(item3Loaded.k2).toBeUndefined()
     expect(Object.keys(item3Loaded)).not.toContain('k2')
     expect(Object.keys(item3)).toContain('k2')
     expect(item3.k2).toBeUndefined()

package/src/testing/dbTest.ts

@@ -110,7 +110,7 @@ export function runCommonDBTest(
   // CREATE TABLE, DROP
   if (createTable) {
     test('createTable, dropIfExists=true', async () => {
-      await db.createTable(TEST_TABLE, testItemDBMJsonSchema.build(), { dropIfExists: true })
+      await db.createTable(TEST_TABLE, testItemDBMJsonSchema, { dropIfExists: true })
     })
   }
 
@@ -128,7 +128,7 @@ export function runCommonDBTest(
     test('runQuery(all), runQueryCount should return empty', async () => {
       if (eventualConsistencyDelay) await pDelay(eventualConsistencyDelay)
       expect((await db.runQuery(queryAll())).rows).toEqual([])
-      expect(await db.runQueryCount(queryAll())).toEqual(0)
+      expect(await db.runQueryCount(queryAll())).toBe(0)
     })
   }
 
@@ -158,7 +158,7 @@ export function runCommonDBTest(
       await db.saveBatch(TEST_TABLE, [item3])
       const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
       expectMatch([item3], [item3Loaded], quirks)
-      expect(item3Loaded.k2).toBe(null)
+      expect(item3Loaded.k2).toBeNull()
     })
   }
 
@@ -175,7 +175,7 @@ export function runCommonDBTest(
       await db.saveBatch(TEST_TABLE, [item3])
       const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
       expectMatch([expected], [item3Loaded], quirks)
-      expect(item3Loaded.k2).toBe(undefined)
+      expect(item3Loaded.k2).toBeUndefined()
       expect(Object.keys(item3Loaded)).not.toContain('k2')
     })
   }

package/src/testing/test.model.ts

@@ -58,18 +58,21 @@ export const testItemBMJsonSchema = jsonSchema
     b1: jsonSchema.buffer().optional(),
   })
   .baseDBEntity()
+  .build()
 
-export const testItemDBMJsonSchema = jsonSchema.rootObject<TestItemDBM>({
-  // todo: figure out how to not copy-paste these 3 fields
-  id: jsonSchema.string(),
-  created: jsonSchema.unixTimestamp(),
-  updated: jsonSchema.unixTimestamp(),
-  k1: jsonSchema.string(),
-  k2: jsonSchema.string().optional(),
-  k3: jsonSchema.number().optional(),
-  even: jsonSchema.boolean().optional(),
-  b1: jsonSchema.buffer().optional(),
-})
+export const testItemDBMJsonSchema = jsonSchema
+  .rootObject<TestItemDBM>({
+    // todo: figure out how to not copy-paste these 3 fields
+    id: jsonSchema.string(),
+    created: jsonSchema.unixTimestamp(),
+    updated: jsonSchema.unixTimestamp(),
+    k1: jsonSchema.string(),
+    k2: jsonSchema.string().optional(),
+    k3: jsonSchema.number().optional(),
+    even: jsonSchema.boolean().optional(),
+    b1: jsonSchema.buffer().optional(),
+  })
+  .build()
 
 export function createTestItemDBM(num = 1): TestItemDBM {
   return {