@naturalcycles/db-lib 8.48.1 → 8.49.0

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

@@ -23,6 +23,7 @@ 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[]>;
     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,6 +42,36 @@ 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 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,6 +21,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: 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_.

package/dist/adapter/file/file.db.js

@@ -34,6 +34,10 @@ 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

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

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

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

@@ -67,6 +67,11 @@ 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] ||= {};

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

@@ -13,6 +13,7 @@ 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>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<ROW[]>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
     updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>>;

package/dist/base.common.db.js

@@ -19,6 +19,9 @@ class BaseCommonDB {
     async createTable(table, schema) {
         // no-op
     }
+    async getByIds(table, ids) {
+        throw new Error('getByIds is not implemented');
+    }
     async deleteByQuery(q) {
         throw new Error('deleteByQuery is not implemented');
     }

package/dist/common.db.d.ts

@@ -27,6 +27,11 @@ 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).
      */

package/dist/commondao/common.dao.js

@@ -8,7 +8,6 @@ const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
 const dbTransaction_1 = require("../transaction/dbTransaction");
 const common_dao_model_1 = require("./common.dao.model");
-/* eslint-disable no-dupe-class-members */
 const isGAE = !!process.env['GAE_INSTANCE'];
 const isCI = !!process.env['CI'];
 /**
@@ -113,14 +112,14 @@ class CommonDao {
         if (opt.timeout) {
             // todo: possibly remove it after debugging is done
             dbm = await (0, js_lib_1.pTimeout)(async () => {
-                return (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
+                return (await this.cfg.db.getByIds(table, [id]))[0];
             }, {
                 timeout: opt.timeout,
                 name: `getById(${table})`,
             });
         }
         else {
-            dbm = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows[0];
+            dbm = (await this.cfg.db.getByIds(table, [id]))[0];
         }
         const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
@@ -145,7 +144,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.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
+        let [dbm] = await this.cfg.db.getByIds(table, [id]);
         if (!opt.raw) {
             dbm = this.anyToDBM(dbm, opt);
         }
@@ -158,7 +157,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.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', id))).rows;
+        const [dbm] = await this.cfg.db.getByIds(table, [id]);
         if (opt.raw) {
             this.logResult(started, op, dbm, table);
             return dbm || null;
@@ -172,7 +171,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.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
+        const dbms = await this.cfg.db.getByIds(table, ids);
         const bms = opt.raw ? dbms : await this.dbmsToBM(dbms, opt);
         this.logResult(started, op, bms, table);
         return bms;
@@ -181,7 +180,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.runQuery(dbQuery_1.DBQuery.create(table).filterIn('id', ids))).rows;
+        const dbms = await this.cfg.db.getByIds(table, ids);
         this.logResult(started, op, dbms, table);
         return dbms;
     }
@@ -231,8 +230,7 @@ class CommonDao {
     }
     async ensureUniqueId(table, dbm) {
         // todo: retry N times
-        const existing = (await this.cfg.db.runQuery(dbQuery_1.DBQuery.create(table).filterEq('id', dbm.id)))
-            .rows;
+        const existing = await this.cfg.db.getByIds(table, [dbm.id]);
         if (existing.length) {
             throw new js_lib_1.AppError(cnst_1.DBLibError.NON_UNIQUE_ID, {
                 table,

package/dist/testing/dbTest.js

@@ -49,15 +49,15 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // GET empty
     test('getByIds(item1.id) should return empty', async () => {
-        const [item1Loaded] = (await db.runQuery(queryAll().filterEq('id', item1.id))).rows;
+        const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
         // console.log(a)
         expect(item1Loaded).toBeUndefined();
     });
     test('getByIds([]) should return []', async () => {
-        expect((await db.runQuery(queryAll().filterIn('id', []))).rows).toEqual([]);
+        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
     });
     test('getByIds(...) should return empty', async () => {
-        expect((await db.runQuery(queryAll().filterIn('id', ['abc', 'abcd']))).rows).toEqual([]);
+        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).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.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
+            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[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.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
+            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([expected], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeUndefined();
             expect(Object.keys(item3Loaded)).not.toContain('k2');
@@ -112,8 +112,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // GET not empty
     test('getByIds all items', async () => {
-        const rows = (await db.runQuery(queryAll().filterIn('id', items.map(i => i.id).concat('abcd'))))
-            .rows;
+        const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));
         expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
@@ -205,7 +204,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
                 b1,
             };
             await db.saveBatch(test_model_1.TEST_TABLE, [item]);
-            const loaded = (await db.runQuery(queryAll().filterEq('id', item.id))).rows[0];
+            const loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item.id]))[0];
             const b1Loaded = loaded.b1;
             // console.log({
             //   b11: typeof b1,

package/package.json

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

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

@@ -1,5 +1,10 @@
 import { Readable } from 'node:stream'
-import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib'
+import {
+  JsonSchemaObject,
+  JsonSchemaRootObject,
+  ObjectWithId,
+  StringMap,
+} from '@naturalcycles/js-lib'
 import { BaseCommonDB } from '../../base.common.db'
 import { CommonDB } from '../../common.db'
 import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model'
@@ -67,6 +72,52 @@ 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 saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],

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

@@ -65,6 +65,15 @@ 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[],

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

@@ -143,6 +143,16 @@ 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[],

package/src/base.common.db.ts

@@ -33,6 +33,10 @@ export class BaseCommonDB implements CommonDB {
     // no-op
   }
 
+  async getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][]): Promise<ROW[]> {
+    throw new Error('getByIds is not implemented')
+  }
+
   async deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
     throw new Error('deleteByQuery is not implemented')
   }

package/src/common.db.ts

@@ -43,6 +43,17 @@ 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).

package/src/commondao/common.dao.ts

@@ -56,8 +56,6 @@ import {
   CommonDaoStreamOptions,
 } from './common.dao.model'
 
-/* eslint-disable no-dupe-class-members */
-
 const isGAE = !!process.env['GAE_INSTANCE']
 const isCI = !!process.env['CI']
 
@@ -136,7 +134,7 @@ export class CommonDao<
       // todo: possibly remove it after debugging is done
       dbm = await pTimeout(
         async () => {
-          return (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows[0]
+          return (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
         },
         {
           timeout: opt.timeout,
@@ -144,7 +142,7 @@ export class CommonDao<
         },
       )
     } else {
-      dbm = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows[0]
+      dbm = (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
     }
 
     const bm = opt.raw ? (dbm as any) : await this.dbmToBM(dbm, opt)
@@ -174,7 +172,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.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows
+    let [dbm] = await this.cfg.db.getByIds<DBM>(table, [id])
     if (!opt.raw) {
       dbm = this.anyToDBM(dbm!, opt)
     }
@@ -189,7 +187,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.runQuery(DBQuery.create<DBM>(table).filterEq('id', id))).rows
+    const [dbm] = await this.cfg.db.getByIds<DBM>(table, [id])
     if (opt.raw) {
       this.logResult(started, op, dbm, table)
       return (dbm as any) || null
@@ -204,7 +202,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.runQuery(DBQuery.create<DBM>(table).filterIn('id', ids))).rows
+    const dbms = await this.cfg.db.getByIds<DBM>(table, ids)
     const bms = opt.raw ? (dbms as any) : await this.dbmsToBM(dbms, opt)
     this.logResult(started, op, bms, table)
     return bms
@@ -214,7 +212,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.runQuery(DBQuery.create<DBM>(table).filterIn('id', ids))).rows
+    const dbms = await this.cfg.db.getByIds<DBM>(table, ids)
     this.logResult(started, op, dbms, table)
     return dbms
   }
@@ -270,8 +268,7 @@ export class CommonDao<
 
   private async ensureUniqueId(table: string, dbm: DBM): Promise<void> {
     // todo: retry N times
-    const existing = (await this.cfg.db.runQuery(DBQuery.create<DBM>(table).filterEq('id', dbm.id)))
-      .rows
+    const existing = await this.cfg.db.getByIds<DBM>(table, [dbm.id])
     if (existing.length) {
       throw new AppError(DBLibError.NON_UNIQUE_ID, {
         table,

package/src/testing/dbTest.ts

@@ -147,17 +147,17 @@ export function runCommonDBTest(
 
   // GET empty
   test('getByIds(item1.id) should return empty', async () => {
-    const [item1Loaded] = (await db.runQuery(queryAll().filterEq('id', item1.id))).rows
+    const [item1Loaded] = await db.getByIds(TEST_TABLE, [item1.id])
     // console.log(a)
     expect(item1Loaded).toBeUndefined()
   })
 
   test('getByIds([]) should return []', async () => {
-    expect((await db.runQuery(queryAll().filterIn('id', []))).rows).toEqual([])
+    expect(await db.getByIds(TEST_TABLE, [])).toEqual([])
   })
 
   test('getByIds(...) should return empty', async () => {
-    expect((await db.runQuery(queryAll().filterIn('id', ['abc', 'abcd']))).rows).toEqual([])
+    expect(await db.getByIds(TEST_TABLE, ['abc', 'abcd'])).toEqual([])
   })
 
   // SAVE
@@ -169,7 +169,7 @@ export function runCommonDBTest(
       }
       deepFreeze(item3)
       await db.saveBatch(TEST_TABLE, [item3])
-      const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0]!
+      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
       expectMatch([item3], [item3Loaded], quirks)
       expect(item3Loaded.k2).toBeNull()
     })
@@ -186,7 +186,7 @@ export function runCommonDBTest(
       delete expected.k2
 
       await db.saveBatch(TEST_TABLE, [item3])
-      const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0]!
+      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
       expectMatch([expected], [item3Loaded], quirks)
       expect(item3Loaded.k2).toBeUndefined()
       expect(Object.keys(item3Loaded)).not.toContain('k2')
@@ -221,8 +221,7 @@ export function runCommonDBTest(
 
   // GET not empty
   test('getByIds all items', async () => {
-    const rows = (await db.runQuery(queryAll().filterIn('id', items.map(i => i.id).concat('abcd'))))
-      .rows
+    const rows = await db.getByIds<TestItemDBM>(TEST_TABLE, items.map(i => i.id).concat('abcd'))
     expectMatch(
       items,
       _sortBy(rows, r => r.id),
@@ -347,7 +346,7 @@ export function runCommonDBTest(
         b1,
       }
       await db.saveBatch(TEST_TABLE, [item])
-      const loaded = (await db.runQuery(queryAll().filterEq('id', item.id))).rows[0]!
+      const loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item.id]))[0]!
       const b1Loaded = loaded.b1!
       // console.log({
       //   b11: typeof b1,