@naturalcycles/db-lib 9.15.1 → 9.17.0

package/dist/adapter/inmemory/queryInMemory.js

@@ -31,8 +31,9 @@ function queryInMemory(q, rows = []) {
     if (order) {
         const { name, descending } = order;
         rows = rows.sort((a, b) => {
+            // biome-ignore lint/suspicious/noDoubleEquals: ok
             if (a[name] == b[name])
-                return 0; // eslint-disable-line eqeqeq
+                return 0;
             if (descending) {
                 return a[name] < b[name] ? 1 : -1;
             }

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

@@ -12,15 +12,15 @@ export declare class BaseCommonDB implements CommonDB {
     support: CommonDBSupport;
     ping(): Promise<void>;
     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: string[]): 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>>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
-    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
-    runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
+    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: string[]): 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>>;
+    runQueryCount<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
+    saveBatch<ROW extends ObjectWithId>(_table: string, _rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW>;
+    deleteByIds(_table: string, _ids: string[], _opt?: CommonDBOptions): Promise<number>;
+    runInTransaction(fn: DBTransactionFn, _opt?: CommonDBTransactionOptions): Promise<void>;
 }

package/dist/base.common.db.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCommonDB = void 0;
 const common_db_1 = require("./common.db");
 const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
-/* eslint-disable unused-imports/no-unused-vars */
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
@@ -19,37 +18,37 @@ class BaseCommonDB {
     async getTables() {
         throw new Error('getTables is not implemented');
     }
-    async getTableSchema(table) {
+    async getTableSchema(_table) {
         throw new Error('getTableSchema is not implemented');
     }
-    async createTable(table, schema) {
+    async createTable(_table, _schema) {
         // no-op
     }
-    async getByIds(table, ids) {
+    async getByIds(_table, _ids) {
         throw new Error('getByIds is not implemented');
     }
-    async deleteByQuery(q) {
+    async deleteByQuery(_q) {
         throw new Error('deleteByQuery is not implemented');
     }
-    async updateByQuery(q, patch, opt) {
+    async updateByQuery(_q, _patch, _opt) {
         throw new Error('updateByQuery is not implemented');
     }
-    async runQuery(q) {
+    async runQuery(_q) {
         throw new Error('runQuery is not implemented');
     }
-    async runQueryCount(q) {
+    async runQueryCount(_q) {
         throw new Error('runQueryCount is not implemented');
     }
-    async saveBatch(table, rows, opt) {
+    async saveBatch(_table, _rows, _opt) {
         throw new Error('saveBatch is not implemented');
     }
-    streamQuery(q) {
+    streamQuery(_q) {
         throw new Error('streamQuery is not implemented');
     }
-    async deleteByIds(table, ids, opt) {
+    async deleteByIds(_table, _ids, _opt) {
         throw new Error('deleteByIds is not implemented');
     }
-    async runInTransaction(fn, opt) {
+    async runInTransaction(fn, _opt) {
         const tx = new dbTransaction_util_1.FakeDBTransaction(this);
         await fn(tx);
         // there's no try/catch and rollback, as there's nothing to rollback

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

@@ -11,19 +11,19 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoPatchB
  * 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> {
-    cfg: CommonDaoCfg<BM, DBM>;
-    constructor(cfg: CommonDaoCfg<BM, DBM>);
+export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> {
+    cfg: CommonDaoCfg<BM, DBM, ID>;
+    constructor(cfg: CommonDaoCfg<BM, DBM, ID>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): BM;
     getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getById(id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
-    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
+    getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>;
+    getByIdOrEmpty(id: ID, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>;
-    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
-    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<DBM[]>;
-    requireById(id: string, opt?: CommonDaoOptions): Promise<BM>;
-    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<DBM>;
+    getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIds(ids: ID[], opt?: CommonDaoOptions): Promise<BM[]>;
+    getByIdsAsDBM(ids: ID[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    requireById(id: ID, opt?: CommonDaoOptions): Promise<BM>;
+    requireByIdAsDBM(id: ID, opt?: CommonDaoOptions): Promise<DBM>;
     private throwRequiredError;
     /**
      * Throws if readOnly is true
@@ -40,7 +40,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     /**
      * Pass `table` to override table
      */
-    query(table?: string): RunnableDBQuery<BM, DBM>;
+    query(table?: string): RunnableDBQuery<BM, DBM, ID>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
@@ -69,9 +69,9 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * You can do `.pipe(transformNoOp)` to make it "valid again".
      */
     streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;
-    queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<string[]>;
-    streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<string>): ReadableTyped<string>;
-    streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
+    queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<ID[]>;
+    streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<ID>): ReadableTyped<ID>;
+    streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<ID, void>, opt?: CommonDaoStreamForEachOptions<ID>): Promise<void>;
     /**
      * Mutates!
      * "Returns", just to have a type of "Saved"
@@ -86,11 +86,11 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * 2. Applies the patch on top of loaded data.
      * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
-    patchById(id: string, patch: Partial<BM>, opt?: CommonDaoPatchByIdOptions<DBM>): Promise<BM>;
+    patchById(id: ID, patch: Partial<BM>, opt?: CommonDaoPatchByIdOptions<DBM>): Promise<BM>;
     /**
      * Like patchById, but runs all operations within a Transaction.
      */
-    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoPatchByIdOptions<DBM>): Promise<BM>;
+    patchByIdInTransaction(id: ID, patch: Partial<BM>, opt?: CommonDaoPatchByIdOptions<DBM>): Promise<BM>;
     /**
      * Same as patchById, but takes the whole object as input.
      * This "whole object" is mutated with the patch and returned.
@@ -119,16 +119,16 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     /**
      * @returns number of deleted items
      */
-    deleteById(id?: string | null, opt?: CommonDaoOptions): Promise<number>;
-    deleteByIds(ids: string[], opt?: CommonDaoOptions): Promise<number>;
+    deleteById(id?: ID | null, opt?: CommonDaoOptions): Promise<number>;
+    deleteByIds(ids: ID[], opt?: CommonDaoOptions): Promise<number>;
     /**
      * Pass `chunkSize: number` (e.g 500) option to use Streaming: it will Stream the query, chunk by 500, and execute
      * `deleteByIds` for each chunk concurrently (infinite concurrency).
      * This is expected to be more memory-efficient way of deleting large number of rows.
      */
     deleteByQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamDeleteOptions<DBM>): Promise<number>;
-    updateById(id: string, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
-    updateByIds(ids: string[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    updateById(id: ID, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
+    updateByIds(ids: ID[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(q: DBQuery<DBM>, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
     dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<BM>;
@@ -157,6 +157,10 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      */
     ping(): Promise<void>;
     runInTransaction<T = void>(fn: CommonDaoTransactionFn<T>, opt?: CommonDBTransactionOptions): Promise<T>;
+    /**
+     * Throws if query uses a property that is in `excludeFromIndexes` list.
+     */
+    private validateQueryIndexes;
     protected logResult(started: number, op: string, res: any, table: string): void;
     protected logSaveResult(started: number, op: string, table: string): void;
     protected logStarted(op: string, table: string, force?: boolean): UnixTimestampMillisNumber;
@@ -180,8 +184,8 @@ export declare class CommonDaoTransaction {
      * Perform a graceful rollback without throwing/re-throwing any error.
      */
     rollback(): Promise<void>;
-    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
-    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
+    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(dao: CommonDao<BM, DBM, ID>, ids: ID[], opt?: CommonDaoOptions): 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[]>;
     /**
@@ -191,7 +195,7 @@ export declare class CommonDaoTransaction {
      *
      * So, this method is a rather simple convenience "Object.assign and then save".
      */
-    patch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM>, bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<BM>;
-    deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
-    deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
+    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>;
 }

package/dist/commondao/common.dao.js

@@ -202,6 +202,7 @@ class CommonDao {
         return (0, js_lib_1._uniqBy)(results, r => r.id);
     }
     async runQueryExtended(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         const op = `runQuery(${q.pretty()})`;
         const started = this.logStarted(op, q.table);
@@ -222,6 +223,7 @@ class CommonDao {
         return rows;
     }
     async runQueryExtendedAsDBM(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         const op = `runQueryAsDBM(${q.pretty()})`;
         const started = this.logStarted(op, q.table);
@@ -235,6 +237,7 @@ class CommonDao {
         return { rows: dbms, ...queryResult };
     }
     async runQueryCount(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         const op = `runQueryCount(${q.pretty()})`;
         const started = this.logStarted(op, q.table);
@@ -245,6 +248,7 @@ class CommonDao {
         return count;
     }
     async streamQueryForEach(q, mapper, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
@@ -283,6 +287,7 @@ class CommonDao {
         }
     }
     async streamQueryAsDBMForEach(q, mapper, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
@@ -324,6 +329,7 @@ class CommonDao {
      * Stream as Readable, to be able to .pipe() it further with support of backpressure.
      */
     streamQueryAsDBM(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
@@ -354,6 +360,7 @@ class CommonDao {
      * You can do `.pipe(transformNoOp)` to make it "valid again".
      */
     streamQuery(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.skipValidation = opt.skipValidation !== false; // default true
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
@@ -394,11 +401,13 @@ class CommonDao {
             .pipe((0, nodejs_lib_1.transformNoOp)()));
     }
     async queryIds(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         const { rows } = await this.cfg.db.runQuery(q.select(['id']), opt);
         return rows.map(r => r.id);
     }
     streamQueryIds(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
         // Experimental: using `.map()`
@@ -417,6 +426,7 @@ class CommonDao {
         return stream;
     }
     async streamQueryIdsForEach(q, mapper, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         q.table = opt.table || q.table;
         opt.errorMode ||= js_lib_1.ErrorMode.SUPPRESS;
         const op = `streamQueryIdsForEach(${q.pretty()})`;
@@ -455,7 +465,8 @@ class CommonDao {
             obj.updated = opt.preserveUpdatedCreated && obj.updated ? obj.updated : now;
         }
         if (this.cfg.generateId) {
-            obj.id ||= this.cfg.hooks.createNaturalId?.(obj) || this.cfg.hooks.createRandomId();
+            obj.id ||= (this.cfg.hooks.createNaturalId?.(obj) ||
+                this.cfg.hooks.createRandomId());
         }
         return obj;
     }
@@ -777,6 +788,7 @@ class CommonDao {
      * This is expected to be more memory-efficient way of deleting large number of rows.
      */
     async deleteByQuery(q, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         this.requireWriteAccess();
         this.requireObjectMutability(opt);
         q.table = opt.table || q.table;
@@ -820,6 +832,7 @@ class CommonDao {
         return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt);
     }
     async updateByQuery(q, patch, opt = {}) {
+        this.validateQueryIndexes(q); // throws if query uses `excludeFromIndexes` property
         this.requireWriteAccess();
         this.requireObjectMutability(opt);
         q.table = opt.table || q.table;
@@ -959,6 +972,19 @@ class CommonDao {
         }, opt);
         return r;
     }
+    /**
+     * Throws if query uses a property that is in `excludeFromIndexes` list.
+     */
+    validateQueryIndexes(q) {
+        const { excludeFromIndexes } = this.cfg;
+        if (!excludeFromIndexes)
+            return;
+        for (const f of q._filters) {
+            (0, js_lib_1._assert)(!excludeFromIndexes.includes(f.name), `cannot query on non-indexed property: ${this.cfg.table}.${f.name}`, {
+                query: q.pretty(),
+            });
+        }
+    }
     logResult(started, op, res, table) {
         if (!this.cfg.logLevel)
             return;

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

@@ -2,24 +2,24 @@ import { BaseDBEntity, CommonLogger, ErrorMode, Promisable, ZodError, ZodSchema
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchema, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']> {
     /**
      * Allows to override the id generation function.
      * By default it uses `stringId` from nodejs-lib
      * (which uses lowercase alphanumberic alphabet and the size of 16).
      */
-    createRandomId: () => string;
+    createRandomId: () => ID;
     /**
      * createNaturalId hook is called (tried) first.
      * If it doesn't exist - createRandomId is called.
      */
-    createNaturalId: (obj: DBM | BM) => string;
+    createNaturalId: (obj: DBM | BM) => ID;
     /**
      * It's a counter-part of `createNaturalId`.
      * Allows to provide a parser function to parse "natural id" into
      * DBM components (e.g accountId and some other property that is part of the id).
      */
-    parseNaturalId: (id: string) => Partial<DBM>;
+    parseNaturalId: (id: ID) => Partial<DBM>;
     /**
      * It is called only on `dao.create` method.
      * Dao.create method is called in:
@@ -93,7 +93,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
+export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> {
     db: CommonDB;
     table: string;
     /**
@@ -138,7 +138,7 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * @default false
      */
     logStarted?: boolean;
-    hooks?: Partial<CommonDaoHooks<BM, DBM>>;
+    hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>;
     /**
      * Defaults to true.
      * Set to false to disable auto-generation of `id`.

package/dist/query/dbQuery.d.ts

@@ -87,12 +87,12 @@ 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> extends DBQuery<DBM> {
-    dao: CommonDao<BM, DBM>;
+export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> extends DBQuery<DBM> {
+    dao: CommonDao<BM, DBM, ID>;
     /**
      * Pass `table` to override table.
      */
-    constructor(dao: CommonDao<BM, DBM>, table?: string);
+    constructor(dao: CommonDao<BM, DBM, ID>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
     runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
@@ -104,8 +104,8 @@ export declare class RunnableDBQuery<BM extends BaseDBEntity, DBM extends BaseDB
     streamQueryAsDBMForEach(mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     streamQuery(opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;
     streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM>;
-    queryIds(opt?: CommonDaoOptions): Promise<string[]>;
-    streamQueryIds(opt?: CommonDaoStreamOptions<string>): ReadableTyped<string>;
-    streamQueryIdsForEach(mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
+    queryIds(opt?: CommonDaoOptions): Promise<ID[]>;
+    streamQueryIds(opt?: CommonDaoStreamOptions<ID>): ReadableTyped<ID>;
+    streamQueryIdsForEach(mapper: AsyncMapper<ID, void>, opt?: CommonDaoStreamForEachOptions<ID>): Promise<void>;
     deleteByQuery(opt?: CommonDaoStreamDeleteOptions<DBM>): Promise<number>;
 }

package/dist/testing/daoTest.js

@@ -8,7 +8,6 @@ const __1 = require("..");
 const common_dao_1 = require("../commondao/common.dao");
 const dbTest_1 = require("./dbTest");
 const test_model_1 = require("./test.model");
-// eslint-disable-next-line jest/no-export
 function runCommonDaoTest(db, quirks = {}) {
     const { support } = db;
     const dao = new common_dao_1.CommonDao({

package/dist/testing/dbTest.js

@@ -7,11 +7,10 @@ const common_db_1 = require("../common.db");
 const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
 const test_model_1 = require("./test.model");
-const test_util_1 = require("./test.util");
 function runCommonDBTest(db, quirks = {}) {
     const { support } = db;
     const items = (0, test_model_1.createTestItemsDBM)(3);
-    (0, test_util_1.deepFreeze)(items);
+    (0, js_lib_1._deepFreeze)(items);
     const item1 = items[0];
     const queryAll = () => dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE);
     test('ping', async () => {
@@ -54,7 +53,7 @@ function runCommonDBTest(db, quirks = {}) {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: null,
             };
-            (0, test_util_1.deepFreeze)(item3);
+            (0, js_lib_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];
             expectMatch([item3], [item3Loaded], quirks);
@@ -67,7 +66,7 @@ function runCommonDBTest(db, quirks = {}) {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: undefined,
             };
-            (0, test_util_1.deepFreeze)(item3);
+            (0, js_lib_1._deepFreeze)(item3);
             const expected = { ...item3 };
             delete expected.k2;
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);

package/dist/testing/keyValueDBTest.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDBTest = runCommonKeyValueDBTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const test_model_1 = require("./test.model");
-/* eslint-disable jest/no-export */
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
 function runCommonKeyValueDBTest(db) {

package/dist/testing/keyValueDaoTest.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDaoTest = runCommonKeyValueDaoTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
-/* eslint-disable jest/no-export */
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
 function runCommonKeyValueDaoTest(dao) {

package/dist/transaction/dbTransaction.util.d.ts

@@ -24,5 +24,5 @@ export declare class FakeDBTransaction implements DBTransaction {
     rollback(): Promise<void>;
     getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
     saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
 }

package/package.json

@@ -45,7 +45,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "9.15.1",
+  "version": "9.17.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/queryInMemory.ts

@@ -35,7 +35,8 @@ export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: R
   if (order) {
     const { name, descending } = order
     rows = rows.sort((a, b) => {
-      if (a[name] == b[name]) return 0 // eslint-disable-line eqeqeq
+      // biome-ignore lint/suspicious/noDoubleEquals: ok
+      if (a[name] == b[name]) return 0
 
       if (descending) {
         return a[name] < b[name] ? 1 : -1

package/src/base.common.db.ts

@@ -12,8 +12,6 @@ import {
 import { DBQuery } from './query/dbQuery'
 import { FakeDBTransaction } from './transaction/dbTransaction.util'
 
-/* eslint-disable unused-imports/no-unused-vars */
-
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
@@ -32,59 +30,59 @@ export class BaseCommonDB implements CommonDB {
   }
 
   async getTableSchema<ROW extends ObjectWithId>(
-    table: string,
+    _table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     throw new Error('getTableSchema is not implemented')
   }
 
   async createTable<ROW extends ObjectWithId>(
-    table: string,
-    schema: JsonSchemaObject<ROW>,
+    _table: string,
+    _schema: JsonSchemaObject<ROW>,
   ): Promise<void> {
     // no-op
   }
 
-  async getByIds<ROW extends ObjectWithId>(table: string, ids: string[]): Promise<ROW[]> {
+  async getByIds<ROW extends ObjectWithId>(_table: string, _ids: string[]): Promise<ROW[]> {
     throw new Error('getByIds is not implemented')
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+  async deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number> {
     throw new Error('deleteByQuery is not implemented')
   }
 
   async updateByQuery<ROW extends ObjectWithId>(
-    q: DBQuery<ROW>,
-    patch: DBPatch<ROW>,
-    opt?: CommonDBOptions,
+    _q: DBQuery<ROW>,
+    _patch: DBPatch<ROW>,
+    _opt?: CommonDBOptions,
   ): Promise<number> {
     throw new Error('updateByQuery is not implemented')
   }
 
-  async runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
+  async runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
     throw new Error('runQuery is not implemented')
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+  async runQueryCount<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number> {
     throw new Error('runQueryCount is not implemented')
   }
 
   async saveBatch<ROW extends ObjectWithId>(
-    table: string,
-    rows: ROW[],
-    opt?: CommonDBSaveOptions<ROW>,
+    _table: string,
+    _rows: ROW[],
+    _opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
     throw new Error('saveBatch is not implemented')
   }
 
-  streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW> {
+  streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW> {
     throw new Error('streamQuery is not implemented')
   }
 
-  async deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number> {
+  async deleteByIds(_table: string, _ids: string[], _opt?: CommonDBOptions): Promise<number> {
     throw new Error('deleteByIds is not implemented')
   }
 
-  async runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void> {
+  async runInTransaction(fn: DBTransactionFn, _opt?: CommonDBTransactionOptions): Promise<void> {
     const tx = new FakeDBTransaction(this)
     await fn(tx)
     // there's no try/catch and rollback, as there's nothing to rollback

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

@@ -17,26 +17,26 @@ import {
 import { CommonDB } from '../common.db'
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model'
 
-export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']> {
   /**
    * Allows to override the id generation function.
    * By default it uses `stringId` from nodejs-lib
    * (which uses lowercase alphanumberic alphabet and the size of 16).
    */
-  createRandomId: () => string
+  createRandomId: () => ID
 
   /**
    * createNaturalId hook is called (tried) first.
    * If it doesn't exist - createRandomId is called.
    */
-  createNaturalId: (obj: DBM | BM) => string
+  createNaturalId: (obj: DBM | BM) => ID
 
   /**
    * It's a counter-part of `createNaturalId`.
    * Allows to provide a parser function to parse "natural id" into
    * DBM components (e.g accountId and some other property that is part of the id).
    */
-  parseNaturalId: (id: string) => Partial<DBM>
+  parseNaturalId: (id: ID) => Partial<DBM>
 
   /**
    * It is called only on `dao.create` method.
@@ -118,7 +118,11 @@ export enum CommonDaoLogLevel {
   DATA_FULL = 30,
 }
 
-export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
+export interface CommonDaoCfg<
+  BM extends BaseDBEntity,
+  DBM extends BaseDBEntity = BM,
+  ID = BM['id'],
+> {
   db: CommonDB
   table: string
 
@@ -174,7 +178,7 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
   logStarted?: boolean
 
   // Hooks are designed with inspiration from got/ky interface
-  hooks?: Partial<CommonDaoHooks<BM, DBM>>
+  hooks?: Partial<CommonDaoHooks<BM, DBM, ID>>
 
   /**
    * Defaults to true.

package/src/commondao/common.dao.ts

@@ -72,8 +72,8 @@ const isCI = !!process.env['CI']
  * 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> {
-  constructor(public cfg: CommonDaoCfg<BM, DBM>) {
+export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, ID = BM['id']> {
+  constructor(public cfg: CommonDaoCfg<BM, DBM, ID>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
@@ -93,11 +93,11 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
         anonymize: dbm => dbm,
         onValidationError: err => err,
         ...cfg.hooks,
-      } satisfies Partial<CommonDaoHooks<BM, DBM>>,
+      } satisfies Partial<CommonDaoHooks<BM, DBM, ID>>,
     }
 
     if (this.cfg.generateId) {
-      this.cfg.hooks!.createRandomId ||= () => stringId()
+      this.cfg.hooks!.createRandomId ||= () => stringId() as ID
     } else {
       delete this.cfg.hooks!.createRandomId
     }
@@ -113,14 +113,14 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
 
   // GET
   async getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getById(id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>
-  async getById(id?: string | null, opt: CommonDaoOptions = {}): Promise<BM | null> {
+  async getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>
+  async getById(id?: ID | null, opt: CommonDaoOptions = {}): Promise<BM | null> {
     if (!id) return null
     const op = `getById(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
 
-    let dbm = (await (opt.tx || this.cfg.db).getByIds<DBM>(table, [id]))[0]
+    let dbm = (await (opt.tx || this.cfg.db).getByIds<DBM>(table, [id as string]))[0]
     if (dbm && this.cfg.hooks!.afterLoad) {
       dbm = (await this.cfg.hooks!.afterLoad(dbm)) || undefined
     }
@@ -130,7 +130,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return bm || null
   }
 
-  async getByIdOrEmpty(id: string, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<BM> {
+  async getByIdOrEmpty(id: ID, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<BM> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
@@ -138,13 +138,13 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>
-  async getByIdAsDBM(id?: string | null, opt: CommonDaoOptions = {}): Promise<DBM | null> {
+  async getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>
+  async getByIdAsDBM(id?: ID | null, opt: CommonDaoOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const op = `getByIdAsDBM(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    let [dbm] = await (opt.tx || this.cfg.db).getByIds<DBM>(table, [id])
+    let [dbm] = await (opt.tx || this.cfg.db).getByIds<DBM>(table, [id as string])
     if (dbm && this.cfg.hooks!.afterLoad) {
       dbm = (await this.cfg.hooks!.afterLoad(dbm)) || undefined
     }
@@ -154,12 +154,12 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return dbm || null
   }
 
-  async getByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<BM[]> {
+  async getByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<BM[]> {
     if (!ids.length) return []
     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)
-    let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids)
+    let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids as string[])
     if (this.cfg.hooks!.afterLoad && dbms.length) {
       dbms = (await pMap(dbms, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _isTruthy,
@@ -171,12 +171,12 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return bms
   }
 
-  async getByIdsAsDBM(ids: string[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
+  async getByIdsAsDBM(ids: ID[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
     if (!ids.length) return []
     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)
-    let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids)
+    let dbms = await (opt.tx || this.cfg.db).getByIds<DBM>(table, ids as string[])
     if (this.cfg.hooks!.afterLoad && dbms.length) {
       dbms = (await pMap(dbms, async dbm => await this.cfg.hooks!.afterLoad!(dbm))).filter(
         _isTruthy,
@@ -187,7 +187,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return dbms
   }
 
-  async requireById(id: string, opt: CommonDaoOptions = {}): Promise<BM> {
+  async requireById(id: ID, opt: CommonDaoOptions = {}): Promise<BM> {
     const r = await this.getById(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -195,7 +195,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return r
   }
 
-  async requireByIdAsDBM(id: string, opt: CommonDaoOptions = {}): Promise<DBM> {
+  async requireByIdAsDBM(id: ID, opt: CommonDaoOptions = {}): Promise<DBM> {
     const r = await this.getByIdAsDBM(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -203,7 +203,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return r
   }
 
-  private throwRequiredError(id: string, opt: CommonDaoOptions): never {
+  private throwRequiredError(id: ID, opt: CommonDaoOptions): never {
     const table = opt.table || this.cfg.table
     throw new AppError(`DB row required, but not found in ${table}`, {
       table,
@@ -261,8 +261,8 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   /**
    * Pass `table` to override table
    */
-  query(table?: string): RunnableDBQuery<BM, DBM> {
-    return new RunnableDBQuery<BM, DBM>(this, table)
+  query(table?: string): RunnableDBQuery<BM, DBM, ID> {
+    return new RunnableDBQuery<BM, DBM, ID>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]> {
@@ -295,6 +295,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   async runQueryExtended(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<RunQueryResult<BM>> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     const op = `runQuery(${q.pretty()})`
     const started = this.logStarted(op, q.table)
@@ -323,6 +324,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     q: DBQuery<DBM>,
     opt: CommonDaoOptions = {},
   ): Promise<RunQueryResult<DBM>> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     const op = `runQueryAsDBM(${q.pretty()})`
     const started = this.logStarted(op, q.table)
@@ -340,6 +342,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   async runQueryCount(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     const op = `runQueryCount(${q.pretty()})`
     const started = this.logStarted(op, q.table)
@@ -355,6 +358,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     mapper: AsyncMapper<BM, void>,
     opt: CommonDaoStreamForEachOptions<BM> = {},
   ): Promise<void> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.skipValidation = opt.skipValidation !== false // default true
     opt.errorMode ||= ErrorMode.SUPPRESS
@@ -404,6 +408,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     mapper: AsyncMapper<DBM, void>,
     opt: CommonDaoStreamForEachOptions<DBM> = {},
   ): Promise<void> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.skipValidation = opt.skipValidation !== false // default true
     opt.errorMode ||= ErrorMode.SUPPRESS
@@ -452,6 +457,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
    * Stream as Readable, to be able to .pipe() it further with support of backpressure.
    */
   streamQueryAsDBM(q: DBQuery<DBM>, opt: CommonDaoStreamOptions<DBM> = {}): ReadableTyped<DBM> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.skipValidation = opt.skipValidation !== false // default true
     opt.errorMode ||= ErrorMode.SUPPRESS
@@ -490,6 +496,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
    * You can do `.pipe(transformNoOp)` to make it "valid again".
    */
   streamQuery(q: DBQuery<DBM>, opt: CommonDaoStreamOptions<BM> = {}): ReadableTyped<BM> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.skipValidation = opt.skipValidation !== false // default true
     opt.errorMode ||= ErrorMode.SUPPRESS
@@ -539,21 +546,23 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     )
   }
 
-  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<string[]> {
+  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<ID[]> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     const { rows } = await this.cfg.db.runQuery(q.select(['id']), opt)
-    return rows.map(r => r.id)
+    return rows.map(r => r.id as ID)
   }
 
-  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions<string> = {}): ReadableTyped<string> {
+  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions<ID> = {}): ReadableTyped<ID> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
     // Experimental: using `.map()`
-    const stream: ReadableTyped<string> = this.cfg.db
+    const stream: ReadableTyped<ID> = this.cfg.db
       .streamQuery<DBM>(q.select(['id']), opt)
       // .on('error', err => stream.emit('error', err))
-      .map((r: ObjectWithId) => r.id)
+      .map((r: ObjectWithId) => r.id as ID)
 
     // const stream: ReadableTyped<string> = this.cfg.db
     //   .streamQuery<DBM>(q.select(['id']), opt)
@@ -569,9 +578,10 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
 
   async streamQueryIdsForEach(
     q: DBQuery<DBM>,
-    mapper: AsyncMapper<string, void>,
-    opt: CommonDaoStreamForEachOptions<string> = {},
+    mapper: AsyncMapper<ID, void>,
+    opt: CommonDaoStreamForEachOptions<ID> = {},
   ): Promise<void> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
@@ -584,7 +594,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
         count++
         return r.id
       }),
-      transformMap<string, void>(mapper, {
+      transformMap<ID, void>(mapper, {
         ...opt,
         predicate: _passthroughPredicate,
       }),
@@ -617,7 +627,8 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     }
 
     if (this.cfg.generateId) {
-      obj.id ||= this.cfg.hooks!.createNaturalId?.(obj as any) || this.cfg.hooks!.createRandomId!()
+      obj.id ||= (this.cfg.hooks!.createNaturalId?.(obj as any) ||
+        this.cfg.hooks!.createRandomId!()) as T['id']
     }
 
     return obj as T
@@ -634,7 +645,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
    * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
    */
   async patchById(
-    id: string,
+    id: ID,
     patch: Partial<BM>,
     opt: CommonDaoPatchByIdOptions<DBM> = {},
   ): Promise<BM> {
@@ -671,7 +682,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
    * Like patchById, but runs all operations within a Transaction.
    */
   async patchByIdInTransaction(
-    id: string,
+    id: ID,
     patch: Partial<BM>,
     opt?: CommonDaoPatchByIdOptions<DBM>,
   ): Promise<BM> {
@@ -706,7 +717,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
       }
       Object.assign(bm, patch)
     } else {
-      const loaded = await this.getById(bm.id, opt)
+      const loaded = await this.getById(bm.id as ID, opt)
 
       if (loaded) {
         const loadedWithPatch: BM = {
@@ -989,19 +1000,19 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   /**
    * @returns number of deleted items
    */
-  async deleteById(id?: string | null, opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteById(id?: ID | null, opt: CommonDaoOptions = {}): Promise<number> {
     if (!id) return 0
     return await this.deleteByIds([id], opt)
   }
 
-  async deleteByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<number> {
     if (!ids.length) return 0
     this.requireWriteAccess()
     this.requireObjectMutability(opt)
     const op = `deleteByIds(${ids.join(', ')})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const count = await (opt.tx || this.cfg.db).deleteByIds(table, ids, opt)
+    const count = await (opt.tx || this.cfg.db).deleteByIds(table, ids as string[], opt)
     this.logSaveResult(started, op, table)
     return count
   }
@@ -1015,6 +1026,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     q: DBQuery<DBM>,
     opt: CommonDaoStreamDeleteOptions<DBM> = {},
   ): Promise<number> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     this.requireWriteAccess()
     this.requireObjectMutability(opt)
     q.table = opt.table || q.table
@@ -1055,15 +1067,11 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return deleted
   }
 
-  async updateById(id: string, patch: DBPatch<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
+  async updateById(id: ID, patch: DBPatch<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
     return await this.updateByQuery(this.query().filterEq('id', id), patch, opt)
   }
 
-  async updateByIds(
-    ids: string[],
-    patch: DBPatch<DBM>,
-    opt: CommonDaoOptions = {},
-  ): Promise<number> {
+  async updateByIds(ids: ID[], patch: DBPatch<DBM>, opt: CommonDaoOptions = {}): Promise<number> {
     if (!ids.length) return 0
     return await this.updateByQuery(this.query().filterIn('id', ids), patch, opt)
   }
@@ -1073,6 +1081,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     patch: DBPatch<DBM>,
     opt: CommonDaoOptions = {},
   ): Promise<number> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     this.requireWriteAccess()
     this.requireObjectMutability(opt)
     q.table = opt.table || q.table
@@ -1092,7 +1101,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
 
     // optimization: no need to run full joi DBM validation, cause BM validation will be run
     // const dbm = this.anyToDBM(_dbm, opt)
-    let dbm: DBM = { ..._dbm, ...this.cfg.hooks!.parseNaturalId!(_dbm.id) }
+    let dbm: DBM = { ..._dbm, ...this.cfg.hooks!.parseNaturalId!(_dbm.id as ID) }
 
     if (opt.anonymize) {
       dbm = this.cfg.hooks!.anonymize!(dbm)
@@ -1138,7 +1147,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     // this shouldn't be happening on load! but should on save!
     // this.assignIdCreatedUpdated(dbm, opt)
 
-    dbm = { ...dbm, ...this.cfg.hooks!.parseNaturalId!(dbm.id) }
+    dbm = { ...dbm, ...this.cfg.hooks!.parseNaturalId!(dbm.id as ID) }
 
     // todo: is this the right place?
     // todo: is anyToDBM even needed?
@@ -1259,6 +1268,24 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     return r!
   }
 
+  /**
+   * Throws if query uses a property that is in `excludeFromIndexes` list.
+   */
+  private validateQueryIndexes(q: DBQuery<DBM>): void {
+    const { excludeFromIndexes } = this.cfg
+    if (!excludeFromIndexes) return
+
+    for (const f of q._filters) {
+      _assert(
+        !excludeFromIndexes.includes(f.name),
+        `cannot query on non-indexed property: ${this.cfg.table}.${f.name as string}`,
+        {
+          query: q.pretty(),
+        },
+      )
+    }
+  }
+
   protected logResult(started: number, op: string, res: any, table: string): void {
     if (!this.cfg.logLevel) return
 
@@ -1345,17 +1372,17 @@ export class CommonDaoTransaction {
     }
   }
 
-  async getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM>,
-    id?: string | null,
+  async getById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+    dao: CommonDao<BM, DBM, ID>,
+    id?: ID | null,
     opt?: CommonDaoOptions,
   ): Promise<BM | null> {
     return await dao.getById(id, { ...opt, tx: this.tx })
   }
 
-  async getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM>,
-    ids: string[],
+  async getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+    dao: CommonDao<BM, DBM, ID>,
+    ids: ID[],
     opt?: CommonDaoOptions,
   ): Promise<BM[]> {
     return await dao.getByIds(ids, { ...opt, tx: this.tx })
@@ -1398,8 +1425,8 @@ export class CommonDaoTransaction {
    *
    * So, this method is a rather simple convenience "Object.assign and then save".
    */
-  async patch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(
-    dao: CommonDao<BM, DBM>,
+  async patch<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+    dao: CommonDao<BM, DBM, ID>,
     bm: BM,
     patch: Partial<BM>,
     opt?: CommonDaoSaveOptions<BM, DBM>,
@@ -1409,16 +1436,20 @@ export class CommonDaoTransaction {
     return await dao.save(bm, { ...opt, skipIfEquals, tx: this.tx })
   }
 
-  async deleteById(
-    dao: CommonDao<any>,
-    id?: string | null,
+  async deleteById<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+    dao: CommonDao<BM, DBM, ID>,
+    id?: ID | null,
     opt?: CommonDaoOptions,
   ): Promise<number> {
     if (!id) return 0
     return await this.deleteByIds(dao, [id], opt)
   }
 
-  async deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number> {
+  async deleteByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity, ID = BM['id']>(
+    dao: CommonDao<BM, DBM, ID>,
+    ids: ID[],
+    opt?: CommonDaoOptions,
+  ): Promise<number> {
     return await dao.deleteByIds(ids, { ...opt, tx: this.tx })
   }
 }

package/src/query/dbQuery.ts

@@ -193,7 +193,7 @@ export class DBQuery<ROW extends ObjectWithId> {
   }
 
   prettyConditions(): string[] {
-    const tokens = []
+    const tokens: string[] = []
 
     // if (this.name) {
     //   tokens.push(`"${this.name}"`)
@@ -240,12 +240,13 @@ export class DBQuery<ROW extends ObjectWithId> {
 export class RunnableDBQuery<
   BM extends BaseDBEntity,
   DBM extends BaseDBEntity = BM,
+  ID = BM['id'],
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.
    */
   constructor(
-    public dao: CommonDao<BM, DBM>,
+    public dao: CommonDao<BM, DBM, ID>,
     table?: string,
   ) {
     super(table || dao.cfg.table)
@@ -301,17 +302,17 @@ export class RunnableDBQuery<
     return this.dao.streamQueryAsDBM(this, opt)
   }
 
-  async queryIds(opt?: CommonDaoOptions): Promise<string[]> {
+  async queryIds(opt?: CommonDaoOptions): Promise<ID[]> {
     return await this.dao.queryIds(this, opt)
   }
 
-  streamQueryIds(opt?: CommonDaoStreamOptions<string>): ReadableTyped<string> {
+  streamQueryIds(opt?: CommonDaoStreamOptions<ID>): ReadableTyped<ID> {
     return this.dao.streamQueryIds(this, opt)
   }
 
   async streamQueryIdsForEach(
-    mapper: AsyncMapper<string, void>,
-    opt?: CommonDaoStreamForEachOptions<string>,
+    mapper: AsyncMapper<ID, void>,
+    opt?: CommonDaoStreamForEachOptions<ID>,
   ): Promise<void> {
     await this.dao.streamQueryIdsForEach(this, mapper, opt)
   }

package/src/testing/daoTest.ts

@@ -14,7 +14,6 @@ import {
   testItemBMSchema,
 } from './test.model'
 
-// eslint-disable-next-line jest/no-export
 export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQuirks = {}): void {
   const { support } = db
   const dao = new CommonDao({

package/src/testing/dbTest.ts

@@ -1,4 +1,4 @@
-import { _filterObject, _pick, _sortBy, pMap } from '@naturalcycles/js-lib'
+import { _deepFreeze, _filterObject, _pick, _sortBy, pMap } from '@naturalcycles/js-lib'
 import { CommonDB, CommonDBType } from '../common.db'
 import { DBIncrement, DBPatch } from '../db.model'
 import { DBQuery } from '../query/dbQuery'
@@ -9,9 +9,6 @@ import {
   testItemBMJsonSchema,
   TestItemDBM,
 } from './test.model'
-import { deepFreeze } from './test.util'
-
-/* eslint-disable jest/no-export */
 
 /**
  * All options default to `false`.
@@ -31,7 +28,7 @@ export interface CommonDBImplementationQuirks {
 export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuirks = {}): void {
   const { support } = db
   const items = createTestItemsDBM(3)
-  deepFreeze(items)
+  _deepFreeze(items)
   const item1 = items[0]!
 
   const queryAll = (): DBQuery<TestItemDBM> => DBQuery.create<TestItemDBM>(TEST_TABLE)
@@ -88,7 +85,7 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
         ...createTestItemDBM(3),
         k2: null,
       }
-      deepFreeze(item3)
+      _deepFreeze(item3)
       await db.saveBatch(TEST_TABLE, [item3])
       const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
       expectMatch([item3], [item3Loaded], quirks)
@@ -102,7 +99,7 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
         ...createTestItemDBM(3),
         k2: undefined,
       }
-      deepFreeze(item3)
+      _deepFreeze(item3)
       const expected = { ...item3 }
       delete expected.k2
 

package/src/testing/keyValueDBTest.ts

@@ -2,8 +2,6 @@ import { _range, _sortBy } from '@naturalcycles/js-lib'
 import { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
 import { TEST_TABLE } from './test.model'
 
-/* eslint-disable jest/no-export */
-
 const testIds = _range(1, 4).map(n => `id${n}`)
 
 const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])

package/src/testing/keyValueDaoTest.ts

@@ -2,8 +2,6 @@ import { _range, _sortBy } from '@naturalcycles/js-lib'
 import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
 import { KeyValueDBTuple } from '../kv/commonKeyValueDB'
 
-/* eslint-disable jest/no-export */
-
 const testIds = _range(1, 4).map(n => `id${n}`)
 const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
 

package/src/transaction/dbTransaction.util.ts

@@ -120,11 +120,7 @@ export class FakeDBTransaction implements DBTransaction {
   ): Promise<void> {
     await this.db.saveBatch(table, rows, opt)
   }
-  async deleteByIds(
-    table: string,
-    ids: string[],
-    opt?: CommonDBOptions | undefined,
-  ): Promise<number> {
+  async deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number> {
     return await this.db.deleteByIds(table, ids, opt)
   }
 }

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

@@ -1,6 +0,0 @@
-/**
- * Does Object.freeze recursively for given object.
- *
- * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
- */
-export declare function deepFreeze(o: any): void;

package/dist/testing/test.util.js

@@ -1,23 +0,0 @@
-"use strict";
-// copy-pasted from test-lib to be able to not include devDependecies there
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepFreeze = deepFreeze;
-/**
- * Does Object.freeze recursively for given object.
- *
- * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
- */
-function deepFreeze(o) {
-    Object.freeze(o);
-    Object.getOwnPropertyNames(o).forEach(prop => {
-        if (
-        // eslint-disable-next-line no-prototype-builtins
-        o.hasOwnProperty(prop) &&
-            o[prop] !== null &&
-            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
-            !Object.isFrozen(o[prop])) {
-            deepFreeze(o[prop]);
-        }
-    });
-    return o;
-}

package/src/testing/test.util.ts

@@ -1,24 +0,0 @@
-// copy-pasted from test-lib to be able to not include devDependecies there
-
-/**
- * Does Object.freeze recursively for given object.
- *
- * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
- */
-export function deepFreeze(o: any): void {
-  Object.freeze(o)
-
-  Object.getOwnPropertyNames(o).forEach(prop => {
-    if (
-      // eslint-disable-next-line no-prototype-builtins
-      o.hasOwnProperty(prop) &&
-      o[prop] !== null &&
-      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
-      !Object.isFrozen(o[prop])
-    ) {
-      deepFreeze(o[prop])
-    }
-  })
-
-  return o
-}