@naturalcycles/db-lib 9.15.1 → 9.16.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

@@ -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;

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()})`;
@@ -777,6 +787,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 +831,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 +971,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/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/package.json

@@ -13,6 +13,7 @@
     "@naturalcycles/nodejs-lib": "^13.1.1"
   },
   "devDependencies": {
+    "@biomejs/biome": "^1.8.3",
     "@naturalcycles/bench-lib": "^3.0.0",
     "@naturalcycles/dev-lib": "^15.4.1",
     "@types/node": "^22.1.0",
@@ -45,7 +46,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "9.15.1",
+  "version": "9.16.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.ts

@@ -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
@@ -540,12 +547,14 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
   }
 
   async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<string[]> {
+    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: DBQuery<DBM>, opt: CommonDaoStreamOptions<string> = {}): ReadableTyped<string> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
@@ -572,6 +581,7 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     mapper: AsyncMapper<string, void>,
     opt: CommonDaoStreamForEachOptions<string> = {},
   ): Promise<void> {
+    this.validateQueryIndexes(q) // throws if query uses `excludeFromIndexes` property
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
@@ -1015,6 +1025,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
@@ -1073,6 +1084,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
@@ -1259,6 +1271,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
 

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/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
-}