@naturalcycles/db-lib 9.19.0 → 9.21.0

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

@@ -7,6 +7,10 @@ export interface InMemoryKeyValueDBCfg {
 export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     cfg: InMemoryKeyValueDBCfg;
     constructor(cfg?: InMemoryKeyValueDBCfg);
+    support: {
+        count?: boolean;
+        increment?: boolean;
+    };
     data: StringMap<StringMap<Buffer>>;
     ping(): Promise<void>;
     createTable(_table: string, _opt?: CommonDBCreateOptions): Promise<void>;

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryKeyValueDB = void 0;
 const node_stream_1 = require("node:stream");
+const commonKeyValueDB_1 = require("../../kv/commonKeyValueDB");
 class InMemoryKeyValueDB {
     constructor(cfg = {}) {
         this.cfg = cfg;
+        this.support = {
+            ...commonKeyValueDB_1.commonKeyValueDBFullSupport,
+        };
         // data[table][id] > Buffer
         this.data = {};
     }

package/dist/common.db.d.ts

@@ -15,21 +15,6 @@ export interface CommonDB {
      * Manifest of supported features.
      */
     support: CommonDBSupport;
-    supportsQueries?: boolean;
-    supportsDBQueryFilter?: boolean;
-    supportsDBQueryFilterIn?: boolean;
-    supportsDBQueryOrder?: boolean;
-    supportsDBQuerySelectFields?: boolean;
-    supportsInsertSaveMethod?: boolean;
-    supportsUpdateSaveMethod?: boolean;
-    supportsUpdateByQuery?: boolean;
-    supportsDBIncrement?: boolean;
-    supportsCreateTable?: boolean;
-    supportsTableSchemas?: boolean;
-    supportsStreaming?: boolean;
-    supportsBufferValues?: boolean;
-    supportsNullValues?: boolean;
-    supportsTransactions?: boolean;
     /**
      * Checks that connection/credentials/etc is ok.
      * Also acts as a "warmup request" for a DB.

package/dist/kv/commonKeyValueDB.d.ts

@@ -1,20 +1,16 @@
 import { UnixTimestampNumber } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDBCreateOptions } from '../db.model';
-export type KeyValueDBTuple = [key: string, value: Buffer];
-export interface CommonKeyValueDBSaveBatchOptions {
-    /**
-     * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
-     * E.g EXAT in Redis.
-     */
-    expireAt?: UnixTimestampNumber;
-}
 /**
  * Common interface for Key-Value database implementations.
  *
  * @experimental
  */
 export interface CommonKeyValueDB {
+    /**
+     * Manifest of supported features.
+     */
+    support: CommonKeyValueDBSupport;
     /**
      * Check that DB connection is working properly.
      */
@@ -45,3 +41,19 @@ export interface CommonKeyValueDB {
      */
     increment: (table: string, id: string, by?: number) => Promise<number>;
 }
+export type KeyValueDBTuple = [key: string, value: Buffer];
+export interface CommonKeyValueDBSaveBatchOptions {
+    /**
+     * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
+     * E.g EXAT in Redis.
+     */
+    expireAt?: UnixTimestampNumber;
+}
+/**
+ * Manifest of supported features.
+ */
+export interface CommonKeyValueDBSupport {
+    count?: boolean;
+    increment?: boolean;
+}
+export declare const commonKeyValueDBFullSupport: CommonKeyValueDBSupport;

package/dist/kv/commonKeyValueDB.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonKeyValueDBFullSupport = void 0;
+exports.commonKeyValueDBFullSupport = {
+    count: true,
+    increment: true,
+};

package/dist/kv/commonKeyValueDao.d.ts

@@ -3,7 +3,7 @@ import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { CommonDaoLogLevel } from '../commondao/common.dao.model';
 import { CommonDBCreateOptions } from '../db.model';
 import { CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, KeyValueDBTuple } from './commonKeyValueDB';
-export interface CommonKeyValueDaoCfg<T> {
+export interface CommonKeyValueDaoCfg<V> {
     db: CommonKeyValueDB;
     table: string;
     /**
@@ -24,9 +24,9 @@ export interface CommonKeyValueDaoCfg<T> {
      */
     logStarted?: boolean;
     hooks?: {
-        mapValueToBuffer?: (v: T) => Promise<Buffer>;
-        mapBufferToValue?: (b: Buffer) => Promise<T>;
-        beforeCreate?: (v: Partial<T>) => Partial<T>;
+        mapValueToBuffer?: (v: V) => Promise<Buffer>;
+        mapBufferToValue?: (b: Buffer) => Promise<V>;
+        beforeCreate?: (v: Partial<V>) => Partial<V>;
     };
     /**
      * Set to `true` to conveniently enable zipping+JSON.stringify
@@ -36,37 +36,40 @@ 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>;
-    streamIds(limit?: number): ReadableTyped<string>;
-    streamValues(limit?: number): ReadableTyped<T>;
-    streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;
+    deleteByIds(ids: K[]): Promise<void>;
+    deleteById(id: K): Promise<void>;
+    streamIds(limit?: number): ReadableTyped<K>;
+    streamValues(limit?: number): ReadableTyped<V>;
+    streamEntries(limit?: number): ReadableTyped<KeyValueTuple<K, V>>;
+    getAllKeys(limit?: number): Promise<K[]>;
+    getAllValues(limit?: number): Promise<V[]>;
+    getAllEntries(limit?: number): Promise<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);
@@ -157,6 +157,15 @@ class CommonKeyValueDao {
             concurrency: 32,
         });
     }
+    async getAllKeys(limit) {
+        return await this.streamIds(limit).toArray();
+    }
+    async getAllValues(limit) {
+        return await this.streamValues(limit).toArray();
+    }
+    async getAllEntries(limit) {
+        return await this.streamEntries(limit).toArray();
+    }
     /**
      * Increments the `id` field by the amount specified in `by`,
      * or by 1 if `by` is not specified.

package/dist/testing/keyValueDBTest.js

@@ -18,6 +18,7 @@ function runCommonKeyValueDBTest(db) {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
+    const { support } = db;
     test('ping', async () => {
         await db.ping();
     });
@@ -40,9 +41,11 @@ function runCommonKeyValueDBTest(db) {
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
         expect(entries).toEqual(testEntries);
     });
-    test('count should be 3', async () => {
-        expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
-    });
+    if (support.count) {
+        test('count should be 3', async () => {
+            expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+        });
+    }
     test('streamIds', async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         ids.sort();
@@ -82,16 +85,18 @@ function runCommonKeyValueDBTest(db) {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
-    test('increment on a non-existing field should set the value to 1', async () => {
-        const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField');
-        expect(result).toBe(1);
-    });
-    test('increment on a existing field should increase the value by one', async () => {
-        const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField');
-        expect(result).toBe(2);
-    });
-    test('increment should increase the value by the specified amount', async () => {
-        const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField', 2);
-        expect(result).toBe(4);
-    });
+    if (support.increment) {
+        test('increment on a non-existing field should set the value to 1', async () => {
+            const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField');
+            expect(result).toBe(1);
+        });
+        test('increment on a existing field should increase the value by one', async () => {
+            const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField');
+            expect(result).toBe(2);
+        });
+        test('increment should increase the value by the specified amount', async () => {
+            const result = await db.increment(test_model_1.TEST_TABLE, 'nonExistingField', 2);
+            expect(result).toBe(4);
+        });
+    }
 }

package/dist/testing/keyValueDaoTest.js

@@ -17,6 +17,7 @@ function runCommonKeyValueDaoTest(dao) {
         const ids = await dao.streamIds().toArray();
         await dao.deleteByIds(ids);
     });
+    const { support } = dao.cfg.db;
     test('ping', async () => {
         await dao.ping();
     });
@@ -75,16 +76,18 @@ function runCommonKeyValueDaoTest(dao) {
         const results = await dao.getByIds(testIds);
         expect(results).toEqual([]);
     });
-    test('increment on a non-existing field should set the value to 1', async () => {
-        const result = await dao.increment('nonExistingField');
-        expect(result).toBe(1);
-    });
-    test('increment on a existing field should increase the value by one', async () => {
-        const result = await dao.increment('nonExistingField');
-        expect(result).toBe(2);
-    });
-    test('increment should increase the value by the specified amount', async () => {
-        const result = await dao.increment('nonExistingField', 2);
-        expect(result).toBe(4);
-    });
+    if (support.increment) {
+        test('increment on a non-existing field should set the value to 1', async () => {
+            const result = await dao.increment('nonExistingField');
+            expect(result).toBe(1);
+        });
+        test('increment on a existing field should increase the value by one', async () => {
+            const result = await dao.increment('nonExistingField');
+            expect(result).toBe(2);
+        });
+        test('increment should increase the value by the specified amount', async () => {
+            const result = await dao.increment('nonExistingField', 2);
+            expect(result).toBe(4);
+        });
+    }
 }

package/package.json

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

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -2,13 +2,21 @@ import { Readable } from 'node:stream'
 import { StringMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../../db.model'
-import { CommonKeyValueDB, KeyValueDBTuple } from '../../kv/commonKeyValueDB'
+import {
+  CommonKeyValueDB,
+  commonKeyValueDBFullSupport,
+  KeyValueDBTuple,
+} from '../../kv/commonKeyValueDB'
 
 export interface InMemoryKeyValueDBCfg {}
 
 export class InMemoryKeyValueDB implements CommonKeyValueDB {
   constructor(public cfg: InMemoryKeyValueDBCfg = {}) {}
 
+  support = {
+    ...commonKeyValueDBFullSupport,
+  }
+
   // data[table][id] > Buffer
   data: StringMap<StringMap<Buffer>> = {}
 

package/src/common.db.ts

@@ -28,23 +28,6 @@ export interface CommonDB {
    */
   support: CommonDBSupport
 
-  // Support flags indicate which of the CommonDB features are supported by this implementation.
-  supportsQueries?: boolean
-  supportsDBQueryFilter?: boolean
-  supportsDBQueryFilterIn?: boolean
-  supportsDBQueryOrder?: boolean
-  supportsDBQuerySelectFields?: boolean
-  supportsInsertSaveMethod?: boolean
-  supportsUpdateSaveMethod?: boolean
-  supportsUpdateByQuery?: boolean
-  supportsDBIncrement?: boolean
-  supportsCreateTable?: boolean
-  supportsTableSchemas?: boolean
-  supportsStreaming?: boolean
-  supportsBufferValues?: boolean
-  supportsNullValues?: boolean
-  supportsTransactions?: boolean
-
   /**
    * Checks that connection/credentials/etc is ok.
    * Also acts as a "warmup request" for a DB.

package/src/kv/commonKeyValueDB.ts

@@ -2,22 +2,17 @@ import { UnixTimestampNumber } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDBCreateOptions } from '../db.model'
 
-export type KeyValueDBTuple = [key: string, value: Buffer]
-
-export interface CommonKeyValueDBSaveBatchOptions {
-  /**
-   * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
-   * E.g EXAT in Redis.
-   */
-  expireAt?: UnixTimestampNumber
-}
-
 /**
  * Common interface for Key-Value database implementations.
  *
  * @experimental
  */
 export interface CommonKeyValueDB {
+  /**
+   * Manifest of supported features.
+   */
+  support: CommonKeyValueDBSupport
+
   /**
    * Check that DB connection is working properly.
    */
@@ -59,3 +54,26 @@ export interface CommonKeyValueDB {
    */
   increment: (table: string, id: string, by?: number) => Promise<number>
 }
+
+export type KeyValueDBTuple = [key: string, value: Buffer]
+
+export interface CommonKeyValueDBSaveBatchOptions {
+  /**
+   * If set (and if it's implemented by the driver) - will set expiry TTL for each key of the batch.
+   * E.g EXAT in Redis.
+   */
+  expireAt?: UnixTimestampNumber
+}
+
+/**
+ * Manifest of supported features.
+ */
+export interface CommonKeyValueDBSupport {
+  count?: boolean
+  increment?: boolean
+}
+
+export const commonKeyValueDBFullSupport: CommonKeyValueDBSupport = {
+  count: true,
+  increment: true,
+}

package/src/kv/commonKeyValueDao.ts

@@ -8,7 +8,7 @@ import {
   KeyValueDBTuple,
 } from './commonKeyValueDB'
 
-export interface CommonKeyValueDaoCfg<T> {
+export interface CommonKeyValueDaoCfg<V> {
   db: CommonKeyValueDB
 
   table: string
@@ -35,9 +35,9 @@ export interface CommonKeyValueDaoCfg<T> {
   logStarted?: boolean
 
   hooks?: {
-    mapValueToBuffer?: (v: T) => Promise<Buffer>
-    mapBufferToValue?: (b: Buffer) => Promise<T>
-    beforeCreate?: (v: Partial<T>) => Partial<T>
+    mapValueToBuffer?: (v: V) => Promise<Buffer>
+    mapBufferToValue?: (b: Buffer) => Promise<V>
+    beforeCreate?: (v: Partial<V>) => Partial<V>
   }
 
   /**
@@ -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,23 +195,23 @@ 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])
   }
 
-  streamIds(limit?: number): ReadableTyped<string> {
-    return this.cfg.db.streamIds(this.cfg.table, limit)
+  streamIds(limit?: number): ReadableTyped<K> {
+    return this.cfg.db.streamIds(this.cfg.table, limit) as ReadableTyped<K>
   }
 
-  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,16 +229,16 @@ 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(
+    return (
+      this.cfg.db.streamEntries(this.cfg.table, limit) as ReadableTyped<KeyValueTuple<K, Buffer>>
+    ).flatMap(
       async ([id, buf]) => {
         try {
           return [[id, await mapBufferToValue(buf)]]
@@ -253,13 +253,25 @@ export class CommonKeyValueDao<T> {
     )
   }
 
+  async getAllKeys(limit?: number): Promise<K[]> {
+    return await this.streamIds(limit).toArray()
+  }
+
+  async getAllValues(limit?: number): Promise<V[]> {
+    return await this.streamValues(limit).toArray()
+  }
+
+  async getAllEntries(limit?: number): Promise<KeyValueTuple<K, V>[]> {
+    return await this.streamEntries(limit).toArray()
+  }
+
   /**
    * 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.
    */
-  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)
   }
 }

package/src/testing/keyValueDBTest.ts

@@ -21,6 +21,8 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     await db.deleteByIds(TEST_TABLE, ids)
   })
 
+  const { support } = db
+
   test('ping', async () => {
     await db.ping()
   })
@@ -50,9 +52,11 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(entries).toEqual(testEntries)
   })
 
-  test('count should be 3', async () => {
-    expect(await db.count(TEST_TABLE)).toBe(3)
-  })
+  if (support.count) {
+    test('count should be 3', async () => {
+      expect(await db.count(TEST_TABLE)).toBe(3)
+    })
+  }
 
   test('streamIds', async () => {
     const ids = await db.streamIds(TEST_TABLE).toArray()
@@ -100,18 +104,20 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(results).toEqual([])
   })
 
-  test('increment on a non-existing field should set the value to 1', async () => {
-    const result = await db.increment(TEST_TABLE, 'nonExistingField')
-    expect(result).toBe(1)
-  })
+  if (support.increment) {
+    test('increment on a non-existing field should set the value to 1', async () => {
+      const result = await db.increment(TEST_TABLE, 'nonExistingField')
+      expect(result).toBe(1)
+    })
 
-  test('increment on a existing field should increase the value by one', async () => {
-    const result = await db.increment(TEST_TABLE, 'nonExistingField')
-    expect(result).toBe(2)
-  })
+    test('increment on a existing field should increase the value by one', async () => {
+      const result = await db.increment(TEST_TABLE, 'nonExistingField')
+      expect(result).toBe(2)
+    })
 
-  test('increment should increase the value by the specified amount', async () => {
-    const result = await db.increment(TEST_TABLE, 'nonExistingField', 2)
-    expect(result).toBe(4)
-  })
+    test('increment should increase the value by the specified amount', async () => {
+      const result = await db.increment(TEST_TABLE, 'nonExistingField', 2)
+      expect(result).toBe(4)
+    })
+  }
 }

package/src/testing/keyValueDaoTest.ts

@@ -20,6 +20,8 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     await dao.deleteByIds(ids)
   })
 
+  const { support } = dao.cfg.db
+
   test('ping', async () => {
     await dao.ping()
   })
@@ -91,18 +93,20 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     expect(results).toEqual([])
   })
 
-  test('increment on a non-existing field should set the value to 1', async () => {
-    const result = await dao.increment('nonExistingField')
-    expect(result).toBe(1)
-  })
+  if (support.increment) {
+    test('increment on a non-existing field should set the value to 1', async () => {
+      const result = await dao.increment('nonExistingField')
+      expect(result).toBe(1)
+    })
 
-  test('increment on a existing field should increase the value by one', async () => {
-    const result = await dao.increment('nonExistingField')
-    expect(result).toBe(2)
-  })
+    test('increment on a existing field should increase the value by one', async () => {
+      const result = await dao.increment('nonExistingField')
+      expect(result).toBe(2)
+    })
 
-  test('increment should increase the value by the specified amount', async () => {
-    const result = await dao.increment('nonExistingField', 2)
-    expect(result).toBe(4)
-  })
+    test('increment should increase the value by the specified amount', async () => {
+      const result = await dao.increment('nonExistingField', 2)
+      expect(result).toBe(4)
+    })
+  }
 }