@naturalcycles/db-lib 9.2.1 → 9.3.0

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

@@ -1,6 +1,5 @@
-/// <reference types="node" />
-import { Readable } from 'node:stream';
-import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } from '@naturalcycles/js-lib';
+import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { BaseCommonDB } from '../../base.common.db';
 import { CommonDB, CommonDBSupport } from '../../common.db';
 import { DBPatch, RunQueryResult } from '../../db.model';
@@ -21,13 +20,13 @@ export declare class CacheDB extends BaseCommonDB implements CommonDB {
      * Resets InMemory DB data
      */
     getTables(): Promise<string[]>;
-    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: ROW['id'][], opt?: CacheDBSaveOptions<ROW>): Promise<ROW[]>;
-    saveBatch<ROW extends Partial<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): Readable;
-    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>;
+    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>;
 }

package/dist/adapter/cachedb/cache.db.model.d.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, 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 Partial<ObjectWithId>> extends CacheDBOptions, CommonDBSaveOptions<ROW> {
+export interface CacheDBSaveOptions<ROW extends PartialObjectWithId> extends CacheDBOptions, CommonDBSaveOptions<ROW> {
 }
 export interface CacheDBStreamOptions extends CacheDBOptions, CommonDBStreamOptions {
 }

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

@@ -1,4 +1,4 @@
-import { JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaRootObject, Saved, PartialObjectWithId } 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 ObjectWithId>(table: string, ids: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends Partial<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>;
+    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>;
     deleteByIds(table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    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[];
+    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[];
     private logStarted;
     private logFinished;
 }

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

@@ -1,10 +1,10 @@
-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>;
 }
 export interface FileDBCfg {

package/dist/adapter/file/localFile.persistence.plugin.d.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';
 export interface LocalFilePersistencePluginCfg {
@@ -19,7 +19,7 @@ export declare class LocalFilePersistencePlugin implements FileDBPersistencePlug
     cfg: LocalFilePersistencePluginCfg;
     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[]): Promise<void>;
-    saveFile<ROW extends ObjectWithId>(table: string, rows: ROW[]): Promise<void>;
+    saveFile<ROW extends PartialObjectWithId>(table: string, rows: ROW[]): Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { ObjectWithId } from '@naturalcycles/js-lib';
+import { PartialObjectWithId, Saved } 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 ObjectWithId>(_table: string): Promise<ROW[]>;
+    loadFile<ROW extends PartialObjectWithId>(_table: string): Promise<Saved<ROW>[]>;
     saveFiles(_ops: DBSaveBatchOperation[]): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, StringMap, JsonSchemaRootObject, ObjectWithId, CommonLogger, PartialObjectWithId, Saved } 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 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: ROW['id'][], _opt?: CommonDBOptions): Promise<ROW[]>;
-    saveBatch<ROW extends Partial<ObjectWithId>>(_table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    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>;
     deleteByIds(_table: string, ids: string[], _opt?: CommonDBOptions): Promise<number>;
-    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>;
+    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>>;
     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 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): Promise<number>;
     commit(): Promise<void>;
     rollback(): Promise<void>;

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

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

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

@@ -1,4 +1,4 @@
-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 { 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 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 Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-    streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW>;
+    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>>;
     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, ObjectWithId } from '@naturalcycles/js-lib';
+import { JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved } 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 ObjectWithId>(table: string) => Promise<JsonSchemaRootObject<ROW>>;
+    getTableSchema: <ROW extends PartialObjectWithId>(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 ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions) => Promise<void>;
+    createTable: <ROW extends PartialObjectWithId>(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 ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<ROW[]>;
+    getByIds: <ROW extends PartialObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions) => Promise<Saved<ROW>[]>;
     /**
      * Order by 'id' is not supported by all implementations (for example, Datastore doesn't support it).
      */
-    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>;
+    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>>;
     /**
      * rows can have missing ids only if DB supports auto-generating them (like mysql auto_increment).
      */
-    saveBatch: <ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>) => Promise<void>;
+    saveBatch: <ROW extends PartialObjectWithId>(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 ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    deleteByQuery: <ROW extends PartialObjectWithId>(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 ObjectWithId>(q: DBQuery<ROW>, patch: DBPatch<ROW>, opt?: CommonDBOptions) => Promise<number>;
+    updateByQuery: <ROW extends PartialObjectWithId>(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, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId, Saved, UnixTimestampMillisNumber, Unsaved, ZodSchema } from '@naturalcycles/js-lib';
+import { AnyObject, AsyncMapper, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, PartialObjectWithId, Saved, UnixTimestampMillisNumber, 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 Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM extends AnyObject = BM> {
+export declare class CommonDao<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM extends AnyObject = BM> {
     cfg: CommonDaoCfg<BM, DBM, TM>;
     constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<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<DBM>;
+    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
     getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
-    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<DBM | null>;
+    getByIdAsDBM(id?: string | null, opt?: CommonDaoOptions): Promise<Saved<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<DBM[]>;
+    getByIdsAsDBM(ids: string[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
     requireById(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<DBM>;
+    requireByIdAsDBM(id: string, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
     private throwRequiredError;
     /**
      * Throws if readOnly is true
@@ -54,8 +54,8 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      */
     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<DBM[]>;
-    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>>;
+    runQueryAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
+    runQueryExtendedAsDBM(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<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>;
@@ -82,13 +82,12 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * Mutates!
      * "Returns", just to have a type of "Saved"
      */
-    assignIdCreatedUpdated(obj: DBM, opt?: CommonDaoOptions): DBM;
-    assignIdCreatedUpdated(obj: BM, opt?: CommonDaoOptions): Saved<BM>;
-    assignIdCreatedUpdated(obj: Unsaved<BM>, opt?: CommonDaoOptions): Saved<BM>;
+    assignIdCreatedUpdated(obj: Partial<DBM>, opt?: CommonDaoOptions): Saved<Partial<DBM>>;
+    assignIdCreatedUpdated(obj: Partial<BM>, opt?: CommonDaoOptions): Saved<Partial<BM>>;
     /**
      * Mutates with id, created, updated
      */
-    save(bm: Unsaved<BM>, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
+    save(bm: BM, opt?: CommonDaoSaveOptions<BM, DBM>): Promise<Saved<BM>>;
     /**
      * 1. Applies the patch
      * 2. If object is the same after patching - skips saving it
@@ -115,9 +114,9 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      * 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<DBM>;
-    saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
-    saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM[]>;
+    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>[]>;
     /**
      * "Streaming" is implemented by buffering incoming rows into **batches**
      * (of size opt.batchSize, which defaults to 500),
@@ -141,18 +140,18 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
     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?: DBM, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    dbmsToBM(dbms: DBM[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    dbmToBM(_dbm?: Saved<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    dbmsToBM(dbms: Saved<DBM>[], opt?: CommonDaoOptions): Promise<Saved<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<DBM>;
-    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<DBM[]>;
+    bmToDBM(bm?: BM, opt?: CommonDaoOptions): Promise<Saved<DBM>>;
+    bmsToDBM(bms: BM[], opt?: CommonDaoOptions): Promise<Saved<DBM>[]>;
     anyToDBM(dbm: undefined, opt?: CommonDaoOptions): undefined;
-    anyToDBM(dbm?: any, opt?: CommonDaoOptions): DBM;
-    anyToDBMs(entities: DBM[], opt?: CommonDaoOptions): DBM[];
+    anyToDBM(dbm?: any, opt?: CommonDaoOptions): Saved<DBM>;
+    anyToDBMs(entities: Saved<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[];
@@ -193,10 +192,10 @@ export declare class CommonDaoTransaction {
      * Perform a graceful rollback without throwing/re-throwing any error.
      */
     rollback(): Promise<void>;
-    getById<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, id?: string | null, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIds<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, ids: string[], opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
-    save<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bm: Unsaved<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    saveBatch<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(dao: CommonDao<BM, DBM, any>, bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
+    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>[]>;
     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

@@ -26,8 +26,8 @@ class CommonDao {
             logLevel: isGAE || isCI ? common_dao_model_1.CommonDaoLogLevel.NONE : common_dao_model_1.CommonDaoLogLevel.OPERATIONS,
             createId: true,
             assignGeneratedIds: false,
-            created: true,
-            updated: true,
+            useCreatedProperty: true,
+            useUpdatedProperty: true,
             logger: console,
             ...cfg,
             hooks: {
@@ -447,7 +447,7 @@ class CommonDao {
         const stream = this.cfg.db
             .streamQuery(q.select(['id']), opt)
             .on('error', err => stream.emit('error', err))
-            .pipe((0, nodejs_lib_1.transformMapSimple)(objectWithId => objectWithId.id, {
+            .pipe((0, nodejs_lib_1.transformMapSimple)(r => r.id, {
             errorMode: js_lib_1.ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
         }));
         return stream;
@@ -460,9 +460,9 @@ class CommonDao {
         let count = 0;
         await (0, nodejs_lib_1._pipeline)([
             this.cfg.db.streamQuery(q.select(['id']), opt),
-            (0, nodejs_lib_1.transformMapSimple)(objectWithId => {
+            (0, nodejs_lib_1.transformMapSimple)(r => {
                 count++;
-                return objectWithId.id;
+                return r.id;
             }),
             (0, nodejs_lib_1.transformMap)(mapper, {
                 ...opt,
@@ -481,11 +481,11 @@ class CommonDao {
     }
     assignIdCreatedUpdated(obj, opt = {}) {
         const now = Math.floor(Date.now() / 1000);
-        if (this.cfg.created) {
+        if (this.cfg.useCreatedProperty) {
             ;
             obj['created'] ||= obj['updated'] || now;
         }
-        if (this.cfg.updated) {
+        if (this.cfg.useUpdatedProperty) {
             ;
             obj['updated'] =
                 opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now;
@@ -801,7 +801,7 @@ class CommonDao {
             const { batchSize, batchConcurrency = 16 } = opt;
             await (0, nodejs_lib_1._pipeline)([
                 this.cfg.db.streamQuery(q.select(['id']), opt),
-                (0, nodejs_lib_1.transformMapSimple)(objectWithId => objectWithId.id, {
+                (0, nodejs_lib_1.transformMapSimple)(r => r.id, {
                     errorMode: js_lib_1.ErrorMode.SUPPRESS,
                 }),
                 (0, nodejs_lib_1.transformBuffer)({ batchSize }),
@@ -998,7 +998,7 @@ class CommonDao {
                 await fn(daoTx);
             }
             catch (err) {
-                await daoTx.rollback();
+                await daoTx.rollback(); // graceful rollback that "never throws"
                 throw err;
             }
         }, opt);
@@ -1088,7 +1088,7 @@ class CommonDaoTransaction {
         return await dao.getByIds(ids, { ...opt, tx: this.tx });
     }
     // todo: Queries inside Transaction are not supported yet
-    // async runQuery<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId>(
+    // async runQuery<BM extends PartialObjectWithId, DBM extends ObjectWithId>(
     //   dao: CommonDao<BM, DBM, any>,
     //   q: DBQuery<DBM>,
     //   opt?: CommonDaoOptions,

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

@@ -1,8 +1,8 @@
-import { CommonLogger, ErrorMode, ObjectWithId, Promisable, Saved, ZodError, ZodSchema } from '@naturalcycles/js-lib';
+import { CommonLogger, ErrorMode, PartialObjectWithId, Promisable, Saved, 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 Partial<ObjectWithId>, DBM extends ObjectWithId, TM> {
+export interface CommonDaoHooks<BM extends PartialObjectWithId, DBM extends PartialObjectWithId, 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 Partial<ObjectWithId>, DBM extends Ob
      * as it only validates "final state", not intermediate
      */
     beforeDBMValidate: (dbm: Partial<DBM>) => Partial<DBM>;
-    beforeDBMToBM: (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
+    beforeDBMToBM: (dbm: Saved<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 Partial<ObjectWithId>, DBM extends Ob
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    afterLoad?: (dbm: DBM) => Promisable<DBM | null>;
+    afterLoad?: (dbm: Saved<DBM>) => Promisable<Saved<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 Partial<ObjectWithId>, DBM extends Ob
      *
      * You can do validations as needed here and throw errors, they will be propagated.
      */
-    beforeSave?: (dbm: DBM) => Promisable<DBM | null>;
+    beforeSave?: (dbm: Saved<DBM>) => Promisable<Saved<DBM> | null>;
     /**
      * Called in:
      * - dbmToBM (applied before DBM becomes BM)
@@ -77,7 +77,7 @@ export interface CommonDaoHooks<BM extends Partial<ObjectWithId>, DBM extends Ob
      * It still applies to BM "transitively", during dbmToBM
      * (e.g after loaded from the Database).
      */
-    anonymize: (dbm: DBM) => DBM;
+    anonymize: (dbm: Saved<DBM>) => Saved<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 Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM = BM> {
+export interface CommonDaoCfg<BM extends PartialObjectWithId, DBM extends PartialObjectWithId = BM, TM = BM> {
     db: CommonDB;
     table: string;
     /**
@@ -157,12 +157,12 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends Obje
      * Defaults to true
      * Set to false to disable `created` field management.
      */
-    created?: boolean;
+    useCreatedProperty?: boolean;
     /**
      * Defaults to true
      * Set to false to disable `updated` field management.
      */
-    updated?: boolean;
+    useUpdatedProperty?: boolean;
     /**
      * Default is false.
      * If true - will run `_filterNullishValues` inside `validateAndConvert` function
@@ -223,7 +223,7 @@ export interface CommonDaoOptions extends CommonDBOptions {
      */
     table?: string;
 }
-export interface CommonDaoSaveOptions<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId> extends CommonDaoSaveBatchOptions<DBM> {
+export interface CommonDaoSaveOptions<BM extends PartialObjectWithId, DBM extends PartialObjectWithId> 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.
@@ -237,7 +237,7 @@ export interface CommonDaoSaveOptions<BM extends Partial<ObjectWithId>, DBM exte
 /**
  * All properties default to undefined.
  */
-export interface CommonDaoSaveBatchOptions<DBM extends ObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
+export interface CommonDaoSaveBatchOptions<DBM extends PartialObjectWithId> extends CommonDaoOptions, CommonDBSaveOptions<DBM> {
     /**
      * @default false
      *
@@ -249,9 +249,9 @@ export interface CommonDaoSaveBatchOptions<DBM extends ObjectWithId> extends Com
      */
     ensureUniqueId?: boolean;
 }
-export interface CommonDaoStreamDeleteOptions<DBM extends ObjectWithId> extends CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamDeleteOptions<DBM extends PartialObjectWithId> extends CommonDaoStreamOptions<DBM> {
 }
-export interface CommonDaoStreamSaveOptions<DBM extends ObjectWithId> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
+export interface CommonDaoStreamSaveOptions<DBM extends PartialObjectWithId> extends CommonDaoSaveBatchOptions<DBM>, CommonDaoStreamOptions<DBM> {
 }
 export interface CommonDaoStreamForEachOptions<IN> extends CommonDaoStreamOptions<IN>, TransformMapOptions<IN, any> {
 }

package/dist/db.model.d.ts

@@ -1,4 +1,4 @@
-import type { ObjectWithId } from '@naturalcycles/js-lib';
+import type { PartialObjectWithId } from '@naturalcycles/js-lib';
 import { CommonDB } from './common.db';
 /**
  * Similar to SQL INSERT, UPDATE.
@@ -48,7 +48,7 @@ export interface CommonDBOptions {
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions<ROW extends Partial<ObjectWithId> = any> extends CommonDBOptions {
+export interface CommonDBSaveOptions<ROW extends PartialObjectWithId = any> extends CommonDBOptions {
     excludeFromIndexes?: (keyof ROW)[];
     /**
      * Default is `upsert`
@@ -76,7 +76,7 @@ export interface RunQueryResult<T> {
     endCursor?: string;
 }
 export type DBOperation = DBSaveBatchOperation | DBDeleteByIdsOperation;
-export interface DBSaveBatchOperation<ROW extends Partial<ObjectWithId> = any> {
+export interface DBSaveBatchOperation<ROW extends PartialObjectWithId = any> {
     type: 'saveBatch';
     table: string;
     rows: ROW[];
@@ -109,4 +109,4 @@ export declare class DBIncrement {
     private constructor();
     static of(amount: number): DBIncrement;
 }
-export type DBPatch<ROW extends Partial<ObjectWithId>> = Partial<Record<keyof ROW, ROW[keyof ROW] | DBIncrement>>;
+export type DBPatch<ROW extends PartialObjectWithId> = Partial<Record<keyof ROW, ROW[keyof ROW] | DBIncrement>>;