@naturalcycles/db-lib 9.3.2 → 9.4.1

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

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB, CommonDBSupport } from '../../common.db';
@@ -20,13 +20,13 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
      * Resets InMemory DB data
      */
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CacheDBSaveOptions<ROW>): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): ReadableTyped<Saved<ROW>>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CacheDBOptions): Promise<number>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CacheDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CacheDBSaveOptions<ROW>): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CacheDBSaveOptions<ROW>): Promise<void>;
+    runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBSaveOptions<ROW>): Promise<RunQueryResult<ROW>>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBStreamOptions): ReadableTyped<ROW>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CacheDBOptions): Promise<number>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CacheDBOptions): Promise<number>;
 }

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

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

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

@@ -1,4 +1,4 @@
-import { JsonSchemaRootObject, Saved, PartialObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB, CommonDBSupport, DBSaveBatchOperation } from '../..';
 import { CommonDB } from '../../common.db';
@@ -21,18 +21,18 @@ export declare class FileDB extends BaseCommonDB implements CommonDB {
     cfg: FileDBCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], _opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    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>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     deleteByIds(table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]>;
-    saveFile<ROW extends PartialObjectWithId>(table: string, _rows: ROW[]): Promise<void>;
-    saveFiles<ROW extends PartialObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
-    sortRows<ROW extends PartialObjectWithId>(rows: ROW[]): ROW[];
+    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<ROW extends ObjectWithId>(ops: DBSaveBatchOperation<ROW>[]): Promise<void>;
+    sortRows<ROW extends ObjectWithId>(rows: ROW[]): ROW[];
     private logStarted;
     private logFinished;
 }

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

@@ -1,10 +1,10 @@
-import { CommonLogger, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { CommonLogger, ObjectWithId } 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 PartialObjectWithId>(table: string) => Promise<Saved<ROW>[]>;
+    loadFile: <ROW extends ObjectWithId>(table: string) => Promise<ROW[]>;
     saveFiles: (ops: DBSaveBatchOperation<any>[]) => Promise<void>;
 }
 export interface FileDBCfg {
@@ -12,7 +12,7 @@ export interface FileDBCfg {
     /**
      * @default undefined, which means "insertion order"
      */
-    sortOnSave?: DBQueryOrder;
+    sortOnSave?: DBQueryOrder<any>;
     /**
      * @default true
      * If true - will run `sortObjectDeep()` on each object to achieve deterministic sort

package/dist/adapter/file/inMemory.persistence.plugin.d.ts

@@ -9,5 +9,5 @@ export declare class InMemoryPersistencePlugin implements FileDBPersistencePlugi
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
     loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
+    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
 }

package/dist/adapter/file/localFile.persistence.plugin.d.ts

@@ -1,4 +1,4 @@
-import { PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import { FileDBPersistencePlugin } from './file.db.model';
 export interface LocalFilePersistencePluginCfg {
@@ -19,7 +19,7 @@ export declare class LocalFilePersistencePlugin implements FileDBPersistencePlug
     cfg: LocalFilePersistencePluginCfg;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends PartialObjectWithId>(table: string): Promise<Saved<ROW>[]>;
-    saveFiles(ops: DBSaveBatchOperation[]): Promise<void>;
-    saveFile<ROW extends PartialObjectWithId>(table: string, rows: ROW[]): Promise<void>;
+    loadFile<ROW extends ObjectWithId>(table: string): Promise<ROW[]>;
+    saveFiles(ops: DBSaveBatchOperation<any>[]): Promise<void>;
+    saveFile<ROW extends ObjectWithId>(table: string, rows: ROW[]): Promise<void>;
 }

package/dist/adapter/file/noop.persistence.plugin.d.ts

@@ -1,9 +1,9 @@
-import { PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBSaveBatchOperation } from '../../db.model';
 import { FileDBPersistencePlugin } from './file.db.model';
 export declare class NoopPersistencePlugin implements FileDBPersistencePlugin {
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    loadFile<ROW extends PartialObjectWithId>(_table: string): Promise<Saved<ROW>[]>;
-    saveFiles(_ops: DBSaveBatchOperation[]): Promise<void>;
+    loadFile<ROW extends ObjectWithId>(_table: string): Promise<ROW[]>;
+    saveFiles(_ops: DBSaveBatchOperation<any>[]): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBTransactionOptions, CommonDBType, DBOperation, DBPatch, DBTransactionFn } from '../..';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../../db.model';
@@ -78,16 +78,16 @@ export declare class InMemoryDB implements CommonDB {
      */
     resetCache(_table?: string): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<Saved<ROW>[]>;
-    saveBatch<ROW extends PartialObjectWithId>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    getTableSchema<ROW extends ObjectWithId>(_table: string): Promise<JsonSchemaRootObject<ROW>>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): Promise<number>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): ReadableTyped<Saved<ROW>>;
+    updateByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>): 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>;
     runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
     /**
      * Flushes all tables (all namespaces) at once.
@@ -104,8 +104,8 @@ export declare class InMemoryDBTransaction implements DBTransaction {
     constructor(db: InMemoryDB, opt: Required<CommonDBTransactionOptions>);
     ops: DBOperation[];
     writeOperationHappened: boolean;
-    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>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
     deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
     commit(): Promise<void>;
     rollback(): Promise<void>;

package/dist/adapter/inmemory/queryInMemory.d.ts

@@ -1,3 +1,3 @@
-import { PartialObjectWithId } from '@naturalcycles/js-lib';
+import { ObjectWithId } from '@naturalcycles/js-lib';
 import { DBQuery } from '../../query/dbQuery';
-export declare function queryInMemory<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];
+export declare function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows?: ROW[]): ROW[];

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

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDB, CommonDBSupport, CommonDBType } from './common.db';
 import { CommonDBOptions, CommonDBSaveOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
@@ -12,15 +12,15 @@ export declare class BaseCommonDB implements CommonDB {
     support: CommonDBSupport;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends PartialObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
-    createTable<ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>): Promise<void>;
-    getByIds<ROW extends PartialObjectWithId>(table: string, ids: string[]): Promise<Saved<ROW>[]>;
-    deleteByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number>;
-    updateByQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions): Promise<number>;
-    runQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): Promise<number>;
-    saveBatch<ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    streamQuery<ROW extends PartialObjectWithId>(q: DBQuery<ROW>): ReadableTyped<Saved<ROW>>;
+    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/common.db.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBTransactionOptions, DBPatch, DBTransactionFn, RunQueryResult } from './db.model';
 import { DBQuery } from './query/dbQuery';
@@ -47,27 +47,27 @@ export interface CommonDB {
      *
      * This is important for the code to rely on it, and it's verified by dbTest
      */
-    getTableSchema: <ROW extends PartialObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
+    getTableSchema: <ROW extends ObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
     /**
      * Will do like `create table ...` for mysql.
      * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
      */
-    createTable: <ROW extends PartialObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, 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).
      */
-    getByIds: <ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<Saved<ROW>[]>;
+    getByIds: <ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<ROW[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
-    runQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<RunQueryResult<Saved<ROW>>>;
-    runQueryCount: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
-    streamQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBStreamOptions) => ReadableTyped<Saved<ROW>>;
+    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>;
     /**
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
-    saveBatch: <ROW extends PartialObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => 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).
@@ -77,7 +77,7 @@ export interface CommonDB {
      * Returns number of deleted items.
      * Not supported by all implementations (e.g Datastore will always return same number as number of ids).
      */
-    deleteByQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    deleteByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Applies patch to the rows returned by the query.
      *
@@ -96,7 +96,7 @@ export interface CommonDB {
      *
      * Returns number of rows affected.
      */
-    updateByQuery: <ROW extends PartialObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    updateByQuery: <ROW extends ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
     /**
      * Should be implemented as a Transaction (best effort), which means that
      * either ALL or NONE of the operations should be applied.

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Transform } from 'node:stream';
-import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved, UnixTimestampMillisNumber, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, BaseDBEntity, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, Saved, UnixTimestampMillisNumber, UnsavedId, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, ObjectSchema, ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBTransactionOptions, DBModelType, DBPatch, DBTransaction, RunQueryResult } from '../db.model';
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery';
@@ -12,7 +12,7 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveBa
  * BM = Backend model (optimized for API access)
  * TM = Transport model (optimized to be sent over the wire)
  */
-export declare class CommonDao<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> {
+export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
     cfg: CommonDaoCfg<BM, DBM, TM>;
     constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
@@ -82,11 +82,11 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * Mutates!
      * "Returns", just to have a type of "Saved"
      */
-    assignIdCreatedUpdated<T extends BaseDBEntity>(obj: T, opt?: CommonDaoOptions): Saved<T>;
+    assignIdCreatedUpdated<T extends BaseDBEntity>(obj: Partial<T>, opt?: CommonDaoOptions): T;
     /**
      * Mutates with id, created, updated
      */
-    save(bm: BM, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
+    save(bm: UnsavedId<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -95,7 +95,7 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * Similar to `save` with skipIfEquals.
      * Similar to `patch`, but doesn't load the object from the Database.
      */
-    savePatch(bm: Saved<BM>, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    savePatch(bm: BM, patch: Partial<BM>, opt: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     /**
      * Convenience method to replace 3 operations (loading+patching+saving) with one:
      *
@@ -106,16 +106,24 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
     patchById(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    /**
+     * Like patchById, but runs all operations within a Transaction.
+     */
+    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     /**
      * Same as patchById, but takes the whole object as input.
      * This "whole object" is mutated with the patch and returned.
      * Otherwise, similar behavior as patchById.
      * It still loads the row from the DB.
      */
-    patch(bm: Saved<BM>, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveAsDBM(dbm: DBM, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>>;
-    saveBatch(bms: BM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
-    saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>[]>;
+    patch(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    /**
+     * Like patch, but runs all operations within a Transaction.
+     */
+    patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    saveAsDBM(dbm: UnsavedId<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>>;
+    saveBatch(bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    saveBatchAsDBM(dbms: UnsavedId<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<DBM>[]>;
     /**
      * "Streaming" is implemented by buffering incoming rows into **batches**
      * (of size opt.batchSize, which defaults to 500),
@@ -139,8 +147,8 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
     updateByIds(ids: string[], patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     updateByQuery(q: DBQuery<DBM>, patch: DBPatch<DBM>, opt?: CommonDaoOptions): Promise<number>;
     dbmToBM(_dbm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
-    dbmToBM(_dbm?: Saved<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    dbmsToBM(dbms: Saved<DBM>[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    dbmToBM(_dbm?: DBM, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
     /**
      * Mutates object with properties: id, created, updated.
      * Returns DBM (new reference).
@@ -150,24 +158,24 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
     bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
     anyToDBM(dbm?: any, opt?: CommonDaoOptions): Saved<DBM>;
-    anyToDBMs(entities: Saved<DBM>[], opt?: CommonDaoOptions): Saved<DBM>[];
+    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): Saved<DBM>[];
     bmToTM(bm: undefined, opt?: CommonDaoOptions): TM | undefined;
-    bmToTM(bm?: Saved<BM>, opt?: CommonDaoOptions): TM;
-    bmsToTM(bms: Saved<BM>[], opt?: CommonDaoOptions): TM[];
+    bmToTM(bm?: BM, opt?: CommonDaoOptions): TM;
+    bmsToTM(bms: BM[], opt?: CommonDaoOptions): TM[];
     /**
      * Returns *converted value*.
      * Validates (unless `skipValidation=true` passed).
      *
      * Does NOT mutate the object.
      */
-    validateAndConvert<IN, OUT = IN>(obj: Partial<IN>, schema: ObjectSchema<IN> | AjvSchema<IN> | ZodSchema<IN> | undefined, modelType: DBModelType, opt?: CommonDaoOptions): OUT;
+    validateAndConvert<T>(obj: Partial<T>, schema: ObjectSchema<T> | AjvSchema<T> | ZodSchema<T> | undefined, modelType: DBModelType, opt?: CommonDaoOptions): any;
     getTableSchema(): Promise<JsonSchemaRootObject<DBM>>;
     createTable(schema: JsonSchemaObject<DBM>, opt?: CommonDaoCreateOptions): Promise<void>;
     /**
      * Proxy to this.cfg.db.ping
      */
     ping(): Promise<void>;
-    runInTransaction(fn: CommonDaoTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
+    runInTransaction<T = void>(fn: CommonDaoTransactionFn<T>, opt?: CommonDBTransactionOptions): Promise<T>;
     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;
@@ -178,23 +186,23 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
  *
  * Transaction is rolled back when the function returns rejected Promise (aka "throws").
  */
-export type CommonDaoTransactionFn = (tx: CommonDaoTransaction) => Promise<void>;
+export type CommonDaoTransactionFn<T = void> = (tx: CommonDaoTransaction) => Promise<T>;
 /**
  * Transaction context.
  * Has similar API than CommonDao, but all operations are performed in the context of the transaction.
  */
 export declare class CommonDaoTransaction {
-    private tx;
+    tx: DBTransaction;
     private logger;
     constructor(tx: DBTransaction, logger: CommonLogger);
     /**
      * Perform a graceful rollback without throwing/re-throwing any error.
      */
     rollback(): Promise<void>;
-    getById<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIds<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    save<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, bm: BM, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveBatch<BM extends PartialObjectWithId, DBM extends PartialObjectWithId>(dao: CommonDao<BM, DBM, any>, bms: BM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    getById<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bm: UnsavedId<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bms: UnsavedId<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
     deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
 }