@naturalcycles/db-lib 9.22.1 → 9.23.0

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

@@ -1,7 +1,7 @@
-import { KeyValueTuple, StringMap } from '@naturalcycles/js-lib';
+import { StringMap } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../../db.model';
-import { CommonKeyValueDB, IncrementTuple } from '../../kv/commonKeyValueDB';
+import { CommonKeyValueDB, IncrementTuple, KeyValueDBTuple } from '../../kv/commonKeyValueDB';
 export interface InMemoryKeyValueDBCfg {
 }
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
@@ -15,11 +15,11 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     ping(): Promise<void>;
     createTable(_table: string, _opt?: CommonDBCreateOptions): Promise<void>;
     deleteByIds(table: string, ids: string[]): Promise<void>;
-    getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]>;
-    saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void>;
+    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
+    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues<V>(table: string, limit?: number): ReadableTyped<V>;
-    streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>>;
+    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
+    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
     incrementBatch(table: string, entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -9,7 +9,7 @@ class InMemoryKeyValueDB {
         this.support = {
             ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
         };
-        // data[table][id] => V
+        // data[table][id] => any (can be Buffer, or number)
         this.data = {};
     }
     async ping() { }

package/dist/kv/commonKeyValueDB.d.ts

@@ -1,4 +1,4 @@
-import { Integer, KeyValueTuple, UnixTimestampNumber } from '@naturalcycles/js-lib';
+import { Integer, UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
 /**
@@ -25,12 +25,12 @@ export interface CommonKeyValueDB {
      *
      * Currently it is NOT required to maintain the same order as input `ids`.
      */
-    getByIds: <V>(table: string, ids: string[]) => Promise<KeyValueTuple<string, V>[]>;
+    getByIds: (table: string, ids: string[]) => Promise<KeyValueDBTuple[]>;
     deleteByIds: (table: string, ids: string[]) => Promise<void>;
-    saveBatch: <V>(table: string, entries: KeyValueTuple<string, V>[], opt?: CommonKeyValueDBSaveBatchOptions) => Promise<void>;
+    saveBatch: (table: string, entries: KeyValueDBTuple[], opt?: CommonKeyValueDBSaveBatchOptions) => Promise<void>;
     streamIds: (table: string, limit?: number) => ReadableTyped<string>;
-    streamValues: <V>(table: string, limit?: number) => ReadableTyped<V>;
-    streamEntries: <V>(table: string, limit?: number) => ReadableTyped<KeyValueTuple<string, V>>;
+    streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>;
+    streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>;
     count: (table: string) => Promise<number>;
     /**
      * Perform a batch of Increment operations.
@@ -49,6 +49,7 @@ export interface CommonKeyValueDB {
      */
     incrementBatch: (table: string, entries: IncrementTuple[]) => Promise<IncrementTuple[]>;
 }
+export type KeyValueDBTuple = [key: string, value: Buffer];
 export type IncrementTuple = [key: string, value: Integer];
 export interface CommonKeyValueDBSaveBatchOptions {
     /**

package/dist/kv/commonKeyValueDao.d.ts

@@ -2,8 +2,8 @@ import { CommonLogger, 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, CommonKeyValueDBSaveBatchOptions, IncrementTuple } from './commonKeyValueDB';
-export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
+import { CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple, KeyValueDBTuple } from './commonKeyValueDB';
+export interface CommonKeyValueDaoCfg<V> {
     db: CommonKeyValueDB;
     table: string;
     /**
@@ -23,31 +23,29 @@ export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
      * @default false
      */
     logStarted?: boolean;
-    transformer?: CommonKeyValueDaoTransformer<V, RAW_V>;
+    transformer?: CommonKeyValueDaoTransformer<V>;
 }
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions;
-export interface CommonKeyValueDaoTransformer<V, RAW_V> {
-    valueToRaw: (v: V) => Promise<RAW_V>;
-    rawToValue: (raw: RAW_V) => Promise<V>;
+export interface CommonKeyValueDaoTransformer<V> {
+    valueToBuffer: (v: V) => Promise<Buffer>;
+    bufferToValue: (buf: Buffer) => Promise<V>;
 }
-export declare const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any, Buffer>;
-export declare class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
-    constructor(cfg: CommonKeyValueDaoCfg<RAW_V, V>);
-    cfg: CommonKeyValueDaoCfg<RAW_V, V> & {
+export declare const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any>;
+export declare class CommonKeyValueDao<K extends string = string, V = Buffer> {
+    constructor(cfg: CommonKeyValueDaoCfg<V>);
+    cfg: CommonKeyValueDaoCfg<V> & {
         logger: CommonLogger;
     };
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
     getById(id?: K): Promise<V | null>;
-    getByIdRaw(id?: K): Promise<RAW_V | null>;
+    getByIdAsBuffer(id?: K): Promise<Buffer | null>;
     requireById(id: K): Promise<V>;
-    requireByIdRaw(id: K): Promise<RAW_V>;
+    requireByIdAsBuffer(id: K): Promise<Buffer>;
     getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]>;
-    getByIdsRaw(ids: K[]): Promise<KeyValueTuple<K, RAW_V>[]>;
+    getByIdsAsBuffer(ids: K[]): Promise<KeyValueDBTuple[]>;
     save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveRaw(id: K, value: RAW_V, opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     saveBatch(entries: KeyValueTuple<K, V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
-    saveBatchRaw(entries: KeyValueTuple<K, RAW_V>[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     deleteByIds(ids: K[]): Promise<void>;
     deleteById(id: K): Promise<void>;
     streamIds(limit?: number): ReadableTyped<K>;

package/dist/kv/commonKeyValueDao.js

@@ -4,8 +4,8 @@ exports.CommonKeyValueDao = exports.commonKeyValueDaoDeflatedJsonTransformer = v
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 exports.commonKeyValueDaoDeflatedJsonTransformer = {
-    valueToRaw: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
-    rawToValue: async (raw) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(raw)),
+    valueToBuffer: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
+    bufferToValue: async (buf) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(buf)),
 };
 // todo: logging
 // todo: readonly
@@ -28,7 +28,7 @@ class CommonKeyValueDao {
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
-    async getByIdRaw(id) {
+    async getByIdAsBuffer(id) {
         if (!id)
             return null;
         const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
@@ -45,7 +45,7 @@ class CommonKeyValueDao {
         }
         return r[1];
     }
-    async requireByIdRaw(id) {
+    async requireByIdAsBuffer(id) {
         const [r] = await this.cfg.db.getByIds(this.cfg.table, [id]);
         if (!r) {
             const { table } = this.cfg;
@@ -62,18 +62,15 @@ class CommonKeyValueDao {
             return entries;
         return await (0, js_lib_1.pMap)(entries, async ([id, raw]) => [
             id,
-            await this.cfg.transformer.rawToValue(raw),
+            await this.cfg.transformer.bufferToValue(raw),
         ]);
     }
-    async getByIdsRaw(ids) {
-        return (await this.cfg.db.getByIds(this.cfg.table, ids));
+    async getByIdsAsBuffer(ids) {
+        return await this.cfg.db.getByIds(this.cfg.table, ids);
     }
     async save(id, value, opt) {
         await this.saveBatch([[id, value]], opt);
     }
-    async saveRaw(id, value, opt) {
-        await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt);
-    }
     async saveBatch(entries, opt) {
         const { transformer } = this.cfg;
         let rawEntries;
@@ -81,13 +78,10 @@ class CommonKeyValueDao {
             rawEntries = entries;
         }
         else {
-            rawEntries = await (0, js_lib_1.pMap)(entries, async ([id, v]) => [id, await transformer.valueToRaw(v)]);
+            rawEntries = await (0, js_lib_1.pMap)(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)]);
         }
         await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt);
     }
-    async saveBatchRaw(entries, opt) {
-        await this.cfg.db.saveBatch(this.cfg.table, entries, opt);
-    }
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
     }
@@ -102,9 +96,9 @@ class CommonKeyValueDao {
         if (!transformer) {
             return this.cfg.db.streamValues(this.cfg.table, limit);
         }
-        return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(async (raw) => {
+        return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(async (buf) => {
             try {
-                return [await transformer.rawToValue(raw)];
+                return [await transformer.bufferToValue(buf)];
             }
             catch (err) {
                 this.cfg.logger.error(err);
@@ -119,9 +113,9 @@ class CommonKeyValueDao {
         if (!transformer) {
             return this.cfg.db.streamEntries(this.cfg.table, limit);
         }
-        return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(async ([id, raw]) => {
+        return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(async ([id, buf]) => {
             try {
-                return [[id, await transformer.rawToValue(raw)]];
+                return [[id, await transformer.bufferToValue(buf)]];
             }
             catch (err) {
                 this.cfg.logger.error(err);

package/package.json

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

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -1,11 +1,12 @@
 import { Readable } from 'node:stream'
-import { KeyValueTuple, StringMap } from '@naturalcycles/js-lib'
+import { StringMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../../db.model'
 import {
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
   IncrementTuple,
+  KeyValueDBTuple,
 } from '../../kv/commonKeyValueDB'
 
 export interface InMemoryKeyValueDBCfg {}
@@ -17,7 +18,7 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ...commonKeyValueDBFullSupport,
   }
 
-  // data[table][id] => V
+  // data[table][id] => any (can be Buffer, or number)
   data: StringMap<StringMap<any>> = {}
 
   async ping(): Promise<void> {}
@@ -29,12 +30,12 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     ids.forEach(id => delete this.data[table]![id])
   }
 
-  async getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]> {
+  async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
     this.data[table] ||= {}
-    return ids.map(id => [id, this.data[table]![id]!] as KeyValueTuple<string, V>).filter(e => e[1])
+    return ids.map(id => [id, this.data[table]![id]!] as KeyValueDBTuple).filter(e => e[1])
   }
 
-  async saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void> {
+  async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
     this.data[table] ||= {}
     entries.forEach(([id, v]) => (this.data[table]![id] = v))
   }
@@ -43,11 +44,11 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     return Readable.from(Object.keys(this.data[table] || {}).slice(0, limit))
   }
 
-  streamValues<V>(table: string, limit?: number): ReadableTyped<V> {
+  streamValues(table: string, limit?: number): ReadableTyped<Buffer> {
     return Readable.from(Object.values(this.data[table] || {}).slice(0, limit))
   }
 
-  streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>> {
+  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     return Readable.from(Object.entries(this.data[table] || {}).slice(0, limit))
   }
 

package/src/kv/commonKeyValueDB.ts

@@ -1,4 +1,4 @@
-import { Integer, KeyValueTuple, UnixTimestampNumber } from '@naturalcycles/js-lib'
+import { Integer, UnixTimestampNumber } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../db.model'
 
@@ -29,19 +29,19 @@ export interface CommonKeyValueDB {
    *
    * Currently it is NOT required to maintain the same order as input `ids`.
    */
-  getByIds: <V>(table: string, ids: string[]) => Promise<KeyValueTuple<string, V>[]>
+  getByIds: (table: string, ids: string[]) => Promise<KeyValueDBTuple[]>
 
   deleteByIds: (table: string, ids: string[]) => Promise<void>
 
-  saveBatch: <V>(
+  saveBatch: (
     table: string,
-    entries: KeyValueTuple<string, V>[],
+    entries: KeyValueDBTuple[],
     opt?: CommonKeyValueDBSaveBatchOptions,
   ) => Promise<void>
 
   streamIds: (table: string, limit?: number) => ReadableTyped<string>
-  streamValues: <V>(table: string, limit?: number) => ReadableTyped<V>
-  streamEntries: <V>(table: string, limit?: number) => ReadableTyped<KeyValueTuple<string, V>>
+  streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>
+  streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>
 
   count: (table: string) => Promise<number>
 
@@ -63,6 +63,8 @@ export interface CommonKeyValueDB {
   incrementBatch: (table: string, entries: IncrementTuple[]) => Promise<IncrementTuple[]>
 }
 
+export type KeyValueDBTuple = [key: string, value: Buffer]
+
 export type IncrementTuple = [key: string, value: Integer]
 
 export interface CommonKeyValueDBSaveBatchOptions {

package/src/kv/commonKeyValueDao.ts

@@ -6,9 +6,10 @@ import {
   CommonKeyValueDB,
   CommonKeyValueDBSaveBatchOptions,
   IncrementTuple,
+  KeyValueDBTuple,
 } from './commonKeyValueDB'
 
-export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
+export interface CommonKeyValueDaoCfg<V> {
   db: CommonKeyValueDB
 
   table: string
@@ -34,33 +35,33 @@ export interface CommonKeyValueDaoCfg<RAW_V, V = RAW_V> {
    */
   logStarted?: boolean
 
-  transformer?: CommonKeyValueDaoTransformer<V, RAW_V>
+  transformer?: CommonKeyValueDaoTransformer<V>
 }
 
 export type CommonKeyValueDaoSaveOptions = CommonKeyValueDBSaveBatchOptions
 
-export interface CommonKeyValueDaoTransformer<V, RAW_V> {
-  valueToRaw: (v: V) => Promise<RAW_V>
-  rawToValue: (raw: RAW_V) => Promise<V>
+export interface CommonKeyValueDaoTransformer<V> {
+  valueToBuffer: (v: V) => Promise<Buffer>
+  bufferToValue: (buf: Buffer) => Promise<V>
 }
 
-export const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any, Buffer> = {
-  valueToRaw: async v => await deflateString(JSON.stringify(v)),
-  rawToValue: async raw => JSON.parse(await inflateToString(raw)),
+export const commonKeyValueDaoDeflatedJsonTransformer: CommonKeyValueDaoTransformer<any> = {
+  valueToBuffer: async v => await deflateString(JSON.stringify(v)),
+  bufferToValue: async buf => JSON.parse(await inflateToString(buf)),
 }
 
 // todo: logging
 // todo: readonly
 
-export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
-  constructor(cfg: CommonKeyValueDaoCfg<RAW_V, V>) {
+export class CommonKeyValueDao<K extends string = string, V = Buffer> {
+  constructor(cfg: CommonKeyValueDaoCfg<V>) {
     this.cfg = {
       logger: console,
       ...cfg,
     }
   }
 
-  cfg: CommonKeyValueDaoCfg<RAW_V, V> & {
+  cfg: CommonKeyValueDaoCfg<V> & {
     logger: CommonLogger
   }
 
@@ -78,9 +79,9 @@ export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
     return r?.[1] || null
   }
 
-  async getByIdRaw(id?: K): Promise<RAW_V | null> {
+  async getByIdAsBuffer(id?: K): Promise<Buffer | null> {
     if (!id) return null
-    const [r] = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, [id])
+    const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
     return r?.[1] || null
   }
 
@@ -98,8 +99,8 @@ export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
     return r[1]
   }
 
-  async requireByIdRaw(id: K): Promise<RAW_V> {
-    const [r] = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, [id])
+  async requireByIdAsBuffer(id: K): Promise<Buffer> {
+    const [r] = await this.cfg.db.getByIds(this.cfg.table, [id])
 
     if (!r) {
       const { table } = this.cfg
@@ -113,50 +114,39 @@ export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
   }
 
   async getByIds(ids: K[]): Promise<KeyValueTuple<string, V>[]> {
-    const entries = await this.cfg.db.getByIds<RAW_V>(this.cfg.table, ids)
+    const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
     if (!this.cfg.transformer) return entries as any
 
     return await pMap(entries, async ([id, raw]) => [
       id,
-      await this.cfg.transformer!.rawToValue(raw),
+      await this.cfg.transformer!.bufferToValue(raw),
     ])
   }
 
-  async getByIdsRaw(ids: K[]): Promise<KeyValueTuple<K, RAW_V>[]> {
-    return (await this.cfg.db.getByIds(this.cfg.table, ids)) as KeyValueTuple<K, RAW_V>[]
+  async getByIdsAsBuffer(ids: K[]): Promise<KeyValueDBTuple[]> {
+    return await this.cfg.db.getByIds(this.cfg.table, ids)
   }
 
   async save(id: K, value: V, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
     await this.saveBatch([[id, value]], opt)
   }
 
-  async saveRaw(id: K, value: RAW_V, opt?: CommonKeyValueDaoSaveOptions): Promise<void> {
-    await this.cfg.db.saveBatch(this.cfg.table, [[id, value]], opt)
-  }
-
   async saveBatch(
     entries: KeyValueTuple<K, V>[],
     opt?: CommonKeyValueDaoSaveOptions,
   ): Promise<void> {
     const { transformer } = this.cfg
-    let rawEntries: KeyValueTuple<string, RAW_V>[]
+    let rawEntries: KeyValueDBTuple[]
 
     if (!transformer) {
       rawEntries = entries as any
     } else {
-      rawEntries = await pMap(entries, async ([id, v]) => [id, await transformer.valueToRaw(v)])
+      rawEntries = await pMap(entries, async ([id, v]) => [id, await transformer.valueToBuffer(v)])
     }
 
     await this.cfg.db.saveBatch(this.cfg.table, rawEntries, opt)
   }
 
-  async saveBatchRaw(
-    entries: KeyValueTuple<K, RAW_V>[],
-    opt?: CommonKeyValueDaoSaveOptions,
-  ): Promise<void> {
-    await this.cfg.db.saveBatch(this.cfg.table, entries, opt)
-  }
-
   async deleteByIds(ids: K[]): Promise<void> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
@@ -173,13 +163,13 @@ export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
     const { transformer } = this.cfg
 
     if (!transformer) {
-      return this.cfg.db.streamValues<V>(this.cfg.table, limit)
+      return this.cfg.db.streamValues(this.cfg.table, limit) as ReadableTyped<V>
     }
 
-    return this.cfg.db.streamValues<RAW_V>(this.cfg.table, limit).flatMap(
-      async raw => {
+    return this.cfg.db.streamValues(this.cfg.table, limit).flatMap(
+      async buf => {
         try {
-          return [await transformer.rawToValue(raw)]
+          return [await transformer.bufferToValue(buf)]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -195,15 +185,13 @@ export class CommonKeyValueDao<K extends string, RAW_V, V = RAW_V> {
     const { transformer } = this.cfg
 
     if (!transformer) {
-      return this.cfg.db.streamEntries<V>(this.cfg.table, limit) as any
+      return this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, V>>
     }
 
-    return (
-      this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, RAW_V>>
-    ).flatMap(
-      async ([id, raw]) => {
+    return this.cfg.db.streamEntries(this.cfg.table, limit).flatMap(
+      async ([id, buf]) => {
         try {
-          return [[id, await transformer.rawToValue(raw)]]
+          return [[id as K, await transformer.bufferToValue(buf)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP

package/src/testing/keyValueDBTest.ts

@@ -50,7 +50,7 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   test('saveBatch, then getByIds', async () => {
     await db.saveBatch(TEST_TABLE, testEntries)
 
-    const entries = await db.getByIds<Buffer>(TEST_TABLE, testIds)
+    const entries = await db.getByIds(TEST_TABLE, testIds)
     _sortBy(entries, e => e[0], true)
     expect(entries).toEqual(testEntries)
   })
@@ -76,26 +76,26 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
   })
 
   test('streamValues', async () => {
-    const values = await db.streamValues<Buffer>(TEST_TABLE).toArray()
+    const values = await db.streamValues(TEST_TABLE).toArray()
     values.sort()
     expect(values).toEqual(testEntries.map(e => e[1]))
   })
 
   test('streamValues limited', async () => {
-    const valuesLimited = await db.streamValues<Buffer>(TEST_TABLE, 2).toArray()
+    const valuesLimited = await db.streamValues(TEST_TABLE, 2).toArray()
     // valuesLimited.sort()
     // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
     expect(valuesLimited.length).toBe(2)
   })
 
   test('streamEntries', async () => {
-    const entries = await db.streamEntries<Buffer>(TEST_TABLE).toArray()
+    const entries = await db.streamEntries(TEST_TABLE).toArray()
     entries.sort()
     expect(entries).toEqual(testEntries)
   })
 
   test('streamEntries limited', async () => {
-    const entriesLimited = await db.streamEntries<Buffer>(TEST_TABLE, 2).toArray()
+    const entriesLimited = await db.streamEntries(TEST_TABLE, 2).toArray()
     // entriesLimited.sort()
     // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
     expect(entriesLimited.length).toBe(2)