@naturalcycles/db-lib 8.24.3 → 8.27.0

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

@@ -17,4 +17,5 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    count(table: string): Promise<number>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -34,5 +34,10 @@ class InMemoryKeyValueDB {
     streamEntries(table, limit) {
         return stream_1.Readable.from(Object.entries(this.data[table] || {}).slice(0, limit));
     }
+    async count(table) {
+        var _a;
+        (_a = this.data)[table] || (_a[table] = {});
+        return Object.keys(this.data[table]).length;
+    }
 }
 exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

package/dist/commondao/common.dao.js

@@ -56,7 +56,17 @@ class CommonDao {
         const op = `getById(${id})`;
         const table = opt.table || this.cfg.table;
         const started = this.logStarted(op, table);
-        const [dbm] = await this.cfg.db.getByIds(table, [id]);
+        let dbm;
+        if (opt.timeout) {
+            // todo: possibly remove it after debugging is done
+            dbm = (await (0, js_lib_1.pTimeout)(this.cfg.db.getByIds(table, [id]), {
+                timeout: opt.timeout,
+                name: `getById(${table})`,
+            }))[0];
+        }
+        else {
+            dbm = (await this.cfg.db.getByIds(table, [id]))[0];
+        }
         const bm = opt.raw ? dbm : await this.dbmToBM(dbm, opt);
         this.logResult(started, op, bm, table);
         return bm || null;

package/dist/commondao/common.dao.model.d.ts

@@ -135,6 +135,13 @@ export interface CommonDaoOptions extends CommonDBOptions {
      * Useful e.g in AirtableDB where you can have one Dao to control multiple tables.
      */
     table?: string;
+    /**
+     * If set - wraps the method in `pTimeout` with a timeout of given number of milliseconds.
+     * Currently, it is only used to debug an ongoing GCP infra issue.
+     *
+     * @experimental
+     */
+    timeout?: number;
 }
 /**
  * All properties default to undefined.

package/dist/kv/commonKeyValueDB.d.ts

@@ -28,4 +28,5 @@ export interface CommonKeyValueDB {
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    count(table: string): Promise<number>;
 }

package/dist/kv/commonKeyValueDao.d.ts

@@ -35,6 +35,7 @@ export declare class CommonKeyValueDao<T> {
     save(id: string, value: T): Promise<void>;
     saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void>;
     deleteByIds(ids: string[]): Promise<void>;
+    deleteById(id: string): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
     streamValues(limit?: number): ReadableTyped<Buffer>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;

package/dist/kv/commonKeyValueDao.js

@@ -49,6 +49,9 @@ class CommonKeyValueDao {
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
     }
+    async deleteById(id) {
+        await this.cfg.db.deleteByIds(this.cfg.table, [id]);
+    }
     streamIds(limit) {
         return this.cfg.db.streamIds(this.cfg.table, limit);
     }

package/dist/testing/dbTest.d.ts

@@ -18,6 +18,11 @@ export interface CommonDBImplementationFeatures {
     streaming?: boolean;
     bufferSupport?: boolean;
     nullValues?: boolean;
+    /**
+     * Set false for SQL (relational) databases,
+     * they will return `null` for all missing properties.
+     */
+    documentDB?: boolean;
 }
 /**
  * All options default to `false`.

package/dist/testing/dbTest.js

@@ -12,7 +12,7 @@ const test_util_1 = require("./test.util");
 function runCommonDBTest(db, features = {}, quirks = {}) {
     const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -71,20 +71,22 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(item3Loaded.k2).toBe(null);
         });
     }
-    test('undefined values should not be saved/loaded', async () => {
-        const item3 = {
-            ...(0, test_model_1.createTestItemDBM)(3),
-            k2: undefined,
-        };
-        (0, test_util_1.deepFreeze)(item3);
-        const expected = { ...item3 };
-        delete expected.k2;
-        await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-        const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
-        expectMatch([expected], [item3Loaded], quirks);
-        expect(item3Loaded.k2).toBe(undefined);
-        expect(Object.keys(item3Loaded)).not.toContain('k2');
-    });
+    if (documentDB) {
+        test('undefined values should not be saved/loaded', async () => {
+            const item3 = {
+                ...(0, test_model_1.createTestItemDBM)(3),
+                k2: undefined,
+            };
+            (0, test_util_1.deepFreeze)(item3);
+            const expected = { ...item3 };
+            delete expected.k2;
+            await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
+            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            expectMatch([expected], [item3Loaded], quirks);
+            expect(item3Loaded.k2).toBe(undefined);
+            expect(Object.keys(item3Loaded)).not.toContain('k2');
+        });
+    }
     test('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });

package/dist/testing/keyValueDBTest.js

@@ -20,12 +20,18 @@ function runCommonKeyValueDBTest(db) {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
+    test('count should be 0', async () => {
+        expect(await db.count(test_model_1.TEST_TABLE)).toBe(0);
+    });
     test('saveBatch, then getByIds', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, testEntries);
         const entries = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         (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);
+    });
     test('streamIds', async () => {
         const ids = await (0, nodejs_lib_1.readableToArray)(db.streamIds(test_model_1.TEST_TABLE));
         ids.sort();

package/package.json

@@ -12,8 +12,9 @@
   "devDependencies": {
     "@naturalcycles/bench-lib": "^1.0.0",
     "@naturalcycles/dev-lib": "^12.0.1",
-    "@types/node": "^16.0.0",
-    "jest": "^27.0.3"
+    "@types/node": "^17.0.0",
+    "jest": "^27.0.3",
+    "weak-napi": "^2.0.2"
   },
   "files": [
     "dist",
@@ -42,7 +43,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.24.3",
+  "version": "8.27.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -42,4 +42,9 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
   streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     return Readable.from(Object.entries(this.data[table] || {}).slice(0, limit))
   }
+
+  async count(table: string): Promise<number> {
+    this.data[table] ||= {}
+    return Object.keys(this.data[table]!).length
+  }
 }

package/src/commondao/common.dao.model.ts

@@ -168,6 +168,14 @@ export interface CommonDaoOptions extends CommonDBOptions {
    * Useful e.g in AirtableDB where you can have one Dao to control multiple tables.
    */
   table?: string
+
+  /**
+   * If set - wraps the method in `pTimeout` with a timeout of given number of milliseconds.
+   * Currently, it is only used to debug an ongoing GCP infra issue.
+   *
+   * @experimental
+   */
+  timeout?: number
 }
 
 /**

package/src/commondao/common.dao.ts

@@ -12,6 +12,7 @@ import {
   JsonSchemaRootObject,
   ObjectWithId,
   pMap,
+  pTimeout,
   Saved,
 } from '@naturalcycles/js-lib'
 import {
@@ -103,7 +104,21 @@ export class CommonDao<
     const op = `getById(${id})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
-    const [dbm] = await this.cfg.db.getByIds<DBM>(table, [id])
+
+    let dbm: DBM | undefined
+
+    if (opt.timeout) {
+      // todo: possibly remove it after debugging is done
+      dbm = (
+        await pTimeout(this.cfg.db.getByIds<DBM>(table, [id]), {
+          timeout: opt.timeout,
+          name: `getById(${table})`,
+        })
+      )[0]
+    } else {
+      dbm = (await this.cfg.db.getByIds<DBM>(table, [id]))[0]
+    }
+
     const bm = opt.raw ? (dbm as any) : await this.dbmToBM(dbm, opt)
     this.logResult(started, op, bm, table)
     return bm || null

package/src/kv/commonKeyValueDB.ts

@@ -34,4 +34,6 @@ export interface CommonKeyValueDB {
   streamIds(table: string, limit?: number): ReadableTyped<string>
   streamValues(table: string, limit?: number): ReadableTyped<Buffer>
   streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>
+
+  count(table: string): Promise<number>
 }

package/src/kv/commonKeyValueDao.ts

@@ -84,6 +84,10 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
 
+  async deleteById(id: string): 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)
   }

package/src/testing/dbTest.ts

@@ -35,6 +35,12 @@ export interface CommonDBImplementationFeatures {
 
   bufferSupport?: boolean
   nullValues?: boolean
+
+  /**
+   * Set false for SQL (relational) databases,
+   * they will return `null` for all missing properties.
+   */
+  documentDB?: boolean
 }
 
 /**
@@ -78,6 +84,7 @@ export function runCommonDBTest(
     strongConsistency = true,
     bufferSupport = true,
     nullValues = true,
+    documentDB = true,
   } = features
 
   // const {
@@ -151,21 +158,23 @@ export function runCommonDBTest(
     })
   }
 
-  test('undefined values should not be saved/loaded', async () => {
-    const item3 = {
-      ...createTestItemDBM(3),
-      k2: undefined,
-    }
-    deepFreeze(item3)
-    const expected = { ...item3 }
-    delete expected.k2
-
-    await db.saveBatch(TEST_TABLE, [item3])
-    const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
-    expectMatch([expected], [item3Loaded], quirks)
-    expect(item3Loaded.k2).toBe(undefined)
-    expect(Object.keys(item3Loaded)).not.toContain('k2')
-  })
+  if (documentDB) {
+    test('undefined values should not be saved/loaded', async () => {
+      const item3 = {
+        ...createTestItemDBM(3),
+        k2: undefined,
+      }
+      deepFreeze(item3)
+      const expected = { ...item3 }
+      delete expected.k2
+
+      await db.saveBatch(TEST_TABLE, [item3])
+      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
+      expectMatch([expected], [item3Loaded], quirks)
+      expect(item3Loaded.k2).toBe(undefined)
+      expect(Object.keys(item3Loaded)).not.toContain('k2')
+    })
+  }
 
   test('saveBatch test items', async () => {
     await db.saveBatch(TEST_TABLE, items)

package/src/testing/keyValueDBTest.ts

@@ -25,6 +25,10 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(results).toEqual([])
   })
 
+  test('count should be 0', async () => {
+    expect(await db.count(TEST_TABLE)).toBe(0)
+  })
+
   test('saveBatch, then getByIds', async () => {
     await db.saveBatch(TEST_TABLE, testEntries)
 
@@ -33,6 +37,10 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(entries).toEqual(testEntries)
   })
 
+  test('count should be 3', async () => {
+    expect(await db.count(TEST_TABLE)).toBe(3)
+  })
+
   test('streamIds', async () => {
     const ids = await readableToArray(db.streamIds(TEST_TABLE))
     ids.sort()