@naturalcycles/db-lib 9.4.0 → 9.4.2

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, UnixTimestampMillisNumber, Unsaved, 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,22 +12,22 @@ 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>;
+    create(part?: Partial<BM>, opt?: CommonDaoOptions): BM;
     getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getById(id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
+    getById(id?: string | null, opt?: CommonDaoOptions): Promise<BM | null>;
+    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
+    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<Saved<DBM> | null>;
+    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIdAsTM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsTM(id?: string | null, opt?: CommonDaoOptions): Promise<TM | null>;
-    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
-    requireById(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
+    getByIds(ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
+    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    requireById(id: string, opt?: CommonDaoOptions): Promise<BM>;
+    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<DBM>;
     private throwRequiredError;
     /**
      * Throws if readOnly is true
@@ -38,33 +38,33 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      */
     private requireObjectMutability;
     private ensureUniqueId;
-    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>[]>;
+    getBy(by: keyof DBM, value: any, limit?: number, opt?: CommonDaoOptions): Promise<BM[]>;
+    getOneBy(by: keyof DBM, value: any, opt?: CommonDaoOptions): Promise<BM | null>;
+    getAll(opt?: CommonDaoOptions): Promise<BM[]>;
     /**
      * Pass `table` to override table
      */
     query(table?: string): RunnableDBQuery<BM, DBM, TM>;
-    runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<BM[]>;
     runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
      * Convenience method that runs multiple queries in parallel and then merges their results together.
      * Does deduplication by id.
      * Order is not guaranteed, as queries run in parallel.
      */
-    runUnionQueries(queries: DBQuery<DBM>[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    runQueryExtended(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;
-    runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
-    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<DBM>>>;
+    runUnionQueries(queries: DBQuery<DBM>[], opt?: CommonDaoOptions): Promise<BM[]>;
+    runQueryExtended(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<BM>>;
+    runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<DBM[]>;
+    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
     runQueryAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<TM[]>;
     runQueryExtendedAsTM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<TM>>;
     runQueryCount(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<number>;
-    streamQueryForEach(q: DBQuery<DBM>, mapper: AsyncMapper<Saved<BM>, void>, opt?: CommonDaoStreamForEachOptions<Saved<BM>>): Promise<void>;
-    streamQueryAsDBMForEach(q: DBQuery<DBM>, mapper: AsyncMapper<Saved<DBM>, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
+    streamQueryForEach(q: DBQuery<DBM>, mapper: AsyncMapper<BM, void>, opt?: CommonDaoStreamForEachOptions<BM>): Promise<void>;
+    streamQueryAsDBMForEach(q: DBQuery<DBM>, mapper: AsyncMapper<DBM, void>, opt?: CommonDaoStreamForEachOptions<DBM>): Promise<void>;
     /**
      * Stream as Readable, to be able to .pipe() it further with support of backpressure.
      */
-    streamQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<Saved<DBM>>;
+    streamQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM>;
     /**
      * Stream as Readable, to be able to .pipe() it further with support of backpressure.
      *
@@ -74,7 +74,7 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      *
      * You can do `.pipe(transformNoOp)` to make it "valid again".
      */
-    streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<Saved<BM>>): ReadableTyped<Saved<BM>>;
+    streamQuery(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM>;
     queryIds(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<string[]>;
     streamQueryIds(q: DBQuery<DBM>, opt?: CommonDaoStreamOptions<string>): ReadableTyped<string>;
     streamQueryIdsForEach(q: DBQuery<DBM>, mapper: AsyncMapper<string, void>, opt?: CommonDaoStreamForEachOptions<string>): Promise<void>;
@@ -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: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<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<BM>;
     /**
      * Convenience method to replace 3 operations (loading+patching+saving) with one:
      *
@@ -105,25 +105,25 @@ export declare class CommonDao<BM extends PartialObjectWithId, DBM extends Parti
      * 2. Applies the patch on top of loaded data.
      * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
-    patchById(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patchById(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Like patchById, but runs all operations within a Transaction.
      */
-    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    patchByIdInTransaction(id: string, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<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>>;
+    patch(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
     /**
      * Like patch, but runs all operations within a Transaction.
      */
-    patchInTransaction(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>[]>;
+    patchInTransaction(bm: BM, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
+    saveAsDBM(dbm: Unsaved<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM>;
+    saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
+    saveBatchAsDBM(dbms: Unsaved<DBM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM[]>;
     /**
      * "Streaming" is implemented by buffering incoming rows into **batches**
      * (of size opt.batchSize, which defaults to 500),
@@ -147,21 +147,21 @@ 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<BM>;
+    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<BM[]>;
     /**
      * Mutates object with properties: id, created, updated.
      * Returns DBM (new reference).
      */
     bmToDBM(bm: undefined, opt?: CommonDaoOptions): Promise<undefined>;
-    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
-    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
+    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<DBM>;
+    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<DBM[]>;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
-    anyToDBM(dbm?: any, opt?: CommonDaoOptions): Saved<DBM>;
-    anyToDBMs(entities: Saved<DBM>[], opt?: CommonDaoOptions): Saved<DBM>[];
+    anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
+    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): 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).
@@ -199,10 +199,10 @@ export declare class CommonDaoTransaction {
      * 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<BM | null>;
+    getByIds<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<BM[]>;
+    save<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM>;
+    saveBatch<BM extends BaseDBEntity, DBM extends BaseDBEntity>(dao: CommonDao<BM, DBM, any>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<BM[]>;
     deleteById(dao: CommonDao<any>, id?: string | null, opt?: CommonDaoOptions): Promise<number>;
     deleteByIds(dao: CommonDao<any>, ids: string[], opt?: CommonDaoOptions): Promise<number>;
 }

package/dist/commondao/common.dao.js

@@ -419,7 +419,7 @@ class CommonDao {
         return (stream
             // optimization: 1 validation is enough
             // .pipe(transformMap<any, DBM>(dbm => this.anyToDBM(dbm, opt), safeOpt))
-            // .pipe(transformMap<DBM, Saved<BM>>(dbm => this.dbmToBM(dbm, opt), safeOpt))
+            // .pipe(transformMap<DBM, BM>(dbm => this.dbmToBM(dbm, opt), safeOpt))
             .on('error', err => stream.emit('error', err))
             .pipe((0, nodejs_lib_1.transformMap)(async (dbm) => {
             if (this.cfg.hooks.afterLoad) {
@@ -508,6 +508,7 @@ class CommonDao {
         }
         const idWasGenerated = !bm.id && this.cfg.generateId;
         this.assignIdCreatedUpdated(bm, opt); // mutates
+        (0, js_lib_1._typeCast)(bm);
         let dbm = await this.bmToDBM(bm, opt);
         if (this.cfg.hooks.beforeSave) {
             dbm = (await this.cfg.hooks.beforeSave(dbm));
@@ -1116,7 +1117,7 @@ class CommonDaoTransaction {
     //   dao: CommonDao<BM, DBM, any>,
     //   q: DBQuery<DBM>,
     //   opt?: CommonDaoOptions,
-    // ): Promise<Saved<BM>[]> {
+    // ): Promise<BM[]> {
     //   try {
     //     return await dao.runQuery(q, { ...opt, tx: this.tx })
     //   } catch (err) {

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

@@ -1,8 +1,8 @@
-import { AnyObject, CommonLogger, ErrorMode, PartialObjectWithId, Promisable, Saved, ZodError, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, BaseDBEntity, CommonLogger, ErrorMode, Promisable, ZodError, ZodSchema } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError, JoiValidationError, ObjectSchema, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
-export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends PartialObjectWithId, TM> {
+export interface CommonDaoHooks<BM extends BaseDBEntity, DBM extends BaseDBEntity, TM> {
     /**
      * Allows to override the id generation function.
      * By default it uses `stringId` from nodejs-lib
@@ -38,7 +38,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      * as it only validates "final state", not intermediate
      */
     beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>;
-    beforeDBMToBM: (dbm: Saved<DBM>) => Partial<BM> | Promise<Partial<BM>>;
+    beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
     beforeBMToDBM: (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;
     beforeBMToTM: (bm: BM) => Partial<TM>;
     /**
@@ -53,7 +53,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    afterLoad?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>;
+    afterLoad?: (dbm: DBM) => Promisable<DBM | null>;
     /**
      * Allows to access the DBM just before it's supposed to be saved to the DB.
      *
@@ -67,7 +67,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    beforeSave?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>;
+    beforeSave?: (dbm: DBM) => Promisable<DBM | null>;
     /**
      * Called in:
      * - dbmToBM (applied before DBM becomes BM)
@@ -77,7 +77,7 @@ export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends Part
      * It still applies to BM "transitively", during dbmToBM
      * (e.g after loaded from the Database).
      */
-    anonymize: (dbm: Saved<DBM>) => Saved<DBM>;
+    anonymize: (dbm: DBM) => DBM;
     /**
      * If hook is defined - allows to prevent or modify the error thrown.
      * Return `false` to prevent throwing an error.
@@ -104,7 +104,7 @@ export declare enum CommonDaoLogLevel {
      */
     DATA_FULL = 30
 }
-export interface CommonDaoCfg<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> {
+export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, TM extends AnyObject = BM> {
     db: CommonDB;
     table: string;
     /**
@@ -230,7 +230,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
      */
     table?: string;
 }
-export interface CommonDaoSaveOptions<BM extends PartialObjectWithId, DBM extends PartialObjectWithId> extends CommonDaoSaveBatchOptions<DBM> {
+export interface CommonDaoSaveOptions<BM extends BaseDBEntity, DBM extends BaseDBEntity> extends CommonDaoSaveBatchOptions<DBM> {
     /**
      * If provided - a check will be made.
      * If the object for saving equals to the object passed to `skipIfEquals` - save operation will be skipped.
@@ -244,7 +244,7 @@ export interface CommonDaoSaveOptions<BM extends PartialObjectWithId, DBM extend
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveBatchOptions<DBM extends PartialObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveBatchOptions<DBM extends BaseDBEntity> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *
@@ -256,9 +256,9 @@ export interface CommonDaoSaveBatchOptions<DBM extends PartialObjectWithId> exte
      */
     ensureUniqueId?: boolean;
 }
-export interface CommonDaoStreamDeleteOptions<DBM extends PartialObjectWithId> extends CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamDeleteOptions<DBM extends BaseDBEntity> extends CommonDaoStreamOptions<DBM> {
 }
-export interface CommonDaoStreamSaveOptions<DBM extends PartialObjectWithId> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamSaveOptions<DBM extends BaseDBEntity> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
 }
 export interface CommonDaoStreamForEachOptions<IN> extends CommonDaoStreamOptions<IN>, TransformMapOptions<IN, any> {
 }