@naturalcycles/db-lib 10.0.0 → 10.0.2

package/dist/testing/daoTest.js

@@ -4,12 +4,12 @@ exports.runCommonDaoTest = runCommonDaoTest;
 const node_stream_1 = require("node:stream");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
-const vitest_1 = require("vitest");
 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,
@@ -24,52 +24,52 @@ function runCommonDaoTest(db, quirks = {}) {
     const item1 = items[0];
     const expectedItems = items.map(i => ({
         ...i,
-        updated: vitest_1.expect.any(Number),
+        updated: expect.any(Number),
     }));
-    (0, vitest_1.test)('ping', async () => {
+    test('ping', async () => {
         await dao.ping();
     });
     // CREATE TABLE, DROP
     if (support.createTable) {
-        (0, vitest_1.test)('createTable, dropIfExists=true', async () => {
+        test('createTable, dropIfExists=true', async () => {
             await dao.createTable(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 dao.query().select(['id']).runQuery();
             await db.deleteByQuery(__1.DBQuery.create(test_model_1.TEST_TABLE).filter('id', 'in', rows.map(r => r.id)));
         });
         // QUERY empty
-        (0, vitest_1.test)('runQuery(all), runQueryCount should return empty', async () => {
-            (0, vitest_1.expect)(await dao.query().runQuery()).toEqual([]);
-            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(0);
+        test('runQuery(all), runQueryCount should return empty', async () => {
+            expect(await dao.query().runQuery()).toEqual([]);
+            expect(await dao.query().runQueryCount()).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 dao.getByIds([item1.id]);
-        (0, vitest_1.expect)(item1Loaded).toBeUndefined();
-        (0, vitest_1.expect)(await dao.getById(item1.id)).toBeNull();
+        expect(item1Loaded).toBeUndefined();
+        expect(await dao.getById(item1.id)).toBeNull();
     });
-    (0, vitest_1.test)('getByIds([]) should return []', async () => {
-        (0, vitest_1.expect)(await dao.getByIds([])).toEqual([]);
+    test('getByIds([]) should return []', async () => {
+        expect(await dao.getByIds([])).toEqual([]);
     });
-    (0, vitest_1.test)('getByIds(...) should return empty', async () => {
-        (0, vitest_1.expect)(await dao.getByIds(['abc', 'abcd'])).toEqual([]);
+    test('getByIds(...) should return empty', async () => {
+        expect(await dao.getByIds(['abc', 'abcd'])).toEqual([]);
     });
     // TimeMachine
     if (support.timeMachine) {
-        (0, vitest_1.test)('getByIds(...) 10 minutes ago should return []', async () => {
-            (0, vitest_1.expect)(await dao.getByIds([item1.id, 'abc'], {
+        test('getByIds(...) 10 minutes ago should return []', async () => {
+            expect(await dao.getByIds([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.createTestItemBM)(3),
                 k2: null,
@@ -77,13 +77,13 @@ 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);
-            (0, vitest_1.expect)(item3Loaded.k2).toBeNull();
-            (0, vitest_1.expect)(Object.keys(item3)).toContain('k2');
-            (0, vitest_1.expect)(item3.k2).toBeNull();
+            expectMatch([item3], [item3Loaded], quirks);
+            expect(item3Loaded.k2).toBeNull();
+            expect(Object.keys(item3)).toContain('k2');
+            expect(item3.k2).toBeNull();
         });
     }
-    (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.createTestItemBM)(3),
             k2: undefined,
@@ -94,22 +94,22 @@ 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);
-        (0, vitest_1.expect)(item3Loaded.k2).toBeUndefined();
-        (0, vitest_1.expect)(Object.keys(item3Loaded)).not.toContain('k2');
-        (0, vitest_1.expect)(Object.keys(item3)).toContain('k2');
-        (0, vitest_1.expect)(item3.k2).toBeUndefined();
+        expectMatch([expected], [item3Loaded], quirks);
+        expect(item3Loaded.k2).toBeUndefined();
+        expect(Object.keys(item3Loaded)).not.toContain('k2');
+        expect(Object.keys(item3)).toContain('k2');
+        expect(item3.k2).toBeUndefined();
     });
-    (0, vitest_1.test)('saveBatch test items', async () => {
+    test('saveBatch test items', async () => {
         const itemsSaved = await dao.saveBatch(items);
-        (0, vitest_1.expect)(itemsSaved[0]).toBe(items[0]); // expect "same object" returned
+        expect(itemsSaved[0]).toBe(items[0]); // expect "same object" returned
         // no unnecessary mutation
         const { updated: _, ...clone } = itemsClone[0];
-        (0, vitest_1.expect)(items[0]).toMatchObject(clone);
-        (0, dbTest_1.expectMatch)(expectedItems, itemsSaved, quirks);
+        expect(items[0]).toMatchObject(clone);
+        expectMatch(expectedItems, itemsSaved, quirks);
     });
     if (support.increment) {
-        (0, vitest_1.test)('increment', async () => {
+        test('increment', async () => {
             await dao.incrementBatch('k3', { id1: 1, id2: 2 });
             let rows = await dao.query().runQuery();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
@@ -128,104 +128,104 @@ 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);
         });
     }
     // GET not empty
-    (0, vitest_1.test)('getByIds all items', async () => {
+    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) {
-        (0, vitest_1.test)('runQuery(all) should return all items', async () => {
+        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) {
-            (0, vitest_1.test)('query even=true', async () => {
+            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);
             });
-            (0, vitest_1.test)('query nested property', async () => {
+            test('query nested property', async () => {
                 let rows = await dao
                     .query()
                     .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) {
-            (0, vitest_1.test)('query order by k1 desc', async () => {
+            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) {
-            (0, vitest_1.test)('projection query with only ids', async () => {
+            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);
             });
         }
-        (0, vitest_1.test)('runQueryCount should return 3', async () => {
-            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(3);
+        test('runQueryCount should return 3', async () => {
+            expect(await dao.query().runQueryCount()).toBe(3);
         });
     }
     // STREAM
     if (support.streaming) {
-        (0, vitest_1.test)('streamQueryForEach all', async () => {
+        test('streamQueryForEach all', async () => {
             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);
         });
-        (0, vitest_1.test)('streamQuery all', async () => {
+        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);
         });
-        (0, vitest_1.test)('streamQueryIdsForEach all', async () => {
+        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);
         });
-        (0, vitest_1.test)('streamQueryIds all', async () => {
+        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);
         });
-        (0, vitest_1.test)('streamSaveTransform', async () => {
+        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();
         });
     }
     // DELETE BY
     if (support.queries) {
-        (0, vitest_1.test)('deleteByQuery even=false', async () => {
+        test('deleteByQuery even=false', async () => {
             const deleted = await dao.query().filter('even', '==', false).deleteByQuery();
-            (0, vitest_1.expect)(deleted).toBe(items.filter(item => !item.even).length);
-            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(1);
+            expect(deleted).toBe(items.filter(item => !item.even).length);
+            expect(await dao.query().runQueryCount()).toBe(1);
         });
-        (0, vitest_1.test)('cleanup', async () => {
+        test('cleanup', async () => {
             // CLEAN UP
             await dao.query().deleteByQuery();
         });
     }
     if (support.transactions) {
-        (0, vitest_1.test)('transaction happy path', async () => {
+        test('transaction happy path', async () => {
             // cleanup
             await dao.query().deleteByQuery();
             // Test that id, created, updated are created
@@ -235,10 +235,10 @@ function runCommonDaoTest(db, quirks = {}) {
                 await tx.save(dao, row);
             });
             const loaded = await dao.query().runQuery();
-            (0, vitest_1.expect)(loaded.length).toBe(1);
-            (0, vitest_1.expect)(loaded[0].id).toBeDefined();
-            (0, vitest_1.expect)(loaded[0].created).toBeGreaterThanOrEqual(now);
-            (0, vitest_1.expect)(loaded[0].updated).toBe(loaded[0].created);
+            expect(loaded.length).toBe(1);
+            expect(loaded[0].id).toBeDefined();
+            expect(loaded[0].created).toBeGreaterThanOrEqual(now);
+            expect(loaded[0].updated).toBe(loaded[0].created);
             await dao.runInTransaction(async (tx) => {
                 await tx.deleteById(dao, loaded[0].id);
             });
@@ -253,21 +253,36 @@ 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);
         });
-        (0, vitest_1.test)('transaction rollback', async () => {
-            await (0, vitest_1.expect)(dao.runInTransaction(async (tx) => {
+        test('transaction rollback', async () => {
+            await expect(dao.runInTransaction(async (tx) => {
                 await tx.deleteById(dao, items[2].id);
                 await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
             })).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) {
-            (0, vitest_1.test)('transaction cleanup', async () => {
+            test('transaction cleanup', async () => {
                 await dao.query().deleteByQuery();
             });
         }
     }
+    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

@@ -1,4 +1,4 @@
-import { CommonDB } from '../common.db';
+import type { CommonDB } from '../common.db';
 /**
  * All options default to `false`.
  */
@@ -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>;