@naturalcycles/db-lib 9.28.0 → 10.0.1

package/dist/testing/daoTest.d.ts

@@ -1,3 +1,3 @@
 import { CommonDB } from '../common.db';
 import { CommonDBImplementationQuirks } from './dbTest';
-export declare function runCommonDaoTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): void;
+export declare function runCommonDaoTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): Promise<void>;

package/dist/testing/daoTest.js

@@ -6,9 +6,10 @@ const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const __1 = require("..");
 const common_dao_1 = require("../commondao/common.dao");
-const dbTest_1 = require("./dbTest");
 const test_model_1 = require("./test.model");
-function runCommonDaoTest(db, quirks = {}) {
+async function runCommonDaoTest(db, quirks = {}) {
+    // this is because vitest cannot be "required" from cjs
+    const { test, expect } = await import('vitest');
     const { support } = db;
     const dao = new common_dao_1.CommonDao({
         table: test_model_1.TEST_TABLE,
@@ -76,7 +77,7 @@ function runCommonDaoTest(db, quirks = {}) {
             // deepFreeze(item3) // no, Dao is expected to mutate object to add id, created, updated
             await dao.save(item3);
             const item3Loaded = await dao.requireById(item3.id);
-            (0, dbTest_1.expectMatch)([item3], [item3Loaded], quirks);
+            expectMatch([item3], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeNull();
             expect(Object.keys(item3)).toContain('k2');
             expect(item3.k2).toBeNull();
@@ -93,7 +94,7 @@ function runCommonDaoTest(db, quirks = {}) {
         await dao.save(item3);
         expected.updated = item3.updated; // as it's mutated
         const item3Loaded = await dao.requireById(item3.id);
-        (0, dbTest_1.expectMatch)([expected], [item3Loaded], quirks);
+        expectMatch([expected], [item3Loaded], quirks);
         expect(item3Loaded.k2).toBeUndefined();
         expect(Object.keys(item3Loaded)).not.toContain('k2');
         expect(Object.keys(item3)).toContain('k2');
@@ -105,7 +106,7 @@ function runCommonDaoTest(db, quirks = {}) {
         // no unnecessary mutation
         const { updated: _, ...clone } = itemsClone[0];
         expect(items[0]).toMatchObject(clone);
-        (0, dbTest_1.expectMatch)(expectedItems, itemsSaved, quirks);
+        expectMatch(expectedItems, itemsSaved, quirks);
     });
     if (support.increment) {
         test('increment', async () => {
@@ -127,7 +128,7 @@ function runCommonDaoTest(db, quirks = {}) {
                 }
                 return r;
             });
-            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+            expectMatch(expected, rows, quirks);
             // reset the changes
             await dao.increment('k3', 'id1', -1);
             await dao.increment('k3', 'id2', -2);
@@ -136,20 +137,20 @@ function runCommonDaoTest(db, quirks = {}) {
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));
-        (0, dbTest_1.expectMatch)(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
+        expectMatch(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (support.queries) {
         test('runQuery(all) should return all items', async () => {
             let rows = await dao.query().runQuery();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-            (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
+            expectMatch(expectedItems, rows, quirks);
         });
         if (support.dbQueryFilter) {
             test('query even=true', async () => {
                 let rows = await dao.query().filter('even', '==', true).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-                (0, dbTest_1.expectMatch)(expectedItems.filter(i => i.even), rows, quirks);
+                expectMatch(expectedItems.filter(i => i.even), rows, quirks);
             });
             test('query nested property', async () => {
                 let rows = await dao
@@ -157,20 +158,20 @@ function runCommonDaoTest(db, quirks = {}) {
                     .filter('nested.foo', '==', 1)
                     .runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-                (0, dbTest_1.expectMatch)(expectedItems.filter(i => i.nested?.foo === 1), rows, quirks);
+                expectMatch(expectedItems.filter(i => i.nested?.foo === 1), rows, quirks);
             });
         }
         if (support.dbQueryOrder) {
             test('query order by k1 desc', async () => {
                 const rows = await dao.query().order('k1', true).runQuery();
-                (0, dbTest_1.expectMatch)([...expectedItems].reverse(), rows, quirks);
+                expectMatch([...expectedItems].reverse(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
             test('projection query with only ids', async () => {
                 let rows = await dao.query().select(['id']).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-                (0, dbTest_1.expectMatch)(expectedItems.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
+                expectMatch(expectedItems.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
             });
         }
         test('runQueryCount should return 3', async () => {
@@ -183,30 +184,30 @@ function runCommonDaoTest(db, quirks = {}) {
             let rows = [];
             await dao.query().streamQueryForEach(bm => void rows.push(bm));
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-            (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
+            expectMatch(expectedItems, rows, quirks);
         });
         test('streamQuery all', async () => {
             let rows = await dao.query().streamQuery().toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
-            (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
+            expectMatch(expectedItems, rows, quirks);
         });
         test('streamQueryIdsForEach all', async () => {
             let ids = [];
             await dao.query().streamQueryIdsForEach(id => void ids.push(id));
             ids = ids.sort();
-            (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
+            expectMatch(expectedItems.map(i => i.id), ids, quirks);
         });
         test('streamQueryIds all', async () => {
             let ids = await dao.query().streamQueryIds().toArray();
             ids = ids.sort();
-            (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
+            expectMatch(expectedItems.map(i => i.id), ids, quirks);
         });
         test('streamSaveTransform', async () => {
             const items2 = (0, test_model_1.createTestItemsBM)(2).map(i => ({ ...i, id: i.id + '_str' }));
             const ids = items2.map(i => i.id);
             await (0, nodejs_lib_1._pipeline)([node_stream_1.Readable.from(items2), ...dao.streamSaveTransform()]);
             const items2Loaded = await dao.getByIds(ids);
-            (0, dbTest_1.expectMatch)(items2, items2Loaded, quirks);
+            expectMatch(items2, items2Loaded, quirks);
             // cleanup
             await dao.query().filterIn('id', ids).deleteByQuery();
         });
@@ -252,7 +253,7 @@ function runCommonDaoTest(db, quirks = {}) {
             });
             const rows = await dao.query().runQuery();
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
-            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+            expectMatch(expected, rows, quirks);
         });
         test('transaction rollback', async () => {
             await expect(dao.runInTransaction(async (tx) => {
@@ -261,7 +262,7 @@ function runCommonDaoTest(db, quirks = {}) {
             })).rejects.toThrow();
             const rows = await dao.query().runQuery();
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
-            (0, dbTest_1.expectMatch)(expected, rows, quirks);
+            expectMatch(expected, rows, quirks);
         });
         if (support.queries) {
             test('transaction cleanup', async () => {
@@ -269,4 +270,19 @@ function runCommonDaoTest(db, quirks = {}) {
             });
         }
     }
+    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/dbTest.d.ts

@@ -12,5 +12,4 @@ export interface CommonDBImplementationQuirks {
      */
     allowBooleansAsUndefined?: boolean;
 }
-export declare function runCommonDBTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): void;
-export declare function expectMatch(expected: any[], actual: any[], quirks: CommonDBImplementationQuirks): void;
+export declare function runCommonDBTest(db: CommonDB, quirks?: CommonDBImplementationQuirks): Promise<void>;

package/dist/testing/dbTest.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonDBTest = runCommonDBTest;
-exports.expectMatch = expectMatch;
 const js_lib_1 = require("@naturalcycles/js-lib");
 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);
@@ -288,19 +289,19 @@ function runCommonDBTest(db, quirks = {}) {
             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) {
-        expect(actual).toMatchObject(expected);
-    }
-    else {
-        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/keyValueDBTest.d.ts

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

package/dist/testing/keyValueDBTest.js

@@ -8,7 +8,8 @@ const testEntries = testIds.map(id => [
     id,
     Buffer.from(`${id}value`),
 ]);
-function runCommonKeyValueDBTest(db) {
+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,

package/dist/testing/keyValueDaoTest.d.ts

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

package/dist/testing/keyValueDaoTest.js

@@ -7,7 +7,8 @@ const test_model_1 = require("./test.model");
 const testItems = (0, test_model_1.createTestItemsBM)(4);
 const testIds = testItems.map(e => e.id);
 const testEntries = testItems.map(e => [e.id, Buffer.from(`${e.id}value`)]);
-function runCommonKeyValueDaoTest(db) {
+async function runCommonKeyValueDaoTest(db) {
+    const { afterAll, beforeAll, expect, test } = await import('vitest');
     const dao = new commonKeyValueDao_1.CommonKeyValueDao({
         db,
         table: test_model_1.TEST_TABLE,

package/package.json

@@ -14,9 +14,10 @@
   },
   "devDependencies": {
     "@naturalcycles/bench-lib": "^3",
-    "@naturalcycles/dev-lib": "^15",
+    "@naturalcycles/dev-lib": "^16",
     "@types/node": "^22",
-    "jest": "^29"
+    "@vitest/coverage-v8": "^3",
+    "vitest": "^3"
   },
   "files": [
     "dist",
@@ -43,9 +44,9 @@
     "url": "https://github.com/NaturalCycles/db-lib"
   },
   "engines": {
-    "node": ">=22.10.0"
+    "node": ">=22.12.0"
   },
-  "version": "9.28.0",
+  "version": "10.0.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/testing/daoTest.ts

@@ -1,11 +1,11 @@
 import { Readable } from 'node:stream'
-import { _deepCopy, _omit, _pick, _sortBy, localTime } from '@naturalcycles/js-lib'
+import { _deepCopy, _filterObject, _omit, _pick, _sortBy, localTime } from '@naturalcycles/js-lib'
 import { _pipeline } from '@naturalcycles/nodejs-lib'
 import { CommonDaoLogLevel, DBQuery } from '..'
 import { CommonDB } from '../common.db'
 import { CommonDao } from '../commondao/common.dao'
 import { TestItemBM } from '.'
-import { CommonDBImplementationQuirks, expectMatch } from './dbTest'
+import { CommonDBImplementationQuirks } from './dbTest'
 import {
   createTestItemBM,
   createTestItemsBM,
@@ -14,7 +14,13 @@ import {
   testItemBMSchema,
 } from './test.model'
 
-export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQuirks = {}): void {
+export async function runCommonDaoTest(
+  db: CommonDB,
+  quirks: CommonDBImplementationQuirks = {},
+): Promise<void> {
+  // this is because vitest cannot be "required" from cjs
+  const { test, expect } = await import('vitest')
+
   const { support } = db
   const dao = new CommonDao({
     table: TEST_TABLE,
@@ -358,4 +364,21 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
       })
     }
   }
+
+  function expectMatch(expected: any[], actual: any[], quirks: CommonDBImplementationQuirks): void {
+    // const expectedSorted = sortObjectDeep(expected)
+    // const actualSorted = sortObjectDeep(actual)
+
+    if (quirks.allowBooleansAsUndefined) {
+      expected = expected.map(r => {
+        return typeof r !== 'object' ? r : _filterObject(r, (_k, v) => v !== false)
+      })
+    }
+
+    if (quirks.allowExtraPropertiesInResponse) {
+      expect(actual).toMatchObject(expected)
+    } else {
+      expect(actual).toEqual(expected)
+    }
+  }
 }

package/src/testing/dbTest.ts

@@ -24,7 +24,13 @@ export interface CommonDBImplementationQuirks {
   allowBooleansAsUndefined?: boolean
 }
 
-export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuirks = {}): void {
+export async function runCommonDBTest(
+  db: CommonDB,
+  quirks: CommonDBImplementationQuirks = {},
+): Promise<void> {
+  // this is because vitest cannot be "required" from cjs
+  const { test, expect } = await import('vitest')
+
   const { support } = db
   const items = createTestItemsDBM(3)
   _deepFreeze(items)
@@ -379,25 +385,21 @@ export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuir
       await db.deleteByQuery(queryAll())
     })
   }
-}
 
-export function expectMatch(
-  expected: any[],
-  actual: any[],
-  quirks: CommonDBImplementationQuirks,
-): void {
-  // const expectedSorted = sortObjectDeep(expected)
-  // const actualSorted = sortObjectDeep(actual)
-
-  if (quirks.allowBooleansAsUndefined) {
-    expected = expected.map(r => {
-      return typeof r !== 'object' ? r : _filterObject(r, (_k, v) => v !== false)
-    })
-  }
+  function expectMatch(expected: any[], actual: any[], quirks: CommonDBImplementationQuirks): void {
+    // const expectedSorted = sortObjectDeep(expected)
+    // const actualSorted = sortObjectDeep(actual)
 
-  if (quirks.allowExtraPropertiesInResponse) {
-    expect(actual).toMatchObject(expected)
-  } else {
-    expect(actual).toEqual(expected)
+    if (quirks.allowBooleansAsUndefined) {
+      expected = expected.map(r => {
+        return typeof r !== 'object' ? r : _filterObject(r, (_k, v) => v !== false)
+      })
+    }
+
+    if (quirks.allowExtraPropertiesInResponse) {
+      expect(actual).toMatchObject(expected)
+    } else {
+      expect(actual).toEqual(expected)
+    }
   }
 }

package/src/testing/keyValueDBTest.ts

@@ -9,7 +9,9 @@ const testEntries: KeyValueTuple<string, Buffer>[] = testIds.map(id => [
   Buffer.from(`${id}value`),
 ])
 
-export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
+export async function runCommonKeyValueDBTest(db: CommonKeyValueDB): Promise<void> {
+  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,

package/src/testing/keyValueDaoTest.ts

@@ -7,7 +7,9 @@ const testItems = createTestItemsBM(4)
 const testIds = testItems.map(e => e.id)
 const testEntries: KeyValueDBTuple[] = testItems.map(e => [e.id, Buffer.from(`${e.id}value`)])
 
-export function runCommonKeyValueDaoTest(db: CommonKeyValueDB): void {
+export async function runCommonKeyValueDaoTest(db: CommonKeyValueDB): Promise<void> {
+  const { afterAll, beforeAll, expect, test } = await import('vitest')
+
   const dao = new CommonKeyValueDao({
     db,
     table: TEST_TABLE,