@naturalcycles/db-lib 9.17.0 → 9.19.0

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

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

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -35,5 +35,12 @@ class InMemoryKeyValueDB {
         this.data[table] ||= {};
         return Object.keys(this.data[table]).length;
     }
+    async increment(table, id, by = 1) {
+        this.data[table] ||= {};
+        const currentValue = this.data[table][id] ? parseInt(this.data[table][id].toString()) : 0;
+        const newValue = currentValue + by;
+        this.data[table][id] = Buffer.from(String(newValue));
+        return newValue;
+    }
 }
 exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

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

@@ -15,10 +15,8 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     cfg: CommonDaoCfg<BM, DBM, ID>;
     constructor(cfg: CommonDaoCfg<BM, DBM, ID>);
     create(part?: Partial<BM>, opt?: CommonDaoOptions): BM;
-    getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>;
     getByIdOrEmpty(id: ID, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<BM>;
-    getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIds(ids: ID[], opt?: CommonDaoOptions): Promise<BM[]>;
     getByIdsAsDBM(ids: ID[], opt?: CommonDaoOptions): Promise<DBM[]>;

package/dist/commondao/common.dao.js

@@ -53,6 +53,10 @@ class CommonDao {
         this.assignIdCreatedUpdated(bm, opt);
         return this.validateAndConvert(bm, this.cfg.bmSchema, undefined, opt);
     }
+    // GET
+    // overrides are disabled now, as they obfuscate errors when ID branded type is used
+    // async getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+    // async getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>
     async getById(id, opt = {}) {
         if (!id)
             return null;
@@ -73,6 +77,8 @@ class CommonDao {
             return bm;
         return this.create({ ...part, id }, opt);
     }
+    // async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+    // async getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>
     async getByIdAsDBM(id, opt = {}) {
         if (!id)
             return null;

package/dist/kv/commonKeyValueDB.d.ts

@@ -36,4 +36,12 @@ export interface CommonKeyValueDB {
     streamValues: (table: string, limit?: number) => ReadableTyped<Buffer>;
     streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>;
     count: (table: string) => Promise<number>;
+    /**
+     *
+     * Increments the value of a key in a table by a given amount.
+     * Default increment is 1 when `by` is not provided.
+     *
+     * Returns the new value.
+     */
+    increment: (table: string, id: string, by?: number) => Promise<number>;
 }

package/dist/kv/commonKeyValueDao.d.ts

@@ -62,4 +62,11 @@ export declare class CommonKeyValueDao<T> {
     streamIds(limit?: number): ReadableTyped<string>;
     streamValues(limit?: number): ReadableTyped<T>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;
+    /**
+     * 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>;
 }

package/dist/kv/commonKeyValueDao.js

@@ -157,5 +157,14 @@ class CommonKeyValueDao {
             concurrency: 32,
         });
     }
+    /**
+     * 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, by = 1) {
+        return await this.cfg.db.increment(this.cfg.table, id, by);
+    }
 }
 exports.CommonKeyValueDao = CommonKeyValueDao;

package/dist/testing/index.d.ts

@@ -1,6 +1,7 @@
 import { runCommonDaoTest } from './daoTest';
 import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest';
+import { runCommonKeyValueDaoTest } from './keyValueDaoTest';
 import { runCommonKeyValueDBTest } from './keyValueDBTest';
 import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, TestItemBM, testItemBMJsonSchema, testItemBMSchema, TestItemDBM, TestItemTM, testItemTMSchema } from './test.model';
 export type { CommonDBImplementationQuirks, TestItemBM, TestItemDBM, TestItemTM };
-export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, };
+export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, };

package/dist/testing/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testItemTMSchema = exports.testItemBMSchema = exports.testItemBMJsonSchema = exports.TEST_TABLE = exports.runCommonKeyValueDBTest = exports.runCommonDBTest = exports.runCommonDaoTest = exports.createTestItemsDBM = exports.createTestItemsBM = exports.createTestItemDBM = exports.createTestItemBM = void 0;
+exports.testItemTMSchema = exports.testItemBMSchema = exports.testItemBMJsonSchema = exports.TEST_TABLE = exports.runCommonKeyValueDBTest = exports.runCommonKeyValueDaoTest = exports.runCommonDBTest = exports.runCommonDaoTest = exports.createTestItemsDBM = exports.createTestItemsBM = exports.createTestItemDBM = exports.createTestItemBM = void 0;
 const daoTest_1 = require("./daoTest");
 Object.defineProperty(exports, "runCommonDaoTest", { enumerable: true, get: function () { return daoTest_1.runCommonDaoTest; } });
 const dbTest_1 = require("./dbTest");
 Object.defineProperty(exports, "runCommonDBTest", { enumerable: true, get: function () { return dbTest_1.runCommonDBTest; } });
+const keyValueDaoTest_1 = require("./keyValueDaoTest");
+Object.defineProperty(exports, "runCommonKeyValueDaoTest", { enumerable: true, get: function () { return keyValueDaoTest_1.runCommonKeyValueDaoTest; } });
 const keyValueDBTest_1 = require("./keyValueDBTest");
 Object.defineProperty(exports, "runCommonKeyValueDBTest", { enumerable: true, get: function () { return keyValueDBTest_1.runCommonKeyValueDBTest; } });
 const test_model_1 = require("./test.model");

package/dist/testing/keyValueDBTest.js

@@ -6,6 +6,18 @@ const test_model_1 = require("./test.model");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
 function runCommonKeyValueDBTest(db) {
+    beforeAll(async () => {
+        // Tests in this suite are not isolated,
+        // and failing tests can leave the DB in an unexpected state for other tests,
+        // including the following test run.
+        // Here we clear the table before running the tests.
+        const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
+        await db.deleteByIds(test_model_1.TEST_TABLE, ids);
+    });
+    afterAll(async () => {
+        const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
+        await db.deleteByIds(test_model_1.TEST_TABLE, ids);
+    });
     test('ping', async () => {
         await db.ping();
     });
@@ -70,4 +82,16 @@ 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);
+    });
 }

package/dist/testing/keyValueDaoTest.js

@@ -5,6 +5,18 @@ const js_lib_1 = require("@naturalcycles/js-lib");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [id, Buffer.from(`${id}value`)]);
 function runCommonKeyValueDaoTest(dao) {
+    beforeAll(async () => {
+        // Tests in this suite are not isolated,
+        // and failing tests can leave the DB in an unexpected state for other tests,
+        // including the following test run.
+        // Here we clear the table before running the tests.
+        const ids = await dao.streamIds().toArray();
+        await dao.deleteByIds(ids);
+    });
+    afterAll(async () => {
+        const ids = await dao.streamIds().toArray();
+        await dao.deleteByIds(ids);
+    });
     test('ping', async () => {
         await dao.ping();
     });
@@ -63,4 +75,16 @@ 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);
+    });
 }

package/package.json

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

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -47,4 +47,14 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
     this.data[table] ||= {}
     return Object.keys(this.data[table]).length
   }
+
+  async increment(table: string, id: string, by = 1): Promise<number> {
+    this.data[table] ||= {}
+
+    const currentValue = this.data[table][id] ? parseInt(this.data[table][id].toString()) : 0
+    const newValue = currentValue + by
+    this.data[table][id] = Buffer.from(String(newValue))
+
+    return newValue
+  }
 }

package/src/commondao/common.dao.ts

@@ -112,8 +112,9 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, I
   }
 
   // GET
-  async getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>
+  // overrides are disabled now, as they obfuscate errors when ID branded type is used
+  // async getById(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+  // async getById(id?: ID | null, opt?: CommonDaoOptions): Promise<BM | null>
   async getById(id?: ID | null, opt: CommonDaoOptions = {}): Promise<BM | null> {
     if (!id) return null
     const op = `getById(${id})`
@@ -137,8 +138,8 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM, I
     return this.create({ ...part, id }, opt)
   }
 
-  async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>
+  // async getByIdAsDBM(id: undefined | null, opt?: CommonDaoOptions): Promise<null>
+  // async getByIdAsDBM(id?: ID | null, opt?: CommonDaoOptions): Promise<DBM | null>
   async getByIdAsDBM(id?: ID | null, opt: CommonDaoOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const op = `getByIdAsDBM(${id})`

package/src/kv/commonKeyValueDB.ts

@@ -49,4 +49,13 @@ export interface CommonKeyValueDB {
   streamEntries: (table: string, limit?: number) => ReadableTyped<KeyValueDBTuple>
 
   count: (table: string) => Promise<number>
+
+  /**
+   *
+   * Increments the value of a key in a table by a given amount.
+   * Default increment is 1 when `by` is not provided.
+   *
+   * Returns the new value.
+   */
+  increment: (table: string, id: string, by?: number) => Promise<number>
 }

package/src/kv/commonKeyValueDao.ts

@@ -252,4 +252,14 @@ export class CommonKeyValueDao<T> {
       },
     )
   }
+
+  /**
+   * 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> {
+    return await this.cfg.db.increment(this.cfg.table, id, by)
+  }
 }

package/src/testing/index.ts

@@ -1,5 +1,6 @@
 import { runCommonDaoTest } from './daoTest'
 import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest'
+import { runCommonKeyValueDaoTest } from './keyValueDaoTest'
 import { runCommonKeyValueDBTest } from './keyValueDBTest'
 import {
   createTestItemBM,
@@ -24,6 +25,7 @@ export {
   createTestItemsDBM,
   runCommonDaoTest,
   runCommonDBTest,
+  runCommonKeyValueDaoTest,
   runCommonKeyValueDBTest,
   TEST_TABLE,
   testItemBMJsonSchema,

package/src/testing/keyValueDBTest.ts

@@ -7,6 +7,20 @@ const testIds = _range(1, 4).map(n => `id${n}`)
 const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
 
 export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
+  beforeAll(async () => {
+    // Tests in this suite are not isolated,
+    // and failing tests can leave the DB in an unexpected state for other tests,
+    // including the following test run.
+    // Here we clear the table before running the tests.
+    const ids = await db.streamIds(TEST_TABLE).toArray()
+    await db.deleteByIds(TEST_TABLE, ids)
+  })
+
+  afterAll(async () => {
+    const ids = await db.streamIds(TEST_TABLE).toArray()
+    await db.deleteByIds(TEST_TABLE, ids)
+  })
+
   test('ping', async () => {
     await db.ping()
   })
@@ -85,4 +99,19 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     const results = await db.getByIds(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_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 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

@@ -6,6 +6,20 @@ const testIds = _range(1, 4).map(n => `id${n}`)
 const testEntries: KeyValueDBTuple[] = testIds.map(id => [id, Buffer.from(`${id}value`)])
 
 export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
+  beforeAll(async () => {
+    // Tests in this suite are not isolated,
+    // and failing tests can leave the DB in an unexpected state for other tests,
+    // including the following test run.
+    // Here we clear the table before running the tests.
+    const ids = await dao.streamIds().toArray()
+    await dao.deleteByIds(ids)
+  })
+
+  afterAll(async () => {
+    const ids = await dao.streamIds().toArray()
+    await dao.deleteByIds(ids)
+  })
+
   test('ping', async () => {
     await dao.ping()
   })
@@ -76,4 +90,19 @@ export function runCommonKeyValueDaoTest(dao: CommonKeyValueDao<Buffer>): void {
     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)
+  })
 }