@naturalcycles/db-lib 10.17.2 → 10.19.0

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

@@ -1,7 +1,7 @@
 import type { Transform } from 'node:stream';
 import type { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib/json-schema';
 import type { CommonLogger } from '@naturalcycles/js-lib/log';
-import type { AsyncIndexedMapper, BaseDBEntity, StringMap, UnixTimestampMillis, Unsaved } from '@naturalcycles/js-lib/types';
+import { type AsyncIndexedMapper, type BaseDBEntity, type NonNegativeInteger, type StringMap, type UnixTimestampMillis, type Unsaved } from '@naturalcycles/js-lib/types';
 import { type ReadableTyped } from '@naturalcycles/nodejs-lib/stream';
 import type { CommonDBTransactionOptions, DBTransaction, RunQueryResult } from '../db.model.js';
 import type { DBQuery } from '../query/dbQuery.js';
@@ -14,7 +14,7 @@ import type { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoP
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> {
+export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID extends string = BM['id']> {
     cfg: CommonDaoCfg<BM, DBM, ID>;
     constructor(cfg: CommonDaoCfg<BM, DBM, ID>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): BM;
@@ -167,6 +167,26 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
+    withId(id: ID): DaoWithId<typeof this>;
+    withIds(ids: ID[]): DaoWithIds<typeof this>;
+    toSave(input: BM | BM[]): DaoWithRows<typeof this>;
+    /**
+     * Load rows (by their ids) from Multiple tables at once.
+     * An optimized way to load data, minimizing DB round-trips.
+     *
+     * @experimental.
+     */
+    static multiGet<MAP extends Record<string, DaoWithIds<AnyDao> | DaoWithId<AnyDao>>>(inputMap: MAP, opt?: CommonDaoReadOptions): Promise<{
+        [K in keyof MAP]: MAP[K] extends DaoWithIds<any> ? InferBM<MAP[K]['dao']>[] : InferBM<MAP[K]['dao']> | null;
+    }>;
+    private static prepareMultiGetIds;
+    private static multiGetMapByTableById;
+    private static prepareMultiGetOutput;
+    /**
+     * Very @experimental.
+     */
+    static multiDeleteByIds(inputs: DaoWithIds<any>[], _opt?: CommonDaoOptions): Promise<NonNegativeInteger>;
+    static multiSave(inputs: DaoWithRows<any>[], opt?: CommonDaoSaveBatchOptions<any>): Promise<void>;
     createTransaction(opt?: CommonDBTransactionOptions): Promise<CommonDaoTransaction>;
     runInTransaction<T = void>(fn: CommonDaoTransactionFn<T>, opt?: CommonDBTransactionOptions): Promise<T>;
     /**
@@ -202,8 +222,8 @@ export declare class CommonDaoTransaction {
      * Never throws.
      */
     rollback(): Promise<void>;
-    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, id?: ID | null, opt?: CommonDaoReadOptions): Promise<BM | null>;
-    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, ids: ID[], opt?: CommonDaoReadOptions): Promise<BM[]>;
+    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(dao: CommonDao<BM, DBM, ID>, id?: ID | null, opt?: CommonDaoReadOptions): Promise<BM | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(dao: CommonDao<BM, DBM, ID>, ids: ID[], opt?: CommonDaoReadOptions): Promise<BM[]>;
     save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
     saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
     /**
@@ -213,7 +233,23 @@ export declare class CommonDaoTransaction {
      *
      * So, this method is a rather simple convenience "Object.assign and then save".
      */
-    patch<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
-    deleteById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, id?: ID | null, opt?: CommonDaoOptions): Promise<number>;
-    deleteByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, ids: ID[], opt?: CommonDaoOptions): Promise<number>;
+    patch<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(dao: CommonDao<BM, DBM, ID>, bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
+    deleteById<DAO extends AnyDao>(dao: DAO, id?: InferID<DAO> | null, opt?: CommonDaoOptions): Promise<number>;
+    deleteByIds<DAO extends AnyDao>(dao: DAO, ids: InferID<DAO>[], opt?: CommonDaoOptions): Promise<number>;
+}
+export interface DaoWithIds<DAO extends AnyDao> {
+    dao: DAO;
+    ids: string[];
+}
+export interface DaoWithId<DAO extends AnyDao> {
+    dao: DAO;
+    id: string;
+}
+export interface DaoWithRows<DAO extends AnyDao> {
+    dao: DAO;
+    rows: InferBM<DAO>[];
 }
+type InferBM<DAO> = DAO extends CommonDao<infer BM> ? BM : never;
+type InferID<DAO> = DAO extends CommonDao<any, any, infer ID> ? ID : never;
+export type AnyDao = CommonDao<any>;
+export {};

package/dist/commondao/common.dao.js

@@ -7,6 +7,7 @@ import { _deepJsonEquals } from '@naturalcycles/js-lib/object/deepEquals.js';
 import { _deepCopy, _filterUndefinedValues, _objectAssignExact, } from '@naturalcycles/js-lib/object/object.util.js';
 import { pMap } from '@naturalcycles/js-lib/promise/pMap.js';
 import { _truncate } from '@naturalcycles/js-lib/string/string.util.js';
+import { _stringMapEntries, _stringMapValues, } from '@naturalcycles/js-lib/types';
 import { _passthroughPredicate, _typeCast, SKIP } from '@naturalcycles/js-lib/types';
 import { stringId } from '@naturalcycles/nodejs-lib';
 import { transformFlatten } from '@naturalcycles/nodejs-lib/stream';
@@ -981,6 +982,122 @@ export class CommonDao {
     async ping() {
         await this.cfg.db.ping();
     }
+    withId(id) {
+        return {
+            dao: this,
+            id,
+        };
+    }
+    withIds(ids) {
+        return {
+            dao: this,
+            ids,
+        };
+    }
+    toSave(input) {
+        return {
+            dao: this,
+            rows: [input].flat(),
+        };
+    }
+    /**
+     * Load rows (by their ids) from Multiple tables at once.
+     * An optimized way to load data, minimizing DB round-trips.
+     *
+     * @experimental.
+     */
+    static async multiGet(inputMap, opt = {}) {
+        const db = Object.values(inputMap)[0]?.dao.cfg.db;
+        if (!db) {
+            return {};
+        }
+        const idsByTable = CommonDao.prepareMultiGetIds(inputMap);
+        // todo: support tx
+        const dbmsByTable = await db.multiGet(idsByTable, opt);
+        const dbmByTableById = CommonDao.multiGetMapByTableById(dbmsByTable);
+        return (await CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt));
+    }
+    static prepareMultiGetIds(inputMap) {
+        const idSetByTable = {};
+        for (const input of _stringMapValues(inputMap)) {
+            const { table } = input.dao.cfg;
+            idSetByTable[table] ||= new Set();
+            if ('id' in input) {
+                // Singular
+                idSetByTable[table].add(input.id);
+            }
+            else {
+                // Plural
+                for (const id of input.ids) {
+                    idSetByTable[table].add(id);
+                }
+            }
+        }
+        const idsByTable = {};
+        for (const [table, idSet] of _stringMapEntries(idSetByTable)) {
+            idsByTable[table] = [...idSet];
+        }
+        return idsByTable;
+    }
+    static multiGetMapByTableById(dbmsByTable) {
+        // We create this "map of maps", to be able to track the results back to the input props
+        // This is needed to support:
+        // - having multiple props from the same table
+        const dbmByTableById = {};
+        for (const [table, dbms] of _stringMapEntries(dbmsByTable)) {
+            dbmByTableById[table] ||= {};
+            for (const dbm of dbms) {
+                dbmByTableById[table][dbm.id] = dbm;
+            }
+        }
+        return dbmByTableById;
+    }
+    static async prepareMultiGetOutput(inputMap, dbmByTableById, opt = {}) {
+        const bmsByProp = {};
+        // Loop over input props again, to produce the output of the same shape as requested
+        await pMap(_stringMapEntries(inputMap), async ([prop, input]) => {
+            const { dao } = input;
+            const { table } = dao.cfg;
+            if ('id' in input) {
+                // Singular
+                const dbm = dbmByTableById[table][input.id];
+                bmsByProp[prop] = (await dao.dbmToBM(dbm, opt)) || null;
+            }
+            else {
+                // Plural
+                // We apply filtering, to be able to support multiple input props fetching from the same table.
+                // Without filtering - every prop will get ALL rows from that table.
+                const dbms = input.ids.map(id => dbmByTableById[table][id]).filter(_isTruthy);
+                bmsByProp[prop] = await dao.dbmsToBM(dbms, opt);
+            }
+        });
+        return bmsByProp;
+    }
+    /**
+     * Very @experimental.
+     */
+    static async multiDeleteByIds(inputs, _opt = {}) {
+        if (!inputs.length)
+            return 0;
+        const { db } = inputs[0].dao.cfg;
+        const idsByTable = {};
+        for (const { dao, ids } of inputs) {
+            idsByTable[dao.cfg.table] = ids;
+        }
+        return await db.multiDelete(idsByTable);
+    }
+    static async multiSave(inputs, opt = {}) {
+        if (!inputs.length)
+            return;
+        const { db } = inputs[0].dao.cfg;
+        const dbmsByTable = {};
+        await pMap(inputs, async ({ dao, rows }) => {
+            const { table } = dao.cfg;
+            rows.forEach(bm => dao.assignIdCreatedUpdated(bm, opt));
+            dbmsByTable[table] = await dao.bmsToDBM(rows, opt);
+        });
+        await db.multiSave(dbmsByTable);
+    }
     async createTransaction(opt) {
         const tx = await this.cfg.db.createTransaction(opt);
         return new CommonDaoTransaction(tx, this.cfg.logger);
@@ -1134,6 +1251,7 @@ export class CommonDaoTransaction {
         Object.assign(bm, patch);
         return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx });
     }
+    // todo: use AnyDao/Infer in other methods as well, if this works well
     async deleteById(dao, id, opt) {
         if (!id)
             return 0;

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

@@ -1,7 +1,7 @@
 import type { ValidationFunction } from '@naturalcycles/js-lib';
 import type { AppError, ErrorMode } from '@naturalcycles/js-lib/error';
 import type { CommonLogger } from '@naturalcycles/js-lib/log';
-import type { BaseDBEntity, NumberOfMilliseconds, Promisable, UnixTimestamp } from '@naturalcycles/js-lib/types';
+import type { BaseDBEntity, Promisable, UnixTimestamp } from '@naturalcycles/js-lib/types';
 import type { TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib/stream';
 import type { CommonDB } from '../commondb/common.db.js';
 import type { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model.js';
@@ -332,8 +332,3 @@ export interface CommonDaoStreamOptions<IN> extends CommonDaoReadOptions, Transf
     chunkConcurrency?: number;
 }
 export type CommonDaoCreateOptions = CommonDBCreateOptions;
-export interface OnValidationTimeData {
-    tookMillis: NumberOfMilliseconds;
-    table: string;
-    obj: any;
-}

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

@@ -1,7 +1,7 @@
 import type { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib/json-schema';
 import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib/stream';
-import type { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBTransaction, DBTransactionFn, RunQueryResult } from '../db.model.js';
+import type { CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBTransaction, DBTransactionFn, RunQueryResult } from '../db.model.js';
 import type { DBQuery } from '../query/dbQuery.js';
 import type { CommonDB, CommonDBSupport } from './common.db.js';
 import { CommonDBType } from './common.db.js';
@@ -19,6 +19,7 @@ export declare class BaseCommonDB implements CommonDB {
     getByIds<ROW extends ObjectWithId>(_table: string, _ids: string[]): Promise<ROW[]>;
     deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
     patchByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>, _patch: Partial<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    patchById<ROW extends ObjectWithId>(_table: string, _id: string, _patch: Partial<ROW>, _opt?: CommonDBOptions): Promise<void>;
     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>;
@@ -27,4 +28,7 @@ export declare class BaseCommonDB implements CommonDB {
     runInTransaction(fn: DBTransactionFn, _opt?: CommonDBTransactionOptions): Promise<void>;
     createTransaction(_opt?: CommonDBTransactionOptions): Promise<DBTransaction>;
     incrementBatch(_table: string, _prop: string, _incrementMap: StringMap<number>, _opt?: CommonDBOptions): Promise<StringMap<number>>;
+    multiGet<ROW extends ObjectWithId>(_map: StringMap<string[]>, _opt?: CommonDBReadOptions): Promise<StringMap<ROW[]>>;
+    multiSave<ROW extends ObjectWithId>(_map: StringMap<ROW[]>, _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    multiDelete(_map: StringMap<string[]>, _opt?: CommonDBOptions): Promise<number>;
 }

package/dist/commondb/base.common.db.js

@@ -28,6 +28,9 @@ export class BaseCommonDB {
     async patchByQuery(_q, _patch, _opt) {
         throw new Error('patchByQuery is not implemented');
     }
+    async patchById(_table, _id, _patch, _opt) {
+        throw new Error('patchById is not implemented');
+    }
     async runQuery(_q) {
         throw new Error('runQuery is not implemented');
     }
@@ -54,4 +57,13 @@ export class BaseCommonDB {
     async incrementBatch(_table, _prop, _incrementMap, _opt) {
         throw new Error('incrementBatch is not implemented');
     }
+    async multiGet(_map, _opt) {
+        throw new Error('multiGetByIds is not implemented');
+    }
+    async multiSave(_map, _opt) {
+        throw new Error('multiSaveBatch is not implemented');
+    }
+    async multiDelete(_map, _opt) {
+        throw new Error('multiDeleteByIds is not implemented');
+    }
 }

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

@@ -1,12 +1,8 @@
 import type { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib/json-schema';
-import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types';
+import type { NonNegativeInteger, ObjectWithId, StringMap } from '@naturalcycles/js-lib/types';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib/stream';
 import type { CommonDBCreateOptions, CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBTransaction, DBTransactionFn, RunQueryResult } from '../db.model.js';
 import type { DBQuery } from '../query/dbQuery.js';
-export declare enum CommonDBType {
-    'document' = "document",
-    'relational' = "relational"
-}
 export interface CommonDB {
     /**
      * Relational databases are expected to return `null` for all missing properties.
@@ -44,26 +40,83 @@ export interface CommonDB {
      * (Such limitation exists because Datastore doesn't support it).
      */
     getByIds: <ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBReadOptions) => Promise<ROW[]>;
+    /**
+     * Get rows from multiple tables at once.
+     * Mimics the API of some NoSQL databases like Firestore.
+     *
+     * Takes `map`, which is a map from "table name" to an array of ids.
+     * Example:
+     * {
+     *   'TableOne': ['id1', 'id2'],
+     *   'TableTwo': ['id3'],
+     * }
+     *
+     * Returns a map with the same keys (table names) and arrays of rows as values.
+     * Even if some table is not found, it will return an empty array of results for that table.
+     *
+     * @experimental
+     */
+    multiGet: <ROW extends ObjectWithId>(idsByTable: StringMap<string[]>, opt?: CommonDBReadOptions) => Promise<StringMap<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?: CommonDBReadOptions) => Promise<RunQueryResult<ROW>>;
-    runQueryCount: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBReadOptions) => Promise<number>;
+    runQueryCount: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBReadOptions) => Promise<NonNegativeInteger>;
     streamQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions) => ReadableTyped<ROW>;
     /**
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
     saveBatch: <ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
+    /**
+     * Save rows for multiple tables at once.
+     * Mimics the API of some NoSQL databases like Firestore.
+     *
+     * Takes `map`, which is a map from "table name" to an array of rows.
+     * Example:
+     * {
+     *  'TableOne': [{ id: 'id1', ... }, { id: 'id2', ... }],
+     *  'TableTwo': [{ id: 'id3', ... }],
+     * }
+     *
+     * @experimental
+     */
+    multiSave: <ROW extends ObjectWithId>(rowsByTable: StringMap<ROW[]>, opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
+    /**
+     * Perform a partial update of a row by its id.
+     * Unlike save - doesn't require to first load the doc.
+     * Mimics the API of some NoSQL databases like Firestore.
+     *
+     * The object with given id has to exist, otherwise an error will be thrown.
+     *
+     * @experimental
+     */
+    patchById: <ROW extends ObjectWithId>(table: string, id: string, patch: Partial<ROW>, opt?: CommonDBOptions) => 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: (table: string, ids: string[], opt?: CommonDBOptions) => Promise<NonNegativeInteger>;
     /**
+     * Deletes rows from multiple tables at once.
+     * Mimics the API of some NoSQL databases like Firestore.
+     * Takes `map`, which is a map from "table name" to an array of ids to delete.
+     * Example:
+     * {
+     *  'TableOne': ['id1', 'id2'],
+     *  'TableTwo': ['id3'],
+     * }
+     *
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
+     *
+     * @experimental
      */
-    deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    multiDelete: (idsByTable: StringMap<string[]>, opt?: CommonDBOptions) => Promise<NonNegativeInteger>;
+    /**
+     * Returns number of deleted items.
+     * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
+     */
+    deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<NonNegativeInteger>;
     /**
      * Applies patch to all the rows that are matched by the query.
      *
@@ -111,6 +164,10 @@ export interface CommonDB {
      */
     incrementBatch: (table: string, prop: string, incrementMap: StringMap<number>, opt?: CommonDBOptions) => Promise<StringMap<number>>;
 }
+export declare enum CommonDBType {
+    'document' = "document",
+    'relational' = "relational"
+}
 /**
  * Manifest of supported features.
  */
@@ -123,6 +180,7 @@ export interface CommonDBSupport {
     insertSaveMethod?: boolean;
     updateSaveMethod?: boolean;
     patchByQuery?: boolean;
+    patchById?: boolean;
     increment?: boolean;
     createTable?: boolean;
     tableSchemas?: boolean;
@@ -131,5 +189,6 @@ export interface CommonDBSupport {
     nullValues?: boolean;
     transactions?: boolean;
     timeMachine?: boolean;
+    multiTableOperations?: boolean;
 }
-export declare const commonDBFullSupport: CommonDBSupport;
+export declare const commonDBFullSupport: Required<CommonDBSupport>;

package/dist/commondb/common.db.js

@@ -12,6 +12,7 @@ export const commonDBFullSupport = {
     insertSaveMethod: true,
     updateSaveMethod: true,
     patchByQuery: true,
+    patchById: true,
     increment: true,
     createTable: true,
     tableSchemas: true,
@@ -20,4 +21,5 @@ export const commonDBFullSupport = {
     nullValues: true,
     transactions: true,
     timeMachine: true,
+    multiTableOperations: true,
 };

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

@@ -50,9 +50,13 @@ export declare class InMemoryDB implements CommonDB {
     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[]>;
+    multiGet<ROW extends ObjectWithId>(map: StringMap<string[]>, _opt?: CommonDBOptions): Promise<StringMap<ROW[]>>;
     saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    multiSave<ROW extends ObjectWithId>(map: StringMap<ROW[]>, opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    patchById<ROW extends ObjectWithId>(_table: string, id: string, patch: Partial<ROW>, _opt?: CommonDBOptions): Promise<void>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
+    multiDelete(map: StringMap<string[]>, _opt?: CommonDBOptions): Promise<number>;
     patchByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: Partial<ROW>): 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/inmemory/inMemory.db.js

@@ -74,18 +74,28 @@ export class InMemoryDB {
         this.data[table] ||= {};
         return ids.map(id => this.data[table][id]).filter(Boolean);
     }
+    async multiGet(map, _opt = {}) {
+        const result = {};
+        for (const [tableName, ids] of _stringMapEntries(map)) {
+            const table = this.cfg.tablesPrefix + tableName;
+            result[table] = ids.map(id => this.data[table]?.[id]).filter(Boolean);
+        }
+        return result;
+    }
     async saveBatch(_table, rows, opt = {}) {
         const table = this.cfg.tablesPrefix + _table;
         this.data[table] ||= {};
+        const isInsert = opt.saveMethod === 'insert';
+        const isUpdate = opt.saveMethod === 'update';
         for (const r of rows) {
             if (!r.id) {
                 this.cfg.logger.warn({ rows });
                 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]) {
+            if (isInsert && 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]) {
+            if (isUpdate && !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:
@@ -94,6 +104,16 @@ export class InMemoryDB {
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), bufferReviver);
         }
     }
+    async multiSave(map, opt = {}) {
+        for (const [table, rows] of _stringMapEntries(map)) {
+            await this.saveBatch(table, rows, opt);
+        }
+    }
+    async patchById(_table, id, patch, _opt) {
+        const table = this.cfg.tablesPrefix + _table;
+        _assert(!this.data[table]?.[id], `InMemoryDB: patchById failed, entity doesn't exist: ${table}.${id}`);
+        Object.assign(this.data[table][id], patch);
+    }
     async deleteByQuery(q, _opt) {
         const table = this.cfg.tablesPrefix + q.table;
         if (!this.data[table])
@@ -114,6 +134,13 @@ export class InMemoryDB {
         }
         return count;
     }
+    async multiDelete(map, _opt) {
+        let count = 0;
+        for (const [table, ids] of _stringMapEntries(map)) {
+            count += await this.deleteByIds(table, ids, _opt);
+        }
+        return count;
+    }
     async patchByQuery(q, patch) {
         if (_isEmptyObject(patch))
             return 0;

package/dist/query/dbQuery.d.ts

@@ -87,7 +87,7 @@ export declare class DBQuery<ROW extends ObjectWithId> {
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> extends DBQuery<DBM> {
+export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID extends string = BM['id']> extends DBQuery<DBM> {
     dao: CommonDao<BM, DBM, ID>;
     /**
      * Pass `table` to override table.

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

@@ -2,6 +2,7 @@ import type { JsonSchemaObject } from '@naturalcycles/js-lib/json-schema';
 import type { BaseDBEntity } from '@naturalcycles/js-lib/types';
 import { type ObjectSchema } from '@naturalcycles/nodejs-lib/joi';
 export declare const TEST_TABLE = "TEST_TABLE";
+export declare const TEST_TABLE_2 = "TEST_TABLE_2";
 export interface TestItemBM extends BaseDBEntity {
     k1: string;
     k2?: string | null;

package/dist/testing/test.model.js

@@ -3,6 +3,7 @@ import { j } from '@naturalcycles/js-lib/json-schema';
 import { baseDBEntitySchema, binarySchema, booleanSchema, numberSchema, objectSchema, stringSchema, } from '@naturalcycles/nodejs-lib/joi';
 const MOCK_TS_2018_06_21 = 1529539200;
 export const TEST_TABLE = 'TEST_TABLE';
+export const TEST_TABLE_2 = 'TEST_TABLE_2';
 export const testItemBMSchema = objectSchema({
     k1: stringSchema,
     k2: stringSchema.allow(null).optional(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.17.2",
+  "version": "10.19.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

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

@@ -1,12 +1,7 @@
 import type { ValidationFunction } from '@naturalcycles/js-lib'
 import type { AppError, ErrorMode } from '@naturalcycles/js-lib/error'
 import type { CommonLogger } from '@naturalcycles/js-lib/log'
-import type {
-  BaseDBEntity,
-  NumberOfMilliseconds,
-  Promisable,
-  UnixTimestamp,
-} from '@naturalcycles/js-lib/types'
+import type { BaseDBEntity, Promisable, UnixTimestamp } from '@naturalcycles/js-lib/types'
 import type {
   TransformLogProgressOptions,
   TransformMapOptions,
@@ -403,9 +398,3 @@ export interface CommonDaoStreamOptions<IN>
 }
 
 export type CommonDaoCreateOptions = CommonDBCreateOptions
-
-export interface OnValidationTimeData {
-  tookMillis: NumberOfMilliseconds
-  table: string
-  obj: any
-}

package/src/commondao/common.dao.ts

@@ -14,13 +14,16 @@ import {
 } from '@naturalcycles/js-lib/object/object.util.js'
 import { pMap } from '@naturalcycles/js-lib/promise/pMap.js'
 import { _truncate } from '@naturalcycles/js-lib/string/string.util.js'
-import type {
-  AsyncIndexedMapper,
-  BaseDBEntity,
-  ObjectWithId,
-  StringMap,
-  UnixTimestampMillis,
-  Unsaved,
+import {
+  _stringMapEntries,
+  _stringMapValues,
+  type AsyncIndexedMapper,
+  type BaseDBEntity,
+  type NonNegativeInteger,
+  type ObjectWithId,
+  type StringMap,
+  type UnixTimestampMillis,
+  type Unsaved,
 } from '@naturalcycles/js-lib/types'
 import { _passthroughPredicate, _typeCast, SKIP } from '@naturalcycles/js-lib/types'
 import { stringId } from '@naturalcycles/nodejs-lib'
@@ -61,7 +64,11 @@ import { CommonDaoLogLevel } from './common.dao.model.js'
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> {
+export class CommonDao<
+  BM extends BaseDBEntity,
+  DBM extends BaseDBEntity = BM,
+  ID extends string = BM['id'],
+> {
   constructor(public cfg: CommonDaoCfg<BM, DBM, ID>) {
     this.cfg = {
       logLevel: CommonDaoLogLevel.NONE,
@@ -1257,6 +1264,159 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, I
     await this.cfg.db.ping()
   }
 
+  withId(id: ID): DaoWithId<typeof this> {
+    return {
+      dao: this,
+      id,
+    }
+  }
+
+  withIds(ids: ID[]): DaoWithIds<typeof this> {
+    return {
+      dao: this,
+      ids,
+    }
+  }
+
+  toSave(input: BM | BM[]): DaoWithRows<typeof this> {
+    return {
+      dao: this,
+      rows: [input].flat() as any[],
+    }
+  }
+
+  /**
+   * Load rows (by their ids) from Multiple tables at once.
+   * An optimized way to load data, minimizing DB round-trips.
+   *
+   * @experimental.
+   */
+  static async multiGet<MAP extends Record<string, DaoWithIds<AnyDao> | DaoWithId<AnyDao>>>(
+    inputMap: MAP,
+    opt: CommonDaoReadOptions = {},
+  ): Promise<{
+    [K in keyof MAP]: MAP[K] extends DaoWithIds<any>
+      ? InferBM<MAP[K]['dao']>[]
+      : InferBM<MAP[K]['dao']> | null
+  }> {
+    const db = Object.values(inputMap)[0]?.dao.cfg.db
+    if (!db) {
+      return {} as any
+    }
+
+    const idsByTable = CommonDao.prepareMultiGetIds(inputMap)
+
+    // todo: support tx
+    const dbmsByTable = await db.multiGet(idsByTable, opt)
+
+    const dbmByTableById = CommonDao.multiGetMapByTableById(dbmsByTable)
+
+    return (await CommonDao.prepareMultiGetOutput(inputMap, dbmByTableById, opt)) as any
+  }
+
+  private static prepareMultiGetIds(
+    inputMap: StringMap<DaoWithIds<AnyDao> | DaoWithId<AnyDao>>,
+  ): StringMap<string[]> {
+    const idSetByTable: StringMap<Set<string>> = {}
+
+    for (const input of _stringMapValues(inputMap)) {
+      const { table } = input.dao.cfg
+      idSetByTable[table] ||= new Set()
+      if ('id' in input) {
+        // Singular
+        idSetByTable[table].add(input.id)
+      } else {
+        // Plural
+        for (const id of input.ids) {
+          idSetByTable[table].add(id)
+        }
+      }
+    }
+
+    const idsByTable: StringMap<string[]> = {}
+    for (const [table, idSet] of _stringMapEntries(idSetByTable)) {
+      idsByTable[table] = [...idSet]
+    }
+    return idsByTable
+  }
+
+  private static multiGetMapByTableById(
+    dbmsByTable: StringMap<ObjectWithId[]>,
+  ): StringMap<StringMap<ObjectWithId>> {
+    // We create this "map of maps", to be able to track the results back to the input props
+    // This is needed to support:
+    // - having multiple props from the same table
+    const dbmByTableById: StringMap<StringMap<ObjectWithId>> = {}
+    for (const [table, dbms] of _stringMapEntries(dbmsByTable)) {
+      dbmByTableById[table] ||= {}
+      for (const dbm of dbms) {
+        dbmByTableById[table][dbm.id] = dbm
+      }
+    }
+
+    return dbmByTableById
+  }
+
+  private static async prepareMultiGetOutput(
+    inputMap: StringMap<DaoWithIds<AnyDao> | DaoWithId<AnyDao>>,
+    dbmByTableById: StringMap<StringMap<ObjectWithId>>,
+    opt: CommonDaoReadOptions = {},
+  ): Promise<StringMap<unknown>> {
+    const bmsByProp: StringMap<unknown> = {}
+
+    // Loop over input props again, to produce the output of the same shape as requested
+    await pMap(_stringMapEntries(inputMap), async ([prop, input]) => {
+      const { dao } = input
+      const { table } = dao.cfg
+      if ('id' in input) {
+        // Singular
+        const dbm = dbmByTableById[table]![input.id]
+        bmsByProp[prop] = (await dao.dbmToBM(dbm, opt)) || null
+      } else {
+        // Plural
+        // We apply filtering, to be able to support multiple input props fetching from the same table.
+        // Without filtering - every prop will get ALL rows from that table.
+        const dbms = input.ids.map(id => dbmByTableById[table]![id]).filter(_isTruthy)
+        bmsByProp[prop] = await dao.dbmsToBM(dbms, opt)
+      }
+    })
+
+    return bmsByProp as any
+  }
+
+  /**
+   * Very @experimental.
+   */
+  static async multiDeleteByIds(
+    inputs: DaoWithIds<any>[],
+    _opt: CommonDaoOptions = {},
+  ): Promise<NonNegativeInteger> {
+    if (!inputs.length) return 0
+    const { db } = inputs[0]!.dao.cfg
+    const idsByTable: StringMap<string[]> = {}
+    for (const { dao, ids } of inputs) {
+      idsByTable[dao.cfg.table] = ids
+    }
+
+    return await db.multiDelete(idsByTable)
+  }
+
+  static async multiSave(
+    inputs: DaoWithRows<any>[],
+    opt: CommonDaoSaveBatchOptions<any> = {},
+  ): Promise<void> {
+    if (!inputs.length) return
+    const { db } = inputs[0]!.dao.cfg
+    const dbmsByTable: StringMap<any[]> = {}
+    await pMap(inputs, async ({ dao, rows }) => {
+      const { table } = dao.cfg
+      rows.forEach(bm => dao.assignIdCreatedUpdated(bm, opt))
+      dbmsByTable[table] = await dao.bmsToDBM(rows, opt)
+    })
+
+    await db.multiSave(dbmsByTable)
+  }
+
   async createTransaction(opt?: CommonDBTransactionOptions): Promise<CommonDaoTransaction> {
     const tx = await this.cfg.db.createTransaction(opt)
     return new CommonDaoTransaction(tx, this.cfg.logger!)
@@ -1395,7 +1555,7 @@ export class CommonDaoTransaction {
     }
   }
 
-  async getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+  async getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(
     dao: CommonDao<BM, DBM, ID>,
     id?: ID | null,
     opt?: CommonDaoReadOptions,
@@ -1403,7 +1563,7 @@ export class CommonDaoTransaction {
     return await dao.getById(id, { ...opt, tx: this.tx })
   }
 
-  async getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+  async getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(
     dao: CommonDao<BM, DBM, ID>,
     ids: ID[],
     opt?: CommonDaoReadOptions,
@@ -1448,7 +1608,7 @@ export class CommonDaoTransaction {
    *
    * So, this method is a rather simple convenience "Object.assign and then save".
    */
-  async patch<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+  async patch<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID extends string = BM['id']>(
     dao: CommonDao<BM, DBM, ID>,
     bm: BM,
     patch: Partial<BM>,
@@ -1459,20 +1619,42 @@ export class CommonDaoTransaction {
     return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx })
   }
 
-  async deleteById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
-    dao: CommonDao<BM, DBM, ID>,
-    id?: ID | null,
+  // todo: use AnyDao/Infer in other methods as well, if this works well
+  async deleteById<DAO extends AnyDao>(
+    dao: DAO,
+    id?: InferID<DAO> | null,
     opt?: CommonDaoOptions,
   ): Promise<number> {
     if (!id) return 0
     return await this.deleteByIds(dao, [id], opt)
   }
 
-  async deleteByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
-    dao: CommonDao<BM, DBM, ID>,
-    ids: ID[],
+  async deleteByIds<DAO extends AnyDao>(
+    dao: DAO,
+    ids: InferID<DAO>[],
     opt?: CommonDaoOptions,
   ): Promise<number> {
     return await dao.deleteByIds(ids, { ...opt, tx: this.tx })
   }
 }
+
+export interface DaoWithIds<DAO extends AnyDao> {
+  dao: DAO
+  ids: string[]
+}
+
+export interface DaoWithId<DAO extends AnyDao> {
+  dao: DAO
+  id: string
+}
+
+export interface DaoWithRows<DAO extends AnyDao> {
+  dao: DAO
+  rows: InferBM<DAO>[]
+}
+
+type InferBM<DAO> = DAO extends CommonDao<infer BM> ? BM : never
+// type InferDBM<DAO> = DAO extends CommonDao<any, infer DBM> ? DBM : never
+type InferID<DAO> = DAO extends CommonDao<any, any, infer ID> ? ID : never
+
+export type AnyDao = CommonDao<any>

package/src/commondb/base.common.db.ts

@@ -3,6 +3,7 @@ import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types'
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib/stream'
 import type {
   CommonDBOptions,
+  CommonDBReadOptions,
   CommonDBSaveOptions,
   CommonDBTransactionOptions,
   DBTransaction,
@@ -60,6 +61,15 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('patchByQuery is not implemented')
   }
 
+  async patchById<ROW extends ObjectWithId>(
+    _table: string,
+    _id: string,
+    _patch: Partial<ROW>,
+    _opt?: CommonDBOptions,
+  ): Promise<void> {
+    throw new Error('patchById is not implemented')
+  }
+
   async runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
     throw new Error('runQuery is not implemented')
   }
@@ -102,4 +112,22 @@ export class BaseCommonDB implements CommonDB {
   ): Promise<StringMap<number>> {
     throw new Error('incrementBatch is not implemented')
   }
+
+  async multiGet<ROW extends ObjectWithId>(
+    _map: StringMap<string[]>,
+    _opt?: CommonDBReadOptions,
+  ): Promise<StringMap<ROW[]>> {
+    throw new Error('multiGetByIds is not implemented')
+  }
+
+  async multiSave<ROW extends ObjectWithId>(
+    _map: StringMap<ROW[]>,
+    _opt?: CommonDBSaveOptions<ROW>,
+  ): Promise<void> {
+    throw new Error('multiSaveBatch is not implemented')
+  }
+
+  async multiDelete(_map: StringMap<string[]>, _opt?: CommonDBOptions): Promise<number> {
+    throw new Error('multiDeleteByIds is not implemented')
+  }
 }

package/src/commondb/common.db.ts

@@ -1,5 +1,5 @@
 import type { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib/json-schema'
-import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types'
+import type { NonNegativeInteger, ObjectWithId, StringMap } from '@naturalcycles/js-lib/types'
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib/stream'
 import type {
   CommonDBCreateOptions,
@@ -14,11 +14,6 @@ import type {
 } from '../db.model.js'
 import type { DBQuery } from '../query/dbQuery.js'
 
-export enum CommonDBType {
-  'document' = 'document',
-  'relational' = 'relational',
-}
-
 export interface CommonDB {
   /**
    * Relational databases are expected to return `null` for all missing properties.
@@ -72,6 +67,27 @@ export interface CommonDB {
     opt?: CommonDBReadOptions,
   ) => Promise<ROW[]>
 
+  /**
+   * Get rows from multiple tables at once.
+   * Mimics the API of some NoSQL databases like Firestore.
+   *
+   * Takes `map`, which is a map from "table name" to an array of ids.
+   * Example:
+   * {
+   *   'TableOne': ['id1', 'id2'],
+   *   'TableTwo': ['id3'],
+   * }
+   *
+   * Returns a map with the same keys (table names) and arrays of rows as values.
+   * Even if some table is not found, it will return an empty array of results for that table.
+   *
+   * @experimental
+   */
+  multiGet: <ROW extends ObjectWithId>(
+    idsByTable: StringMap<string[]>,
+    opt?: CommonDBReadOptions,
+  ) => Promise<StringMap<ROW[]>>
+
   // QUERY
   /**
    * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
@@ -84,7 +100,7 @@ export interface CommonDB {
   runQueryCount: <ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     opt?: CommonDBReadOptions,
-  ) => Promise<number>
+  ) => Promise<NonNegativeInteger>
 
   streamQuery: <ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
@@ -101,12 +117,66 @@ export interface CommonDB {
     opt?: CommonDBSaveOptions<ROW>,
   ) => Promise<void>
 
+  /**
+   * Save rows for multiple tables at once.
+   * Mimics the API of some NoSQL databases like Firestore.
+   *
+   * Takes `map`, which is a map from "table name" to an array of rows.
+   * Example:
+   * {
+   *  'TableOne': [{ id: 'id1', ... }, { id: 'id2', ... }],
+   *  'TableTwo': [{ id: 'id3', ... }],
+   * }
+   *
+   * @experimental
+   */
+  multiSave: <ROW extends ObjectWithId>(
+    rowsByTable: StringMap<ROW[]>,
+    opt?: CommonDBSaveOptions<ROW>,
+  ) => Promise<void>
+
+  /**
+   * Perform a partial update of a row by its id.
+   * Unlike save - doesn't require to first load the doc.
+   * Mimics the API of some NoSQL databases like Firestore.
+   *
+   * The object with given id has to exist, otherwise an error will be thrown.
+   *
+   * @experimental
+   */
+  patchById: <ROW extends ObjectWithId>(
+    table: string,
+    id: string,
+    patch: Partial<ROW>,
+    opt?: CommonDBOptions,
+  ) => Promise<void>
+
   // DELETE
   /**
    * 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: (table: string, ids: string[], opt?: CommonDBOptions) => Promise<NonNegativeInteger>
+
+  /**
+   * Deletes rows from multiple tables at once.
+   * Mimics the API of some NoSQL databases like Firestore.
+   * Takes `map`, which is a map from "table name" to an array of ids to delete.
+   * Example:
+   * {
+   *  'TableOne': ['id1', 'id2'],
+   *  'TableTwo': ['id3'],
+   * }
+   *
+   * Returns number of deleted items.
+   * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
+   *
+   * @experimental
+   */
+  multiDelete: (
+    idsByTable: StringMap<string[]>,
+    opt?: CommonDBOptions,
+  ) => Promise<NonNegativeInteger>
 
   /**
    * Returns number of deleted items.
@@ -115,7 +185,7 @@ export interface CommonDB {
   deleteByQuery: <ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     opt?: CommonDBOptions,
-  ) => Promise<number>
+  ) => Promise<NonNegativeInteger>
 
   /**
    * Applies patch to all the rows that are matched by the query.
@@ -178,6 +248,11 @@ export interface CommonDB {
   ) => Promise<StringMap<number>>
 }
 
+export enum CommonDBType {
+  'document' = 'document',
+  'relational' = 'relational',
+}
+
 /**
  * Manifest of supported features.
  */
@@ -190,6 +265,7 @@ export interface CommonDBSupport {
   insertSaveMethod?: boolean
   updateSaveMethod?: boolean
   patchByQuery?: boolean
+  patchById?: boolean
   increment?: boolean
   createTable?: boolean
   tableSchemas?: boolean
@@ -198,9 +274,10 @@ export interface CommonDBSupport {
   nullValues?: boolean
   transactions?: boolean
   timeMachine?: boolean
+  multiTableOperations?: boolean
 }
 
-export const commonDBFullSupport: CommonDBSupport = {
+export const commonDBFullSupport: Required<CommonDBSupport> = {
   queries: true,
   dbQueryFilter: true,
   dbQueryFilterIn: true,
@@ -209,6 +286,7 @@ export const commonDBFullSupport: CommonDBSupport = {
   insertSaveMethod: true,
   updateSaveMethod: true,
   patchByQuery: true,
+  patchById: true,
   increment: true,
   createTable: true,
   tableSchemas: true,
@@ -217,4 +295,5 @@ export const commonDBFullSupport: CommonDBSupport = {
   nullValues: true,
   transactions: true,
   timeMachine: true,
+  multiTableOperations: true,
 }

package/src/inmemory/inMemory.db.ts

@@ -145,6 +145,20 @@ export class InMemoryDB implements CommonDB {
     return ids.map(id => this.data[table]![id] as ROW).filter(Boolean)
   }
 
+  async multiGet<ROW extends ObjectWithId>(
+    map: StringMap<string[]>,
+    _opt: CommonDBOptions = {},
+  ): Promise<StringMap<ROW[]>> {
+    const result: StringMap<ROW[]> = {}
+
+    for (const [tableName, ids] of _stringMapEntries(map)) {
+      const table = this.cfg.tablesPrefix + tableName
+      result[table] = ids.map(id => this.data[table]?.[id] as ROW).filter(Boolean)
+    }
+
+    return result
+  }
+
   async saveBatch<ROW extends ObjectWithId>(
     _table: string,
     rows: ROW[],
@@ -152,6 +166,8 @@ export class InMemoryDB implements CommonDB {
   ): Promise<void> {
     const table = this.cfg.tablesPrefix + _table
     this.data[table] ||= {}
+    const isInsert = opt.saveMethod === 'insert'
+    const isUpdate = opt.saveMethod === 'update'
 
     for (const r of rows) {
       if (!r.id) {
@@ -161,11 +177,11 @@ export class InMemoryDB implements CommonDB {
         )
       }
 
-      if (opt.saveMethod === 'insert' && this.data[table][r.id]) {
+      if (isInsert && 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]) {
+      if (isUpdate && !this.data[table][r.id]) {
         throw new Error(`InMemoryDB: UPDATE failed, entity doesn't exist: ${table}.${r.id}`)
       }
 
@@ -176,6 +192,29 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
+  async multiSave<ROW extends ObjectWithId>(
+    map: StringMap<ROW[]>,
+    opt: CommonDBSaveOptions<ROW> = {},
+  ): Promise<void> {
+    for (const [table, rows] of _stringMapEntries(map)) {
+      await this.saveBatch(table, rows, opt)
+    }
+  }
+
+  async patchById<ROW extends ObjectWithId>(
+    _table: string,
+    id: string,
+    patch: Partial<ROW>,
+    _opt?: CommonDBOptions,
+  ): Promise<void> {
+    const table = this.cfg.tablesPrefix + _table
+    _assert(
+      !this.data[table]?.[id],
+      `InMemoryDB: patchById failed, entity doesn't exist: ${table}.${id}`,
+    )
+    Object.assign(this.data[table]![id]!, patch)
+  }
+
   async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
@@ -200,6 +239,16 @@ export class InMemoryDB implements CommonDB {
     return count
   }
 
+  async multiDelete(map: StringMap<string[]>, _opt?: CommonDBOptions): Promise<number> {
+    let count = 0
+
+    for (const [table, ids] of _stringMapEntries(map)) {
+      count += await this.deleteByIds(table, ids, _opt)
+    }
+
+    return count
+  }
+
   async patchByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     patch: Partial<ROW>,

package/src/query/dbQuery.ts

@@ -236,7 +236,7 @@ export class DBQuery<ROW extends ObjectWithId> {
 export class RunnableDBQuery<
   BM extends BaseDBEntity,
   DBM extends BaseDBEntity = BM,
-  ID = BM['id'],
+  ID extends string = BM['id'],
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.

package/src/testing/test.model.ts

@@ -15,6 +15,7 @@ import {
 const MOCK_TS_2018_06_21 = 1529539200 as UnixTimestamp
 
 export const TEST_TABLE = 'TEST_TABLE'
+export const TEST_TABLE_2 = 'TEST_TABLE_2'
 
 export interface TestItemBM extends BaseDBEntity {
   k1: string