@atscript/db 0.1.146 → 0.1.148

package/dist/relation-loader-ByY1Byrl.mjs

@@ -0,0 +1,370 @@
+import { B as slicePerGroup, F as compositeKey, L as findFKForRelation, N as relationStaticFilter, R as findRemoteFK, T as andFilters, z as resolveRelationTargetTable } from "./nested-writer-CUBoq1ZO.mjs";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/rel/relation-loader.ts
+var relation_loader_exports = /* @__PURE__ */ __exportAll({
+	ensureSelectIncludesFields: () => ensureSelectIncludesFields,
+	loadRelationsImpl: () => loadRelationsImpl
+});
+/**
+* Loads related data for `$with` relations and attaches them to result rows.
+*/
+async function loadRelationsImpl(rows, withRelations, host) {
+	if (rows.length === 0 || withRelations.length === 0) return;
+	if (host.adapter.supportsNativeRelations()) return host.adapter.loadRelations(rows, withRelations, host._meta.relations, host._meta.foreignKeys, host._tableResolver);
+	if (!host._tableResolver) return;
+	const tasks = [];
+	for (const withRel of withRelations) {
+		const relName = withRel.name;
+		if (relName.includes(".")) continue;
+		const relation = host._meta.relations.get(relName);
+		if (!relation) throw new Error(`Unknown relation "${relName}" in $with. Available relations: ${[...host._meta.relations.keys()].join(", ") || "(none)"}`);
+		const targetType = relation.targetType();
+		if (!targetType) continue;
+		const targetTable = host._tableResolver(targetType);
+		if (!targetTable) {
+			host.logger.warn(`Could not resolve table for relation "${relName}" — skipping`);
+			continue;
+		}
+		const statics = relationStaticFilter(relation, relName);
+		const merged = andFilters(statics.target, withRel.filter);
+		const filter = Object.keys(merged).length > 0 ? merged : void 0;
+		const flatRel = withRel;
+		const controls = { ...withRel.controls || {} };
+		if (flatRel.$sort && !controls.$sort) controls.$sort = flatRel.$sort;
+		if (flatRel.$limit !== null && flatRel.$limit !== void 0 && (controls.$limit === null || controls.$limit === void 0)) controls.$limit = flatRel.$limit;
+		if (flatRel.$skip !== null && flatRel.$skip !== void 0 && (controls.$skip === null || controls.$skip === void 0)) controls.$skip = flatRel.$skip;
+		if (flatRel.$select && !controls.$select) controls.$select = flatRel.$select;
+		if (flatRel.$with && !controls.$with) controls.$with = flatRel.$with;
+		const { $skip, $limit, ...pageless } = controls;
+		const skip = asCount($skip) || void 0;
+		const limit = asCount($limit);
+		const relQuery = {
+			filter,
+			controls: pageless,
+			page: skip === void 0 && limit === void 0 ? void 0 : {
+				skip,
+				limit
+			},
+			junctionFilter: statics.junction
+		};
+		if (relation.direction === "to") tasks.push(loadToRelation(rows, {
+			relName,
+			relation,
+			targetTable,
+			relQuery
+		}, host));
+		else if (relation.direction === "via") tasks.push(loadViaRelation(rows, {
+			relName,
+			relation,
+			targetTable,
+			relQuery
+		}, host));
+		else tasks.push(loadFromRelation(rows, {
+			relName,
+			relation,
+			targetTable,
+			relQuery
+		}, host));
+	}
+	await Promise.all(tasks);
+}
+/**
+* Loads a `@db.rel.to` relation (FK is on this table). Single-valued: the
+* relation's `$skip` / `$limit` page each row's (at most one) target row.
+*/
+async function loadToRelation(rows, opts, host) {
+	const { relName, relation, targetTable, relQuery } = opts;
+	const fkEntry = findFKForRelation(relation, host._meta.foreignKeys);
+	if (!fkEntry) return;
+	const { localFields, targetFields } = fkEntry;
+	const index = indexFirst(await readRelatedByKeys(rows, {
+		localFields,
+		targetFields,
+		targetTable,
+		relQuery
+	}), targetFields);
+	for (const row of rows) row[relName] = index.get(compositeKey(localFields, row)) ?? null;
+}
+/**
+* Loads a `@db.rel.from` relation (FK is on the target table). `$sort`,
+* `$skip` and `$limit` apply to the related rows of each row.
+*/
+async function loadFromRelation(rows, opts, host) {
+	const { relName, relation, targetTable, relQuery } = opts;
+	const remoteFK = findRemoteFK(targetTable, host.tableName, relation.alias);
+	if (!remoteFK) {
+		host.logger.warn(`Could not find FK on target table for relation "${relName}"`);
+		return;
+	}
+	const localFields = remoteFK.targetFields;
+	const remoteFields = remoteFK.fields;
+	const related = await readRelatedByKeys(rows, {
+		localFields,
+		targetFields: remoteFields,
+		targetTable,
+		relQuery
+	});
+	if (relation.isArray) {
+		const groups = groupBy(related, (item) => compositeKey(remoteFields, item));
+		for (const row of rows) row[relName] = groups.get(compositeKey(localFields, row)) ?? [];
+	} else {
+		const index = indexFirst(related, remoteFields);
+		for (const row of rows) row[relName] = index.get(compositeKey(localFields, row)) ?? null;
+	}
+}
+/**
+* Loads a `@db.rel.via` relation (M:N through a junction table). The target
+* rows are read once for all rows; `$sort` orders, and `$skip` / `$limit`
+* page, the target rows of each row.
+*/
+async function loadViaRelation(rows, opts, host) {
+	const { relName, relation, targetTable, relQuery } = opts;
+	if (!relation.viaType || !host._tableResolver) return;
+	const junctionType = relation.viaType();
+	if (!junctionType) return;
+	const junctionTable = host._tableResolver(junctionType);
+	if (!junctionTable) {
+		host.logger.warn(`Could not resolve junction table for via relation "${relName}"`);
+		return;
+	}
+	const fkToThis = findRemoteFK(junctionTable, host.tableName);
+	if (!fkToThis) {
+		host.logger.warn(`Could not find FK on junction table pointing to "${host.tableName}" for via relation "${relName}"`);
+		return;
+	}
+	const targetTableName = resolveRelationTargetTable(relation);
+	const fkToTarget = findRemoteFK(junctionTable, targetTableName);
+	if (!fkToTarget) {
+		host.logger.warn(`Could not find FK on junction table pointing to target "${targetTableName}" for via relation "${relName}"`);
+		return;
+	}
+	const localPKFields = fkToThis.targetFields;
+	const fields = {
+		junctionLocalFields: fkToThis.fields,
+		junctionTargetFields: fkToTarget.fields,
+		targetPKFields: fkToTarget.targetFields
+	};
+	const parentFilter = matchAnyFilter(rows, localPKFields, fields.junctionLocalFields);
+	const junctionRows = parentFilter ? await junctionTable.findMany({
+		filter: andFilters(parentFilter, relQuery.junctionFilter),
+		controls: { $select: [...fields.junctionLocalFields, ...fields.junctionTargetFields] }
+	}) : [];
+	const targetFilter = matchAnyFilter(junctionRows, fields.junctionTargetFields, fields.targetPKFields);
+	if (!targetFilter) {
+		for (const row of rows) row[relName] = relation.isArray ? [] : null;
+		return;
+	}
+	const sorted = hasSort(relQuery.controls);
+	let groups = /* @__PURE__ */ new Map();
+	const pick = (targets) => {
+		groups = groupViaTargets(targets, junctionRows, fields, sorted);
+		const page = relQuery.page;
+		if (!page) return targets;
+		const start = page.skip ?? 0;
+		const end = page.limit === void 0 ? void 0 : start + page.limit;
+		const kept = /* @__PURE__ */ new Set();
+		for (const [key, group] of groups) {
+			const slice = group.slice(start, end);
+			groups.set(key, slice);
+			for (const target of slice) kept.add(target);
+		}
+		return targets.filter((target) => kept.has(target));
+	};
+	await readRelated(targetTable, {
+		filter: relQuery.filter ? { $and: [targetFilter, relQuery.filter] } : targetFilter,
+		controls: ensureSelectIncludesFields(relQuery.controls, fields.targetPKFields)
+	}, { pick });
+	for (const row of rows) {
+		const group = groups.get(compositeKey(localPKFields, row));
+		row[relName] = relation.isArray ? group ?? [] : group?.[0] ?? null;
+	}
+}
+/**
+* Each row's targets (keyed by the junction's local key), once per junction
+* row. The junction rows only map rows to targets: with a `$sort` the targets
+* keep the order the target read returned them in, else junction order.
+*/
+function groupViaTargets(targets, junctionRows, fields, sorted) {
+	const groups = /* @__PURE__ */ new Map();
+	if (sorted) {
+		const linksByTarget = groupBy(junctionRows, (jRow) => compositeKey(fields.junctionTargetFields, jRow));
+		for (const target of targets) for (const jRow of linksByTarget.get(compositeKey(fields.targetPKFields, target)) ?? []) appendTo(groups, compositeKey(fields.junctionLocalFields, jRow), target);
+	} else {
+		const index = indexFirst(targets, fields.targetPKFields);
+		for (const jRow of junctionRows) {
+			const target = index.get(compositeKey(fields.junctionTargetFields, jRow));
+			if (target) appendTo(groups, compositeKey(fields.junctionLocalFields, jRow), target);
+		}
+	}
+	return groups;
+}
+/**
+* Reads the target rows whose `targetFields` match `localFields` of any of
+* `rows`, the relation's `$skip` / `$limit` applied per such row.
+*/
+async function readRelatedByKeys(rows, opts) {
+	const { localFields, targetFields, targetTable, relQuery } = opts;
+	const keyFilter = matchAnyFilter(rows, localFields, targetFields);
+	if (!keyFilter) return [];
+	return readRelated(targetTable, {
+		filter: relQuery.filter ? { $and: [keyFilter, relQuery.filter] } : keyFilter,
+		controls: ensureSelectIncludesFields(relQuery.controls, targetFields)
+	}, {
+		partitionBy: targetFields,
+		page: relQuery.page
+	});
+}
+/**
+* Reads related rows. With `partitionBy` and a `page`, the page applies per
+* group of rows sharing the `partitionBy` values; `pick` keeps a subset of
+* the rows before their own (nested) `$with` relations load.
+*/
+async function readRelated(table, query, opts) {
+	const { partitionBy, page, pick } = opts;
+	const partitioned = partitionBy && page;
+	if (table._findManyForRelation) {
+		const controls = partitioned ? {
+			...query.controls,
+			...pageControls(page)
+		} : query.controls;
+		return table._findManyForRelation({
+			filter: query.filter,
+			controls
+		}, {
+			partitionBy: partitioned ? partitionBy : void 0,
+			pick
+		});
+	}
+	let rows = await table.findMany(query);
+	if (partitioned) rows = slicePerGroup(rows, (row) => compositeKey(partitionBy, row), page);
+	return pick ? pick(rows) : rows;
+}
+/** A `$skip` / `$limit` value as a number (`undefined` when unset or not a number). */
+function asCount(value) {
+	if (value === null || value === void 0 || value === "") return;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : void 0;
+}
+/** `$skip` / `$limit` controls of a page (only the ones set). */
+function pageControls(page) {
+	const controls = {};
+	if (page.skip !== void 0) controls.$skip = page.skip;
+	if (page.limit !== void 0) controls.$limit = page.limit;
+	return controls;
+}
+/** Whether `controls` carry a non-empty `$sort`. */
+function hasSort(controls) {
+	const sort = controls.$sort;
+	return !!sort && typeof sort === "object" && Object.keys(sort).length > 0;
+}
+/**
+* A filter matching the rows whose `toFields` equal `fromFields` of any of
+* `rows` — `$in` for a single field, `$or` of conditions for a composite key.
+* `undefined` when no row has every `fromFields` value.
+*/
+function matchAnyFilter(rows, fromFields, toFields) {
+	if (fromFields.length === 1) {
+		const values = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			const v = row[fromFields[0]];
+			if (v !== null && v !== void 0) values.add(v);
+		}
+		return values.size > 0 ? { [toFields[0]]: { $in: [...values] } } : void 0;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const conditions = [];
+	for (const row of rows) {
+		const key = compositeKey(fromFields, row);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const condition = {};
+		let valid = true;
+		for (let i = 0; i < fromFields.length; i++) {
+			const v = row[fromFields[i]];
+			if (v === null || v === void 0) {
+				valid = false;
+				break;
+			}
+			condition[toFields[i]] = v;
+		}
+		if (valid) conditions.push(condition);
+	}
+	if (conditions.length === 0) return;
+	return conditions.length === 1 ? conditions[0] : { $or: conditions };
+}
+/** The first of `items` per `fields` key. */
+function indexFirst(items, fields) {
+	const index = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = compositeKey(fields, item);
+		if (!index.has(key)) index.set(key, item);
+	}
+	return index;
+}
+/** `items` grouped by `keyOf`, each group in the order of `items`. */
+function groupBy(items, keyOf) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) appendTo(groups, keyOf(item), item);
+	return groups;
+}
+function appendTo(groups, key, item) {
+	const group = groups.get(key);
+	if (group) group.push(item);
+	else groups.set(key, [item]);
+}
+/**
+* Ensure the given join fields survive the user's $select on a $with relation
+* read. Without this, the JS-side join would key off undefined and silently
+* return empty relations.
+*
+* - Array $select: append missing FK fields.
+* - Include-mode object $select (any value is 1/true, or empty object): set
+*   missing FK fields to 1.
+* - Exclude-mode object $select: leave alone — FK survives by default. If the
+*   FK is explicitly excluded, throw rather than silently override user intent.
+*/
+function ensureSelectIncludesFields(controls, fields) {
+	if (!controls) return controls;
+	const sel = controls.$select;
+	if (sel === void 0 || sel === null) return controls;
+	if (Array.isArray(sel)) {
+		const augmented = [...sel];
+		for (const f of fields) if (!augmented.includes(f)) augmented.push(f);
+		return {
+			...controls,
+			$select: augmented
+		};
+	}
+	if (typeof sel === "object") {
+		const selObj = sel;
+		const isInclude = Object.keys(selObj).length === 0 || Object.values(selObj).some((v) => v === 1 || v === true);
+		const augmented = { ...selObj };
+		let mutated = false;
+		for (const f of fields) {
+			const v = augmented[f];
+			if (v === 0 || v === false) throw new Error(`Cannot exclude join column "${f}" from $select on $with relation`);
+			if (v === void 0 && isInclude) {
+				augmented[f] = 1;
+				mutated = true;
+			}
+		}
+		return mutated ? {
+			...controls,
+			$select: augmented
+		} : controls;
+	}
+	return controls;
+}
+//#endregion
+export { relation_loader_exports as n, loadRelationsImpl as t };