@naturalcycles/db-lib 8.26.0 → 8.28.2

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

@@ -13,12 +13,11 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOp
 export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM = BM> {
     cfg: CommonDaoCfg<BM, DBM, TM>;
     constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
-    create(input: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
+    create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
     getById(id: undefined, opt?: CommonDaoOptions): Promise<null>;
     getById(id?: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIdOrCreate(id: string, bmToCreate: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdOrEmpty(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, opt?: CommonDaoOptions): Promise<DBM>;
+    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsDBM(id?: string, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>;

package/dist/commondao/common.dao.js

@@ -44,8 +44,8 @@ class CommonDao {
         };
     }
     // CREATE
-    create(input, opt = {}) {
-        let bm = this.cfg.hooks.beforeCreate(input);
+    create(part = {}, opt = {}) {
+        let bm = this.cfg.hooks.beforeCreate(part);
         bm = this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
         // If no SCHEMA - return as is
         return this.assignIdCreatedUpdated(bm, opt);
@@ -71,23 +71,17 @@ class CommonDao {
         this.logResult(started, op, bm, table);
         return bm || null;
     }
-    async getByIdOrCreate(id, bmToCreate, opt) {
+    async getByIdOrEmpty(id, part = {}, opt) {
         const bm = await this.getById(id, opt);
         if (bm)
             return bm;
-        return this.create({ ...bmToCreate, id }, opt);
+        return this.create({ ...part, id }, opt);
     }
-    async getByIdOrEmpty(id, opt) {
-        const bm = await this.getById(id, opt);
-        if (bm)
-            return bm;
-        return this.create({ id }, opt);
-    }
-    async getByIdAsDBMOrEmpty(id, opt) {
+    async getByIdAsDBMOrEmpty(id, part = {}, opt) {
         const dbm = await this.getByIdAsDBM(id, opt);
         if (dbm)
             return dbm;
-        const bm = this.create({ id }, opt);
+        const bm = this.create({ ...part, id }, opt);
         return await this.bmToDBM(bm, opt);
     }
     async getByIdAsDBM(id, opt = {}) {
@@ -458,7 +452,7 @@ class CommonDao {
      */
     async patch(id, patch, opt = {}) {
         return await this.save({
-            ...(await this.getByIdOrCreate(id, patch, opt)),
+            ...(await this.getByIdOrEmpty(id, patch, opt)),
             ...patch,
         }, opt);
     }

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

@@ -4,7 +4,7 @@ import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
 export declare type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string;
 export declare type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>;
-export declare type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => BM;
+export declare type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>;
 export declare type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>;
 export declare type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
 export declare type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;

package/dist/kv/commonKeyValueDao.d.ts

@@ -21,8 +21,9 @@ export interface CommonKeyValueDaoCfg<T> {
      */
     logStarted?: boolean;
     hooks?: {
-        mapValueToBuffer(v: T): Promise<Buffer>;
-        mapBufferToValue(b: Buffer): Promise<T>;
+        mapValueToBuffer?: (v: T) => Promise<Buffer>;
+        mapBufferToValue?: (b: Buffer) => Promise<T>;
+        beforeCreate?: (v: Partial<T>) => Partial<T>;
     };
 }
 export declare class CommonKeyValueDao<T> {
@@ -30,11 +31,15 @@ export declare class CommonKeyValueDao<T> {
     constructor(cfg: CommonKeyValueDaoCfg<T>);
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
+    create(input?: Partial<T>): T;
     getById(id?: string): Promise<T | null>;
+    getByIdOrEmpty(id: string, part?: Partial<T>): Promise<T>;
+    patch(id: string, patch: Partial<T>): Promise<T>;
     getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]>;
     save(id: string, value: T): Promise<void>;
     saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void>;
     deleteByIds(ids: string[]): Promise<void>;
+    deleteById(id: string): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
     streamValues(limit?: number): ReadableTyped<Buffer>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;

package/dist/kv/commonKeyValueDao.js

@@ -15,12 +15,34 @@ class CommonKeyValueDao {
     async createTable(opt = {}) {
         await this.cfg.db.createTable(this.cfg.table, opt);
     }
+    create(input = {}) {
+        return {
+            ...this.cfg.hooks?.beforeCreate?.(input),
+        };
+    }
     async getById(id) {
         if (!id)
             return null;
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
+    async getByIdOrEmpty(id, part = {}) {
+        const [r] = await this.getByIds([id]);
+        if (r)
+            return r[1];
+        return {
+            ...this.cfg.hooks?.beforeCreate?.({}),
+            ...part,
+        };
+    }
+    async patch(id, patch) {
+        const v = {
+            ...(await this.getByIdOrEmpty(id)),
+            ...patch,
+        };
+        await this.save(id, v);
+        return v;
+    }
     async getByIds(ids) {
         const entries = await this.cfg.db.getByIds(this.cfg.table, ids);
         if (!this.cfg.hooks?.mapBufferToValue)
@@ -49,6 +71,9 @@ class CommonKeyValueDao {
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
     }
+    async deleteById(id) {
+        await this.cfg.db.deleteByIds(this.cfg.table, [id]);
+    }
     streamIds(limit) {
         return this.cfg.db.streamIds(this.cfg.table, limit);
     }

package/package.json

@@ -43,7 +43,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.26.0",
+  "version": "8.28.2",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

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

@@ -13,7 +13,7 @@ import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../
 // Hook DBM, BM, TM types should follow this exact order
 export type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string
 export type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>
-export type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => BM
+export type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>
 export type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>
 export type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
 export type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>

package/src/commondao/common.dao.ts

@@ -88,8 +88,8 @@ export class CommonDao<
   }
 
   // CREATE
-  create(input: Partial<BM>, opt: CommonDaoOptions = {}): Saved<BM> {
-    let bm = this.cfg.hooks!.beforeCreate!(input)
+  create(part: Partial<BM> = {}, opt: CommonDaoOptions = {}): Saved<BM> {
+    let bm = this.cfg.hooks!.beforeCreate!(part) as BM
     bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
 
     // If no SCHEMA - return as is
@@ -124,29 +124,26 @@ export class CommonDao<
     return bm || null
   }
 
-  async getByIdOrCreate(
+  async getByIdOrEmpty(
     id: string,
-    bmToCreate: Partial<BM>,
+    part: Partial<BM> = {},
     opt?: CommonDaoOptions,
   ): Promise<Saved<BM>> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
-    return this.create({ ...bmToCreate, id }, opt)
+    return this.create({ ...part, id }, opt)
   }
 
-  async getByIdOrEmpty(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>> {
-    const bm = await this.getById(id, opt)
-    if (bm) return bm
-
-    return this.create({ id } as Partial<BM>, opt)
-  }
-
-  async getByIdAsDBMOrEmpty(id: string, opt?: CommonDaoOptions): Promise<DBM> {
+  async getByIdAsDBMOrEmpty(
+    id: string,
+    part: Partial<BM> = {},
+    opt?: CommonDaoOptions,
+  ): Promise<DBM> {
     const dbm = await this.getByIdAsDBM(id, opt)
     if (dbm) return dbm
 
-    const bm: BM = this.create({ id } as Partial<BM>, opt) as any
+    const bm: BM = this.create({ ...part, id }, opt) as any
     return await this.bmToDBM(bm, opt)
   }
 
@@ -614,7 +611,7 @@ export class CommonDao<
   ): Promise<Saved<BM>> {
     return await this.save(
       {
-        ...(await this.getByIdOrCreate(id, patch, opt)),
+        ...(await this.getByIdOrEmpty(id, patch, opt)),
         ...patch,
       } as any,
       opt,

package/src/kv/commonKeyValueDao.ts

@@ -26,8 +26,9 @@ export interface CommonKeyValueDaoCfg<T> {
   logStarted?: boolean
 
   hooks?: {
-    mapValueToBuffer(v: T): Promise<Buffer>
-    mapBufferToValue(b: Buffer): Promise<T>
+    mapValueToBuffer?: (v: T) => Promise<Buffer>
+    mapBufferToValue?: (b: Buffer) => Promise<T>
+    beforeCreate?: (v: Partial<T>) => Partial<T>
   }
 }
 
@@ -45,19 +46,46 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.createTable(this.cfg.table, opt)
   }
 
+  create(input: Partial<T> = {}): T {
+    return {
+      ...this.cfg.hooks?.beforeCreate?.(input),
+    } as T
+  }
+
   async getById(id?: string): Promise<T | null> {
     if (!id) return null
     const [r] = await this.getByIds([id])
     return r?.[1] || null
   }
 
+  async getByIdOrEmpty(id: string, part: Partial<T> = {}): Promise<T> {
+    const [r] = await this.getByIds([id])
+    if (r) return r[1]
+
+    return {
+      ...this.cfg.hooks?.beforeCreate?.({}),
+      ...part,
+    } as T
+  }
+
+  async patch(id: string, patch: Partial<T>): Promise<T> {
+    const v: T = {
+      ...(await this.getByIdOrEmpty(id)),
+      ...patch,
+    }
+
+    await this.save(id, v)
+
+    return v
+  }
+
   async getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
     if (!this.cfg.hooks?.mapBufferToValue) return entries as any
 
     return await pMap(entries, async ([id, buf]) => [
       id,
-      await this.cfg.hooks!.mapBufferToValue(buf),
+      await this.cfg.hooks!.mapBufferToValue!(buf),
     ])
   }
 
@@ -73,7 +101,7 @@ export class CommonKeyValueDao<T> {
     } else {
       bufferEntries = await pMap(entries, async ([id, v]) => [
         id,
-        await this.cfg.hooks!.mapValueToBuffer(v),
+        await this.cfg.hooks!.mapValueToBuffer!(v),
       ])
     }
 
@@ -84,6 +112,10 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
 
+  async deleteById(id: string): Promise<void> {
+    await this.cfg.db.deleteByIds(this.cfg.table, [id])
+  }
+
   streamIds(limit?: number): ReadableTyped<string> {
     return this.cfg.db.streamIds(this.cfg.table, limit)
   }
@@ -96,7 +128,7 @@ export class CommonKeyValueDao<T> {
     // todo: consider it when readableMap supports `errorMode: SUPPRESS`
     // readableMap(this.cfg.db.streamValues(this.cfg.table, limit), async buf => await this.cfg.hooks!.mapBufferToValue(buf))
     return this.cfg.db.streamValues(this.cfg.table, limit).pipe(
-      transformMap(async buf => await this.cfg.hooks!.mapBufferToValue(buf), {
+      transformMap(async buf => await this.cfg.hooks!.mapBufferToValue!(buf), {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
       }),
     )
@@ -108,7 +140,7 @@ export class CommonKeyValueDao<T> {
     }
 
     return this.cfg.db.streamEntries(this.cfg.table, limit).pipe(
-      transformMap(async ([id, buf]) => [id, await this.cfg.hooks!.mapBufferToValue(buf)], {
+      transformMap(async ([id, buf]) => [id, await this.cfg.hooks!.mapBufferToValue!(buf)], {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
       }),
     )