@naturalcycles/db-lib 10.50.0 → 10.52.0

package/dist/adapter/file/localFile.persistence.plugin.js

@@ -28,7 +28,7 @@ export class LocalFilePersistencePlugin {
         return await Pipeline.fromNDJsonFile(filePath).toArray();
     }
     async saveFiles(ops) {
-        await pMap(ops, async op => await this.saveFile(op.table, op.rows), { concurrency: 32 });
+        await pMap(ops, async (op) => await this.saveFile(op.table, op.rows), { concurrency: 32 });
     }
     async saveFile(table, rows) {
         await fs2.ensureDirAsync(this.cfg.storagePath);

package/dist/cnst.js

@@ -1,5 +1,4 @@
-export { DBLibError };
-var DBLibError;
+export var DBLibError;
 (function (DBLibError) {
     DBLibError["DB_ROW_REQUIRED"] = "DB_ROW_REQUIRED";
     DBLibError["DAO_IS_READ_ONLY"] = "DAO_IS_READ_ONLY";

package/dist/commondao/common.dao.js

@@ -51,7 +51,7 @@ export class CommonDao {
         // then we need to ensure that the '__compressed' property is part of the index exclusion list.
         if (this.cfg.compress?.keys) {
             const current = this.cfg.excludeFromIndexes;
-            this.cfg.excludeFromIndexes = current ? [...current] : [];
+            this.cfg.excludeFromIndexes = current ? current.slice() : [];
             if (!this.cfg.excludeFromIndexes.includes('__compressed')) {
                 this.cfg.excludeFromIndexes.push('__compressed');
             }
@@ -140,7 +140,7 @@ export class CommonDao {
      * Order is not guaranteed, as queries run in parallel.
      */
     async runUnionQueries(queries, opt) {
-        const results = (await pMap(queries, async q => (await this.runQueryExtended(q, opt)).rows)).flat();
+        const results = (await pMap(queries, async (q) => (await this.runQueryExtended(q, opt)).rows)).flat();
         return _uniqBy(results, r => r.id);
     }
     async runQueryExtended(q, opt = {}) {
@@ -274,7 +274,7 @@ export class CommonDao {
      * Like patchById, but runs all operations within a Transaction.
      */
     async patchByIdInTransaction(id, patch, opt) {
-        return await this.runInTransaction(async daoTx => {
+        return await this.runInTransaction(async (daoTx) => {
             return await this.patchById(id, patch, { ...opt, tx: daoTx.tx });
         });
     }
@@ -326,7 +326,7 @@ export class CommonDao {
      * Like patch, but runs all operations within a Transaction.
      */
     async patchInTransaction(bm, patch, opt) {
-        return await this.runInTransaction(async daoTx => {
+        return await this.runInTransaction(async (daoTx) => {
             return await this.patch(bm, patch, { ...opt, tx: daoTx.tx });
         });
     }
@@ -447,14 +447,14 @@ export class CommonDao {
         const { beforeSave } = this.cfg.hooks;
         const { chunkSize = 500, chunkConcurrency = 32, errorMode } = opt;
         await p
-            .map(async bm => {
+            .map(async (bm) => {
             this.assignIdCreatedUpdated(bm, opt);
             const dbm = this.bmToDBM(bm, opt);
             beforeSave?.(dbm);
             return await this.dbmToStorageRow(dbm);
         }, { errorMode })
             .chunk(chunkSize)
-            .map(async batch => {
+            .map(async (batch) => {
             await this.cfg.db.saveBatch(table, batch, saveOptions);
             return batch;
         }, {
@@ -501,7 +501,7 @@ export class CommonDao {
                 .streamQuery(q.select(['id']), opt)
                 .mapSync(r => r.id)
                 .chunk(chunkSize)
-                .map(async ids => {
+                .map(async (ids) => {
                 await this.cfg.db.deleteByIds(q.table, ids, opt);
                 deleted += ids.length;
             }, {
@@ -613,7 +613,7 @@ export class CommonDao {
     async dbmsToStorageRows(dbms) {
         if (!this.cfg.compress?.keys.length)
             return dbms;
-        return await pMap(dbms, async dbm => {
+        return await pMap(dbms, async (dbm) => {
             const row = { ...dbm };
             await this.compress(row);
             return row;
@@ -792,7 +792,7 @@ export class CommonDao {
         }
         const idsByTable = {};
         for (const [table, idSet] of _stringMapEntries(idSetByTable)) {
-            idsByTable[table] = [...idSet];
+            idsByTable[table] = Array.from(idSet);
         }
         return idsByTable;
     }
@@ -862,7 +862,7 @@ export class CommonDao {
             return;
         const { db } = inputs[0].dao.cfg;
         const dbmsByTable = {};
-        await pMap(inputs, async input => {
+        await pMap(inputs, async (input) => {
             const { dao } = input;
             const { table } = dao.cfg;
             dbmsByTable[table] ||= [];
@@ -904,7 +904,7 @@ export class CommonDao {
     }
     async runInTransaction(fn, opt) {
         let r;
-        await this.cfg.db.runInTransaction(async tx => {
+        await this.cfg.db.runInTransaction(async (tx) => {
             const daoTx = new CommonDaoTransaction(tx, this.cfg.logger);
             try {
                 r = await fn(daoTx);

package/dist/commondao/common.dao.model.js

@@ -1,5 +1,4 @@
-export { CommonDaoLogLevel };
-var CommonDaoLogLevel;
+export var CommonDaoLogLevel;
 (function (CommonDaoLogLevel) {
     /**
      * Same as undefined

package/dist/commondb/common.db.js

@@ -1,5 +1,4 @@
-export { CommonDBType };
-var CommonDBType;
+export var CommonDBType;
 (function (CommonDBType) {
     CommonDBType["document"] = "document";
     CommonDBType["relational"] = "relational";

package/dist/db.model.js

@@ -1,11 +1,9 @@
-export { DBRelation };
-var DBRelation;
+export var DBRelation;
 (function (DBRelation) {
     DBRelation["ONE_TO_ONE"] = "ONE_TO_ONE";
     DBRelation["ONE_TO_MANY"] = "ONE_TO_MANY";
 })(DBRelation || (DBRelation = {}));
-export { DBModelType };
-var DBModelType;
+export var DBModelType;
 (function (DBModelType) {
     DBModelType["DBM"] = "DBM";
     DBModelType["BM"] = "BM";

package/dist/inmemory/inMemoryKeyValueDB.d.ts

@@ -8,8 +8,8 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     cfg: InMemoryKeyValueDBCfg;
     constructor(cfg?: InMemoryKeyValueDBCfg);
     support: {
-        count?: boolean | undefined;
-        increment?: boolean | undefined;
+        count?: boolean;
+        increment?: boolean;
     };
     data: StringMap<StringMap<any>>;
     ping(): Promise<void>;

package/dist/inmemory/queryInMemory.js

@@ -1,3 +1,4 @@
+import { comparators } from '@naturalcycles/js-lib/array';
 import { _get, _pick } from '@naturalcycles/js-lib/object/object.util.js';
 const FILTER_FNS = {
     '==': (v, val) => v === val,
@@ -30,15 +31,7 @@ export function queryInMemory(q, rows = []) {
     const [order] = q._orders;
     if (order) {
         const { name, descending } = order;
-        rows = rows.sort((a, b) => {
-            // oxlint-disable-next-line eqeqeq
-            if (a[name] == b[name])
-                return 0;
-            if (descending) {
-                return a[name] < b[name] ? 1 : -1;
-            }
-            return a[name] > b[name] ? 1 : -1;
-        });
+        rows = rows.sort(comparators.by(r => r[name], { dir: descending ? 'desc' : 'asc' }));
     }
     // .offset()
     if (q._offsetValue) {

package/dist/kv/index.d.ts

@@ -1,4 +1,4 @@
 export * from './commonKeyValueDao.js';
 export * from './commonKeyValueDaoMemoCache.js';
 export * from './commonKeyValueDB.js';
-export * from './commonSyncKeyValueDB.js';
+export type * from './commonSyncKeyValueDB.js';

package/dist/kv/index.js

@@ -1,4 +1,3 @@
 export * from './commonKeyValueDao.js';
 export * from './commonKeyValueDaoMemoCache.js';
 export * from './commonKeyValueDB.js';
-export * from './commonSyncKeyValueDB.js';

package/dist/pipeline/dbPipelineBackup.js

@@ -23,7 +23,7 @@ export async function dbPipelineBackup(opt) {
     tables ||= await db.getTables();
     console.log(`${yellow(tables.length)} ${boldWhite('table(s)')}:\n` + tables.join('\n'));
     const statsPerTable = {};
-    await pMap(tables, async table => {
+    await pMap(tables, async (table) => {
         let q = DBQuery.create(table).limit(limit);
         const sinceUpdated = opt.sinceUpdatedPerTable?.[table] ?? opt.sinceUpdated;
         if (sinceUpdated) {

package/dist/pipeline/dbPipelineCopy.js

@@ -19,7 +19,7 @@ export async function dbPipelineCopy(opt) {
     tables ||= await dbInput.getTables();
     console.log(`${yellow(tables.length)} ${boldWhite('table(s)')}:\n` + tables.join('\n'));
     const statsPerTable = {};
-    await pMap(tables, async table => {
+    await pMap(tables, async (table) => {
         let q = DBQuery.create(table).limit(limit);
         if (sinceUpdated) {
             q = q.filter('updated', '>=', sinceUpdated);
@@ -43,7 +43,7 @@ export async function dbPipelineCopy(opt) {
             .flattenIfNeeded()
             .tapSync(() => rows++)
             .chunk(chunkSize)
-            .forEach(async dbms => {
+            .forEach(async (dbms) => {
             await dbOutput.saveBatch(table, dbms, saveOptions);
         });
         const stats = NDJsonStats.create({

package/dist/pipeline/dbPipelineRestore.js

@@ -48,7 +48,7 @@ export async function dbPipelineRestore(opt) {
     console.log(`${yellow(tables.length)} ${boldWhite('table(s)')}:\n`, sizeStrByTable);
     // const schemaByTable: Record<string, CommonSchema> = {}
     if (recreateTables) {
-        await pMap(tables, async table => {
+        await pMap(tables, async (table) => {
             const schemaFilePath = `${inputDirPath}/${table}.schema.json`;
             if (!fs2.pathExists(schemaFilePath)) {
                 console.warn(`${schemaFilePath} does not exist!`);
@@ -58,7 +58,7 @@ export async function dbPipelineRestore(opt) {
             await db.createTable(table, schema, { dropIfExists: true });
         });
     }
-    await pMap(tables, async table => {
+    await pMap(tables, async (table) => {
         const zst = tablesToCompress.has(table);
         const filePath = `${inputDirPath}/${table}.ndjson` + (zst ? '.zst' : '');
         const saveOptions = saveOptionsPerTable[table] || {};
@@ -82,7 +82,7 @@ export async function dbPipelineRestore(opt) {
         })
             .flattenIfNeeded()
             .chunk(chunkSize)
-            .forEach(async dbms => {
+            .forEach(async (dbms) => {
             await db.saveBatch(table, dbms, saveOptions);
         });
         const stats = NDJsonStats.create({

package/dist/query/dbQuery.js

@@ -101,12 +101,12 @@ export class DBQuery {
     }
     clone() {
         return _objectAssign(new DBQuery(this.table), {
-            _filters: [...this._filters],
+            _filters: this._filters.slice(),
             _limitValue: this._limitValue,
             _offsetValue: this._offsetValue,
-            _orders: [...this._orders],
-            _selectedFieldNames: this._selectedFieldNames && [...this._selectedFieldNames],
-            _groupByFieldNames: this._groupByFieldNames && [...this._groupByFieldNames],
+            _orders: this._orders.slice(),
+            _selectedFieldNames: this._selectedFieldNames?.slice(),
+            _groupByFieldNames: this._groupByFieldNames?.slice(),
             _distinct: this._distinct,
             _startCursor: this._startCursor,
             _endCursor: this._endCursor,

package/dist/testing/commonDBTest.js

@@ -130,7 +130,7 @@ export async function runCommonDBTest(db, quirks = {}) {
             test('query order by k1 desc', async () => {
                 const q = new DBQuery(TEST_TABLE).order('k1', true);
                 const { rows } = await db.runQuery(q);
-                expectMatch([...items].reverse(), rows, quirks);
+                expectMatch(items.toReversed(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
@@ -169,7 +169,7 @@ export async function runCommonDBTest(db, quirks = {}) {
         const tables = await db.getTables();
         // console.log({ tables })
         if (support.tableSchemas) {
-            await pMap(tables, async table => {
+            await pMap(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
                 // console.log(schema)
                 expect(schema.$id).toBe(`${table}.schema.json`);
@@ -227,7 +227,7 @@ export async function runCommonDBTest(db, quirks = {}) {
             // save item3 with k1: k1_mod
             // delete item2
             // remaining: item1, item3_with_k1_mod
-            await db.runInTransaction(async tx => {
+            await db.runInTransaction(async (tx) => {
                 await tx.saveBatch(TEST_TABLE, items);
                 await tx.saveBatch(TEST_TABLE, [{ ...items[2], k1: 'k1_mod' }]);
                 await tx.deleteByIds(TEST_TABLE, [items[1].id]);
@@ -252,7 +252,7 @@ export async function runCommonDBTest(db, quirks = {}) {
             const expected = await prepare();
             let err;
             try {
-                await db.runInTransaction(async tx => {
+                await db.runInTransaction(async (tx) => {
                     await tx.deleteByIds(TEST_TABLE, [items[2].id]);
                     // It should fail on id == null
                     await tx.saveBatch(TEST_TABLE, [{ ...items[0], k1: 5, id: null }]);

package/dist/testing/commonDaoTest.js

@@ -160,7 +160,7 @@ export async function runCommonDaoTest(db, quirks = {}) {
         if (support.dbQueryOrder) {
             test('query order by k1 desc', async () => {
                 const rows = await dao.query().order('k1', true).runQuery();
-                expectMatch([...expectedItems].reverse(), rows, quirks);
+                expectMatch(expectedItems.toReversed(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
@@ -242,7 +242,7 @@ export async function runCommonDaoTest(db, quirks = {}) {
             await dao.query().deleteByQuery();
             // Test that id, created, updated are created
             const now = localTime.nowUnix();
-            await dao.runInTransaction(async tx => {
+            await dao.runInTransaction(async (tx) => {
                 const row = _omit(item1, ['id', 'created', 'updated']);
                 await tx.save(dao, row);
             });
@@ -251,14 +251,14 @@ export async function runCommonDaoTest(db, quirks = {}) {
             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 dao.runInTransaction(async (tx) => {
                 await tx.deleteById(dao, loaded[0].id);
             });
             // saveBatch [item1, 2, 3]
             // save item3 with k1: k1_mod
             // delete item2
             // remaining: item1, item3_with_k1_mod
-            await dao.runInTransaction(async tx => {
+            await dao.runInTransaction(async (tx) => {
                 await tx.saveBatch(dao, items);
                 await tx.save(dao, { ...items[2], k1: 'k1_mod' });
                 await tx.deleteById(dao, items[1].id);
@@ -303,7 +303,7 @@ export async function runCommonDaoTest(db, quirks = {}) {
             const expected = await prepare();
             let err;
             try {
-                await dao.runInTransaction(async tx => {
+                await dao.runInTransaction(async (tx) => {
                     await tx.deleteById(dao, items[2].id);
                     await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
                 });

package/dist/timeseries/commonTimeSeriesDao.js

@@ -40,7 +40,7 @@ export class CommonTimeSeriesDao {
     async commitTransaction(ops) {
         if (!ops.length)
             return;
-        await this.cfg.db.runInTransaction(async tx => {
+        await this.cfg.db.runInTransaction(async (tx) => {
             for (const op of ops) {
                 const rows = op.dataPoints.map(([ts, v]) => ({
                     id: String(ts), // Convert Number id into String id, as per CommonDB

package/dist/validation/index.d.ts

@@ -1,3 +1,5 @@
+import type { ObjectWithId } from '@naturalcycles/js-lib/types';
+import { JBuilder } from '@naturalcycles/nodejs-lib/ajv';
 import type { CommonDBOptions } from '../db.model.js';
 export declare const commonDBOptionsSchema: () => JBuilder<CommonDBOptions, false>;
 export declare const commonDBSaveOptionsSchema: <ROW extends ObjectWithId>() => any;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.50.0",
+  "version": "10.52.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"
   },
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260301.1",
-    "@naturalcycles/dev-lib": "18.4.2"
+    "@typescript/native-preview": "beta",
+    "@naturalcycles/dev-lib": "20.48.0"
   },
   "files": [
     "dist",

package/src/commondao/common.dao.ts

@@ -95,7 +95,7 @@ export class CommonDao<
     // then we need to ensure that the '__compressed' property is part of the index exclusion list.
     if (this.cfg.compress?.keys) {
       const current = this.cfg.excludeFromIndexes
-      this.cfg.excludeFromIndexes = current ? [...current] : []
+      this.cfg.excludeFromIndexes = current ? current.slice() : []
       if (!this.cfg.excludeFromIndexes.includes('__compressed' as any)) {
         this.cfg.excludeFromIndexes.push('__compressed' as any)
       }
@@ -1028,7 +1028,7 @@ export class CommonDao<
 
     const idsByTable: StringMap<string[]> = {}
     for (const [table, idSet] of _stringMapEntries(idSetByTable)) {
-      idsByTable[table] = [...idSet]
+      idsByTable[table] = Array.from(idSet)
     }
     return idsByTable
   }

package/src/inmemory/queryInMemory.ts

@@ -1,3 +1,4 @@
+import { comparators } from '@naturalcycles/js-lib/array'
 import { _get, _pick } from '@naturalcycles/js-lib/object/object.util.js'
 import type { ObjectWithId } from '@naturalcycles/js-lib/types'
 import type { DBQuery, DBQueryFilterOperator } from '../query/dbQuery.js'
@@ -38,15 +39,9 @@ export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: R
   const [order] = q._orders
   if (order) {
     const { name, descending } = order
-    rows = rows.sort((a, b) => {
-      // oxlint-disable-next-line eqeqeq
-      if (a[name] == b[name]) return 0
-
-      if (descending) {
-        return a[name] < b[name] ? 1 : -1
-      }
-      return a[name] > b[name] ? 1 : -1
-    })
+    rows = rows.sort(
+      comparators.by(r => r[name] as string | number, { dir: descending ? 'desc' : 'asc' }),
+    )
   }
 
   // .offset()

package/src/kv/index.ts

@@ -1,4 +1,4 @@
 export * from './commonKeyValueDao.js'
 export * from './commonKeyValueDaoMemoCache.js'
 export * from './commonKeyValueDB.js'
-export * from './commonSyncKeyValueDB.js'
+export type * from './commonSyncKeyValueDB.js'

package/src/query/dbQuery.ts

@@ -171,12 +171,12 @@ export class DBQuery<ROW extends ObjectWithId> {
 
   clone(): DBQuery<ROW> {
     return _objectAssign(new DBQuery<ROW>(this.table), {
-      _filters: [...this._filters],
+      _filters: this._filters.slice(),
       _limitValue: this._limitValue,
       _offsetValue: this._offsetValue,
-      _orders: [...this._orders],
-      _selectedFieldNames: this._selectedFieldNames && [...this._selectedFieldNames],
-      _groupByFieldNames: this._groupByFieldNames && [...this._groupByFieldNames],
+      _orders: this._orders.slice(),
+      _selectedFieldNames: this._selectedFieldNames?.slice(),
+      _groupByFieldNames: this._groupByFieldNames?.slice(),
       _distinct: this._distinct,
       _startCursor: this._startCursor,
       _endCursor: this._endCursor,

package/src/testing/commonDBTest.ts

@@ -192,7 +192,7 @@ export async function runCommonDBTest(
       test('query order by k1 desc', async () => {
         const q = new DBQuery<TestItemDBM>(TEST_TABLE).order('k1', true)
         const { rows } = await db.runQuery(q)
-        expectMatch([...items].reverse(), rows, quirks)
+        expectMatch(items.toReversed(), rows, quirks)
       })
     }
 

package/src/testing/commonDaoTest.ts

@@ -213,7 +213,7 @@ export async function runCommonDaoTest(
     if (support.dbQueryOrder) {
       test('query order by k1 desc', async () => {
         const rows = await dao.query().order('k1', true).runQuery()
-        expectMatch([...expectedItems].reverse(), rows, quirks)
+        expectMatch(expectedItems.toReversed(), rows, quirks)
       })
     }