@naturalcycles/db-lib 8.45.0 → 8.46.0

package/dist/adapter/inmemory/inMemory.db.js

@@ -93,7 +93,7 @@ class InMemoryDB {
     }
     async deleteByIds(_table, ids, _opt) {
         const table = this.cfg.tablesPrefix + _table;
-        this.data[table] = this.data[table] || {};
+        this.data[table] ||= {};
         return ids
             .map(id => {
             const exists = !!this.data[table][id];

package/dist/kv/commonKeyValueDao.d.ts

@@ -3,7 +3,7 @@ import { KeyValueTuple } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoLogLevel } from '../commondao/common.dao.model';
 import { CommonDBCreateOptions } from '../db.model';
-import { CommonKeyValueDB } from './commonKeyValueDB';
+import { CommonKeyValueDB, KeyValueDBTuple } from './commonKeyValueDB';
 export interface CommonKeyValueDaoCfg<T> {
     db: CommonKeyValueDB;
     table: string;
@@ -39,15 +39,20 @@ export declare class CommonKeyValueDao<T> {
     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>): Promise<T>;
     getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]>;
+    getByIdsAsBuffer(ids: string[]): Promise<KeyValueTuple<string, Buffer>[]>;
     save(id: string, value: T): Promise<void>;
+    saveAsBuffer(id: string, value: Buffer): Promise<void>;
     saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void>;
+    saveBatchAsBuffer(entries: KeyValueDBTuple[]): Promise<void>;
     deleteByIds(ids: string[]): Promise<void>;
     deleteById(id: string): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
-    streamValues(limit?: number): ReadableTyped<Buffer>;
+    streamValues(limit?: number): ReadableTyped<T>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;
 }

package/dist/kv/commonKeyValueDao.js

@@ -34,6 +34,12 @@ class CommonKeyValueDao {
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
+    async getByIdAsBuffer(id) {
+        if (!id)
+            return null;
+        const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
+        return r?.[1] || null;
+    }
     async requireById(id) {
         const [r] = await this.getByIds([id]);
         if (!r) {
@@ -46,6 +52,18 @@ class CommonKeyValueDao {
         }
         return r[1];
     }
+    async requireByIdAsBuffer(id) {
+        const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
+        if (!r) {
+            const { table } = this.cfg;
+            throw new js_lib_1.AppError(`DB row required, but not found: ${table}.${id}`, {
+                code: cnst_1.DBLibError.DB_ROW_REQUIRED,
+                table,
+                id,
+            });
+        }
+        return r[1];
+    }
     async getByIdOrEmpty(id, part = {}) {
         const [r] = await this.getByIds([id]);
         if (r)
@@ -72,9 +90,15 @@ class CommonKeyValueDao {
             await this.cfg.hooks.mapBufferToValue(buf),
         ]);
     }
+    async getByIdsAsBuffer(ids) {
+        return await this.cfg.db.getByIds(this.cfg.table, ids);
+    }
     async save(id, value) {
         await this.saveBatch([[id, value]]);
     }
+    async saveAsBuffer(id, value) {
+        await this.cfg.db.saveBatch(this.cfg.table, [[id, value]]);
+    }
     async saveBatch(entries) {
         let bufferEntries = [];
         if (!this.cfg.hooks?.mapValueToBuffer) {
@@ -88,6 +112,9 @@ class CommonKeyValueDao {
         }
         await this.cfg.db.saveBatch(this.cfg.table, bufferEntries);
     }
+    async saveBatchAsBuffer(entries) {
+        await this.cfg.db.saveBatch(this.cfg.table, entries);
+    }
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
     }

package/package.json

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

package/src/adapter/inmemory/inMemory.db.ts

@@ -189,7 +189,7 @@ export class InMemoryDB implements CommonDB {
     _opt?: CommonDBOptions,
   ): Promise<number> {
     const table = this.cfg.tablesPrefix + _table
-    this.data[table] = this.data[table] || {}
+    this.data[table] ||= {}
 
     return ids
       .map(id => {

package/src/kv/commonKeyValueDao.ts

@@ -79,6 +79,12 @@ export class CommonKeyValueDao<T> {
     return r?.[1] || null
   }
 
+  async getByIdAsBuffer(id?: string): 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> {
     const [r] = await this.getByIds([id])
 
@@ -94,6 +100,21 @@ export class CommonKeyValueDao<T> {
     return r[1]
   }
 
+  async requireByIdAsBuffer(id: string): Promise<Buffer> {
+    const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
+
+    if (!r) {
+      const { table } = this.cfg
+      throw new AppError(`DB row required, but not found: ${table}.${id}`, {
+        code: DBLibError.DB_ROW_REQUIRED,
+        table,
+        id,
+      })
+    }
+
+    return r[1]
+  }
+
   async getByIdOrEmpty(id: string, part: Partial<T> = {}): Promise<T> {
     const [r] = await this.getByIds([id])
     if (r) return r[1]
@@ -125,10 +146,18 @@ export class CommonKeyValueDao<T> {
     ])
   }
 
+  async getByIdsAsBuffer(ids: string[]): Promise<KeyValueTuple<string, Buffer>[]> {
+    return await this.cfg.db.getByIds(this.cfg.table, ids)
+  }
+
   async save(id: string, value: T): Promise<void> {
     await this.saveBatch([[id, value]])
   }
 
+  async saveAsBuffer(id: string, value: Buffer): Promise<void> {
+    await this.cfg.db.saveBatch(this.cfg.table, [[id, value]])
+  }
+
   async saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void> {
     let bufferEntries: KeyValueDBTuple[] = []
 
@@ -144,6 +173,10 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.saveBatch(this.cfg.table, bufferEntries)
   }
 
+  async saveBatchAsBuffer(entries: KeyValueDBTuple[]): Promise<void> {
+    await this.cfg.db.saveBatch(this.cfg.table, entries)
+  }
+
   async deleteByIds(ids: string[]): Promise<void> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
@@ -156,14 +189,14 @@ export class CommonKeyValueDao<T> {
     return this.cfg.db.streamIds(this.cfg.table, limit)
   }
 
-  streamValues(limit?: number): ReadableTyped<Buffer> {
+  streamValues(limit?: number): ReadableTyped<T> {
     if (!this.cfg.hooks?.mapBufferToValue) {
       return this.cfg.db.streamValues(this.cfg.table, limit)
     }
 
     // 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))
-    const stream: ReadableTyped<Buffer> = this.cfg.db
+    const stream: ReadableTyped<T> = this.cfg.db
       .streamValues(this.cfg.table, limit)
       .on('error', err => stream.emit('error', err))
       .pipe(