@naturalcycles/db-lib 10.51.0 → 10.53.0

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');
             }
@@ -653,12 +653,17 @@ export class CommonDao {
     async compress(dbm) {
         if (!this.cfg.compress?.keys.length)
             return; // No compression requested
-        const { keys, level = 1 } = this.cfg.compress;
+        const { keys, level = 1, warnSizeBytes, onOversizeWarning } = this.cfg.compress;
         const properties = _pick(dbm, keys);
         const bufferString = JSON.stringify(properties);
         // Unlike `decompress`, we're testing to use async zstd compression.
         // Async Decompression leaks memory severely. But Compression seems fine.
         const __compressed = await zip2.zstdCompress(bufferString, level);
+        if (warnSizeBytes && onOversizeWarning && __compressed.byteLength > warnSizeBytes) {
+            // Shallow-clone: `dbm` is mutated below (omit source keys + assign __compressed),
+            // so we hand the hook a snapshot of the pre-mutation state.
+            onOversizeWarning({ ...dbm }, __compressed.byteLength);
+        }
         _omitWithUndefined(dbm, _objectKeys(properties), { mutate: true });
         Object.assign(dbm, { __compressed });
     }
@@ -792,7 +797,7 @@ export class CommonDao {
         }
         const idsByTable = {};
         for (const [table, idSet] of _stringMapEntries(idSetByTable)) {
-            idsByTable[table] = [...idSet];
+            idsByTable[table] = Array.from(idSet);
         }
         return idsByTable;
     }

package/dist/commondao/common.dao.model.d.ts

@@ -185,6 +185,22 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
          * Undefined will default to level 1 (not the 3, which is the zstd default)
          */
         level?: Integer;
+        /**
+         * If set, `onOversizeWarning` is invoked whenever the resulting `__compressed`
+         * Buffer exceeds this size in bytes. Useful for monitoring rows approaching
+         * DB row-size limits (e.g. Datastore's 1MB per entity).
+         *
+         * No-op unless `onOversizeWarning` is also provided.
+         */
+        warnSizeBytes?: number;
+        /**
+         * Invoked when the `__compressed` Buffer exceeds `warnSizeBytes`.
+         *
+         * Called with a shallow clone of the DBM (since the original is mutated
+         * later in the compression step) and the resulting compressed size in bytes.
+         * The consumer decides how to surface the warning (Sentry, logger, metrics, etc.).
+         */
+        onOversizeWarning?: (dbm: DBM, size: number) => 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/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) {

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) {

package/package.json

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

package/src/commondao/common.dao.model.ts

@@ -224,6 +224,22 @@ export interface CommonDaoCfg<
      * Undefined will default to level 1 (not the 3, which is the zstd default)
      */
     level?: Integer
+    /**
+     * If set, `onOversizeWarning` is invoked whenever the resulting `__compressed`
+     * Buffer exceeds this size in bytes. Useful for monitoring rows approaching
+     * DB row-size limits (e.g. Datastore's 1MB per entity).
+     *
+     * No-op unless `onOversizeWarning` is also provided.
+     */
+    warnSizeBytes?: number
+    /**
+     * Invoked when the `__compressed` Buffer exceeds `warnSizeBytes`.
+     *
+     * Called with a shallow clone of the DBM (since the original is mutated
+     * later in the compression step) and the resulting compressed size in bytes.
+     * The consumer decides how to surface the warning (Sentry, logger, metrics, etc.).
+     */
+    onOversizeWarning?: (dbm: DBM, size: number) => void
   }
 }
 

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)
       }
@@ -849,12 +849,17 @@ export class CommonDao<
   private async compress(dbm: DBM): Promise<void> {
     if (!this.cfg.compress?.keys.length) return // No compression requested
 
-    const { keys, level = 1 } = this.cfg.compress
+    const { keys, level = 1, warnSizeBytes, onOversizeWarning } = this.cfg.compress
     const properties = _pick(dbm, keys)
     const bufferString = JSON.stringify(properties)
     // Unlike `decompress`, we're testing to use async zstd compression.
     // Async Decompression leaks memory severely. But Compression seems fine.
     const __compressed = await zip2.zstdCompress(bufferString, level)
+    if (warnSizeBytes && onOversizeWarning && __compressed.byteLength > warnSizeBytes) {
+      // Shallow-clone: `dbm` is mutated below (omit source keys + assign __compressed),
+      // so we hand the hook a snapshot of the pre-mutation state.
+      onOversizeWarning({ ...dbm }, __compressed.byteLength)
+    }
     _omitWithUndefined(dbm as any, _objectKeys(properties), { mutate: true })
     Object.assign(dbm, { __compressed })
   }
@@ -1028,7 +1033,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/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)
       })
     }