@naturalcycles/db-lib 9.2.0 → 9.3.0

package/dist/query/dbQuery.d.ts

@@ -1,4 +1,4 @@
-import { AnyObjectWithId, ObjectWithId, AsyncMapper, Saved, AnyObject } from '@naturalcycles/js-lib';
+import { AsyncMapper, Saved, AnyObject, PartialObjectWithId, AnyPartialObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoOptions, CommonDaoStreamDeleteOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, DBPatch } from '..';
 import { CommonDao } from '../commondao/common.dao';
@@ -24,12 +24,12 @@ import { RunQueryResult } from '../db.model';
  */
 export type DBQueryFilterOperator = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'in' | 'not-in' | 'array-contains' | 'array-contains-any';
 export declare const dbQueryFilterOperatorValues: DBQueryFilterOperator[];
-export interface DBQueryFilter<ROW extends ObjectWithId = AnyObjectWithId> {
+export interface DBQueryFilter<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
     name: keyof ROW;
     op: DBQueryFilterOperator;
     val: any;
 }
-export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
+export interface DBQueryOrder<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
     name: keyof ROW;
     descending?: boolean;
 }
@@ -43,14 +43,14 @@ export interface DBQueryOrder<ROW extends ObjectWithId = AnyObjectWithId> {
  *
  * <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 = AnyObjectWithId> {
+export declare class DBQuery<ROW extends PartialObjectWithId = AnyPartialObjectWithId> {
     table: string;
     constructor(table: string);
     /**
      * Convenience method.
      */
-    static create<ROW extends ObjectWithId = AnyObjectWithId>(table: string): DBQuery<ROW>;
-    static fromPlainObject<ROW extends ObjectWithId = AnyObjectWithId>(obj: Partial<DBQuery<ROW>> & {
+    static create<ROW extends PartialObjectWithId = AnyPartialObjectWithId>(table: string): DBQuery<ROW>;
+    static fromPlainObject<ROW extends PartialObjectWithId = AnyPartialObjectWithId>(obj: Partial<DBQuery<ROW>> & {
         table: string;
     }): DBQuery<ROW>;
     _filters: DBQueryFilter<ROW>[];
@@ -84,7 +84,7 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
 /**
  * DBQuery that has additional method to support Fluent API style.
  */
-export declare class RunnableDBQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM extends AnyObject = BM> extends DBQuery<DBM> {
+export declare class RunnableDBQuery<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> extends DBQuery<DBM> {
     dao: CommonDao<BM, DBM, TM>;
     /**
      * Pass `table` to override table.
@@ -92,10 +92,10 @@ export declare class RunnableDBQuery<BM extends Partial<ObjectWithId>, DBM exten
     constructor(dao: CommonDao<BM, DBM, TM>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
-    runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
+    runQueryAsDBM(opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
     runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]>;
     runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
-    runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
+    runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<DBM>>>;
     runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
     runQueryCount(opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;

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

@@ -2,14 +2,13 @@
 import { BaseDBEntity, Saved, JsonSchemaObject } from '@naturalcycles/js-lib';
 export declare const TEST_TABLE = "TEST_TABLE";
 export interface TestItemBM extends BaseDBEntity {
-    id: string;
     k1: string;
     k2?: string | null;
     k3?: number;
     even?: boolean;
     b1?: Buffer;
 }
-export interface TestItemDBM extends Saved<TestItemBM> {
+export interface TestItemDBM extends TestItemBM {
 }
 export interface TestItemTM {
     k1: string;
@@ -20,7 +19,7 @@ export declare const testItemDBMSchema: import("joi").ObjectSchema<TestItemDBM>;
 export declare const testItemTMSchema: import("joi").ObjectSchema<TestItemTM>;
 export declare const testItemBMJsonSchema: JsonSchemaObject<TestItemBM>;
 export declare const testItemDBMJsonSchema: JsonSchemaObject<TestItemDBM>;
-export declare function createTestItemDBM(num?: number): TestItemDBM;
+export declare function createTestItemDBM(num?: number): Saved<TestItemDBM>;
 export declare function createTestItemBM(num?: number): Saved<TestItemBM>;
-export declare function createTestItemsDBM(count?: number): TestItemDBM[];
+export declare function createTestItemsDBM(count?: number): Saved<TestItemDBM>[];
 export declare function createTestItemsBM(count?: number): Saved<TestItemBM>[];

package/dist/testing/test.model.js

@@ -18,7 +18,7 @@ exports.testItemDBMSchema = (0, nodejs_lib_1.objectSchema)({
     k3: nodejs_lib_1.numberSchema.optional(),
     even: nodejs_lib_1.booleanSchema.optional(),
     b1: nodejs_lib_1.binarySchema.optional(),
-}).concat(nodejs_lib_1.savedDBEntitySchema);
+}).concat(nodejs_lib_1.baseDBEntitySchema);
 exports.testItemTMSchema = (0, nodejs_lib_1.objectSchema)({
     k1: nodejs_lib_1.stringSchema,
     even: nodejs_lib_1.booleanSchema.optional(),

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

@@ -1,4 +1,4 @@
-import { ObjectWithId } from '@naturalcycles/js-lib';
+import { PartialObjectWithId } from '@naturalcycles/js-lib';
 import type { CommonDB } from '../common.db';
 import { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model';
 /**
@@ -22,7 +22,7 @@ export declare class FakeDBTransaction implements DBTransaction {
     protected db: CommonDB;
     constructor(db: CommonDB);
     rollback(): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
 }

package/dist/validation/index.d.ts

@@ -3,6 +3,6 @@ import { DBQuery, DBQueryFilter, DBQueryFilterOperator, DBQueryOrder } from '../
 export declare const commonDBOptionsSchema: import("joi").ObjectSchema<CommonDBOptions>;
 export declare const commonDBSaveOptionsSchema: import("joi").ObjectSchema<CommonDBSaveOptions<any>>;
 export declare const dbQueryFilterOperatorSchema: import("@naturalcycles/nodejs-lib/dist/validation/joi/string.extensions").StringSchema<DBQueryFilterOperator>;
-export declare const dbQueryFilterSchema: import("joi").ObjectSchema<DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId>>;
-export declare const dbQueryOrderSchema: import("joi").ObjectSchema<DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId>>;
+export declare const dbQueryFilterSchema: import("joi").ObjectSchema<DBQueryFilter<import("@naturalcycles/js-lib").AnyPartialObjectWithId>>;
+export declare const dbQueryOrderSchema: import("joi").ObjectSchema<DBQueryOrder<import("@naturalcycles/js-lib").AnyPartialObjectWithId>>;
 export declare const dbQuerySchema: import("joi").ObjectSchema<DBQuery<any>>;

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "9.2.0",
+  "version": "9.3.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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

@@ -1,4 +1,4 @@
-import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib'
+import { CommonLogger, PartialObjectWithId } from '@naturalcycles/js-lib'
 import { CommonDB } from '../../common.db'
 import {
   CommonDBCreateOptions,
@@ -62,7 +62,7 @@ export interface CacheDBOptions extends CommonDBOptions {
   onlyCache?: boolean
 }
 
-export interface CacheDBSaveOptions<ROW extends Partial<ObjectWithId>>
+export interface CacheDBSaveOptions<ROW extends PartialObjectWithId>
   extends CacheDBOptions,
     CommonDBSaveOptions<ROW> {}
 

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

@@ -3,9 +3,11 @@ import {
   _isTruthy,
   JsonSchemaObject,
   JsonSchemaRootObject,
-  ObjectWithId,
+  PartialObjectWithId,
+  Saved,
   StringMap,
 } from '@naturalcycles/js-lib'
+import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { BaseCommonDB } from '../../base.common.db'
 import { CommonDB, commonDBFullSupport, CommonDBSupport } from '../../common.db'
 import { DBPatch, RunQueryResult } from '../../db.model'
@@ -57,13 +59,13 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return await this.cfg.downstreamDB.getTables()
   }
 
-  override async getTableSchema<ROW extends ObjectWithId>(
+  override async getTableSchema<ROW extends PartialObjectWithId>(
     table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     return await this.cfg.downstreamDB.getTableSchema<ROW>(table)
   }
 
-  override async createTable<ROW extends ObjectWithId>(
+  override async createTable<ROW extends PartialObjectWithId>(
     table: string,
     schema: JsonSchemaObject<ROW>,
     opt: CacheDBCreateOptions = {},
@@ -77,13 +79,13 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
+  override async getByIds<ROW extends PartialObjectWithId>(
     table: string,
-    ids: ROW['id'][],
+    ids: string[],
     opt: CacheDBSaveOptions<ROW> = {},
-  ): Promise<ROW[]> {
-    const resultMap: StringMap<ROW> = {}
-    const missingIds: ROW['id'][] = []
+  ): Promise<Saved<ROW>[]> {
+    const resultMap: StringMap<Saved<ROW>> = {}
+    const missingIds: string[] = []
 
     if (!opt.skipCache && !this.cfg.skipCache) {
       const results = await this.cfg.cacheDB.getByIds<ROW>(table, ids, opt)
@@ -123,7 +125,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return ids.map(id => resultMap[id]).filter(_isTruthy)
   }
 
-  override async saveBatch<ROW extends Partial<ObjectWithId>>(
+  override async saveBatch<ROW extends PartialObjectWithId>(
     table: string,
     rows: ROW[],
     opt: CacheDBSaveOptions<ROW> = {},
@@ -152,10 +154,10 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async runQuery<ROW extends ObjectWithId>(
+  override async runQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     opt: CacheDBSaveOptions<ROW> = {},
-  ): Promise<RunQueryResult<ROW>> {
+  ): Promise<RunQueryResult<Saved<ROW>>> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const { rows, ...queryResult } = await this.cfg.downstreamDB.runQuery(q, opt)
 
@@ -182,7 +184,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return { rows, ...queryResult }
   }
 
-  override async runQueryCount<ROW extends ObjectWithId>(
+  override async runQueryCount<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     opt: CacheDBOptions = {},
   ): Promise<number> {
@@ -199,10 +201,10 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return count
   }
 
-  override streamQuery<ROW extends ObjectWithId>(
+  override streamQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     opt: CacheDBStreamOptions = {},
-  ): Readable {
+  ): ReadableTyped<Saved<ROW>> {
     if (!opt.onlyCache && !this.cfg.onlyCache) {
       const stream = this.cfg.downstreamDB.streamQuery<ROW>(q, opt)
 
@@ -238,7 +240,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return stream
   }
 
-  override async deleteByQuery<ROW extends ObjectWithId>(
+  override async deleteByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     opt: CacheDBOptions = {},
   ): Promise<number> {
@@ -270,7 +272,7 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return deletedIds
   }
 
-  override async updateByQuery<ROW extends ObjectWithId>(
+  override async updateByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     patch: DBPatch<ROW>,
     opt: CacheDBOptions = {},

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

@@ -1,11 +1,11 @@
-import { CommonLogger, ObjectWithId } from '@naturalcycles/js-lib'
+import { CommonLogger, PartialObjectWithId, Saved } from '@naturalcycles/js-lib'
 import { DBSaveBatchOperation } from '../../db.model'
 import type { DBQueryOrder } from '../../query/dbQuery'
 
 export interface FileDBPersistencePlugin {
   ping: () => Promise<void>
   getTables: () => Promise<string[]>
-  loadFile: <ROW extends ObjectWithId>(table: string) => Promise<ROW[]>
+  loadFile: <ROW extends PartialObjectWithId>(table: string) => Promise<Saved<ROW>[]>
   saveFiles: (ops: DBSaveBatchOperation<any>[]) => Promise<void>
 }
 

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

@@ -8,9 +8,9 @@ import {
   _stringMapValues,
   JsonSchemaRootObject,
   _filterUndefinedValues,
-  ObjectWithId,
   _assert,
   Saved,
+  PartialObjectWithId,
 } from '@naturalcycles/js-lib'
 import { readableCreate, ReadableTyped, dimGrey } from '@naturalcycles/nodejs-lib'
 import {
@@ -74,16 +74,16 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return tables
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
+  override async getByIds<ROW extends PartialObjectWithId>(
     table: string,
-    ids: ROW['id'][],
+    ids: string[],
     _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
+  ): Promise<Saved<ROW>[]> {
     const byId = _by(await this.loadFile<ROW>(table), r => r.id)
     return ids.map(id => byId[id]!).filter(Boolean)
   }
 
-  override async saveBatch<ROW extends Partial<ObjectWithId>>(
+  override async saveBatch<ROW extends PartialObjectWithId>(
     table: string,
     rows: ROW[],
     _opt?: CommonDBSaveOptions<ROW>,
@@ -111,23 +111,23 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async runQuery<ROW extends ObjectWithId>(
+  override async runQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
-  ): Promise<RunQueryResult<ROW>> {
+  ): Promise<RunQueryResult<Saved<ROW>>> {
     return {
       rows: queryInMemory(q, await this.loadFile<ROW>(q.table)),
     }
   }
 
-  override async runQueryCount<ROW extends ObjectWithId>(
+  override async runQueryCount<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
     return (await this.loadFile(q.table)).length
   }
 
-  override streamQuery<ROW extends ObjectWithId>(
+  override streamQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     opt?: CommonDBStreamOptions,
   ): ReadableTyped<ROW> {
@@ -141,7 +141,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return readable
   }
 
-  override async deleteByQuery<ROW extends ObjectWithId>(
+  override async deleteByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
@@ -181,7 +181,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return deleted
   }
 
-  override async getTableSchema<ROW extends ObjectWithId>(
+  override async getTableSchema<ROW extends PartialObjectWithId>(
     table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     const rows = await this.loadFile(table)
@@ -192,7 +192,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   }
 
   // wrapper, to handle logging
-  async loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]> {
     const started = this.logStarted(`loadFile(${table})`)
     const rows = await this.cfg.plugin.loadFile<ROW>(table)
     this.logFinished(started, `loadFile(${table}) ${rows.length} row(s)`)
@@ -200,7 +200,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   }
 
   // wrapper, to handle logging, sorting rows before saving
-  async saveFile<ROW extends ObjectWithId>(table: string, _rows: ROW[]): Promise<void> {
+  async saveFile<ROW extends PartialObjectWithId>(table: string, _rows: ROW[]): Promise<void> {
     // if (!_rows.length) return // NO, it should be able to save file with 0 rows!
 
     // Sort the rows, if needed
@@ -212,7 +212,9 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     this.logFinished(started, op)
   }
 
-  async saveFiles<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void> {
+  async saveFiles<ROW extends PartialObjectWithId>(
+    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')
@@ -225,7 +227,7 @@ export class FileDB extends BaseCommonDB implements CommonDB {
   //   return new FileDBTransaction(this)
   // }
 
-  sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[] {
+  sortRows<ROW extends PartialObjectWithId>(rows: ROW[]): ROW[] {
     rows = rows.map(r => _filterUndefinedValues(r))
 
     if (this.cfg.sortOnSave) {

package/src/adapter/file/localFile.persistence.plugin.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import fsp from 'node:fs/promises'
 import { Readable } from 'node:stream'
 import { createGzip, createUnzip } from 'node:zlib'
-import { pMap, ObjectWithId } from '@naturalcycles/js-lib'
+import { pMap, PartialObjectWithId, Saved } from '@naturalcycles/js-lib'
 import {
   transformJsonParse,
   transformSplit,
@@ -48,7 +48,7 @@ export class LocalFilePersistencePlugin implements FileDBPersistencePlugin {
       .map(f => f.split('.ndjson')[0]!)
   }
 
-  async loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]> {
+  async loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]> {
     await fs2.ensureDirAsync(this.cfg.storagePath)
     const ext = `ndjson${this.cfg.gzip ? '.gz' : ''}`
     const filePath = `${this.cfg.storagePath}/${table}.${ext}`
@@ -57,7 +57,7 @@ export class LocalFilePersistencePlugin implements FileDBPersistencePlugin {
 
     const transformUnzip = this.cfg.gzip ? [createUnzip()] : []
 
-    const rows: ROW[] = []
+    const rows: Saved<ROW>[] = []
 
     await _pipeline([
       fs.createReadStream(filePath),
@@ -74,7 +74,7 @@ export class LocalFilePersistencePlugin implements FileDBPersistencePlugin {
     await pMap(ops, async op => await this.saveFile(op.table, op.rows), { concurrency: 16 })
   }
 
-  async saveFile<ROW extends ObjectWithId>(table: string, rows: ROW[]): Promise<void> {
+  async saveFile<ROW extends PartialObjectWithId>(table: string, rows: ROW[]): Promise<void> {
     await fs2.ensureDirAsync(this.cfg.storagePath)
     const ext = `ndjson${this.cfg.gzip ? '.gz' : ''}`
     const filePath = `${this.cfg.storagePath}/${table}.${ext}`

package/src/adapter/file/noop.persistence.plugin.ts

@@ -1,4 +1,4 @@
-import { ObjectWithId } from '@naturalcycles/js-lib'
+import { PartialObjectWithId, Saved } from '@naturalcycles/js-lib'
 import { DBSaveBatchOperation } from '../../db.model'
 import { FileDBPersistencePlugin } from './file.db.model'
 
@@ -9,7 +9,7 @@ export class NoopPersistencePlugin implements FileDBPersistencePlugin {
     return []
   }
 
-  async loadFile<ROW extends ObjectWithId>(_table: string): Promise<ROW[]> {
+  async loadFile<ROW extends PartialObjectWithId>(_table: string): Promise<Saved<ROW>[]> {
     return []
   }
 

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

@@ -16,6 +16,8 @@ import {
   CommonLogger,
   _deepCopy,
   _assert,
+  PartialObjectWithId,
+  Saved,
 } from '@naturalcycles/js-lib'
 import {
   bufferReviver,
@@ -152,7 +154,7 @@ export class InMemoryDB implements CommonDB {
     return Object.keys(this.data).filter(t => t.startsWith(this.cfg.tablesPrefix))
   }
 
-  async getTableSchema<ROW extends ObjectWithId>(
+  async getTableSchema<ROW extends PartialObjectWithId>(
     _table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     const table = this.cfg.tablesPrefix + _table
@@ -162,7 +164,7 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async createTable<ROW extends ObjectWithId>(
+  async createTable<ROW extends PartialObjectWithId>(
     _table: string,
     _schema: JsonSchemaObject<ROW>,
     opt: CommonDBCreateOptions = {},
@@ -175,17 +177,17 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async getByIds<ROW extends ObjectWithId>(
+  async getByIds<ROW extends PartialObjectWithId>(
     _table: string,
-    ids: ROW['id'][],
+    ids: string[],
     _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
+  ): Promise<Saved<ROW>[]> {
     const table = this.cfg.tablesPrefix + _table
     this.data[table] ||= {}
-    return ids.map(id => this.data[table]![id] as ROW).filter(Boolean)
+    return ids.map(id => this.data[table]![id] as Saved<ROW>).filter(Boolean)
   }
 
-  async saveBatch<ROW extends Partial<ObjectWithId>>(
+  async saveBatch<ROW extends PartialObjectWithId>(
     _table: string,
     rows: ROW[],
     opt: CommonDBSaveOptions<ROW> = {},
@@ -216,13 +218,13 @@ export class InMemoryDB implements CommonDB {
     })
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(
+  async deleteByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
     const table = this.cfg.tablesPrefix + q.table
     if (!this.data[table]) return 0
-    const ids = queryInMemory(q, Object.values(this.data[table]!) as ROW[]).map(r => r.id)
+    const ids = queryInMemory(q, Object.values(this.data[table]!) as Saved<ROW>[]).map(r => r.id)
     return await this.deleteByIds(q.table, ids)
   }
 
@@ -240,7 +242,7 @@ export class InMemoryDB implements CommonDB {
     return count
   }
 
-  async updateByQuery<ROW extends ObjectWithId>(
+  async updateByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     patch: DBPatch<ROW>,
   ): Promise<number> {
@@ -262,15 +264,15 @@ export class InMemoryDB implements CommonDB {
     return rows.length
   }
 
-  async runQuery<ROW extends ObjectWithId>(
+  async runQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
-  ): Promise<RunQueryResult<ROW>> {
+  ): Promise<RunQueryResult<Saved<ROW>>> {
     const table = this.cfg.tablesPrefix + q.table
-    return { rows: queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]) }
+    return { rows: queryInMemory(q, Object.values(this.data[table] || {}) as Saved<ROW>[]) }
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(
+  async runQueryCount<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
@@ -278,10 +280,10 @@ export class InMemoryDB implements CommonDB {
     return queryInMemory<any>(q, Object.values(this.data[table] || {})).length
   }
 
-  streamQuery<ROW extends ObjectWithId>(
+  streamQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
-  ): ReadableTyped<ROW> {
+  ): ReadableTyped<Saved<ROW>> {
     const table = this.cfg.tablesPrefix + q.table
     return Readable.from(queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]))
   }
@@ -388,7 +390,7 @@ export class InMemoryDBTransaction implements DBTransaction {
   // used to enforce forbidReadAfterWrite setting
   writeOperationHappened = false
 
-  async getByIds<ROW extends ObjectWithId>(
+  async getByIds<ROW extends PartialObjectWithId>(
     table: string,
     ids: string[],
     opt?: CommonDBOptions,
@@ -403,7 +405,7 @@ export class InMemoryDBTransaction implements DBTransaction {
     return await this.db.getByIds(table, ids, opt)
   }
 
-  async saveBatch<ROW extends Partial<ObjectWithId>>(
+  async saveBatch<ROW extends PartialObjectWithId>(
     table: string,
     rows: ROW[],
     opt?: CommonDBSaveOptions<ROW>,

package/src/adapter/inmemory/queryInMemory.ts

@@ -1,4 +1,4 @@
-import { _pick, ObjectWithId } from '@naturalcycles/js-lib'
+import { _pick, PartialObjectWithId } from '@naturalcycles/js-lib'
 import { DBQuery, DBQueryFilterOperator } from '../../query/dbQuery'
 
 type FilterFn = (v: any, val: any) => boolean
@@ -18,7 +18,10 @@ const FILTER_FNS: Record<DBQueryFilterOperator, FilterFn> = {
 
 // Important: q.table is not used in this function, so tablesPrefix is not needed.
 // But should be careful here..
-export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: ROW[] = []): ROW[] {
+export function queryInMemory<ROW extends PartialObjectWithId>(
+  q: DBQuery<ROW>,
+  rows: ROW[] = [],
+): ROW[] {
   // .filter
   // eslint-disable-next-line unicorn/no-array-reduce
   rows = q._filters.reduce((rows, filter) => {

package/src/base.common.db.ts

@@ -1,4 +1,9 @@
-import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib'
+import {
+  JsonSchemaObject,
+  JsonSchemaRootObject,
+  PartialObjectWithId,
+  Saved,
+} from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDB, CommonDBSupport, CommonDBType } from './common.db'
 import {
@@ -31,28 +36,31 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('getTables is not implemented')
   }
 
-  async getTableSchema<ROW extends ObjectWithId>(
+  async getTableSchema<ROW extends PartialObjectWithId>(
     table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
     throw new Error('getTableSchema is not implemented')
   }
 
-  async createTable<ROW extends ObjectWithId>(
+  async createTable<ROW extends PartialObjectWithId>(
     table: string,
     schema: JsonSchemaObject<ROW>,
   ): Promise<void> {
     // no-op
   }
 
-  async getByIds<ROW extends ObjectWithId>(table: string, ids: string[]): Promise<ROW[]> {
+  async getByIds<ROW extends PartialObjectWithId>(
+    table: string,
+    ids: string[],
+  ): Promise<Saved<ROW>[]> {
     throw new Error('getByIds is not implemented')
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+  async deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number> {
     throw new Error('deleteByQuery is not implemented')
   }
 
-  async updateByQuery<ROW extends ObjectWithId>(
+  async updateByQuery<ROW extends PartialObjectWithId>(
     q: DBQuery<ROW>,
     patch: DBPatch<ROW>,
     opt?: CommonDBOptions,
@@ -60,15 +68,17 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('updateByQuery is not implemented')
   }
 
-  async runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
+  async runQuery<ROW extends PartialObjectWithId>(
+    q: DBQuery<ROW>,
+  ): Promise<RunQueryResult<Saved<ROW>>> {
     throw new Error('runQuery is not implemented')
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+  async runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number> {
     throw new Error('runQueryCount is not implemented')
   }
 
-  async saveBatch<ROW extends Partial<ObjectWithId>>(
+  async saveBatch<ROW extends PartialObjectWithId>(
     table: string,
     rows: ROW[],
     opt?: CommonDBSaveOptions<ROW>,
@@ -76,7 +86,7 @@ export class BaseCommonDB implements CommonDB {
     throw new Error('saveBatch is not implemented')
   }
 
-  streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW> {
+  streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): ReadableTyped<Saved<ROW>> {
     throw new Error('streamQuery is not implemented')
   }