@naturalcycles/db-lib 10.0.2 → 10.1.0

package/dist/testing/{daoTest.js → commonDaoTest.js}

@@ -1,25 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 __1 = require("..");
-const common_dao_1 = require("../commondao/common.dao");
-const test_model_1 = require("./test.model");
-async function runCommonDaoTest(db, quirks = {}) {
+import { Readable } from 'node:stream';
+import { _deepCopy, _filterObject, _omit, _pick, _sortBy, localTime } from '@naturalcycles/js-lib';
+import { _pipeline } from '@naturalcycles/nodejs-lib';
+import { CommonDao } from '../commondao/common.dao.js';
+import { CommonDaoLogLevel } from '../commondao/common.dao.model.js';
+import { DBQuery } from '../query/dbQuery.js';
+import { createTestItemBM, createTestItemsBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, } from './test.model.js';
+export 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,
+    const dao = new CommonDao({
+        table: TEST_TABLE,
         db,
-        bmSchema: test_model_1.testItemBMSchema,
+        bmSchema: testItemBMSchema,
         logStarted: true,
-        logLevel: __1.CommonDaoLogLevel.DATA_FULL,
+        logLevel: CommonDaoLogLevel.DATA_FULL,
     });
-    const items = (0, test_model_1.createTestItemsBM)(3);
-    const itemsClone = (0, js_lib_1._deepCopy)(items);
+    const items = createTestItemsBM(3);
+    const itemsClone = _deepCopy(items);
     // deepFreeze(items) // mutation of id/created/updated is allowed now! (even expected)
     const item1 = items[0];
     const expectedItems = items.map(i => ({
@@ -32,14 +30,14 @@ async function runCommonDaoTest(db, quirks = {}) {
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await dao.createTable(test_model_1.testItemBMJsonSchema, { dropIfExists: true });
+            await dao.createTable(testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {
         // DELETE ALL initially
         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)));
+            await db.deleteByQuery(DBQuery.create(TEST_TABLE).filter('id', 'in', rows.map(r => r.id)));
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
@@ -63,7 +61,7 @@ async function runCommonDaoTest(db, quirks = {}) {
     if (support.timeMachine) {
         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,
+                readAt: localTime.now().minus(10, 'minute').unix,
             })).toEqual([]);
         });
     }
@@ -71,7 +69,7 @@ async function runCommonDaoTest(db, quirks = {}) {
     if (support.nullValues) {
         test('should allow to save and load null values', async () => {
             const item3 = {
-                ...(0, test_model_1.createTestItemBM)(3),
+                ...createTestItemBM(3),
                 k2: null,
             };
             // deepFreeze(item3) // no, Dao is expected to mutate object to add id, created, updated
@@ -85,7 +83,7 @@ async function runCommonDaoTest(db, quirks = {}) {
     }
     test('undefined values should not be saved/loaded', async () => {
         const item3 = {
-            ...(0, test_model_1.createTestItemBM)(3),
+            ...createTestItemBM(3),
             k2: undefined,
         };
         // deepFreeze(item3) // no, Dao is expected to mutate object to add id, created, updated
@@ -112,7 +110,7 @@ async function runCommonDaoTest(db, quirks = {}) {
         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);
+            rows = _sortBy(rows, r => r.id);
             const expected = expectedItems.map(r => {
                 if (r.id === 'id1') {
                     return {
@@ -137,19 +135,19 @@ async function runCommonDaoTest(db, quirks = {}) {
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));
-        expectMatch(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
+        expectMatch(expectedItems, _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);
+            rows = _sortBy(rows, r => r.id);
             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);
+                rows = _sortBy(rows, r => r.id);
                 expectMatch(expectedItems.filter(i => i.even), rows, quirks);
             });
             test('query nested property', async () => {
@@ -157,7 +155,7 @@ async function runCommonDaoTest(db, quirks = {}) {
                     .query()
                     .filter('nested.foo', '==', 1)
                     .runQuery();
-                rows = (0, js_lib_1._sortBy)(rows, r => r.id);
+                rows = _sortBy(rows, r => r.id);
                 expectMatch(expectedItems.filter(i => i.nested?.foo === 1), rows, quirks);
             });
         }
@@ -170,8 +168,8 @@ async function runCommonDaoTest(db, 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);
-                expectMatch(expectedItems.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
+                rows = _sortBy(rows, r => r.id);
+                expectMatch(expectedItems.map(item => _pick(item, ['id'])), rows, quirks);
             });
         }
         test('runQueryCount should return 3', async () => {
@@ -183,12 +181,12 @@ async function runCommonDaoTest(db, quirks = {}) {
         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);
+            rows = _sortBy(rows, r => r.id);
             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);
+            rows = _sortBy(rows, r => r.id);
             expectMatch(expectedItems, rows, quirks);
         });
         test('streamQueryIdsForEach all', async () => {
@@ -203,9 +201,9 @@ async function runCommonDaoTest(db, 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 items2 = 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()]);
+            await _pipeline([Readable.from(items2), ...dao.streamSaveTransform()]);
             const items2Loaded = await dao.getByIds(ids);
             expectMatch(items2, items2Loaded, quirks);
             // cleanup
@@ -225,13 +223,23 @@ async function runCommonDaoTest(db, quirks = {}) {
         });
     }
     if (support.transactions) {
+        /**
+         * Returns expected items in the DB after the preparation.
+         */
+        async function prepare() {
+            // cleanup
+            await dao.query().deleteByQuery();
+            const itemsToSave = [items[0], { ...items[2], k1: 'k1_mod' }];
+            await dao.saveBatch(itemsToSave);
+            return itemsToSave;
+        }
         test('transaction happy path', async () => {
             // cleanup
             await dao.query().deleteByQuery();
             // Test that id, created, updated are created
-            const now = js_lib_1.localTime.nowUnix();
+            const now = localTime.nowUnix();
             await dao.runInTransaction(async (tx) => {
-                const row = (0, js_lib_1._omit)(item1, ['id', 'created', 'updated']);
+                const row = _omit(item1, ['id', 'created', 'updated']);
                 await tx.save(dao, row);
             });
             const loaded = await dao.query().runQuery();
@@ -255,13 +263,68 @@ async function runCommonDaoTest(db, quirks = {}) {
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
+        test('createTransaction happy path', async () => {
+            // cleanup
+            await dao.query().deleteByQuery();
+            // Test that id, created, updated are created
+            const now = localTime.nowUnix();
+            const row = _omit(item1, ['id', 'created', 'updated']);
+            let tx = await dao.createTransaction();
+            await tx.save(dao, row);
+            await tx.commit();
+            const loaded = await dao.query().runQuery();
+            expect(loaded.length).toBe(1);
+            expect(loaded[0].id).toBeDefined();
+            expect(loaded[0].created).toBeGreaterThanOrEqual(now);
+            expect(loaded[0].updated).toBe(loaded[0].created);
+            tx = await dao.createTransaction();
+            await tx.deleteById(dao, loaded[0].id);
+            await tx.commit();
+            // saveBatch [item1, 2, 3]
+            // save item3 with k1: k1_mod
+            // delete item2
+            // remaining: item1, item3_with_k1_mod
+            tx = await dao.createTransaction();
+            await tx.saveBatch(dao, items);
+            await tx.save(dao, { ...items[2], k1: 'k1_mod' });
+            await tx.deleteById(dao, items[1].id);
+            await tx.commit();
+            const rows = await dao.query().runQuery();
+            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+            expectMatch(expected, rows, quirks);
+        });
         test('transaction rollback', async () => {
-            await expect(dao.runInTransaction(async (tx) => {
+            const expected = await prepare();
+            let err;
+            try {
+                await dao.runInTransaction(async (tx) => {
+                    await tx.deleteById(dao, items[2].id);
+                    await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
+                });
+            }
+            catch (err_) {
+                err = err_;
+            }
+            expect(err).toBeDefined();
+            expect(err).toBeInstanceOf(Error);
+            const rows = await dao.query().runQuery();
+            expectMatch(expected, rows, quirks);
+        });
+        test('createTransaction rollback', async () => {
+            const expected = await prepare();
+            let err;
+            try {
+                const tx = await dao.createTransaction();
                 await tx.deleteById(dao, items[2].id);
                 await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
-            })).rejects.toThrow();
+                await tx.commit();
+            }
+            catch (err_) {
+                err = err_;
+            }
+            expect(err).toBeDefined();
+            expect(err).toBeInstanceOf(Error);
             const rows = await dao.query().runQuery();
-            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
         if (support.queries) {
@@ -275,7 +338,7 @@ async function runCommonDaoTest(db, quirks = {}) {
         // 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);
+                return typeof r !== 'object' ? r : _filterObject(r, (_k, v) => v !== false);
             });
         }
         if (quirks.allowExtraPropertiesInResponse) {

package/dist/testing/index.d.ts

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

package/dist/testing/index.js

@@ -1,20 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-Object.defineProperty(exports, "createTestItemBM", { enumerable: true, get: function () { return test_model_1.createTestItemBM; } });
-Object.defineProperty(exports, "createTestItemDBM", { enumerable: true, get: function () { return test_model_1.createTestItemDBM; } });
-Object.defineProperty(exports, "createTestItemsBM", { enumerable: true, get: function () { return test_model_1.createTestItemsBM; } });
-Object.defineProperty(exports, "createTestItemsDBM", { enumerable: true, get: function () { return test_model_1.createTestItemsDBM; } });
-Object.defineProperty(exports, "TEST_TABLE", { enumerable: true, get: function () { return test_model_1.TEST_TABLE; } });
-Object.defineProperty(exports, "testItemBMJsonSchema", { enumerable: true, get: function () { return test_model_1.testItemBMJsonSchema; } });
-Object.defineProperty(exports, "testItemBMSchema", { enumerable: true, get: function () { return test_model_1.testItemBMSchema; } });
-Object.defineProperty(exports, "testItemTMSchema", { enumerable: true, get: function () { return test_model_1.testItemTMSchema; } });
+import { runCommonDaoTest } from './commonDaoTest.js';
+import { runCommonDBTest } from './commonDBTest.js';
+import { runCommonKeyValueDaoTest } from './keyValueDaoTest.js';
+import { runCommonKeyValueDBTest } from './keyValueDBTest.js';
+import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, } from './test.model.js';
+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 type { CommonKeyValueDB } from '../kv/commonKeyValueDB';
+import type { CommonKeyValueDB } from '../kv/commonKeyValueDB.js';
 export declare function runCommonKeyValueDBTest(db: CommonKeyValueDB): Promise<void>;

package/dist/testing/keyValueDBTest.js

@@ -1,111 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommonKeyValueDBTest = runCommonKeyValueDBTest;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const test_model_1 = require("./test.model");
-const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
+import { _range, _sortBy } from '@naturalcycles/js-lib';
+import { TEST_TABLE } from './test.model.js';
+const testIds = _range(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [
     id,
     Buffer.from(`${id}value`),
 ]);
-async function runCommonKeyValueDBTest(db) {
+export 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.
         // 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);
+        const ids = await db.streamIds(TEST_TABLE).toArray();
+        await db.deleteByIds(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);
+        const ids = await db.streamIds(TEST_TABLE).toArray();
+        await db.deleteByIds(TEST_TABLE, ids);
     });
     const { support } = db;
     test('ping', async () => {
         await db.ping();
     });
     test('createTable', async () => {
-        await db.createTable(test_model_1.TEST_TABLE, { dropIfExists: true });
+        await db.createTable(TEST_TABLE, { dropIfExists: true });
     });
     test('deleteByIds non existing', async () => {
-        await db.deleteByIds(test_model_1.TEST_TABLE, testIds);
+        await db.deleteByIds(TEST_TABLE, testIds);
     });
     test('getByIds should return empty', async () => {
-        const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
+        const results = await db.getByIds(TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
     test('count should be 0', async () => {
-        expect(await db.count(test_model_1.TEST_TABLE)).toBe(0);
+        expect(await db.count(TEST_TABLE)).toBe(0);
     });
     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);
+        await db.saveBatch(TEST_TABLE, testEntries);
+        const entries = await db.getByIds(TEST_TABLE, testIds);
+        _sortBy(entries, e => e[0], true);
         expect(entries).toEqual(testEntries);
     });
     if (support.count) {
         test('count should be 3', async () => {
-            expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+            expect(await db.count(TEST_TABLE)).toBe(3);
         });
     }
     test('streamIds', async () => {
-        const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
+        const ids = await db.streamIds(TEST_TABLE).toArray();
         ids.sort();
         expect(ids).toEqual(testIds);
     });
     test('streamIds limited', async () => {
-        const idsLimited = await db.streamIds(test_model_1.TEST_TABLE, 2).toArray();
+        const idsLimited = await db.streamIds(TEST_TABLE, 2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
         expect(idsLimited.length).toBe(2);
     });
     test('streamValues', async () => {
-        const values = await db.streamValues(test_model_1.TEST_TABLE).toArray();
+        const values = await db.streamValues(TEST_TABLE).toArray();
         values.sort();
         expect(values).toEqual(testEntries.map(e => e[1]));
     });
     test('streamValues limited', async () => {
-        const valuesLimited = await db.streamValues(test_model_1.TEST_TABLE, 2).toArray();
+        const valuesLimited = await db.streamValues(TEST_TABLE, 2).toArray();
         // valuesLimited.sort()
         // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
         expect(valuesLimited.length).toBe(2);
     });
     test('streamEntries', async () => {
-        const entries = await db.streamEntries(test_model_1.TEST_TABLE).toArray();
+        const entries = await db.streamEntries(TEST_TABLE).toArray();
         entries.sort();
         expect(entries).toEqual(testEntries);
     });
     test('streamEntries limited', async () => {
-        const entriesLimited = await db.streamEntries(test_model_1.TEST_TABLE, 2).toArray();
+        const entriesLimited = await db.streamEntries(TEST_TABLE, 2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
         expect(entriesLimited.length).toBe(2);
     });
     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);
+        await db.deleteByIds(TEST_TABLE, testIds);
+        const results = await db.getByIds(TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
     if (support.increment) {
         const id = 'nonExistingField';
         const id2 = 'nonExistingField2';
         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]]);
+            const result = await db.incrementBatch(TEST_TABLE, [[id, 1]]);
             expect(result).toEqual([[id, 1]]);
         });
         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]]);
+            const result = await db.incrementBatch(TEST_TABLE, [[id, 1]]);
             expect(result).toEqual([[id, 2]]);
         });
         test('increment should increase the value by the specified amount', async () => {
-            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 2]]);
+            const result = await db.incrementBatch(TEST_TABLE, [[id, 2]]);
             expect(result).toEqual([[id, 4]]);
         });
         test('increment 2 ids at the same time', async () => {
-            const result = await db.incrementBatch(test_model_1.TEST_TABLE, [
+            const result = await db.incrementBatch(TEST_TABLE, [
                 [id, 1],
                 [id2, 2],
             ]);

package/dist/testing/keyValueDaoTest.d.ts

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

package/dist/testing/keyValueDaoTest.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommonKeyValueDaoTest = runCommonKeyValueDaoTest;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const commonKeyValueDao_1 = require("../kv/commonKeyValueDao");
-const test_model_1 = require("./test.model");
-const testItems = (0, test_model_1.createTestItemsBM)(4);
+import { _sortBy } from '@naturalcycles/js-lib';
+import { CommonKeyValueDao } from '../kv/commonKeyValueDao.js';
+import { createTestItemsBM, TEST_TABLE } from './test.model.js';
+const testItems = createTestItemsBM(4);
 const testIds = testItems.map(e => e.id);
 const testEntries = testItems.map(e => [e.id, Buffer.from(`${e.id}value`)]);
-async function runCommonKeyValueDaoTest(db) {
+export async function runCommonKeyValueDaoTest(db) {
     const { afterAll, beforeAll, expect, test } = await import('vitest');
-    const dao = new commonKeyValueDao_1.CommonKeyValueDao({
+    const dao = new CommonKeyValueDao({
         db,
-        table: test_model_1.TEST_TABLE,
+        table: TEST_TABLE,
         // todo: make this test support "deflatedJson" transformer
     });
     const { support } = db;
@@ -44,7 +41,7 @@ async function runCommonKeyValueDaoTest(db) {
         await dao.saveBatch(testEntries);
         const entries = await dao.getByIds(testIds);
         // console.log(typeof entries[0]![1], entries[0]![1])
-        (0, js_lib_1._sortBy)(entries, e => e[0], true);
+        _sortBy(entries, e => e[0], true);
         expect(entries).toEqual(testEntries); // Jest doesn't allow to compare Buffers directly
         // expect(entries.map(e => e[0])).toEqual(testEntries.map(e => e[0]))
         // expect(entries.map(e => e[1].toString())).toEqual(testEntries.map(e => e[1].toString()))

package/dist/testing/test.model.js

@@ -1,43 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testItemBMJsonSchema = exports.testItemTMSchema = exports.testItemBMSchema = exports.TEST_TABLE = void 0;
-exports.createTestItemDBM = createTestItemDBM;
-exports.createTestItemBM = createTestItemBM;
-exports.createTestItemsDBM = createTestItemsDBM;
-exports.createTestItemsBM = createTestItemsBM;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+import { _range, jsonSchema } from '@naturalcycles/js-lib';
+import { baseDBEntitySchema, binarySchema, booleanSchema, numberSchema, objectSchema, stringSchema, } from '@naturalcycles/nodejs-lib';
 const MOCK_TS_2018_06_21 = 1529539200;
-exports.TEST_TABLE = 'TEST_TABLE';
-exports.testItemBMSchema = (0, nodejs_lib_1.objectSchema)({
-    k1: nodejs_lib_1.stringSchema,
-    k2: nodejs_lib_1.stringSchema.allow(null).optional(),
-    k3: nodejs_lib_1.numberSchema.optional(),
-    even: nodejs_lib_1.booleanSchema.optional(),
-    b1: nodejs_lib_1.binarySchema.optional(),
-    nested: (0, nodejs_lib_1.objectSchema)({
-        foo: nodejs_lib_1.numberSchema,
+export const TEST_TABLE = 'TEST_TABLE';
+export const testItemBMSchema = objectSchema({
+    k1: stringSchema,
+    k2: stringSchema.allow(null).optional(),
+    k3: numberSchema.optional(),
+    even: booleanSchema.optional(),
+    b1: binarySchema.optional(),
+    nested: objectSchema({
+        foo: numberSchema,
     }).optional(),
-}).concat(nodejs_lib_1.baseDBEntitySchema);
-exports.testItemTMSchema = (0, nodejs_lib_1.objectSchema)({
-    k1: nodejs_lib_1.stringSchema,
-    even: nodejs_lib_1.booleanSchema.optional(),
+}).concat(baseDBEntitySchema);
+export const testItemTMSchema = objectSchema({
+    k1: stringSchema,
+    even: booleanSchema.optional(),
 });
-exports.testItemBMJsonSchema = js_lib_1.jsonSchema
+export const testItemBMJsonSchema = jsonSchema
     .rootObject({
     // todo: figure out how to not copy-paste these 3 fields
-    id: js_lib_1.jsonSchema.string(), // todo: not strictly needed here
-    created: js_lib_1.jsonSchema.unixTimestamp(),
-    updated: js_lib_1.jsonSchema.unixTimestamp(),
-    k1: js_lib_1.jsonSchema.string(),
-    k2: js_lib_1.jsonSchema.oneOf([js_lib_1.jsonSchema.string(), js_lib_1.jsonSchema.null()]).optional(),
-    k3: js_lib_1.jsonSchema.number().optional(),
-    even: js_lib_1.jsonSchema.boolean().optional(),
-    b1: js_lib_1.jsonSchema.buffer().optional(),
+    id: jsonSchema.string(), // todo: not strictly needed here
+    created: jsonSchema.unixTimestamp(),
+    updated: jsonSchema.unixTimestamp(),
+    k1: jsonSchema.string(),
+    k2: jsonSchema.oneOf([jsonSchema.string(), jsonSchema.null()]).optional(),
+    k3: jsonSchema.number().optional(),
+    even: jsonSchema.boolean().optional(),
+    b1: jsonSchema.buffer().optional(),
 })
     .baseDBEntity()
     .build();
-function createTestItemDBM(num = 1) {
+export function createTestItemDBM(num = 1) {
     return {
         id: `id${num}`,
         k1: `v${num}`,
@@ -49,12 +42,12 @@ function createTestItemDBM(num = 1) {
         updated: MOCK_TS_2018_06_21,
     };
 }
-function createTestItemBM(num = 1) {
+export function createTestItemBM(num = 1) {
     return createTestItemDBM(num);
 }
-function createTestItemsDBM(count = 1) {
-    return (0, js_lib_1._range)(1, count + 1).map(num => createTestItemDBM(num));
+export function createTestItemsDBM(count = 1) {
+    return _range(1, count + 1).map(num => createTestItemDBM(num));
 }
-function createTestItemsBM(count = 1) {
-    return (0, js_lib_1._range)(1, count + 1).map(num => createTestItemBM(num));
+export function createTestItemsBM(count = 1) {
+    return _range(1, count + 1).map(num => createTestItemBM(num));
 }

package/dist/testing/timeSeriesTest.util.d.ts

@@ -1,2 +1,2 @@
-import type { TimeSeriesDataPoint } from '../timeseries/timeSeries.model';
+import type { TimeSeriesDataPoint } from '../timeseries/timeSeries.model.js';
 export declare function createTestTimeSeries(count?: number): TimeSeriesDataPoint[];

package/dist/testing/timeSeriesTest.util.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTestTimeSeries = createTestTimeSeries;
-const js_lib_1 = require("@naturalcycles/js-lib");
-function createTestTimeSeries(count = 10) {
+import { _randomInt, _range } from '@naturalcycles/js-lib';
+export function createTestTimeSeries(count = 10) {
     const ts = Date.now();
-    return (0, js_lib_1._range)(1, count + 1).map(i => [ts - i * 60_000, (0, js_lib_1._randomInt)(10, 20)]);
+    return _range(1, count + 1).map(i => [ts - i * 60_000, _randomInt(10, 20)]);
 }

package/dist/timeseries/commonTimeSeriesDao.d.ts

@@ -1,4 +1,4 @@
-import type { CommonTimeSeriesDaoCfg, TimeSeriesDataPoint, TimeSeriesQuery, TimeSeriesSaveBatchOp } from './timeSeries.model';
+import type { CommonTimeSeriesDaoCfg, TimeSeriesDataPoint, TimeSeriesQuery, TimeSeriesSaveBatchOp } from './timeSeries.model.js';
 /**
  * TimeSeries DB implementation based on provided CommonDB database.
  * Turns any CommonDB database into TimeSeries DB. Kind of.