@naturalcycles/db-lib 9.18.0 → 9.20.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/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

@@ -36,30 +36,37 @@ 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>;
+    deleteByIds(ids: K[]): Promise<void>;
+    deleteById(id: K): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
-    streamValues(limit?: number): ReadableTyped<T>;
-    streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;
+    streamValues(limit?: number): ReadableTyped<V>;
+    streamEntries(limit?: number): ReadableTyped<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: 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,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.18.0",
+  "version": "9.20.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/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

@@ -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,11 +195,11 @@ 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])
   }
 
@@ -207,11 +207,11 @@ export class CommonKeyValueDao<T> {
     return this.cfg.db.streamIds(this.cfg.table, limit)
   }
 
-  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,19 +229,17 @@ 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(
       async ([id, buf]) => {
         try {
-          return [[id, await mapBufferToValue(buf)]]
+          return [[id as K, await mapBufferToValue(buf)]]
         } catch (err) {
           this.cfg.logger.error(err)
           return [] // SKIP
@@ -252,4 +250,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: K, 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)
+  })
 }