uql-orm 0.56.0 → 0.57.0

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, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/querier/relationCount.d.ts

@@ -1,16 +0,0 @@
-import type { Querier, Query, QueryCount, Type } from '../type/index.js';
-/** What counting asks of a querier, rather than the whole interface: two reads, both batched. */
-type CountingQuerier = Pick<Querier, 'aggregate' | 'findMany'>;
-/**
- * A `$count` groups its tallies by the parent's id, so the id has to outlive the projection - the
- * same reason populating a relation keeps it. A whitelisting `$select` gains the key and an
- * `$exclude` loses it; the raw-array `$select` form has nothing to augment, so it is refused.
- */
-export declare function withIdForCounts<E extends object>(entity: Type<E>, q: Query<E>): Query<E>;
-/**
- * How many rows each counted relation holds, under `_count` on every parent. One grouped aggregate
- * per relation over every parent at once - the batching a populated to-many already gets - so the
- * cost stays flat in the number of rows the read returned rather than one statement per row.
- */
-export declare function fillRelationCounts<E>(querier: CountingQuerier, entity: Type<E>, payload: E[], count?: QueryCount<E>): Promise<void>;
-export {};

package/dist/querier/relationCount.js

@@ -1,121 +0,0 @@
-import { COUNT_ALIAS } from '../dialect/aliases.js';
-import { getMeta, soleIdOf } from '../entity/index.js';
-import { COUNT_RESULT_KEY } from '../type/index.js';
-import { asSelectMap, dataKeyed, getKeys, joinedColumns, keyColumns, parentJoins, parentsIn, rowKey, targetKeyColumns, } from '../util/index.js';
-/**
- * A `$count` groups its tallies by the parent's id, so the id has to outlive the projection - the
- * same reason populating a relation keeps it. A whitelisting `$select` gains the key and an
- * `$exclude` loses it; the raw-array `$select` form has nothing to augment, so it is refused.
- */
-export function withIdForCounts(entity, q) {
-    const meta = getMeta(entity);
-    if (!q.$count) {
-        return q;
-    }
-    const { ids } = meta;
-    const named = ids.join(', ');
-    if (q.$distinct) {
-        // The keys would have to join the projection for the tallies to group by, and that is the set
-        // `$distinct` collapses on: adding them silently stops the grouping collapsing anything at all.
-        throw new TypeError(`$count cannot be combined with $distinct: the tallies group by each row's '${named}', which the grouping does not keep.`);
-    }
-    if (Array.isArray(q.$select)) {
-        // Nothing to add the keys to, and without them every tally would be looked up by `undefined` and
-        // come back zero. Refused rather than answered wrong, the way an unorderable clause is.
-        throw new TypeError(`$count needs the '${named}' of each row to group its tallies by, which a raw $select cannot carry. Use a $select map, or drop the $count.`);
-    }
-    const next = { ...q };
-    const select = asSelectMap(q.$select);
-    const missing = select ? ids.filter((key) => !select[key]) : [];
-    if (missing.length) {
-        next.$select = { ...select, ...Object.fromEntries(missing.map((key) => [key, true])) };
-    }
-    const excluded = ids.filter((key) => q.$exclude?.[key]);
-    if (excluded.length) {
-        const kept = { ...q.$exclude };
-        for (const key of excluded) {
-            delete kept[key];
-        }
-        next.$exclude = kept;
-    }
-    return next;
-}
-/**
- * How many rows each counted relation holds, under `_count` on every parent. One grouped aggregate
- * per relation over every parent at once - the batching a populated to-many already gets - so the
- * cost stays flat in the number of rows the read returned rather than one statement per row.
- */
-export async function fillRelationCounts(querier, entity, payload, count) {
-    if (!payload.length || !count) {
-        return;
-    }
-    const meta = getMeta(entity);
-    // The tallies come back keyed by the columns *this relation* joins from, so those columns are kept
-    // beside them: reading the parent through `meta.ids` instead matches only where the two coincide,
-    // which is a to-many and nothing else.
-    const counted = new Map();
-    for (const relKey of getKeys(count)) {
-        const value = count[relKey];
-        const relOpts = meta.relations[relKey];
-        if (!value || !relOpts) {
-            continue;
-        }
-        const where = typeof value === 'object' ? value.$where : undefined;
-        const joins = parentJoins(relOpts, meta.ids.length);
-        counted.set(relKey, {
-            parentKeys: keyColumns(joins, 'parent'),
-            byParent: await countPerParent(querier, relOpts, joins, payload, where),
-        });
-    }
-    for (const parent of payload) {
-        // A plain object, unlike the tallies below: this one is keyed by relation names the entity
-        // declares, not by data, and it is handed to the caller - who would meet a null prototype.
-        const row = {};
-        for (const [relKey, { parentKeys, byParent }] of counted) {
-            // A parent the grouped result has no row for matched nothing, which is a zero rather than a
-            // gap: `_count` names what the caller asked to count, so every key it asked for is present.
-            row[relKey] = byParent[rowKey(parent, parentKeys)] ?? 0;
-        }
-        parent[COUNT_RESULT_KEY] = row;
-    }
-}
-async function countPerParent(querier, relOpts, joins, parents, where) {
-    const through = relOpts.through;
-    if (through) {
-        return countThroughPerParent(querier, relOpts, through(), joins, parents, where);
-    }
-    return groupedCount(querier, relOpts.entity(), joins, {
-        ...where,
-        ...parentsIn(joins, parents),
-    });
-}
-/**
- * A many-to-many counts its junction rows, one per pairing. A filter names the target's columns,
- * which the junction does not have, so the matching targets are resolved first and the junction
- * counted against them - the one shape here that costs a second statement, and only when filtered.
- */
-async function countThroughPerParent(querier, relOpts, throughEntity, joins, parents, where) {
-    const throughWhere = parentsIn(joins, parents);
-    if (where) {
-        const target = relOpts.entity();
-        const targetId = soleIdOf(getMeta(target), 'a many-to-many target');
-        const targets = await querier.findMany(target, { $select: { [targetId]: true }, $where: where });
-        const [targetColumn] = targetKeyColumns(relOpts, joins.length);
-        throughWhere[targetColumn] = targets.map((it) => it[targetId]);
-    }
-    return groupedCount(querier, throughEntity, joins, throughWhere);
-}
-/** `SELECT <keys>, COUNT(*) ... GROUP BY <keys>`, as a lookup from parent key to tally. */
-async function groupedCount(querier, entity, joins, where) {
-    const $agg = { [COUNT_ALIAS]: { $count: '*' } };
-    const $group = joinedColumns(joins);
-    const rows = await querier.aggregate(entity, { $group, $agg, $where: where });
-    const byParent = dataKeyed();
-    // Keyed by every joined column, which is how a tally finds the one parent whose whole key it
-    // matches - and how the rows an over-selecting `IN` brought back find no parent at all.
-    const joinedKeys = keyColumns(joins, 'joined');
-    for (const row of rows) {
-        byParent[rowKey(row, joinedKeys)] = Number(row[COUNT_ALIAS]);
-    }
-    return byParent;
-}