@naturalcycles/db-lib 9.19.0 → 9.20.0

package/dist/kv/commonKeyValueDao.d.ts

@@ -36,37 +36,37 @@ export interface CommonKeyValueDaoCfg<T> {
     deflatedJsonValue?: boolean;
 }
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions;
-export declare class CommonKeyValueDao<T> {
-    constructor(cfg: CommonKeyValueDaoCfg<T>);
-    cfg: CommonKeyValueDaoCfg<T> & {
-        hooks: NonNullable<CommonKeyValueDaoCfg<T>['hooks']>;
+export declare class CommonKeyValueDao<V, K extends string = string> {
+    constructor(cfg: CommonKeyValueDaoCfg<V>);
+    cfg: CommonKeyValueDaoCfg<V> & {
+        hooks: NonNullable<CommonKeyValueDaoCfg<V>['hooks']>;
         logger: CommonLogger;
     };
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
-    create(input?: Partial<T>): T;
-    getById(id?: string): Promise<T | null>;
-    getByIdAsBuffer(id?: string): Promise<Buffer | null>;
-    requireById(id: string): Promise<T>;
-    requireByIdAsBuffer(id: string): Promise<Buffer>;
-    getByIdOrEmpty(id: string, part?: Partial<T>): Promise<T>;
-    patch(id: string, patch: Partial<T>, opt?: CommonKeyValueDaoSaveOptions): Promise<T>;
-    getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]>;
-    getByIdsAsBuffer(ids: string[]): Promise<KeyValueTuple<string, Buffer>[]>;
-    save(id: string, value: T, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveAsBuffer(id: string, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveBatch(entries: KeyValueTuple<string, T>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
+    create(input?: Partial<V>): V;
+    getById(id?: K): Promise<V | null>;
+    getByIdAsBuffer(id?: K): Promise<Buffer | null>;
+    requireById(id: K): Promise<V>;
+    requireByIdAsBuffer(id: K): Promise<Buffer>;
+    getByIdOrEmpty(id: K, part?: Partial<V>): Promise<V>;
+    patch(id: K, patch: Partial<V>, opt?: CommonKeyValueDaoSaveOptions): Promise<V>;
+    getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]>;
+    getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]>;
+    save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
+    saveAsBuffer(id: K, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
+    saveBatch(entries: KeyValueTuple<K, V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     saveBatchAsBuffer(entries: KeyValueDBTuple[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    deleteByIds(ids: string[]): Promise<void>;
-    deleteById(id: string): Promise<void>;
+    deleteByIds(ids: K[]): Promise<void>;
+    deleteById(id: K): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
-    streamValues(limit?: number): ReadableTyped<T>;
-    streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;
+    streamValues(limit?: number): ReadableTyped<V>;
+    streamEntries(limit?: number): ReadableTyped<KeyValueTuple<K, V>>;
     /**
      * Increments the `id` field by the amount specified in `by`,
      * or by 1 if `by` is not specified.
      *
      * Returns the new value of the field.
      */
-    increment(id: string, by?: number): Promise<number>;
+    increment(id: K, by?: number): Promise<number>;
 }

package/dist/kv/commonKeyValueDao.js

@@ -92,7 +92,7 @@ class CommonKeyValueDao {
         ]);
     }
     async getByIdsAsBuffer(ids) {
-        return await this.cfg.db.getByIds(this.cfg.table, ids);
+        return (await this.cfg.db.getByIds(this.cfg.table, ids));
     }
     async save(id, value, opt) {
         await this.saveBatch([[id, value]], opt);

package/package.json

@@ -45,7 +45,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "9.19.0",
+  "version": "9.20.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/kv/commonKeyValueDao.ts

@@ -53,8 +53,8 @@ export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions
 // todo: logging
 // todo: readonly
 
-export class CommonKeyValueDao<T> {
-  constructor(cfg: CommonKeyValueDaoCfg<T>) {
+export class CommonKeyValueDao<V, K extends string = string> {
+  constructor(cfg: CommonKeyValueDaoCfg<V>) {
     this.cfg = {
       hooks: {},
       logger: console,
@@ -70,8 +70,8 @@ export class CommonKeyValueDao<T> {
     }
   }
 
-  cfg: CommonKeyValueDaoCfg<T> & {
-    hooks: NonNullable<CommonKeyValueDaoCfg<T>['hooks']>
+  cfg: CommonKeyValueDaoCfg<V> & {
+    hooks: NonNullable<CommonKeyValueDaoCfg<V>['hooks']>
     logger: CommonLogger
   }
 
@@ -83,25 +83,25 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.createTable(this.cfg.table, opt)
   }
 
-  create(input: Partial<T> = {}): T {
+  create(input: Partial<V> = {}): V {
     return {
       ...this.cfg.hooks.beforeCreate?.(input),
-    } as T
+    } as V
   }
 
-  async getById(id?: string): Promise<T | null> {
+  async getById(id?: K): Promise<V | null> {
     if (!id) return null
     const [r] = await this.getByIds([id])
     return r?.[1] || null
   }
 
-  async getByIdAsBuffer(id?: string): Promise<Buffer | null> {
+  async getByIdAsBuffer(id?: K): Promise<Buffer | null> {
     if (!id) return null
     const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
     return r?.[1] || null
   }
 
-  async requireById(id: string): Promise<T> {
+  async requireById(id: K): Promise<V> {
     const [r] = await this.getByIds([id])
 
     if (!r) {
@@ -115,7 +115,7 @@ export class CommonKeyValueDao<T> {
     return r[1]
   }
 
-  async requireByIdAsBuffer(id: string): Promise<Buffer> {
+  async requireByIdAsBuffer(id: K): Promise<Buffer> {
     const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
 
     if (!r) {
@@ -129,18 +129,18 @@ export class CommonKeyValueDao<T> {
     return r[1]
   }
 
-  async getByIdOrEmpty(id: string, part: Partial<T> = {}): Promise<T> {
+  async getByIdOrEmpty(id: K, part: Partial<V> = {}): Promise<V> {
     const [r] = await this.getByIds([id])
     if (r) return r[1]
 
     return {
       ...this.cfg.hooks.beforeCreate?.({}),
       ...part,
-    } as T
+    } as V
   }
 
-  async patch(id: string, patch: Partial<T>, opt?: CommonKeyValueDaoSaveOptions): Promise<T> {
-    const v: T = {
+  async patch(id: K, patch: Partial<V>, opt?: CommonKeyValueDaoSaveOptions): Promise<V> {
+    const v: V = {
       ...(await this.getByIdOrEmpty(id)),
       ...patch,
     }
@@ -150,7 +150,7 @@ export class CommonKeyValueDao<T> {
     return v
   }
 
-  async getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]> {
+  async getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
     if (!this.cfg.hooks.mapBufferToValue) return entries as any
 
@@ -160,20 +160,20 @@ export class CommonKeyValueDao<T> {
     ])
   }
 
-  async getByIdsAsBuffer(ids: string[]): Promise<KeyValueTuple<string, Buffer>[]> {
-    return await this.cfg.db.getByIds(this.cfg.table, ids)
+  async getByIdsAsBuffer(ids: K[]): Promise<KeyValueTuple<K, Buffer>[]> {
+    return (await this.cfg.db.getByIds(this.cfg.table, ids)) as KeyValueTuple<K, Buffer>[]
   }
 
-  async save(id: string, value: T, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
+  async save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
     await this.saveBatch([[id, value]], opt)
   }
 
-  async saveAsBuffer(id: string, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
+  async saveAsBuffer(id: K, value: Buffer, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
     await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt)
   }
 
   async saveBatch(
-    entries: KeyValueTuple<string, T>[],
+    entries: KeyValueTuple<K, V>[],
     opt?: CommonKeyValueDaoSaveOptions,
   ): Promise<void> {
     const { mapValueToBuffer } = this.cfg.hooks
@@ -195,11 +195,11 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.saveBatch(this.cfg.table, entries, opt)
   }
 
-  async deleteByIds(ids: string[]): Promise<void> {
+  async deleteByIds(ids: K[]): Promise<void> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
 
-  async deleteById(id: string): Promise<void> {
+  async deleteById(id: K): Promise<void> {
     await this.cfg.db.deleteByIds(this.cfg.table, [id])
   }
 
@@ -207,11 +207,11 @@ export class CommonKeyValueDao<T> {
     return this.cfg.db.streamIds(this.cfg.table, limit)
   }
 
-  streamValues(limit?: number): ReadableTyped<T> {
+  streamValues(limit?: number): ReadableTyped<V> {
     const { mapBufferToValue } = this.cfg.hooks
 
     if (!mapBufferToValue) {
-      return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<T>
+      return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<V>
     }
 
     return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(
@@ -229,19 +229,17 @@ export class CommonKeyValueDao<T> {
     )
   }
 
-  streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>> {
+  streamEntries(limit?: number): ReadableTyped<KeyValueTuple<K, V>> {
     const { mapBufferToValue } = this.cfg.hooks
 
     if (!mapBufferToValue) {
-      return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<
-        KeyValueTuple<string, T>
-      >
+      return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, V>>
     }
 
     return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(
       async ([id, buf]) => {
         try {
-          return [[id, await mapBufferToValue(buf)]]
+          return [[id as K, await mapBufferToValue(buf)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -259,7 +257,7 @@ export class CommonKeyValueDao<T> {
    *
    * Returns the new value of the field.
    */
-  async increment(id: string, by = 1): Promise<number> {
+  async increment(id: K, by = 1): Promise<number> {
     return await this.cfg.db.increment(this.cfg.table, id, by)
   }
 }