uql-orm 0.47.0 → 0.48.0

package/dist/util/relationQuery.util.d.ts

@@ -35,13 +35,16 @@ export declare function targetKeyColumns(relOpts: Pick<RelationMeta, 'references
 /** `{ joined column: true }`: the projection or grouping that keeps a parent's key on the rows read. */
 export declare function joinedColumns(joins: readonly ParentJoin[]): Record<string, true>;
 /**
- * A parent row keyed by the columns a relation joins *from*, and a child or tally row keyed by the
- * columns it carries that key in. The two halves of matching children to parents: they must agree on
- * every column, so each is read through `joins` rather than through the parent's own key list - which
- * is the same set only for a to-many, and silently a different one otherwise.
+ * One side's columns: `'parent'` for the columns a parent is keyed by, `'joined'` for the ones a
+ * child or tally row carries that key in. Matching the two halves means agreeing on every column, so
+ * each side is read through `joins` rather than through the parent's own key list - the same set only
+ * for a to-many, and silently a different one otherwise. `keyof ParentJoin` is what keeps the two
+ * sides from being spelled apart.
+ *
+ * Lifted out of `joins` once per relation, not once per row: {@link rowKey} takes the list and reads
+ * each row itself, so a page of children costs one key each and nothing else.
  */
-export declare function parentRowKey(joins: readonly ParentJoin[], parent: unknown): string;
-export declare function joinedRowKey(joins: readonly ParentJoin[], row: unknown): string;
+export declare function keyColumns(joins: readonly ParentJoin[], side: keyof ParentJoin): string[];
 /**
  * `{ joined column: every parent's value for it }`, the filter that fetches a whole page of parents'
  * children in one statement.

package/dist/util/relationQuery.util.js

@@ -1,6 +1,5 @@
 import { QUERY_BOOLEAN_CLAUSES, QUERY_NUMBER_CLAUSES, QUERY_OBJECT_CLAUSES, QUERY_ROOT_NUMBER_CLAUSES, } from '../type/query.js';
 import { getKeys, someKey } from './object.util.js';
-import { rowKey } from './rowKey.util.js';
 /**
  * Whether a relation holds many rows per parent, so it cannot be joined into the parent's row. Takes
  * the one field it reads, so it answers for a relation being declared as well as for a resolved one.
@@ -37,19 +36,20 @@ export function targetKeyColumns(relOpts, parentKeyCount) {
 }
 /** `{ joined column: true }`: the projection or grouping that keeps a parent's key on the rows read. */
 export function joinedColumns(joins) {
-    return Object.fromEntries(joins.map(({ joined }) => [joined, true]));
+    return Object.fromEntries(keyColumns(joins, 'joined').map((column) => [column, true]));
 }
 /**
- * A parent row keyed by the columns a relation joins *from*, and a child or tally row keyed by the
- * columns it carries that key in. The two halves of matching children to parents: they must agree on
- * every column, so each is read through `joins` rather than through the parent's own key list - which
- * is the same set only for a to-many, and silently a different one otherwise.
+ * One side's columns: `'parent'` for the columns a parent is keyed by, `'joined'` for the ones a
+ * child or tally row carries that key in. Matching the two halves means agreeing on every column, so
+ * each side is read through `joins` rather than through the parent's own key list - the same set only
+ * for a to-many, and silently a different one otherwise. `keyof ParentJoin` is what keeps the two
+ * sides from being spelled apart.
+ *
+ * Lifted out of `joins` once per relation, not once per row: {@link rowKey} takes the list and reads
+ * each row itself, so a page of children costs one key each and nothing else.
  */
-export function parentRowKey(joins, parent) {
-    return rowKey(joins.map(({ parent: key }) => read(parent, key)));
-}
-export function joinedRowKey(joins, row) {
-    return rowKey(joins.map(({ joined }) => read(row, joined)));
+export function keyColumns(joins, side) {
+    return joins.map((join) => join[side]);
 }
 /**
  * `{ joined column: every parent's value for it }`, the filter that fetches a whole page of parents'

package/dist/util/rowKey.util.d.ts

@@ -1,9 +1,23 @@
 /**
- * A row's key as a string, for matching rows to each other in a `Map`.
+ * A row's key as a string, for matching rows to each other in a {@link dataKeyed} lookup.
+ *
+ * Reads the columns off the row rather than taking their values, because every caller matches a
+ * whole page of rows against one fixed column list: taking an array would make each of them build
+ * one per row, which is what a page of 250 rows paid 56 KB for.
  *
  * Values are normalized before joining, not stringified: `String(date)` is locale- and
  * timezone-dependent, so two equal dates could key apart, and a `Uint8Array` stringifies to its
- * bytes with commas. Every part is included, so two rows agreeing on one column of a composite key
- * are not treated as one row.
+ * bytes with commas. Every column is included, so two rows agreeing on one column of a composite
+ * key are not treated as one row.
+ */
+export declare function rowKey(row: unknown, columns: readonly string[]): string;
+/**
+ * A lookup keyed by data rather than by a name this code chose, so a key that spells `__proto__` or
+ * `constructor` is an ordinary entry instead of the prototype: on `{}` those threw when a bucket was
+ * pushed to, and a `_count` tally under one silently read back as an object. Cheaper than a `Map`
+ * here, and faster than `{}`, which walks the prototype chain on every miss.
+ *
+ * It carries none of `Object.prototype`, which no type can say: index it and spread it, but calling
+ * `hasOwnProperty` on one type-checks and throws.
  */
-export declare function rowKey(values: readonly unknown[]): string;
+export declare function dataKeyed<V>(): Record<string, V>;

package/dist/util/rowKey.util.js

@@ -1,15 +1,39 @@
 /** Separates the parts of a composite key: a unit separator, which no column value carries. */
 const KEY_SEPARATOR = '\u001f';
 /**
- * A row's key as a string, for matching rows to each other in a `Map`.
+ * A row's key as a string, for matching rows to each other in a {@link dataKeyed} lookup.
+ *
+ * Reads the columns off the row rather than taking their values, because every caller matches a
+ * whole page of rows against one fixed column list: taking an array would make each of them build
+ * one per row, which is what a page of 250 rows paid 56 KB for.
  *
  * Values are normalized before joining, not stringified: `String(date)` is locale- and
  * timezone-dependent, so two equal dates could key apart, and a `Uint8Array` stringifies to its
- * bytes with commas. Every part is included, so two rows agreeing on one column of a composite key
- * are not treated as one row.
+ * bytes with commas. Every column is included, so two rows agreeing on one column of a composite
+ * key are not treated as one row.
+ */
+export function rowKey(row, columns) {
+    const values = row;
+    let key = '';
+    for (let i = 0; i < columns.length; i++) {
+        if (i) {
+            key += KEY_SEPARATOR;
+        }
+        key += keyPart(values[columns[i]]);
+    }
+    return key;
+}
+/**
+ * A lookup keyed by data rather than by a name this code chose, so a key that spells `__proto__` or
+ * `constructor` is an ordinary entry instead of the prototype: on `{}` those threw when a bucket was
+ * pushed to, and a `_count` tally under one silently read back as an object. Cheaper than a `Map`
+ * here, and faster than `{}`, which walks the prototype chain on every miss.
+ *
+ * It carries none of `Object.prototype`, which no type can say: index it and spread it, but calling
+ * `hasOwnProperty` on one type-checks and throws.
  */
-export function rowKey(values) {
-    return values.map(keyPart).join(KEY_SEPARATOR);
+export function dataKeyed() {
+    return Object.create(null);
 }
 function keyPart(value) {
     if (value instanceof Date) {

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.47.0",
+  "version": "0.48.0",
   "type": "module",
   "engines": {
     "node": ">=24"