@naturalcycles/db-lib 10.0.0 → 10.0.2

package/dist/testing/dbTest.js

@@ -1,62 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonDBTest = runCommonDBTest;
-exports.expectMatch = expectMatch;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const vitest_1 = require("vitest");
 const common_db_1 = require("../common.db");
 const dbQuery_1 = require("../query/dbQuery");
 const test_model_1 = require("./test.model");
-function runCommonDBTest(db, quirks = {}) {
+async function runCommonDBTest(db, quirks = {}) {
+    // this is because vitest cannot be "required" from cjs
+    const { test, expect } = await import('vitest');
     const { support } = db;
     const items = (0, test_model_1.createTestItemsDBM)(3);
     (0, js_lib_1._deepFreeze)(items);
     const item1 = items[0];
     const queryAll = () => dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE);
-    (0, vitest_1.test)('ping', async () => {
+    test('ping', async () => {
         await db.ping();
     });
     // CREATE TABLE, DROP
     if (support.createTable) {
-        (0, vitest_1.test)('createTable, dropIfExists=true', async () => {
+        test('createTable, dropIfExists=true', async () => {
             await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {
         // DELETE ALL initially
-        (0, vitest_1.test)('deleteByIds test items', async () => {
+        test('deleteByIds test items', async () => {
             const { rows } = await db.runQuery(queryAll().select(['id']));
             await db.deleteByQuery(queryAll().filterIn('id', rows.map(i => i.id)));
         });
         // QUERY empty
-        (0, vitest_1.test)('runQuery(all), runQueryCount should return empty', async () => {
-            (0, vitest_1.expect)((await db.runQuery(queryAll())).rows).toEqual([]);
-            (0, vitest_1.expect)(await db.runQueryCount(queryAll())).toBe(0);
+        test('runQuery(all), runQueryCount should return empty', async () => {
+            expect((await db.runQuery(queryAll())).rows).toEqual([]);
+            expect(await db.runQueryCount(queryAll())).toBe(0);
         });
     }
     // GET empty
-    (0, vitest_1.test)('getByIds(item1.id) should return empty', async () => {
+    test('getByIds(item1.id) should return empty', async () => {
         const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
         // console.log(a)
-        (0, vitest_1.expect)(item1Loaded).toBeUndefined();
+        expect(item1Loaded).toBeUndefined();
     });
-    (0, vitest_1.test)('getByIds([]) should return []', async () => {
-        (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
+    test('getByIds([]) should return []', async () => {
+        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
     });
-    (0, vitest_1.test)('getByIds(...) should return empty', async () => {
-        (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
+    test('getByIds(...) should return empty', async () => {
+        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
     });
     // TimeMachine
     if (support.timeMachine) {
-        (0, vitest_1.test)('getByIds(...) 10 minutes ago should return []', async () => {
-            (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, [item1.id, 'abc'], {
+        test('getByIds(...) 10 minutes ago should return []', async () => {
+            expect(await db.getByIds(test_model_1.TEST_TABLE, [item1.id, 'abc'], {
                 readAt: js_lib_1.localTime.now().minus(10, 'minute').unix,
             })).toEqual([]);
         });
     }
     // SAVE
     if (support.nullValues) {
-        (0, vitest_1.test)('should allow to save and load null values', async () => {
+        test('should allow to save and load null values', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: null,
@@ -65,11 +65,11 @@ function runCommonDBTest(db, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
             const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([item3], [item3Loaded], quirks);
-            (0, vitest_1.expect)(item3Loaded.k2).toBeNull();
+            expect(item3Loaded.k2).toBeNull();
         });
     }
     if (db.dbType === common_db_1.CommonDBType.document) {
-        (0, vitest_1.test)('undefined values should not be saved/loaded', async () => {
+        test('undefined values should not be saved/loaded', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: undefined,
@@ -80,45 +80,45 @@ function runCommonDBTest(db, quirks = {}) {
             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);
-            (0, vitest_1.expect)(item3Loaded.k2).toBeUndefined();
-            (0, vitest_1.expect)(Object.keys(item3Loaded)).not.toContain('k2');
+            expect(item3Loaded.k2).toBeUndefined();
+            expect(Object.keys(item3Loaded)).not.toContain('k2');
         });
     }
     if (support.updateSaveMethod) {
-        (0, vitest_1.test)('saveBatch UPDATE method should throw', async () => {
-            await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
+        test('saveBatch UPDATE method should throw', async () => {
+            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
         });
     }
-    (0, vitest_1.test)('saveBatch test items', async () => {
+    test('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });
-    (0, vitest_1.test)('saveBatch should throw on null id', async () => {
-        await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
+    test('saveBatch should throw on null id', async () => {
+        await expect(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
     });
     if (support.insertSaveMethod) {
-        (0, vitest_1.test)('saveBatch INSERT method should throw', async () => {
-            await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
+        test('saveBatch INSERT method should throw', async () => {
+            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
         });
     }
     if (support.updateSaveMethod) {
-        (0, vitest_1.test)('saveBatch UPDATE method should pass', async () => {
+        test('saveBatch UPDATE method should pass', async () => {
             await db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' });
         });
     }
     // GET not empty
-    (0, vitest_1.test)('getByIds all items', async () => {
+    test('getByIds all items', async () => {
         const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));
         expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (support.queries) {
-        (0, vitest_1.test)('runQuery(all) should return all items', async () => {
+        test('runQuery(all) should return all items', async () => {
             let { rows } = await db.runQuery(queryAll());
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // because query doesn't specify order here
             expectMatch(items, rows, quirks);
         });
         if (support.dbQueryFilter) {
-            (0, vitest_1.test)('query even=true', async () => {
+            test('query even=true', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', true);
                 let { rows } = await db.runQuery(q);
                 if (!support.dbQueryOrder)
@@ -127,67 +127,67 @@ function runCommonDBTest(db, quirks = {}) {
             });
         }
         if (support.dbQueryOrder) {
-            (0, vitest_1.test)('query order by k1 desc', async () => {
+            test('query order by k1 desc', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).order('k1', true);
                 const { rows } = await db.runQuery(q);
                 expectMatch([...items].reverse(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
-            (0, vitest_1.test)('projection query with only ids', async () => {
+            test('projection query with only ids', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['id']);
                 let { rows } = await db.runQuery(q);
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified
                 expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
             });
-            (0, vitest_1.test)('projection query without ids', async () => {
+            test('projection query without ids', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['k1']);
                 let { rows } = await db.runQuery(q);
                 rows = (0, js_lib_1._sortBy)(rows, r => r.k1); // cause order is not specified
                 expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['k1'])), rows, quirks);
             });
-            (0, vitest_1.test)('projection query empty fields (edge case)', async () => {
+            test('projection query empty fields (edge case)', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select([]);
                 const { rows } = await db.runQuery(q);
                 expectMatch(items.map(() => ({})), rows, quirks);
             });
         }
-        (0, vitest_1.test)('runQueryCount should return 3', async () => {
-            (0, vitest_1.expect)(await db.runQueryCount(new dbQuery_1.DBQuery(test_model_1.TEST_TABLE))).toBe(3);
+        test('runQueryCount should return 3', async () => {
+            expect(await db.runQueryCount(new dbQuery_1.DBQuery(test_model_1.TEST_TABLE))).toBe(3);
         });
     }
     // STREAM
     if (support.streaming) {
-        (0, vitest_1.test)('streamQuery all', async () => {
+        test('streamQuery all', async () => {
             let rows = await db.streamQuery(queryAll()).toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified in DBQuery
             expectMatch(items, rows, quirks);
         });
     }
     // getTables
-    (0, vitest_1.test)('getTables, getTableSchema (if supported)', async () => {
+    test('getTables, getTableSchema (if supported)', async () => {
         const tables = await db.getTables();
         // console.log({ tables })
         if (support.tableSchemas) {
             await (0, js_lib_1.pMap)(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
                 // console.log(schema)
-                (0, vitest_1.expect)(schema.$id).toBe(`${table}.schema.json`);
+                expect(schema.$id).toBe(`${table}.schema.json`);
             });
         }
     });
     // DELETE BY
     if (support.queries && support.dbQueryFilter) {
-        (0, vitest_1.test)('deleteByQuery even=false', async () => {
+        test('deleteByQuery even=false', async () => {
             const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', false);
             const deleted = await db.deleteByQuery(q);
-            (0, vitest_1.expect)(deleted).toBe(items.filter(item => !item.even).length);
-            (0, vitest_1.expect)(await db.runQueryCount(queryAll())).toBe(1);
+            expect(deleted).toBe(items.filter(item => !item.even).length);
+            expect(await db.runQueryCount(queryAll())).toBe(1);
         });
     }
     // BUFFER
     if (support.bufferValues) {
-        (0, vitest_1.test)('buffer values', async () => {
+        test('buffer values', async () => {
             const s = 'helloWorld 1';
             const b1 = Buffer.from(s);
             const item = {
@@ -205,12 +205,12 @@ function runCommonDBTest(db, quirks = {}) {
             //   b1,
             //   b1Loaded,
             // })
-            (0, vitest_1.expect)(b1Loaded).toEqual(b1);
-            (0, vitest_1.expect)(b1Loaded.toString()).toBe(s);
+            expect(b1Loaded).toEqual(b1);
+            expect(b1Loaded.toString()).toBe(s);
         });
     }
     if (support.transactions) {
-        (0, vitest_1.test)('transaction happy path', async () => {
+        test('transaction happy path', async () => {
             // cleanup
             await db.deleteByQuery(queryAll());
             // saveBatch [item1, 2, 3]
@@ -226,7 +226,7 @@ function runCommonDBTest(db, quirks = {}) {
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
-        (0, vitest_1.test)('transaction rollback', async () => {
+        test('transaction rollback', async () => {
             let err;
             try {
                 await db.runInTransaction(async (tx) => {
@@ -238,14 +238,14 @@ function runCommonDBTest(db, quirks = {}) {
             catch (err_) {
                 err = err_;
             }
-            (0, vitest_1.expect)(err).toBeDefined();
+            expect(err).toBeDefined();
             const { rows } = await db.runQuery(queryAll());
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
     }
     if (support.patchByQuery) {
-        (0, vitest_1.test)('patchByQuery', async () => {
+        test('patchByQuery', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
             await db.saveBatch(test_model_1.TEST_TABLE, items);
@@ -265,7 +265,7 @@ function runCommonDBTest(db, quirks = {}) {
         });
     }
     if (support.increment) {
-        (0, vitest_1.test)('incrementBatch', async () => {
+        test('incrementBatch', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
             await db.saveBatch(test_model_1.TEST_TABLE, items);
@@ -284,24 +284,24 @@ function runCommonDBTest(db, quirks = {}) {
         });
     }
     if (support.queries) {
-        (0, vitest_1.test)('cleanup', async () => {
+        test('cleanup', async () => {
             // CLEAN UP
             await db.deleteByQuery(queryAll());
         });
     }
-}
-function expectMatch(expected, actual, quirks) {
-    // const expectedSorted = sortObjectDeep(expected)
-    // const actualSorted = sortObjectDeep(actual)
-    if (quirks.allowBooleansAsUndefined) {
-        expected = expected.map(r => {
-            return typeof r !== 'object' ? r : (0, js_lib_1._filterObject)(r, (_k, v) => v !== false);
-        });
-    }
-    if (quirks.allowExtraPropertiesInResponse) {
-        (0, vitest_1.expect)(actual).toMatchObject(expected);
-    }
-    else {
-        (0, vitest_1.expect)(actual).toEqual(expected);
+    function expectMatch(expected, actual, quirks) {
+        // const expectedSorted = sortObjectDeep(expected)
+        // const actualSorted = sortObjectDeep(actual)
+        if (quirks.allowBooleansAsUndefined) {
+            expected = expected.map(r => {
+                return typeof r !== 'object' ? r : (0, js_lib_1._filterObject)(r, (_k, v) => v !== false);
+            });
+        }
+        if (quirks.allowExtraPropertiesInResponse) {
+            expect(actual).toMatchObject(expected);
+        }
+        else {
+            expect(actual).toEqual(expected);
+        }
     }
 }

package/dist/testing/index.d.ts

@@ -1,7 +1,9 @@
 import { runCommonDaoTest } from './daoTest';
-import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest';
+import type { CommonDBImplementationQuirks } from './dbTest';
+import { 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';
+import type { TestItemBM, TestItemDBM, TestItemTM } from './test.model';
+import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema } from './test.model';
 export type { CommonDBImplementationQuirks, TestItemBM, TestItemDBM, TestItemTM };
 export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, };

package/dist/testing/keyValueDBTest.d.ts

@@ -1,2 +1,2 @@
-import { CommonKeyValueDB } from '../kv/commonKeyValueDB';
-export declare function runCommonKeyValueDBTest(db: CommonKeyValueDB): void;
+import type { CommonKeyValueDB } from '../kv/commonKeyValueDB';
+export declare function runCommonKeyValueDBTest(db: CommonKeyValueDB): Promise<void>;

package/dist/testing/keyValueDBTest.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDBTest = runCommonKeyValueDBTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const vitest_1 = require("vitest");
 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) {
-    (0, vitest_1.beforeAll)(async () => {
+async function runCommonKeyValueDBTest(db) {
+    const { afterAll, beforeAll, expect, test } = await import('vitest');
+    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.
@@ -18,98 +18,98 @@ function runCommonKeyValueDBTest(db) {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
-    (0, vitest_1.afterAll)(async () => {
+    afterAll(async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
     const { support } = db;
-    (0, vitest_1.test)('ping', async () => {
+    test('ping', async () => {
         await db.ping();
     });
-    (0, vitest_1.test)('createTable', async () => {
+    test('createTable', async () => {
         await db.createTable(test_model_1.TEST_TABLE, { dropIfExists: true });
     });
-    (0, vitest_1.test)('deleteByIds non existing', async () => {
+    test('deleteByIds non existing', async () => {
         await db.deleteByIds(test_model_1.TEST_TABLE, testIds);
     });
-    (0, vitest_1.test)('getByIds should return empty', async () => {
+    test('getByIds should return empty', async () => {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
-        (0, vitest_1.expect)(results).toEqual([]);
+        expect(results).toEqual([]);
     });
-    (0, vitest_1.test)('count should be 0', async () => {
-        (0, vitest_1.expect)(await db.count(test_model_1.TEST_TABLE)).toBe(0);
+    test('count should be 0', async () => {
+        expect(await db.count(test_model_1.TEST_TABLE)).toBe(0);
     });
-    (0, vitest_1.test)('saveBatch, then getByIds', async () => {
+    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);
-        (0, vitest_1.expect)(entries).toEqual(testEntries);
+        expect(entries).toEqual(testEntries);
     });
     if (support.count) {
-        (0, vitest_1.test)('count should be 3', async () => {
-            (0, vitest_1.expect)(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+        test('count should be 3', async () => {
+            expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
         });
     }
-    (0, vitest_1.test)('streamIds', async () => {
+    test('streamIds', async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         ids.sort();
-        (0, vitest_1.expect)(ids).toEqual(testIds);
+        expect(ids).toEqual(testIds);
     });
-    (0, vitest_1.test)('streamIds limited', async () => {
+    test('streamIds limited', async () => {
         const idsLimited = await db.streamIds(test_model_1.TEST_TABLE, 2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
-        (0, vitest_1.expect)(idsLimited.length).toBe(2);
+        expect(idsLimited.length).toBe(2);
     });
-    (0, vitest_1.test)('streamValues', async () => {
+    test('streamValues', async () => {
         const values = await db.streamValues(test_model_1.TEST_TABLE).toArray();
         values.sort();
-        (0, vitest_1.expect)(values).toEqual(testEntries.map(e => e[1]));
+        expect(values).toEqual(testEntries.map(e => e[1]));
     });
-    (0, vitest_1.test)('streamValues limited', async () => {
+    test('streamValues limited', async () => {
         const valuesLimited = await db.streamValues(test_model_1.TEST_TABLE, 2).toArray();
         // valuesLimited.sort()
         // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
-        (0, vitest_1.expect)(valuesLimited.length).toBe(2);
+        expect(valuesLimited.length).toBe(2);
     });
-    (0, vitest_1.test)('streamEntries', async () => {
+    test('streamEntries', async () => {
         const entries = await db.streamEntries(test_model_1.TEST_TABLE).toArray();
         entries.sort();
-        (0, vitest_1.expect)(entries).toEqual(testEntries);
+        expect(entries).toEqual(testEntries);
     });
-    (0, vitest_1.test)('streamEntries limited', async () => {
+    test('streamEntries limited', async () => {
         const entriesLimited = await db.streamEntries(test_model_1.TEST_TABLE, 2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
-        (0, vitest_1.expect)(entriesLimited.length).toBe(2);
+        expect(entriesLimited.length).toBe(2);
     });
-    (0, vitest_1.test)('deleteByIds should clear', async () => {
+    test('deleteByIds should clear', async () => {
         await db.deleteByIds(test_model_1.TEST_TABLE, testIds);
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
-        (0, vitest_1.expect)(results).toEqual([]);
+        expect(results).toEqual([]);
     });
     if (support.increment) {
         const id = 'nonExistingField';
         const id2 = 'nonExistingField2';
-        (0, vitest_1.test)('increment on a non-existing field should set the value to 1', async () => {
+        test('increment on a non-existing field should set the value to 1', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
-            (0, vitest_1.expect)(result).toEqual([[id, 1]]);
+            expect(result).toEqual([[id, 1]]);
         });
-        (0, vitest_1.test)('increment on a existing field should increase the value by one', async () => {
+        test('increment on a existing field should increase the value by one', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
-            (0, vitest_1.expect)(result).toEqual([[id, 2]]);
+            expect(result).toEqual([[id, 2]]);
         });
-        (0, vitest_1.test)('increment should increase the value by the specified amount', async () => {
+        test('increment should increase the value by the specified amount', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 2]]);
-            (0, vitest_1.expect)(result).toEqual([[id, 4]]);
+            expect(result).toEqual([[id, 4]]);
         });
-        (0, vitest_1.test)('increment 2 ids at the same time', async () => {
+        test('increment 2 ids at the same time', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [
                 [id, 1],
                 [id2, 2],
             ]);
-            (0, vitest_1.expect)(Object.fromEntries(result)).toEqual({
+            expect(Object.fromEntries(result)).toEqual({
                 [id]: 5,
                 [id2]: 2,
             });

package/dist/testing/keyValueDaoTest.d.ts

@@ -1,2 +1,2 @@
-import { CommonKeyValueDB } from '../kv/commonKeyValueDB';
-export declare function runCommonKeyValueDaoTest(db: CommonKeyValueDB): void;
+import type { CommonKeyValueDB } from '../kv/commonKeyValueDB';
+export declare function runCommonKeyValueDaoTest(db: CommonKeyValueDB): Promise<void>;