@naturalcycles/db-lib 8.47.0 → 8.48.1

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

@@ -23,8 +23,6 @@ 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): 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>;

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

@@ -42,57 +42,6 @@ class CacheDB extends base_common_db_1.BaseCommonDB {
             await this.cfg.cacheDB.createTable(table, schema, opt);
         }
     }
-    async getByIds(table, ids, opt = {}) {
-        const resultMap = {};
-        const missingIds = [];
-        if (!opt.skipCache && !this.cfg.skipCache) {
-            const results = await this.cfg.cacheDB.getByIds(table, ids, opt);
-            results.forEach(r => (resultMap[r.id] = r));
-            missingIds.push(...ids.filter(id => !resultMap[id]));
-            if (this.cfg.logCached) {
-                this.cfg.logger?.log(`${table}.getByIds ${results.length} rows from cache: [${results
-                    .map(r => r.id)
-                    .join(', ')}]`);
-            }
-        }
-        if (missingIds.length && !opt.onlyCache && !this.cfg.onlyCache) {
-            const results = await this.cfg.downstreamDB.getByIds(table, missingIds, opt);
-            results.forEach(r => (resultMap[r.id] = r));
-            if (this.cfg.logDownstream) {
-                this.cfg.logger?.log(`${table}.getByIds ${results.length} rows from downstream: [${results
-                    .map(r => r.id)
-                    .join(', ')}]`);
-            }
-            if (!opt.skipCache) {
-                const cacheResult = this.cfg.cacheDB.saveBatch(table, results, opt);
-                if (this.cfg.awaitCache)
-                    await cacheResult;
-            }
-        }
-        // return in right order
-        return ids.map(id => resultMap[id]).filter(Boolean);
-    }
-    async deleteByIds(table, ids, opt = {}) {
-        let deletedIds = 0;
-        if (!opt.onlyCache && !this.cfg.onlyCache) {
-            deletedIds = await this.cfg.downstreamDB.deleteByIds(table, ids, opt);
-            if (this.cfg.logDownstream) {
-                this.cfg.logger?.log(`${table}.deleteByIds ${deletedIds} rows from downstream`);
-            }
-        }
-        if (!opt.skipCache && !this.cfg.skipCache) {
-            const cacheResult = this.cfg.cacheDB
-                .deleteByIds(table, ids, opt)
-                .then(deletedFromCache => {
-                if (this.cfg.logCached) {
-                    this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`);
-                }
-            });
-            if (this.cfg.awaitCache)
-                await cacheResult;
-        }
-        return deletedIds;
-    }
     async saveBatch(table, rows, opt = {}) {
         if (!opt.onlyCache && !this.cfg.onlyCache) {
             await this.cfg.downstreamDB.saveBatch(table, rows, opt);

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

@@ -21,7 +21,6 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    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 +29,6 @@ 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: 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

@@ -34,10 +34,6 @@ class FileDB extends __1.BaseCommonDB {
         this.logFinished(started, `getTables() ${tables.length} tables`);
         return tables;
     }
-    async getByIds(table, ids, _opt) {
-        const byId = (0, js_lib_1._by)(await this.loadFile(table), r => r.id);
-        return ids.map(id => byId[id]).filter(Boolean);
-    }
     async saveBatch(table, rows, _opt) {
         if (!rows.length)
             return; // save some api calls
@@ -130,22 +126,6 @@ class FileDB extends __1.BaseCommonDB {
         });
         return readable;
     }
-    async deleteByIds(table, ids, _opt) {
-        if (!ids.length)
-            return 0;
-        let deleted = 0;
-        const rows = (await this.loadFile(table)).filter(r => {
-            if (ids.includes(r.id)) {
-                deleted++;
-                return false;
-            }
-            return true;
-        });
-        if (deleted > 0) {
-            await this.saveFile(table, rows);
-        }
-        return deleted;
-    }
     async deleteByQuery(q, _opt) {
         const byId = (0, js_lib_1._by)(await this.loadFile(q.table), r => r.id);
         let deleted = 0;

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

@@ -52,9 +52,7 @@ 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: 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>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;

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

@@ -8,6 +8,7 @@ const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
 const fs = require("fs-extra");
 const __1 = require("../..");
+const dbQuery_1 = require("../../query/dbQuery");
 class InMemoryDB {
     constructor(cfg) {
         // data[table][id] > {id: 'a', created: ... }
@@ -66,11 +67,6 @@ class InMemoryDB {
             this.data[table] ||= {};
         }
     }
-    async getByIds(_table, ids, _opt) {
-        const table = this.cfg.tablesPrefix + _table;
-        this.data[table] ||= {};
-        return ids.map(id => this.data[table][id]).filter(Boolean);
-    }
     async saveBatch(_table, rows, opt = {}) {
         const table = this.cfg.tablesPrefix + _table;
         this.data[table] ||= {};
@@ -91,24 +87,18 @@ class InMemoryDB {
             this.data[table][r.id] = JSON.parse(JSON.stringify(r), nodejs_lib_1.bufferReviver);
         });
     }
-    async deleteByIds(_table, ids, _opt) {
-        const table = this.cfg.tablesPrefix + _table;
+    async deleteByQuery(q, _opt) {
+        const table = this.cfg.tablesPrefix + q.table;
         this.data[table] ||= {};
         let count = 0;
-        ids.forEach(id => {
-            if (!this.data[table][id])
+        (0, __1.queryInMemory)(q, Object.values(this.data[table] || {})).forEach(r => {
+            if (!this.data[table][r.id])
                 return;
-            delete this.data[table][id];
+            delete this.data[table][r.id];
             count++;
         });
         return count;
     }
-    async deleteByQuery(q, _opt) {
-        const table = this.cfg.tablesPrefix + q.table;
-        const rows = (0, __1.queryInMemory)(q, Object.values(this.data[table] || {}));
-        const ids = rows.map(r => r.id);
-        return await this.deleteByIds(q.table, ids);
-    }
     async updateByQuery(q, patch) {
         const patchEntries = Object.entries(patch);
         if (!patchEntries.length)
@@ -147,7 +137,10 @@ class InMemoryDB {
                     await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
                 }
                 else if (op.type === 'deleteByIds') {
-                    await this.deleteByIds(op.table, op.ids, { ...op.opt, ...opt });
+                    await this.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
+                        ...op.opt,
+                        ...opt,
+                    });
                 }
                 else {
                     throw new Error(`DBOperation not supported: ${op.type}`);

package/dist/adapter/inmemory/queryInMemory.js

@@ -17,10 +17,6 @@ const FILTER_FNS = {
 // Important: q.table is not used in this function, so tablesPrefix is not needed.
 // But should be careful here..
 function queryInMemory(q, rows = []) {
-    // .ids
-    if (q._ids?.length) {
-        rows = rows.filter(r => q._ids.includes(r.id));
-    }
     // .filter
     // eslint-disable-next-line unicorn/no-array-reduce
     rows = q._filters.reduce((rows, filter) => {

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

@@ -13,10 +13,8 @@ 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<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
-    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 Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;

package/dist/base.common.db.js

@@ -17,10 +17,7 @@ class BaseCommonDB {
         throw new Error('getTableSchema is not implemented');
     }
     async createTable(table, schema) {
-        throw new Error('createTable is not implemented');
-    }
-    async deleteByIds(table, ids) {
-        throw new Error('deleteByIds is not implemented');
+        // no-op
     }
     async deleteByQuery(q) {
         throw new Error('deleteByQuery is not implemented');
@@ -28,9 +25,6 @@ class BaseCommonDB {
     async updateByQuery(q, patch, opt) {
         throw new Error('updateByQuery is not implemented');
     }
-    async getByIds(table, ids) {
-        throw new Error('getByIds is not implemented');
-    }
     async runQuery(q) {
         throw new Error('runQuery is not implemented');
     }

package/dist/common.db.d.ts

@@ -27,11 +27,6 @@ export interface CommonDB {
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
     createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    /**
-     * 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: ROW['id'][], opt?: CommonDBOptions): Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
@@ -46,7 +41,6 @@ export interface CommonDB {
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
      */
-    deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: CommonDBOptions): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
     /**
      * Applies patch to the rows returned by the query.

package/dist/commondao/common.dao.js

@@ -112,13 +112,15 @@ class CommonDao {
         let dbm;
         if (opt.timeout) {
             // todo: possibly remove it after debugging is done
-            dbm = (await (0, js_lib_1.pTimeout)(() => this.cfg.db.getByIds(table, [id]), {
+            dbm = await (0, js_lib_1.pTimeout)(async () => {
+                return (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
+            }, {
                 timeout: opt.timeout,
                 name: `getById(${table})`,
-            }))[0];
+            });
         }
         else {
-            dbm = (await this.cfg.db.getByIds(table, [id]))[0];
+            dbm = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
         }
         const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
@@ -143,7 +145,7 @@ class CommonDao {
         const op = `getByIdAsDBM(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        let [dbm] = await this.cfg.db.getByIds(table, [id]);
+        let [dbm] = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
         if (!opt.raw) {
             dbm = this.anyToDBM(dbm, opt);
         }
@@ -156,7 +158,7 @@ class CommonDao {
         const op = `getByIdAsTM(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const [dbm] = await this.cfg.db.getByIds(table, [id]);
+        const [dbm] = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
         if (opt.raw) {
             this.logResult(started, op, dbm, table);
             return dbm || null;
@@ -170,7 +172,7 @@ class CommonDao {
         const op = `getByIds ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const dbms = await this.cfg.db.getByIds(table, ids);
+        const dbms = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
         const bms = opt.raw ? dbms : await this.dbmsToBM(dbms, opt);
         this.logResult(started, op, bms, table);
         return bms;
@@ -179,7 +181,7 @@ class CommonDao {
         const op = `getByIdsAsDBM ${ids.length} id(s) (${(0, js_lib_1._truncate)(ids.slice(0, 10).join(', '), 50)})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const dbms = await this.cfg.db.getByIds(table, ids);
+        const dbms = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
         this.logResult(started, op, dbms, table);
         return dbms;
     }
@@ -229,7 +231,8 @@ class CommonDao {
     }
     async ensureUniqueId(table, dbm) {
         // todo: retry N times
-        const existing = await this.cfg.db.getByIds(table, [dbm.id]);
+        const existing = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', dbm.id)))
+            .rows;
         if (existing.length) {
             throw new js_lib_1.AppError(cnst_1.DBLibError.NON_UNIQUE_ID, {
                 table,
@@ -656,9 +659,9 @@ class CommonDao {
         const op = `deleteById(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const ids = await this.cfg.db.deleteByIds(table, [id]);
+        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id));
         this.logSaveResult(started, op, table);
-        return ids;
+        return count;
     }
     async deleteByIds(ids, opt = {}) {
         this.requireWriteAccess();
@@ -666,9 +669,9 @@ class CommonDao {
         const op = `deleteByIds(${ids.join(', ')})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const deletedIds = await this.cfg.db.deleteByIds(table, ids);
+        const count = await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids));
         this.logSaveResult(started, op, table);
-        return deletedIds;
+        return count;
     }
     /**
      * Pass `stream: true` option to use Streaming: it will Stream the query, batch by 500, and execute
@@ -691,7 +694,7 @@ class CommonDao {
                 }),
                 (0, nodejs_lib_1.transformBuffer)({ batchSize }),
                 (0, nodejs_lib_1.transformMap)(async (ids) => {
-                    deleted += await this.cfg.db.deleteByIds(q.table, ids, opt);
+                    deleted += await this.cfg.db.deleteByQuery(dbQuery_1.DBQuery.create(q.table).filterIn('id', ids), opt);
                 }, {
                     predicate: js_lib_1._passthroughPredicate,
                 }),
@@ -712,10 +715,10 @@ class CommonDao {
         return deleted;
     }
     async updateById(id, patch, opt = {}) {
-        return await this.updateByQuery(this.query().byId(id), patch, opt);
+        return await this.updateByQuery(this.query().filterEq('id', id), patch, opt);
     }
     async updateByIds(ids, patch, opt = {}) {
-        return await this.updateByQuery(this.query().byIds(ids), patch, opt);
+        return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt);
     }
     async updateByQuery(q, patch, opt = {}) {
         this.requireWriteAccess();

package/dist/query/dbQuery.d.ts

@@ -66,9 +66,9 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     _selectedFieldNames?: (keyof ROW)[];
     _groupByFieldNames?: (keyof ROW)[];
     _distinct: boolean;
-    _ids?: ROW['id'][];
     filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this;
     filterEq(name: keyof ROW, val: any): this;
+    filterIn(name: keyof ROW, val: any[]): this;
     limit(limit: number): this;
     offset(offset: number): this;
     order(name: keyof ROW, descending?: boolean): this;
@@ -77,20 +77,6 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     distinct(distinct?: boolean): this;
     startCursor(startCursor?: string): this;
     endCursor(endCursor?: string): this;
-    /**
-     * Allows to query by ids (one or many).
-     * Similar to:
-     * SELECT * FROM table where id in (a, b, c)
-     * or (if only 1 id is passed)
-     * SELECT * FROM table where id = a
-     */
-    byIds(ids: ROW['id'][]): this;
-    /**
-     * Allows to query by id.
-     * Similar to:
-     * SELECT * FROM table where id = a
-     */
-    byId(id: ROW['id']): this;
     clone(): DBQuery<ROW>;
     pretty(): string;
     prettyConditions(): string[];

package/dist/query/dbQuery.js

@@ -50,6 +50,10 @@ class DBQuery {
         this._filters.push({ name, op: '==', val });
         return this;
     }
+    filterIn(name, val) {
+        this._filters.push({ name, op: 'in', val });
+        return this;
+    }
     limit(limit) {
         this._limitValue = limit;
         return this;
@@ -85,26 +89,6 @@ class DBQuery {
         this._endCursor = endCursor;
         return this;
     }
-    /**
-     * Allows to query by ids (one or many).
-     * Similar to:
-     * SELECT * FROM table where id in (a, b, c)
-     * or (if only 1 id is passed)
-     * SELECT * FROM table where id = a
-     */
-    byIds(ids) {
-        this._ids = ids;
-        return this;
-    }
-    /**
-     * Allows to query by id.
-     * Similar to:
-     * SELECT * FROM table where id = a
-     */
-    byId(id) {
-        this._ids = [id];
-        return this;
-    }
     clone() {
         return (0, js_lib_1._objectAssign)(new DBQuery(this.table), {
             _filters: [...this._filters],
@@ -116,7 +100,6 @@ class DBQuery {
             _distinct: this._distinct,
             _startCursor: this._startCursor,
             _endCursor: this._endCursor,
-            _ids: this._ids,
         });
     }
     pretty() {
@@ -130,14 +113,6 @@ class DBQuery {
         if (this._selectedFieldNames) {
             tokens.push(`select${this._distinct ? ' distinct' : ''}(${this._selectedFieldNames.join(',')})`);
         }
-        if (this._ids?.length) {
-            if (this._ids.length === 1) {
-                tokens.push(`id=${this._ids[0]}`);
-            }
-            else {
-                tokens.push(`ids in (${this._ids.join(',')})`);
-            }
-        }
         tokens.push(...this._filters.map(f => `${f.name}${f.op}${f.val}`), ...this._orders.map(o => `order by ${o.name}${o.descending ? ' desc' : ''}`));
         if (this._groupByFieldNames) {
             tokens.push(`groupBy(${this._groupByFieldNames.join(',')})`);

package/dist/testing/daoTest.js

@@ -48,7 +48,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const rows = await dao.query().select(['id']).runQuery();
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.deleteByQuery(__1.DBQuery.create(test_model_1.TEST_TABLE).filter('id', 'in', rows.map(r => r.id)));
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
@@ -114,7 +114,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));
-        (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
+        (0, dbTest_1.expectMatch)(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (querying) {
@@ -187,8 +187,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         });
         test('cleanup', async () => {
             // CLEAN UP
-            const rows = await dao.query().select(['id']).runQuery();
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await dao.query().deleteByQuery();
         });
     }
     if (transactions) {

package/dist/testing/dbTest.js

@@ -37,7 +37,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const { rows } = await db.runQuery(queryAll().select(['id']));
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.deleteByQuery(queryAll().filterIn('id', rows.map(i => i.id)));
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
@@ -49,15 +49,15 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // GET empty
     test('getByIds(item1.id) should return empty', async () => {
-        const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
+        const [item1Loaded] = (await db.runQuery(queryAll().filterEq('id', item1.id))).rows;
         // console.log(a)
         expect(item1Loaded).toBeUndefined();
     });
     test('getByIds([]) should return []', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
+        expect((await db.runQuery(queryAll().filterIn('id', []))).rows).toEqual([]);
     });
     test('getByIds(...) should return empty', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
+        expect((await db.runQuery(queryAll().filterIn('id', ['abc', 'abcd']))).rows).toEqual([]);
     });
     // SAVE
     if (nullValues) {
@@ -68,7 +68,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             };
             (0, test_util_1.deepFreeze)(item3);
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
             expectMatch([item3], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeNull();
         });
@@ -83,7 +83,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             const expected = { ...item3 };
             delete expected.k2;
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
             expectMatch([expected], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeUndefined();
             expect(Object.keys(item3Loaded)).not.toContain('k2');
@@ -112,8 +112,9 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // 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'));
-        expectMatch(items, rows, quirks);
+        const rows = (await db.runQuery(queryAll().filterIn('id', items.map(i => i.id).concat('abcd'))))
+            .rows;
+        expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (querying) {
@@ -204,7 +205,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
                 b1,
             };
             await db.saveBatch(test_model_1.TEST_TABLE, [item]);
-            const [loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item.id]);
+            const loaded = (await db.runQuery(queryAll().filterEq('id', item.id))).rows[0];
             const b1Loaded = loaded.b1;
             // console.log({
             //   b11: typeof b1,
@@ -247,7 +248,6 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         });
     }
     if (updateByQuery) {
-        // todo: query by ids (same as getByIds)
         test('updateByQuery simple', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
@@ -290,8 +290,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     if (querying) {
         test('cleanup', async () => {
             // CLEAN UP
-            const { rows } = await db.runQuery(queryAll().select(['id']));
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.deleteByQuery(queryAll());
         });
     }
 }

package/dist/transaction/dbTransaction.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commitDBTransactionSimple = exports.mergeDBOperations = void 0;
+const dbQuery_1 = require("../query/dbQuery");
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
  * E.g if you save id1 first and then delete it - this function will turn it into a no-op (self-eliminate).
@@ -74,7 +75,10 @@ async function commitDBTransactionSimple(db, tx, opt) {
             await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
         }
         else if (op.type === 'deleteByIds') {
-            await db.deleteByIds(op.table, op.ids, { ...op.opt, ...opt });
+            await db.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
+                ...op.opt,
+                ...opt,
+            });
         }
         else {
             throw new Error(`DBOperation not supported: ${op.type}`);

package/package.json

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

package/src/adapter/cachedb/cache.db.ts

@@ -1,10 +1,5 @@
 import { Readable } from 'node:stream'
-import {
-  JsonSchemaObject,
-  JsonSchemaRootObject,
-  ObjectWithId,
-  StringMap,
-} from '@naturalcycles/js-lib'
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib'
 import { BaseCommonDB } from '../../base.common.db'
 import { CommonDB } from '../../common.db'
 import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model'
@@ -72,81 +67,6 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    opt: CacheDBSaveOptions<ROW> = {},
-  ): Promise<ROW[]> {
-    const resultMap: StringMap<ROW> = {}
-    const missingIds: ROW['id'][] = []
-
-    if (!opt.skipCache && !this.cfg.skipCache) {
-      const results = await this.cfg.cacheDB.getByIds<ROW>(table, ids, opt)
-
-      results.forEach(r => (resultMap[r.id] = r))
-
-      missingIds.push(...ids.filter(id => !resultMap[id]))
-
-      if (this.cfg.logCached) {
-        this.cfg.logger?.log(
-          `${table}.getByIds ${results.length} rows from cache: [${results
-            .map(r => r.id)
-            .join(', ')}]`,
-        )
-      }
-    }
-
-    if (missingIds.length && !opt.onlyCache && !this.cfg.onlyCache) {
-      const results = await this.cfg.downstreamDB.getByIds<ROW>(table, missingIds, opt)
-      results.forEach(r => (resultMap[r.id] = r))
-
-      if (this.cfg.logDownstream) {
-        this.cfg.logger?.log(
-          `${table}.getByIds ${results.length} rows from downstream: [${results
-            .map(r => r.id)
-            .join(', ')}]`,
-        )
-      }
-
-      if (!opt.skipCache) {
-        const cacheResult = this.cfg.cacheDB.saveBatch(table, results, opt)
-        if (this.cfg.awaitCache) await cacheResult
-      }
-    }
-
-    // return in right order
-    return ids.map(id => resultMap[id]!).filter(Boolean)
-  }
-
-  override async deleteByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    opt: CacheDBOptions = {},
-  ): Promise<number> {
-    let deletedIds = 0
-
-    if (!opt.onlyCache && !this.cfg.onlyCache) {
-      deletedIds = await this.cfg.downstreamDB.deleteByIds<ROW>(table, ids, opt)
-
-      if (this.cfg.logDownstream) {
-        this.cfg.logger?.log(`${table}.deleteByIds ${deletedIds} rows from downstream`)
-      }
-    }
-
-    if (!opt.skipCache && !this.cfg.skipCache) {
-      const cacheResult = this.cfg.cacheDB
-        .deleteByIds<ROW>(table, ids, opt)
-        .then(deletedFromCache => {
-          if (this.cfg.logCached) {
-            this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`)
-          }
-        })
-      if (this.cfg.awaitCache) await cacheResult
-    }
-
-    return deletedIds
-  }
-
   override async saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],

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

@@ -65,15 +65,6 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return tables
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
-    const byId = _by(await this.loadFile<ROW>(table), r => r.id)
-    return ids.map(id => byId[id]!).filter(Boolean)
-  }
-
   override async saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],
@@ -198,29 +189,6 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return readable
   }
 
-  override async deleteByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<number> {
-    if (!ids.length) return 0
-
-    let deleted = 0
-    const rows = (await this.loadFile<ROW>(table)).filter(r => {
-      if (ids.includes(r.id)) {
-        deleted++
-        return false
-      }
-      return true
-    })
-
-    if (deleted > 0) {
-      await this.saveFile(table, rows)
-    }
-
-    return deleted
-  }
-
   override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,

package/src/adapter/inmemory/inMemory.db.ts

@@ -143,16 +143,6 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async getByIds<ROW extends ObjectWithId>(
-    _table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
-    const table = this.cfg.tablesPrefix + _table
-    this.data[table] ||= {}
-    return ids.map(id => this.data[table]![id] as ROW).filter(Boolean)
-  }
-
   async saveBatch<ROW extends Partial<ObjectWithId>>(
     _table: string,
     rows: ROW[],
@@ -184,32 +174,21 @@ export class InMemoryDB implements CommonDB {
     })
   }
 
-  async deleteByIds<ROW extends ObjectWithId>(
-    _table: string,
-    ids: ROW['id'][],
+  async deleteByQuery<ROW extends ObjectWithId>(
+    q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
-    const table = this.cfg.tablesPrefix + _table
+    const table = this.cfg.tablesPrefix + q.table
     this.data[table] ||= {}
     let count = 0
-    ids.forEach(id => {
-      if (!this.data[table]![id]) return
-      delete this.data[table]![id]
+    queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]).forEach(r => {
+      if (!this.data[table]![r.id]) return
+      delete this.data[table]![r.id]
       count++
     })
     return count
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(
-    q: DBQuery<ROW>,
-    _opt?: CommonDBOptions,
-  ): Promise<number> {
-    const table = this.cfg.tablesPrefix + q.table
-    const rows = queryInMemory(q, Object.values(this.data[table] || {}) as ROW[])
-    const ids = rows.map(r => r.id)
-    return await this.deleteByIds(q.table, ids)
-  }
-
   async updateByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     patch: DBPatch<ROW>,
@@ -264,7 +243,10 @@ export class InMemoryDB implements CommonDB {
         if (op.type === 'saveBatch') {
           await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
         } else if (op.type === 'deleteByIds') {
-          await this.deleteByIds(op.table, op.ids, { ...op.opt, ...opt })
+          await this.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
+            ...op.opt,
+            ...opt,
+          })
         } else {
           throw new Error(`DBOperation not supported: ${(op as any).type}`)
         }

package/src/adapter/inmemory/queryInMemory.ts

@@ -19,11 +19,6 @@ const FILTER_FNS: Record<DBQueryFilterOperator, FilterFn> = {
 // Important: q.table is not used in this function, so tablesPrefix is not needed.
 // But should be careful here..
 export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: ROW[] = []): ROW[] {
-  // .ids
-  if (q._ids?.length) {
-    rows = rows.filter(r => q._ids!.includes(r.id))
-  }
-
   // .filter
   // eslint-disable-next-line unicorn/no-array-reduce
   rows = q._filters.reduce((rows, filter) => {

package/src/base.common.db.ts

@@ -30,11 +30,7 @@ export class BaseCommonDB implements CommonDB {
     table: string,
     schema: JsonSchemaObject<ROW>,
   ): Promise<void> {
-    throw new Error('createTable is not implemented')
-  }
-
-  async deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<number> {
-    throw new Error('deleteByIds is not implemented')
+    // no-op
   }
 
   async deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
@@ -49,10 +45,6 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('updateByQuery is not implemented')
   }
 
-  async getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<ROW[]> {
-    throw new Error('getByIds is not implemented')
-  }
-
   async runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
     throw new Error('runQuery is not implemented')
   }

package/src/common.db.ts

@@ -43,17 +43,6 @@ export interface CommonDB {
     opt?: CommonDBCreateOptions,
   ): Promise<void>
 
-  // GET
-  /**
-   * 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: ROW['id'][],
-    opt?: CommonDBOptions,
-  ): Promise<ROW[]>
-
   // QUERY
   /**
    * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
@@ -85,12 +74,6 @@ export interface CommonDB {
    * Returns number of deleted items.
    * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
    */
-  deleteByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    opt?: CommonDBOptions,
-  ): Promise<number>
-
   deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>
 
   /**

package/src/commondao/common.dao.ts

@@ -134,14 +134,17 @@ export class CommonDao<
 
     if (opt.timeout) {
       // todo: possibly remove it after debugging is done
-      dbm = (
-        await pTimeout(() => this.cfg.db.getByIds<DBM>(table, [id]), {
+      dbm = await pTimeout(
+        async () => {
+          return (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows[0]
+        },
+        {
           timeout: opt.timeout,
           name: `getById(${table})`,
-        })
-      )[0]
+        },
+      )
     } else {
-      dbm = (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
+      dbm = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows[0]
     }
 
     const bm = opt.raw ? (dbm as any) : await this.dbmToBM(dbm, opt)
@@ -171,7 +174,7 @@ export class CommonDao<
     const op = `getByIdAsDBM(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    let [dbm] = await this.cfg.db.getByIds<DBM>(table, [id])
+    let [dbm] = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows
     if (!opt.raw) {
       dbm = this.anyToDBM(dbm!, opt)
     }
@@ -186,7 +189,7 @@ export class CommonDao<
     const op = `getByIdAsTM(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const [dbm] = await this.cfg.db.getByIds<DBM>(table, [id])
+    const [dbm] = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows
     if (opt.raw) {
       this.logResult(started, op, dbm, table)
       return (dbm as any) || null
@@ -201,7 +204,7 @@ export class CommonDao<
     const op = `getByIds ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const dbms = await this.cfg.db.getByIds<DBM>(table, ids)
+    const dbms = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterIn('id', ids))).rows
     const bms = opt.raw ? (dbms as any) : await this.dbmsToBM(dbms, opt)
     this.logResult(started, op, bms, table)
     return bms
@@ -211,7 +214,7 @@ export class CommonDao<
     const op = `getByIdsAsDBM ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const dbms = await this.cfg.db.getByIds<DBM>(table, ids)
+    const dbms = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterIn('id', ids))).rows
     this.logResult(started, op, dbms, table)
     return dbms
   }
@@ -267,7 +270,8 @@ export class CommonDao<
 
   private async ensureUniqueId(table: string, dbm: DBM): Promise<void> {
     // todo: retry N times
-    const existing = await this.cfg.db.getByIds<DBM>(table, [dbm.id])
+    const existing = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', dbm.id)))
+      .rows
     if (existing.length) {
       throw new AppError(DBLibError.NON_UNIQUE_ID, {
         table,
@@ -869,9 +873,9 @@ export class CommonDao<
     const op = `deleteById(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const ids = await this.cfg.db.deleteByIds(table, [id])
+    const count = await this.cfg.db.deleteByQuery(DBQuery.create(table).filterEq('id', id))
     this.logSaveResult(started, op, table)
-    return ids
+    return count
   }
 
   async deleteByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<number> {
@@ -880,9 +884,9 @@ export class CommonDao<
     const op = `deleteByIds(${ids.join(', ')})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const deletedIds = await this.cfg.db.deleteByIds(table, ids)
+    const count = await this.cfg.db.deleteByQuery(DBQuery.create(table).filterIn('id', ids))
     this.logSaveResult(started, op, table)
-    return deletedIds
+    return count
   }
 
   /**
@@ -912,7 +916,10 @@ export class CommonDao<
         transformBuffer<string>({ batchSize }),
         transformMap<string[], void>(
           async ids => {
-            deleted += await this.cfg.db.deleteByIds(q.table, ids, opt)
+            deleted += await this.cfg.db.deleteByQuery(
+              DBQuery.create(q.table).filterIn('id', ids),
+              opt,
+            )
           },
           {
             predicate: _passthroughPredicate,
@@ -936,11 +943,11 @@ export class CommonDao<
   }
 
   async updateById(id: ID, patch: DBPatch<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
-    return await this.updateByQuery(this.query().byId(id), patch, opt)
+    return await this.updateByQuery(this.query().filterEq('id', id), patch, opt)
   }
 
   async updateByIds(ids: ID[], patch: DBPatch<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
-    return await this.updateByQuery(this.query().byIds(ids), patch, opt)
+    return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt)
   }
 
   async updateByQuery(

package/src/query/dbQuery.ts

@@ -113,7 +113,6 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
   _selectedFieldNames?: (keyof ROW)[]
   _groupByFieldNames?: (keyof ROW)[]
   _distinct = false
-  _ids?: ROW['id'][]
 
   filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this {
     this._filters.push({ name, op, val })
@@ -125,6 +124,11 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     return this
   }
 
+  filterIn(name: keyof ROW, val: any[]): this {
+    this._filters.push({ name, op: 'in', val })
+    return this
+  }
+
   limit(limit: number): this {
     this._limitValue = limit
     return this
@@ -168,28 +172,6 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     return this
   }
 
-  /**
-   * Allows to query by ids (one or many).
-   * Similar to:
-   * SELECT * FROM table where id in (a, b, c)
-   * or (if only 1 id is passed)
-   * SELECT * FROM table where id = a
-   */
-  byIds(ids: ROW['id'][]): this {
-    this._ids = ids
-    return this
-  }
-
-  /**
-   * Allows to query by id.
-   * Similar to:
-   * SELECT * FROM table where id = a
-   */
-  byId(id: ROW['id']): this {
-    this._ids = [id]
-    return this
-  }
-
   clone(): DBQuery<ROW> {
     return _objectAssign(new DBQuery<ROW>(this.table), {
       _filters: [...this._filters],
@@ -201,7 +183,6 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
       _distinct: this._distinct,
       _startCursor: this._startCursor,
       _endCursor: this._endCursor,
-      _ids: this._ids,
     })
   }
 
@@ -222,14 +203,6 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
       )
     }
 
-    if (this._ids?.length) {
-      if (this._ids.length === 1) {
-        tokens.push(`id=${this._ids[0]}`)
-      } else {
-        tokens.push(`ids in (${this._ids.join(',')})`)
-      }
-    }
-
     tokens.push(
       ...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' : ''}`),

package/src/testing/daoTest.ts

@@ -1,6 +1,6 @@
 import { pDelay, _deepCopy, _pick, _sortBy, _omit, localTime } from '@naturalcycles/js-lib'
 import { readableToArray, transformNoOp } from '@naturalcycles/nodejs-lib'
-import { CommonDaoLogLevel } from '..'
+import { CommonDaoLogLevel, DBQuery } from '..'
 import { CommonDB } from '../common.db'
 import { CommonDao } from '../commondao/common.dao'
 import { CommonDBImplementationFeatures, CommonDBImplementationQuirks, expectMatch } from './dbTest'
@@ -75,9 +75,12 @@ export function runCommonDaoTest(
     // DELETE ALL initially
     test('deleteByIds test items', async () => {
       const rows = await dao.query().select(['id']).runQuery()
-      await db.deleteByIds(
-        TEST_TABLE,
-        rows.map(i => i.id),
+      await db.deleteByQuery(
+        DBQuery.create(TEST_TABLE).filter(
+          'id',
+          'in',
+          rows.map(r => r.id),
+        ),
       )
     })
 
@@ -156,7 +159,11 @@ export function runCommonDaoTest(
   // GET not empty
   test('getByIds all items', async () => {
     const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'))
-    expectMatch(expectedItems, rows, quirks)
+    expectMatch(
+      expectedItems,
+      _sortBy(rows, r => r.id),
+      quirks,
+    )
   })
 
   // QUERY
@@ -258,11 +265,7 @@ export function runCommonDaoTest(
 
     test('cleanup', async () => {
       // CLEAN UP
-      const rows = await dao.query().select(['id']).runQuery()
-      await db.deleteByIds(
-        TEST_TABLE,
-        rows.map(i => i.id),
-      )
+      await dao.query().deleteByQuery()
     })
   }
 

package/src/testing/dbTest.ts

@@ -129,9 +129,11 @@ export function runCommonDBTest(
     // DELETE ALL initially
     test('deleteByIds test items', async () => {
       const { rows } = await db.runQuery(queryAll().select(['id']))
-      await db.deleteByIds(
-        TEST_TABLE,
-        rows.map(i => i.id),
+      await db.deleteByQuery(
+        queryAll().filterIn(
+          'id',
+          rows.map(i => i.id),
+        ),
       )
     })
 
@@ -145,17 +147,17 @@ export function runCommonDBTest(
 
   // GET empty
   test('getByIds(item1.id) should return empty', async () => {
-    const [item1Loaded] = await db.getByIds<TestItemDBM>(TEST_TABLE, [item1.id])
+    const [item1Loaded] = (await db.runQuery(queryAll().filterEq('id', item1.id))).rows
     // console.log(a)
     expect(item1Loaded).toBeUndefined()
   })
 
   test('getByIds([]) should return []', async () => {
-    expect(await db.getByIds(TEST_TABLE, [])).toEqual([])
+    expect((await db.runQuery(queryAll().filterIn('id', []))).rows).toEqual([])
   })
 
   test('getByIds(...) should return empty', async () => {
-    expect(await db.getByIds(TEST_TABLE, ['abc', 'abcd'])).toEqual([])
+    expect((await db.runQuery(queryAll().filterIn('id', ['abc', 'abcd']))).rows).toEqual([])
   })
 
   // SAVE
@@ -167,7 +169,7 @@ export function runCommonDBTest(
       }
       deepFreeze(item3)
       await db.saveBatch(TEST_TABLE, [item3])
-      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
+      const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0]!
       expectMatch([item3], [item3Loaded], quirks)
       expect(item3Loaded.k2).toBeNull()
     })
@@ -184,7 +186,7 @@ export function runCommonDBTest(
       delete expected.k2
 
       await db.saveBatch(TEST_TABLE, [item3])
-      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
+      const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0]!
       expectMatch([expected], [item3Loaded], quirks)
       expect(item3Loaded.k2).toBeUndefined()
       expect(Object.keys(item3Loaded)).not.toContain('k2')
@@ -219,8 +221,13 @@ export function runCommonDBTest(
 
   // GET not empty
   test('getByIds all items', async () => {
-    const rows = await db.getByIds<TestItemDBM>(TEST_TABLE, items.map(i => i.id).concat('abcd'))
-    expectMatch(items, rows, quirks)
+    const rows = (await db.runQuery(queryAll().filterIn('id', items.map(i => i.id).concat('abcd'))))
+      .rows
+    expectMatch(
+      items,
+      _sortBy(rows, r => r.id),
+      quirks,
+    )
   })
 
   // QUERY
@@ -340,8 +347,8 @@ export function runCommonDBTest(
         b1,
       }
       await db.saveBatch(TEST_TABLE, [item])
-      const [loaded] = await db.getByIds<TestItemDBM>(TEST_TABLE, [item.id])
-      const b1Loaded = loaded!.b1!
+      const loaded = (await db.runQuery(queryAll().filterEq('id', item.id))).rows[0]!
+      const b1Loaded = loaded.b1!
       // console.log({
       //   b11: typeof b1,
       //   b12: typeof b1Loaded,
@@ -391,7 +398,6 @@ export function runCommonDBTest(
   }
 
   if (updateByQuery) {
-    // todo: query by ids (same as getByIds)
     test('updateByQuery simple', async () => {
       // cleanup, reset initial data
       await db.deleteByQuery(queryAll())
@@ -445,11 +451,7 @@ export function runCommonDBTest(
   if (querying) {
     test('cleanup', async () => {
       // CLEAN UP
-      const { rows } = await db.runQuery(queryAll().select(['id']))
-      await db.deleteByIds(
-        TEST_TABLE,
-        rows.map(i => i.id),
-      )
+      await db.deleteByQuery(queryAll())
     })
   }
 }

package/src/transaction/dbTransaction.util.ts

@@ -1,5 +1,6 @@
 import type { CommonDB } from '../common.db'
 import { CommonDBSaveOptions, DBOperation } from '../db.model'
+import { DBQuery } from '../query/dbQuery'
 import { DBTransaction } from './dbTransaction'
 
 /**
@@ -80,7 +81,10 @@ export async function commitDBTransactionSimple(
     if (op.type === 'saveBatch') {
       await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
     } else if (op.type === 'deleteByIds') {
-      await db.deleteByIds(op.table, op.ids, { ...op.opt, ...opt })
+      await db.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
+        ...op.opt,
+        ...opt,
+      })
     } else {
       throw new Error(`DBOperation not supported: ${(op as any).type}`)
     }