@naturalcycles/db-lib 8.18.0 → 8.19.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [8.19.0](https://github.com/NaturalCycles/db-lib/compare/v8.18.0...v8.19.0) (2021-10-17)
+
+
+### Features
+
+* better-typed Queries, excludeFromIndexes ([b7a37ba](https://github.com/NaturalCycles/db-lib/commit/b7a37ba0ed28d5047f4cea5a5f5900f7d1fe5da4))
+
 # [8.18.0](https://github.com/NaturalCycles/db-lib/compare/v8.17.0...v8.18.0) (2021-10-15)
 
 

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

@@ -23,12 +23,12 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
      */
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable(table: string, schema: JsonSchemaObject, opt?: CacheDBCreateOptions): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBOptions): Promise<ROW[]>;
-    deleteByIds(table: string, ids: string[], opt?: CacheDBOptions): Promise<number>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBOptions): Promise<void>;
-    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<RunQueryResult<ROW>>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
-    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): Readable;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions<ROW>): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBOptions<ROW>): Promise<ROW[]>;
+    deleteByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBOptions<ROW>): Promise<number>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBOptions<ROW>): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions<ROW>): Readable;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions<ROW>): Promise<number>;
 }

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

@@ -1,5 +1,5 @@
 import { CommonDB } from '../../common.db';
-import { CommonDBCreateOptions, CommonDBSaveOptions, CommonDBStreamOptions } from '../../db.model';
+import { CommonDBCreateOptions, CommonDBSaveOptions, CommonDBStreamOptions, ObjectWithId } from '../../db.model';
 export interface CacheDBCfg {
     name: string;
     cacheDB: CommonDB;
@@ -32,7 +32,7 @@ export interface CacheDBCfg {
      */
     logDownstream?: boolean;
 }
-export interface CacheDBOptions extends CommonDBSaveOptions {
+export interface CacheDBOptions<ROW extends ObjectWithId> extends CommonDBSaveOptions<ROW> {
     /**
      * @default false
      */
@@ -42,7 +42,7 @@ export interface CacheDBOptions extends CommonDBSaveOptions {
      */
     onlyCache?: boolean;
 }
-export interface CacheDBStreamOptions extends CacheDBOptions, CommonDBStreamOptions {
+export interface CacheDBStreamOptions<ROW extends ObjectWithId> extends CacheDBOptions<ROW>, CommonDBStreamOptions {
 }
-export interface CacheDBCreateOptions extends CacheDBOptions, CommonDBCreateOptions {
+export interface CacheDBCreateOptions<ROW extends ObjectWithId> extends CacheDBOptions<ROW>, CommonDBCreateOptions {
 }

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

@@ -22,11 +22,11 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     getByIds<ROW extends ObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions): Promise<void>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
      * Implementation is optimized for loading/saving _whole files_.
      */
-    commitTransaction(tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void>;
+    commitTransaction(tx: DBTransaction, _opt?: CommonDBOptions): Promise<void>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
@@ -35,7 +35,7 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
     saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
+    saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
     /**
      * Mutates
      */

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

@@ -47,15 +47,15 @@ export declare class InMemoryDB implements CommonDB {
     resetCache(_table?: string): Promise<void>;
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable(_table: string, _schema: JsonSchemaObject, opt?: CommonDBCreateOptions): Promise<void>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
     getByIds<ROW extends ObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], _opt?: CommonDBSaveOptions): Promise<void>;
+    saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<ROW>;
-    commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void>;
+    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.
      */

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

@@ -1,7 +1,7 @@
 import { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from './common.db';
-import { CommonDBSaveOptions, ObjectWithId, RunQueryResult } from './db.model';
+import { CommonDBOptions, ObjectWithId, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
 import { DBTransaction } from './transaction/dbTransaction';
 /**
@@ -12,7 +12,7 @@ export declare class BaseCommonDB implements CommonDB {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable(_table: string, _schema: JsonSchemaObject): Promise<void>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>): Promise<void>;
     deleteByIds(_table: string, _ids: string[]): Promise<number>;
     deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number>;
     getByIds<ROW extends ObjectWithId>(_table: string, _ids: string[]): Promise<ROW[]>;
@@ -24,5 +24,5 @@ export declare class BaseCommonDB implements CommonDB {
      * Naive implementation.
      * To be extended.
      */
-    commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void>;
+    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
 }

package/dist/common.db.d.ts

@@ -26,7 +26,7 @@ export interface CommonDB {
      * Will do like `create table ...` for mysql.
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
-    createTable(table: string, schema: JsonSchemaObject, opt?: CommonDBCreateOptions): Promise<void>;
+    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).
@@ -38,7 +38,7 @@ export interface CommonDB {
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions): Promise<void>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     /**
      * @returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
@@ -49,5 +49,5 @@ export interface CommonDB {
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.
      */
-    commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void>;
+    commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>;
 }

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

@@ -32,8 +32,8 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * Throws if readOnly is true
      */
     private requireWriteAccess;
-    getBy(by: string, value: any, limit?: number, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    getOneBy(by: string, value: any, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getBy(by: keyof DBM, value: any, limit?: number, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    getOneBy(by: keyof DBM, value: any, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
     getAll(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     /**
      * Pass `table` to override table
@@ -74,7 +74,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
     /**
      * Mutates with id, created, updated
      */
-    save(bm: BM, opt?: CommonDaoSaveOptions): Promise<Saved<BM>>;
+    save(bm: BM, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
     /**
      * Mutates id if needed
      */
@@ -87,11 +87,11 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      *
      * Convenience method to replace 3 operations (loading+patching+saving) with one.
      */
-    patch(id: string, patch: Partial<BM>, opt?: CommonDaoSaveOptions): Promise<Saved<BM>>;
-    patchAsDBM(id: string, patch: Partial<DBM>, opt?: CommonDaoSaveOptions): Promise<DBM>;
-    saveAsDBM(dbm: DBM, opt?: CommonDaoSaveOptions): Promise<DBM>;
-    saveBatch(bms: BM[], opt?: CommonDaoSaveOptions): Promise<Saved<BM>[]>;
-    saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveOptions): Promise<DBM[]>;
+    patch(id: string, patch: Partial<BM>, opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>>;
+    patchAsDBM(id: string, patch: Partial<DBM>, opt?: CommonDaoSaveOptions<DBM>): Promise<DBM>;
+    saveAsDBM(dbm: DBM, opt?: CommonDaoSaveOptions<DBM>): Promise<DBM>;
+    saveBatch(bms: BM[], opt?: CommonDaoSaveOptions<DBM>): Promise<Saved<BM>[]>;
+    saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveOptions<DBM>): Promise<DBM[]>;
     /**
      * @returns number of deleted items
      */

package/dist/commondao/common.dao.js

@@ -155,10 +155,10 @@ class CommonDao {
         }
     }
     async getBy(by, value, limit = 0, opt) {
-        return await this.query().filter(by, '==', value).limit(limit).runQuery(opt);
+        return await this.query().filterEq(by, value).limit(limit).runQuery(opt);
     }
     async getOneBy(by, value, opt) {
-        const [bm] = await this.query().filter(by, '==', value).limit(1).runQuery(opt);
+        const [bm] = await this.query().filterEq(by, value).limit(1).runQuery(opt);
         return bm || null;
     }
     async getAll(opt) {

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

@@ -47,7 +47,7 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends Obje
     dbmSchema?: ObjectSchemaTyped<DBM> | AjvSchema<DBM>;
     bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>;
     tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM>;
-    excludeFromIndexes?: string[];
+    excludeFromIndexes?: (keyof DBM)[];
     /**
      * @default to false
      * Set to true to limit DB writing (will throw an error is such case).
@@ -116,7 +116,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions extends CommonDaoOptions, CommonDBSaveOptions {
+export interface CommonDaoSaveOptions<DBM extends ObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *

package/dist/db.model.d.ts

@@ -1,11 +1,12 @@
+import { AnyObject } from '@naturalcycles/js-lib';
 import { CommonDB } from './common.db';
 export interface CommonDBOptions {
 }
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions extends CommonDBOptions {
-    excludeFromIndexes?: string[];
+export interface CommonDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId> extends CommonDBOptions {
+    excludeFromIndexes?: (keyof ROW)[];
 }
 export declare type CommonDBStreamOptions = CommonDBOptions;
 export interface CommonDBCreateOptions extends CommonDBOptions {
@@ -20,7 +21,7 @@ export interface RunQueryResult<T> {
     endCursor?: string;
 }
 export declare type DBOperation = DBSaveBatchOperation | DBDeleteByIdsOperation;
-export interface DBSaveBatchOperation<ROW extends ObjectWithId = any> {
+export interface DBSaveBatchOperation<ROW extends ObjectWithId = AnyObjectWithId> {
     type: 'saveBatch';
     table: string;
     rows: ROW[];
@@ -49,6 +50,8 @@ export interface CreatedUpdatedId extends CreatedUpdated {
 export interface ObjectWithId {
     id: string;
 }
+export interface AnyObjectWithId extends AnyObject, ObjectWithId {
+}
 /**
  * Interface for a module (lib) that implements CommonDB.
  *

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { DBLibError } from './cnst';
 import { CommonDB } from './common.db';
 import { CommonDao } from './commondao/common.dao';
 import { CommonDaoAnonymizeHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeBMToTMHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeTMToBMHook, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoCreateOptions, CommonDaoLogLevel, CommonDaoOptions, CommonDaoParseNaturalIdHook, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from './commondao/common.dao.model';
-import { CommonDBAdapter, CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CreatedUpdated, CreatedUpdatedId, DBDeleteByIdsOperation, DBModelType, DBOperation, DBRelation, DBSaveBatchOperation, ObjectWithId, RunQueryResult } from './db.model';
+import { AnyObjectWithId, CommonDBAdapter, CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CreatedUpdated, CreatedUpdatedId, DBDeleteByIdsOperation, DBModelType, DBOperation, DBRelation, DBSaveBatchOperation, ObjectWithId, RunQueryResult } from './db.model';
 import { getDB } from './getDB';
 import { CommonKeyValueDao, CommonKeyValueDaoCfg } from './kv/commonKeyValueDao';
 import { CommonKeyValueDB, KeyValueDBTuple } from './kv/commonKeyValueDB';
@@ -17,5 +17,5 @@ import { dbPipelineRestore, DBPipelineRestoreOptions } from './pipeline/dbPipeli
 import { DBQuery, DBQueryFilter, DBQueryFilterOperator, dbQueryFilterOperatorValues, DBQueryOrder, RunnableDBQuery } from './query/dbQuery';
 import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction';
 import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util';
-export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CreatedUpdated, CreatedUpdatedId, ObjectWithId, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoParseNaturalIdHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeTMToBMHook, CommonDaoBeforeBMToTMHook, CommonDaoAnonymizeHook, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, CommonDBAdapter, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
+export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CreatedUpdated, CreatedUpdatedId, AnyObjectWithId, ObjectWithId, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoParseNaturalIdHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeTMToBMHook, CommonDaoBeforeBMToTMHook, CommonDaoAnonymizeHook, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, CommonDBAdapter, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
 export { DBQuery, dbQueryFilterOperatorValues, RunnableDBQuery, CommonDaoLogLevel, DBRelation, DBModelType, CommonDao, createdUpdatedFields, createdUpdatedIdFields, idField, InMemoryDB, InMemoryKeyValueDB, queryInMemory, serializeJsonField, deserializeJsonField, dbPipelineBackup, dbPipelineRestore, dbPipelineCopy, getDB, DBLibError, BaseCommonDB, DBTransaction, RunnableDBTransaction, mergeDBOperations, commitDBTransactionSimple, CommonKeyValueDao, };

package/dist/query/dbQuery.d.ts

@@ -2,7 +2,7 @@ import { AsyncMapper, Saved } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '..';
 import { CommonDao } from '../commondao/common.dao';
-import { ObjectWithId, RunQueryResult } from '../db.model';
+import { AnyObjectWithId, ObjectWithId, RunQueryResult } from '../db.model';
 /**
  * Modeled after Firestore operators (WhereFilterOp type)
  *
@@ -24,13 +24,13 @@ import { ObjectWithId, RunQueryResult } from '../db.model';
  */
 export declare type DBQueryFilterOperator = '<' | '<=' | '==' | '>=' | '>' | 'in' | 'not-in' | 'array-contains' | 'array-contains-any';
 export declare const dbQueryFilterOperatorValues: string[];
-export interface DBQueryFilter {
-    name: string;
+export interface DBQueryFilter<ROW extends ObjectWithId = AnyObjectWithId> {
+    name: keyof ROW;
     op: DBQueryFilterOperator;
     val: any;
 }
-export interface DBQueryOrder {
-    name: string;
+export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
+    name: keyof ROW;
     descending?: boolean;
 }
 /**
@@ -43,33 +43,33 @@ export interface DBQueryOrder {
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-export declare class DBQuery<ROW extends ObjectWithId> {
+export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     table: string;
     constructor(table: string);
     /**
      * Convenience method.
      */
-    static create<ROW extends ObjectWithId = any>(table: string): DBQuery<ROW>;
-    static fromPlainObject<ROW extends ObjectWithId = any>(obj: Partial<DBQuery<ROW>> & {
+    static create<ROW extends ObjectWithId = AnyObjectWithId>(table: string): DBQuery<ROW>;
+    static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
         table: string;
     }): DBQuery<ROW>;
-    _filters: DBQueryFilter[];
+    _filters: DBQueryFilter<ROW>[];
     _limitValue: number;
     _offsetValue: number;
-    _orders: DBQueryOrder[];
+    _orders: DBQueryOrder<ROW>[];
     _startCursor?: string;
     _endCursor?: string;
     /**
      * If defined - only those fields will be selected.
      * In undefined - all fields (*) will be returned.
      */
-    _selectedFieldNames?: string[];
-    filter(name: string, op: DBQueryFilterOperator, val: any): this;
-    filterEq(name: string, val: any): this;
+    _selectedFieldNames?: (keyof ROW)[];
+    filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this;
+    filterEq(name: keyof ROW, val: any): this;
     limit(limit: number): this;
     offset(offset: number): this;
-    order(name: string, descending?: boolean): this;
-    select(fieldNames: string[]): this;
+    order(name: keyof ROW, descending?: boolean): this;
+    select(fieldNames: (keyof ROW)[]): this;
     startCursor(startCursor?: string): this;
     endCursor(endCursor?: string): this;
     clone(): DBQuery<ROW>;

package/dist/query/dbQuery.js

@@ -13,17 +13,6 @@ exports.dbQueryFilterOperatorValues = [
     'array-contains',
     'array-contains-any',
 ];
-// export interface DBQueryData {
-//   _filters: DBQueryFilter[]
-//   _limitValue: number
-//   _orders: DBQueryOrder[]
-//
-//   /**
-//    * If defined - only those fields will be selected.
-//    * In undefined - all fields (*) will be returned.
-//    */
-//   _selectedFieldNames?: string[]
-// }
 /**
  * Lowest Common Denominator Query object.
  * To be executed by CommonDao / CommonDB.

package/dist/timeseries/commonTimeSeriesDao.js

@@ -66,7 +66,7 @@ class CommonTimeSeriesDao {
             dbq.filter('ts', '>=', q.fromIncl);
         if (q.toExcl)
             dbq.filter('ts', '<', q.toExcl);
-        const { rows } = await this.cfg.db.runQuery(dbq);
+        const rows = (await this.cfg.db.runQuery(dbq)).rows;
         // todo: query from aggregated tables when step is above 'hour'
         return rows
             .filter(r => r.v !== null && r.v !== undefined) // can be 0

package/dist/transaction/dbTransaction.d.ts

@@ -1,11 +1,11 @@
 import type { CommonDB } from '../common.db';
-import type { CommonDBSaveOptions, DBOperation, ObjectWithId } from '../db.model';
+import type { AnyObjectWithId, CommonDBSaveOptions, DBOperation, ObjectWithId } from '../db.model';
 /**
  * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
  */
 export declare class DBTransaction {
     ops: DBOperation[];
-    saveBatch<ROW extends ObjectWithId = any>(table: string, rows: ROW[]): this;
+    saveBatch<ROW extends ObjectWithId = AnyObjectWithId>(table: string, rows: ROW[]): this;
     deleteByIds(table: string, ids: string[]): this;
 }
 /**
@@ -15,5 +15,5 @@ export declare class DBTransaction {
 export declare class RunnableDBTransaction extends DBTransaction {
     db: CommonDB;
     constructor(db: CommonDB);
-    commit(opt?: CommonDBSaveOptions): Promise<void>;
+    commit<ROW extends ObjectWithId>(opt?: CommonDBSaveOptions<ROW>): Promise<void>;
 }

package/dist/validation/index.d.ts

@@ -1,8 +1,8 @@
 import { CommonDBOptions, CommonDBSaveOptions } from '../db.model';
 import { DBQuery, DBQueryFilter, DBQueryOrder } from '../query/dbQuery';
 export declare const commonDBOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBOptions, CommonDBOptions>;
-export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions, CommonDBSaveOptions>;
+export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions<import("../db.model").AnyObjectWithId>, CommonDBSaveOptions<import("../db.model").AnyObjectWithId>>;
 export declare const dbQueryFilterOperatorSchema: import("@naturalcycles/nodejs-lib/dist/validation/joi/string.extensions").ExtendedStringSchema;
-export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter, DBQueryFilter>;
-export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder, DBQueryOrder>;
+export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter<import("../db.model").AnyObjectWithId>, DBQueryFilter<import("../db.model").AnyObjectWithId>>;
+export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder<import("../db.model").AnyObjectWithId>, DBQueryOrder<import("../db.model").AnyObjectWithId>>;
 export declare const dbQuerySchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQuery<any>, DBQuery<any>>;

package/package.json

@@ -42,7 +42,7 @@
   "engines": {
     "node": ">=12.13"
   },
-  "version": "8.18.0",
+  "version": "8.19.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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

@@ -1,5 +1,10 @@
 import { CommonDB } from '../../common.db'
-import { CommonDBCreateOptions, CommonDBSaveOptions, CommonDBStreamOptions } from '../../db.model'
+import {
+  CommonDBCreateOptions,
+  CommonDBSaveOptions,
+  CommonDBStreamOptions,
+  ObjectWithId,
+} from '../../db.model'
 
 export interface CacheDBCfg {
   name: string
@@ -39,7 +44,7 @@ export interface CacheDBCfg {
   logDownstream?: boolean
 }
 
-export interface CacheDBOptions extends CommonDBSaveOptions {
+export interface CacheDBOptions<ROW extends ObjectWithId> extends CommonDBSaveOptions<ROW> {
   /**
    * @default false
    */
@@ -51,5 +56,9 @@ export interface CacheDBOptions extends CommonDBSaveOptions {
   onlyCache?: boolean
 }
 
-export interface CacheDBStreamOptions extends CacheDBOptions, CommonDBStreamOptions {}
-export interface CacheDBCreateOptions extends CacheDBOptions, CommonDBCreateOptions {}
+export interface CacheDBStreamOptions<ROW extends ObjectWithId>
+  extends CacheDBOptions<ROW>,
+    CommonDBStreamOptions {}
+export interface CacheDBCreateOptions<ROW extends ObjectWithId>
+  extends CacheDBOptions<ROW>,
+    CommonDBCreateOptions {}

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

@@ -49,10 +49,10 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return await this.cfg.downstreamDB.getTableSchema<ROW>(table)
   }
 
-  override async createTable(
+  override async createTable<ROW extends ObjectWithId>(
     table: string,
-    schema: JsonSchemaObject,
-    opt: CacheDBCreateOptions = {},
+    schema: JsonSchemaObject<ROW>,
+    opt: CacheDBCreateOptions<ROW> = {},
   ): Promise<void> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       await this.cfg.downstreamDB.createTable(table, schema, opt)
@@ -66,7 +66,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<ROW[]> {
     const resultMap: Record<string, ROW> = {}
     const missingIds: string[] = []
@@ -109,10 +109,10 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return ids.map(id => resultMap[id]!).filter(Boolean)
   }
 
-  override async deleteByIds(
+  override async deleteByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<number> {
     let deletedIds = 0
 
@@ -139,7 +139,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
   override async saveBatch<ROW extends ObjectWithId>(
     table: string,
     rows: ROW[],
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<void> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       await this.cfg.downstreamDB.saveBatch(table, rows, opt)
@@ -167,7 +167,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async runQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<RunQueryResult<ROW>> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const { rows, ...queryResult } = await this.cfg.downstreamDB.runQuery(q, opt)
@@ -197,7 +197,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async runQueryCount<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<number> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       return await this.cfg.downstreamDB.runQueryCount(q, opt)
@@ -214,7 +214,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override streamQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBStreamOptions = {},
+    opt: CacheDBStreamOptions<ROW> = {},
   ): Readable {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const stream = this.cfg.downstreamDB.streamQuery<ROW>(q, opt)
@@ -253,7 +253,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
 
   override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt: CacheDBOptions = {},
+    opt: CacheDBOptions<ROW> = {},
   ): Promise<number> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const deletedIds = await this.cfg.downstreamDB.deleteByQuery(q, opt)

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

@@ -13,7 +13,13 @@ import {
 } from '@naturalcycles/js-lib'
 import { Debug, readableCreate, ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { dimGrey } from '@naturalcycles/nodejs-lib/dist/colors'
-import { BaseCommonDB, DBSaveBatchOperation, ObjectWithId, queryInMemory } from '../..'
+import {
+  AnyObjectWithId,
+  BaseCommonDB,
+  DBSaveBatchOperation,
+  ObjectWithId,
+  queryInMemory,
+} from '../..'
 import { CommonDB } from '../../common.db'
 import {
   CommonDBOptions,
@@ -72,7 +78,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   override async saveBatch<ROW extends ObjectWithId>(
     table: string,
     rows: ROW[],
-    _opt?: CommonDBSaveOptions,
+    _opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
     if (!rows.length) return // save some api calls
 
@@ -98,7 +104,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   /**
    * Implementation is optimized for loading/saving _whole files_.
    */
-  override async commitTransaction(tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void> {
+  override async commitTransaction(tx: DBTransaction, _opt?: CommonDBOptions): Promise<void> {
     // data[table][id] => row
     const data: StringMap<StringMap<ObjectWithId>> = {}
 
@@ -131,7 +137,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
       return {
         type: 'saveBatch',
         table,
-        rows: this.sortRows(Object.values(data[table]!)),
+        rows: this.sortRows(Object.values(data[table]!) as AnyObjectWithId[]),
       }
     })
 
@@ -242,7 +248,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     this.logFinished(started, op)
   }
 
-  async saveFiles(ops: DBSaveBatchOperation[]): Promise<void> {
+  async saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void> {
     if (!ops.length) return
     const op =
       `saveFiles ${ops.length} op(s):\n` + ops.map(o => `${o.table} (${o.rows.length})`).join('\n')

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

@@ -122,9 +122,9 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async createTable(
+  async createTable<ROW extends ObjectWithId>(
     _table: string,
-    _schema: JsonSchemaObject,
+    _schema: JsonSchemaObject<ROW>,
     opt: CommonDBCreateOptions = {},
   ): Promise<void> {
     const table = this.cfg.tablesPrefix + _table
@@ -148,7 +148,7 @@ export class InMemoryDB implements CommonDB {
   async saveBatch<ROW extends ObjectWithId>(
     _table: string,
     rows: ROW[],
-    _opt?: CommonDBSaveOptions,
+    _opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
     const table = this.cfg.tablesPrefix + _table
     this.data[table] = this.data[table] || {}
@@ -220,7 +220,7 @@ export class InMemoryDB implements CommonDB {
     return Readable.from(queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]))
   }
 
-  async commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void> {
+  async commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void> {
     for await (const op of tx.ops) {
       if (op.type === 'saveBatch') {
         await this.saveBatch(op.table, op.rows, opt)

package/src/base.common.db.ts

@@ -2,7 +2,7 @@ import { Readable } from 'stream'
 import { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDB } from './common.db'
-import { CommonDBSaveOptions, ObjectWithId, RunQueryResult } from './db.model'
+import { CommonDBOptions, ObjectWithId, RunQueryResult } from './db.model'
 import { DBQuery } from './query/dbQuery'
 import { DBTransaction } from './transaction/dbTransaction'
 import { commitDBTransactionSimple } from './transaction/dbTransaction.util'
@@ -30,7 +30,10 @@ export class BaseCommonDB implements CommonDB {
     }
   }
 
-  async createTable(_table: string, _schema: JsonSchemaObject): Promise<void> {}
+  async createTable<ROW extends ObjectWithId>(
+    _table: string,
+    _schema: JsonSchemaObject<ROW>,
+  ): Promise<void> {}
 
   async deleteByIds(_table: string, _ids: string[]): Promise<number> {
     return 0
@@ -62,7 +65,7 @@ export class BaseCommonDB implements CommonDB {
    * Naive implementation.
    * To be extended.
    */
-  async commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void> {
+  async commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void> {
     await commitDBTransactionSimple(this, tx, opt)
   }
 }

package/src/common.db.ts

@@ -37,7 +37,11 @@ export interface CommonDB {
    * Will do like `create table ...` for mysql.
    * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
    */
-  createTable(table: string, schema: JsonSchemaObject, opt?: CommonDBCreateOptions): Promise<void>
+  createTable<ROW extends ObjectWithId>(
+    table: string,
+    schema: JsonSchemaObject<ROW>,
+    opt?: CommonDBCreateOptions,
+  ): Promise<void>
 
   // GET
   /**
@@ -70,7 +74,7 @@ export interface CommonDB {
   saveBatch<ROW extends ObjectWithId>(
     table: string,
     rows: ROW[],
-    opt?: CommonDBSaveOptions,
+    opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void>
 
   // DELETE
@@ -87,5 +91,5 @@ export interface CommonDB {
    * Should be implemented as a Transaction (best effort), which means that
    * either ALL or NONE of the operations should be applied.
    */
-  commitTransaction(tx: DBTransaction, opt?: CommonDBSaveOptions): Promise<void>
+  commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void>
 }

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

@@ -67,7 +67,7 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends Obje
   bmSchema?: ObjectSchemaTyped<BM> | AjvSchema<BM>
   tmSchema?: ObjectSchemaTyped<TM> | AjvSchema<TM>
 
-  excludeFromIndexes?: string[]
+  excludeFromIndexes?: (keyof DBM)[]
 
   /**
    * @default to false
@@ -149,7 +149,9 @@ export interface CommonDaoOptions extends CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveOptions extends CommonDaoOptions, CommonDBSaveOptions {
+export interface CommonDaoSaveOptions<DBM extends ObjectWithId>
+  extends CommonDaoOptions,
+    CommonDBSaveOptions<DBM> {
   /**
    * @default false
    *

package/src/commondao/common.dao.ts

@@ -216,12 +216,12 @@ export class CommonDao<
     }
   }
 
-  async getBy(by: string, value: any, limit = 0, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
-    return await this.query().filter(by, '==', value).limit(limit).runQuery(opt)
+  async getBy(by: keyof DBM, value: any, limit = 0, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
+    return await this.query().filterEq(by, value).limit(limit).runQuery(opt)
   }
 
-  async getOneBy(by: string, value: any, opt?: CommonDaoOptions): Promise<Saved<BM> | null> {
-    const [bm] = await this.query().filter(by, '==', value).limit(1).runQuery(opt)
+  async getOneBy(by: keyof DBM, value: any, opt?: CommonDaoOptions): Promise<Saved<BM> | null> {
+    const [bm] = await this.query().filterEq(by, value).limit(1).runQuery(opt)
     return bm || null
   }
 
@@ -531,7 +531,7 @@ export class CommonDao<
   /**
    * Mutates with id, created, updated
    */
-  async save(bm: BM, opt: CommonDaoSaveOptions = {}): Promise<Saved<BM>> {
+  async save(bm: BM, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
     this.requireWriteAccess()
     const idWasGenerated = !bm.id
     this.assignIdCreatedUpdated(bm, opt) // mutates
@@ -572,7 +572,11 @@ export class CommonDao<
    *
    * Convenience method to replace 3 operations (loading+patching+saving) with one.
    */
-  async patch(id: string, patch: Partial<BM>, opt: CommonDaoSaveOptions = {}): Promise<Saved<BM>> {
+  async patch(
+    id: string,
+    patch: Partial<BM>,
+    opt: CommonDaoSaveOptions<DBM> = {},
+  ): Promise<Saved<BM>> {
     return await this.save(
       {
         ...(await this.getByIdOrCreate(id, patch, opt)),
@@ -582,7 +586,11 @@ export class CommonDao<
     )
   }
 
-  async patchAsDBM(id: string, patch: Partial<DBM>, opt: CommonDaoSaveOptions = {}): Promise<DBM> {
+  async patchAsDBM(
+    id: string,
+    patch: Partial<DBM>,
+    opt: CommonDaoSaveOptions<DBM> = {},
+  ): Promise<DBM> {
     const dbm =
       (await this.getByIdAsDBM(id, opt)) ||
       (this.create({ ...patch, id } as Partial<BM>, opt) as any as DBM)
@@ -596,7 +604,7 @@ export class CommonDao<
     )
   }
 
-  async saveAsDBM(dbm: DBM, opt: CommonDaoSaveOptions = {}): Promise<DBM> {
+  async saveAsDBM(dbm: DBM, opt: CommonDaoSaveOptions<DBM> = {}): Promise<DBM> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
 
@@ -618,7 +626,7 @@ export class CommonDao<
     return dbm
   }
 
-  async saveBatch(bms: BM[], opt: CommonDaoSaveOptions = {}): Promise<Saved<BM>[]> {
+  async saveBatch(bms: BM[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>[]> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
     bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt))
@@ -643,7 +651,7 @@ export class CommonDao<
     return bms as any[]
   }
 
-  async saveBatchAsDBM(dbms: DBM[], opt: CommonDaoSaveOptions = {}): Promise<DBM[]> {
+  async saveBatchAsDBM(dbms: DBM[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<DBM[]> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
     if (!opt.raw) {

package/src/db.model.ts

@@ -1,3 +1,4 @@
+import { AnyObject } from '@naturalcycles/js-lib'
 import { CommonDB } from './common.db'
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
@@ -6,8 +7,9 @@ export interface CommonDBOptions {}
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions extends CommonDBOptions {
-  excludeFromIndexes?: string[]
+export interface CommonDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId>
+  extends CommonDBOptions {
+  excludeFromIndexes?: (keyof ROW)[]
 }
 
 export type CommonDBStreamOptions = CommonDBOptions
@@ -27,7 +29,7 @@ export interface RunQueryResult<T> {
 
 export type DBOperation = DBSaveBatchOperation | DBDeleteByIdsOperation
 
-export interface DBSaveBatchOperation<ROW extends ObjectWithId = any> {
+export interface DBSaveBatchOperation<ROW extends ObjectWithId = AnyObjectWithId> {
   type: 'saveBatch'
   table: string
   rows: ROW[]
@@ -63,6 +65,8 @@ export interface ObjectWithId {
   id: string
 }
 
+export interface AnyObjectWithId extends AnyObject, ObjectWithId {}
+
 /**
  * Interface for a module (lib) that implements CommonDB.
  *

package/src/index.ts

@@ -24,6 +24,7 @@ import {
   CommonDaoStreamOptions,
 } from './commondao/common.dao.model'
 import {
+  AnyObjectWithId,
   CommonDBAdapter,
   CommonDBCreateOptions,
   CommonDBOptions,
@@ -80,6 +81,7 @@ export type {
   RunQueryResult,
   CreatedUpdated,
   CreatedUpdatedId,
+  AnyObjectWithId,
   ObjectWithId,
   CommonDaoCfg,
   CommonDaoCreateIdHook,

package/src/query/dbQuery.ts

@@ -2,7 +2,7 @@ import { AsyncMapper, _truncate, Saved } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDaoOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions } from '..'
 import { CommonDao } from '../commondao/common.dao'
-import { ObjectWithId, RunQueryResult } from '../db.model'
+import { AnyObjectWithId, ObjectWithId, RunQueryResult } from '../db.model'
 
 /**
  * Modeled after Firestore operators (WhereFilterOp type)
@@ -46,29 +46,17 @@ export const dbQueryFilterOperatorValues = [
   'array-contains-any',
 ]
 
-export interface DBQueryFilter {
-  name: string
+export interface DBQueryFilter<ROW extends ObjectWithId = AnyObjectWithId> {
+  name: keyof ROW
   op: DBQueryFilterOperator
   val: any
 }
 
-export interface DBQueryOrder {
-  name: string
+export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
+  name: keyof ROW
   descending?: boolean
 }
 
-// export interface DBQueryData {
-//   _filters: DBQueryFilter[]
-//   _limitValue: number
-//   _orders: DBQueryOrder[]
-//
-//   /**
-//    * If defined - only those fields will be selected.
-//    * In undefined - all fields (*) will be returned.
-//    */
-//   _selectedFieldNames?: string[]
-// }
-
 /**
  * Lowest Common Denominator Query object.
  * To be executed by CommonDao / CommonDB.
@@ -79,26 +67,26 @@ export interface DBQueryOrder {
  *
  * <DBM> is the type of **queried** object (so e.g `key of DBM` can be used), not **returned** object.
  */
-export class DBQuery<ROW extends ObjectWithId> {
+export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
   constructor(public table: string) {}
 
   /**
    * Convenience method.
    */
-  static create<ROW extends ObjectWithId = any>(table: string): DBQuery<ROW> {
+  static create<ROW extends ObjectWithId = AnyObjectWithId>(table: string): DBQuery<ROW> {
     return new DBQuery(table)
   }
 
-  static fromPlainObject<ROW extends ObjectWithId = any>(
+  static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(
     obj: Partial<DBQuery<ROW>> & { table: string },
   ): DBQuery<ROW> {
     return Object.assign(new DBQuery<ROW>(obj.table), obj)
   }
 
-  _filters: DBQueryFilter[] = []
+  _filters: DBQueryFilter<ROW>[] = []
   _limitValue = 0 // 0 means "no limit"
   _offsetValue = 0 // 0 means "no offset"
-  _orders: DBQueryOrder[] = []
+  _orders: DBQueryOrder<ROW>[] = []
 
   _startCursor?: string
   _endCursor?: string
@@ -107,14 +95,14 @@ export class DBQuery<ROW extends ObjectWithId> {
    * If defined - only those fields will be selected.
    * In undefined - all fields (*) will be returned.
    */
-  _selectedFieldNames?: string[]
+  _selectedFieldNames?: (keyof ROW)[]
 
-  filter(name: string, op: DBQueryFilterOperator, val: any): this {
+  filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this {
     this._filters.push({ name, op, val })
     return this
   }
 
-  filterEq(name: string, val: any): this {
+  filterEq(name: keyof ROW, val: any): this {
     this._filters.push({ name, op: '==', val })
     return this
   }
@@ -129,7 +117,7 @@ export class DBQuery<ROW extends ObjectWithId> {
     return this
   }
 
-  order(name: string, descending?: boolean): this {
+  order(name: keyof ROW, descending?: boolean): this {
     this._orders.push({
       name,
       descending,
@@ -137,7 +125,7 @@ export class DBQuery<ROW extends ObjectWithId> {
     return this
   }
 
-  select(fieldNames: string[]): this {
+  select(fieldNames: (keyof ROW)[]): this {
     this._selectedFieldNames = fieldNames
     return this
   }

package/src/timeseries/commonTimeSeriesDao.ts

@@ -5,6 +5,7 @@ import {
   CommonTimeSeriesDaoCfg,
   TimeSeriesDataPoint,
   TimeSeriesQuery,
+  TimeSeriesRow,
   TimeSeriesSaveBatchOp,
 } from './timeSeries.model'
 
@@ -84,7 +85,7 @@ export class CommonTimeSeriesDao {
     if (q.fromIncl) dbq.filter('ts', '>=', q.fromIncl)
     if (q.toExcl) dbq.filter('ts', '<', q.toExcl)
 
-    const { rows } = await this.cfg.db.runQuery(dbq)
+    const rows = (await this.cfg.db.runQuery(dbq)).rows as any as TimeSeriesRow[]
 
     // todo: query from aggregated tables when step is above 'hour'
 

package/src/transaction/dbTransaction.ts

@@ -1,5 +1,5 @@
 import type { CommonDB } from '../common.db'
-import type { CommonDBSaveOptions, DBOperation, ObjectWithId } from '../db.model'
+import type { AnyObjectWithId, CommonDBSaveOptions, DBOperation, ObjectWithId } from '../db.model'
 
 /**
  * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
@@ -7,7 +7,7 @@ import type { CommonDBSaveOptions, DBOperation, ObjectWithId } from '../db.model
 export class DBTransaction {
   public ops: DBOperation[] = []
 
-  saveBatch<ROW extends ObjectWithId = any>(table: string, rows: ROW[]): this {
+  saveBatch<ROW extends ObjectWithId = AnyObjectWithId>(table: string, rows: ROW[]): this {
     this.ops.push({
       type: 'saveBatch',
       table,
@@ -35,7 +35,7 @@ export class RunnableDBTransaction extends DBTransaction {
     super()
   }
 
-  async commit(opt?: CommonDBSaveOptions): Promise<void> {
+  async commit<ROW extends ObjectWithId>(opt?: CommonDBSaveOptions<ROW>): Promise<void> {
     await this.db.commitTransaction(this, opt)
   }
 }