@naturalcycles/db-lib 9.20.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
@@ -59,9 +59,12 @@ export declare class CommonKeyValueDao<V, K extends string = string> {
     saveBatchAsBuffer(entries: KeyValueDBTuple[], opt?: CommonKeyValueDaoSaveOptions): Promise<void>;
     deleteByIds(ids: K[]): Promise<void>;
     deleteById(id: K): Promise<void>;
-    streamIds(limit?: number): ReadableTyped<string>;
+    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.

package/dist/kv/commonKeyValueDao.js

@@ -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.20.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>
   }
 
   /**
@@ -203,8 +203,8 @@ export class CommonKeyValueDao<V, K extends string = string> {
     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<V> {
@@ -236,10 +236,12 @@ export class CommonKeyValueDao<V, K extends string = string> {
       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 as K, await mapBufferToValue(buf)]]
+          return [[id, await mapBufferToValue(buf)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -251,6 +253,18 @@ export class CommonKeyValueDao<V, K extends string = string> {
     )
   }
 
+  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.

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)
+    })
+  }
 }