@atscript/db 0.1.146 → 0.1.147

package/dist/relation-loader-C0qE8xgR.mjs

@@ -0,0 +1,370 @@
+import { I as findFKForRelation, L as findRemoteFK, M as relationStaticFilter, P as compositeKey, R as resolveRelationTargetTable, w as andFilters, z as slicePerGroup } from "./nested-writer-D35UsDBT.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 };

package/dist/shared.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_validation_utils = require("./validation-utils-DOsB4e6G.cjs");
+const require_validation_utils = require("./validation-utils-Da2GjobR.cjs");
 exports.earlierJoinTargets = require_validation_utils.earlierJoinTargets;
 exports.findFKFieldsPointingTo = require_validation_utils.findFKFieldsPointingTo;
 exports.findViewCycle = require_validation_utils.findViewCycle;

package/dist/shared.d.cts

@@ -108,13 +108,14 @@ declare function viewScopeTypes(owner: SemanticNode): string[];
  */
 declare function hasAnyViewAnnotation(node: SemanticNode): boolean;
 /**
- * Validate that all field refs in a query expression are within `scope` —
- * the same {@link TQueryScope} the editor completes (`lsp-scopes`):
+ * Validate that all field refs in a backtick argument (a query, an `expr` or
+ * an `order`) are within `scope` — the same {@link TQueryScope} the editor
+ * completes (`lsp-scopes`):
  * qualified refs must name one of `scope.allowedTypes`; an unqualified ref
  * (a dotted path included) must be a field of `scope.unqualifiedTarget`, or
  * is rejected outright when that is `null`.
  *
- * @param queryToken - The query arg token (must have .queryNode)
+ * @param queryToken - The backtick arg token (with `.queryNode`, `.exprNode` or `.orderNode`)
  * @param scope - The scope of the argument
  * @param doc - The document for type lookups
  * @param scopeHint - Replaces the default "expected 'A' or 'B'" tail of the out-of-scope message

package/dist/shared.d.mts

@@ -108,13 +108,14 @@ declare function viewScopeTypes(owner: SemanticNode): string[];
  */
 declare function hasAnyViewAnnotation(node: SemanticNode): boolean;
 /**
- * Validate that all field refs in a query expression are within `scope` —
- * the same {@link TQueryScope} the editor completes (`lsp-scopes`):
+ * Validate that all field refs in a backtick argument (a query, an `expr` or
+ * an `order`) are within `scope` — the same {@link TQueryScope} the editor
+ * completes (`lsp-scopes`):
  * qualified refs must name one of `scope.allowedTypes`; an unqualified ref
  * (a dotted path included) must be a field of `scope.unqualifiedTarget`, or
  * is rejected outright when that is `null`.
  *
- * @param queryToken - The query arg token (must have .queryNode)
+ * @param queryToken - The backtick arg token (with `.queryNode`, `.exprNode` or `.orderNode`)
  * @param scope - The scope of the argument
  * @param doc - The document for type lookups
  * @param scopeHint - Replaces the default "expected 'A' or 'B'" tail of the out-of-scope message

package/dist/shared.mjs

@@ -1,2 +1,2 @@
-import { S as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as validateExclusiveWith, c as joinTargets, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as primitiveBaseType, x as validateFieldBaseType, y as refActionAnnotation } from "./validation-utils-CMR4fe2M.mjs";
+import { S as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as validateExclusiveWith, c as joinTargets, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as primitiveBaseType, x as validateFieldBaseType, y as refActionAnnotation } from "./validation-utils-Dq0uZ7ef.mjs";
 export { earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, isAliasDecl, isDbSourceDecl, joinTargets, primitiveBaseType, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };

package/dist/sync.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_db_error = require("./db-error-DTkkeu5b.cjs");
-const require_column_diff = require("./column-diff-D_Kyuh0S.cjs");
+const require_column_diff = require("./column-diff-Dt7EDJsA.cjs");
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.
@@ -745,7 +745,7 @@ async function executeSyncTable(facts, safe, deps, exec) {
 					};
 				} else {
 					if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
-						const keysToDrop = [...fkDiff.removed.map((fk) => require_column_diff.fkKey(fk.fields)), ...fkDiff.changed.map((fk) => require_column_diff.fkKey(fk.desired.fields))];
+						const keysToDrop = [...fkDiff.removed.map((fk) => require_column_diff.fkKey(fk.fields)), ...fkDiff.changed.map((fk) => require_column_diff.fkKey(require_column_diff.fkColumns(fk.desired).fields))];
 						if (keysToDrop.length > 0) {
 							await adapter.dropForeignKeys(keysToDrop);
 							droppedFks.push(...keysToDrop);
@@ -1611,7 +1611,7 @@ var SchemaSync = class {
 			const fkDiff = facts.fkDiff;
 			init.status = "alter";
 			init.fkAdded = fkDiff.added.map((fk) => ({
-				fields: fk.fields,
+				fields: require_column_diff.fkColumns(fk).fields,
 				targetTable: fk.targetTable
 			}));
 			init.fkRemoved = fkDiff.removed.map((fk) => ({
@@ -1619,9 +1619,12 @@ var SchemaSync = class {
 				targetTable: fk.targetTable
 			}));
 			init.fkChanged = fkDiff.changed.map((fk) => ({
-				fields: fk.desired.fields,
+				fields: require_column_diff.fkColumns(fk.desired).fields,
 				targetTable: fk.desired.targetTable,
-				details: buildFkChangeDetails(fk.desired, fk.existing)
+				details: buildFkChangeDetails({
+					...fk.desired,
+					targetFields: require_column_diff.fkColumns(fk.desired).targetFields
+				}, fk.existing)
 			}));
 		}
 		if (facts.diff?.primaryKeyChanged) facts.populated = await adapter.hasRows(pendingRename ? dbName : void 0) ?? "unknown";
@@ -1659,7 +1662,7 @@ var SchemaSync = class {
 							addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the referencing table "${child.name}" is renamed in the same run (from "${child.pendingRename}") — rename it in a separate run first, then retarget the foreign key and re-run.`);
 							continue;
 						}
-						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && require_column_diff.fkKey(desired.fields) === require_column_diff.fkKey(fk.fields) && require_column_diff.fkKey(desired.targetFields) === require_column_diff.fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
+						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && require_column_diff.fkKey(require_column_diff.fkColumns(desired).fields) === require_column_diff.fkKey(fk.fields) && require_column_diff.fkKey(require_column_diff.fkColumns(desired).targetFields) === require_column_diff.fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
 					}
 					for (const f of t.readable.fieldDescriptors) if (!f.ignored && !f.isPrimaryKey && f.defaultValue?.kind === "fn" && f.defaultValue.fn === "increment") addRefusal(refusals, t.name, `"${t.name}.${f.physicalName}" is auto-increment but no longer part of the primary key; auto-increment columns must be primary-key columns.`);
 				}
@@ -1674,6 +1677,7 @@ var SchemaSync = class {
 			if (d.viewObjectKinds.get(view.tableName) === "table") addRefusal(refusals, view.tableName, `A physical table "${view.tableName}" exists where managed view "${view.tableName}" is declared — drop or rename it`);
 			const fns = view.dbAdapter.aggregateFns();
 			for (const col of view.getViewColumnMappings()) if (col.aggFn && !fns.has(col.aggFn)) addRefusal(refusals, view.tableName, `View "${view.tableName}" field "${col.viewPath}": aggregate "${col.aggFn}" is not supported by this adapter (aggregateFns())`);
+			for (const problem of view.viewCapabilityProblems()) addRefusal(refusals, view.tableName, problem);
 			for (const source of d.viewSources.get(view.tableName)) if (d.externalTargets.get(source) === false) addRefusal(refusals, view.tableName, `View "${view.tableName}" reads "${source}" which is neither in the sync inventory nor present in the database`);
 		}
 		if (!safe) for (const r of d.removed) {

package/dist/sync.d.cts

@@ -1,5 +1,5 @@
-import { B as TDbFieldMeta, Et as TTableOptionDiff, Ht as DbSpace, V as TDbForeignKey, bt as TPrimaryKeyChange, ct as TEnsureTableOptions, dt as TExistingTableOption, gn as TGenericLogger, ot as TDerivedChangeReason, q as TDbObjectKind, ut as TExistingForeignKey, xt as TReferencingForeignKey } from "./buckets-DYFu0eZ8.cjs";
-import { a as TTableSnapshot, c as TViewSnapshot, d as computeTableHash, f as computeTableSnapshot, h as snapshotToExistingTableOptions, i as TForeignKeySnapshot, l as canonicalizeQueryNode, m as snapshotToExistingColumns, o as TViewColumnSnapshot, p as computeViewSnapshot, r as TFieldSnapshot, s as TViewJoinSnapshot, t as computeColumnDiff, u as computeSchemaHash } from "./column-diff-w-Mym_3w.cjs";
+import { Dt as TTableOptionDiff, Fn as TGenericLogger, Gt as DbSpace, J as TDbObjectKind, St as TReferencingForeignKey, V as TDbFieldMeta, dt as TExistingForeignKey, ft as TExistingTableOption, lt as TEnsureTableOptions, st as TDerivedChangeReason, xt as TPrimaryKeyChange } from "./buckets-CjdPipCC.cjs";
+import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-DLqwVkKG.cjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts
@@ -472,29 +472,6 @@ declare class SchemaSync {
  */
 declare function computeTableOptionDiff(desired: readonly TExistingTableOption[], existing: readonly TExistingTableOption[], destructiveKeys?: ReadonlySet<string>): TTableOptionDiff;
 //#endregion
-//#region src/schema/fk-diff.d.ts
-interface TForeignKeyDiff {
-  /** FKs present in desired but not in stored snapshot (new). */
-  added: TDbForeignKey[];
-  /** FKs present in stored snapshot but not in desired (removed). */
-  removed: TForeignKeySnapshot[];
-  /** FKs where fields match but target, onDelete, or onUpdate differ. */
-  changed: Array<{
-    desired: TDbForeignKey;
-    existing: TForeignKeySnapshot;
-  }>;
-}
-/** Canonical key for an FK: sorted local field names, comma-joined. */
-declare function fkKey(fields: readonly string[]): string;
-/**
- * Compares desired FK constraints against stored snapshot to detect
- * additions, removals, and property changes (target table, target fields,
- * onDelete, onUpdate).
- */
-declare function computeForeignKeyDiff(desired: ReadonlyMap<string, TDbForeignKey>, existingSnapshot: readonly TForeignKeySnapshot[]): TForeignKeyDiff;
-/** Whether the FK diff contains any changes. */
-declare function hasForeignKeyChanges(diff: TForeignKeyDiff): boolean;
-//#endregion
 //#region src/schema/dependency-order.d.ts
 /** A directed edge `from → to`: `from` depends on `to` (child → parent). */
 type TDependencyEdge = readonly [from: string, to: string];

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { B as TDbFieldMeta, Et as TTableOptionDiff, Ht as DbSpace, V as TDbForeignKey, bt as TPrimaryKeyChange, ct as TEnsureTableOptions, dt as TExistingTableOption, gn as TGenericLogger, ot as TDerivedChangeReason, q as TDbObjectKind, ut as TExistingForeignKey, xt as TReferencingForeignKey } from "./buckets-DRycmhOW.mjs";
-import { a as TTableSnapshot, c as TViewSnapshot, d as computeTableHash, f as computeTableSnapshot, h as snapshotToExistingTableOptions, i as TForeignKeySnapshot, l as canonicalizeQueryNode, m as snapshotToExistingColumns, o as TViewColumnSnapshot, p as computeViewSnapshot, r as TFieldSnapshot, s as TViewJoinSnapshot, t as computeColumnDiff, u as computeSchemaHash } from "./column-diff-Q9UmWn5x.mjs";
+import { Dt as TTableOptionDiff, Fn as TGenericLogger, Gt as DbSpace, J as TDbObjectKind, St as TReferencingForeignKey, V as TDbFieldMeta, dt as TExistingForeignKey, ft as TExistingTableOption, lt as TEnsureTableOptions, st as TDerivedChangeReason, xt as TPrimaryKeyChange } from "./buckets-DYopfd2Y.mjs";
+import { _ as computeTableSnapshot, a as hasForeignKeyChanges, b as snapshotToExistingTableOptions, c as TFieldSnapshot, d as TViewColumnSnapshot, f as TViewJoinSnapshot, g as computeTableHash, h as computeSchemaHash, i as fkKey, l as TForeignKeySnapshot, m as canonicalizeQueryNode, n as computeForeignKeyDiff, o as computeColumnDiff, p as TViewSnapshot, t as TForeignKeyDiff, u as TTableSnapshot, v as computeViewSnapshot, y as snapshotToExistingColumns } from "./fk-diff-BtOmL4OW.mjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts
@@ -472,29 +472,6 @@ declare class SchemaSync {
  */
 declare function computeTableOptionDiff(desired: readonly TExistingTableOption[], existing: readonly TExistingTableOption[], destructiveKeys?: ReadonlySet<string>): TTableOptionDiff;
 //#endregion
-//#region src/schema/fk-diff.d.ts
-interface TForeignKeyDiff {
-  /** FKs present in desired but not in stored snapshot (new). */
-  added: TDbForeignKey[];
-  /** FKs present in stored snapshot but not in desired (removed). */
-  removed: TForeignKeySnapshot[];
-  /** FKs where fields match but target, onDelete, or onUpdate differ. */
-  changed: Array<{
-    desired: TDbForeignKey;
-    existing: TForeignKeySnapshot;
-  }>;
-}
-/** Canonical key for an FK: sorted local field names, comma-joined. */
-declare function fkKey(fields: readonly string[]): string;
-/**
- * Compares desired FK constraints against stored snapshot to detect
- * additions, removals, and property changes (target table, target fields,
- * onDelete, onUpdate).
- */
-declare function computeForeignKeyDiff(desired: ReadonlyMap<string, TDbForeignKey>, existingSnapshot: readonly TForeignKeySnapshot[]): TForeignKeyDiff;
-/** Whether the FK diff contains any changes. */
-declare function hasForeignKeyChanges(diff: TForeignKeyDiff): boolean;
-//#endregion
 //#region src/schema/dependency-order.d.ts
 /** A directed edge `from → to`: `from` depends on `to` (child → parent). */
 type TDependencyEdge = readonly [from: string, to: string];

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { r as DbError } from "./db-error-D5uilS_A.mjs";
-import { a as hasForeignKeyChanges, c as computeTableHash, d as snapshotToExistingColumns, f as snapshotToExistingTableOptions, i as fkKey, l as computeTableSnapshot, o as canonicalizeQueryNode, p as viewSnapshotSources, r as computeForeignKeyDiff, s as computeSchemaHash, st as NoopLogger, t as computeColumnDiff, tt as aliasTargetOf, u as computeViewSnapshot } from "./column-diff-e2oHc71_.mjs";
+import { a as computeTableHash, c as snapshotToExistingColumns, d as computeForeignKeyDiff, f as fkColumns, i as computeSchemaHash, l as snapshotToExistingTableOptions, lt as NoopLogger, m as hasForeignKeyChanges, o as computeTableSnapshot, p as fkKey, r as canonicalizeQueryNode, rt as aliasTargetOf, s as computeViewSnapshot, t as computeColumnDiff, u as viewSnapshotSources } from "./column-diff-CO06iQvI.mjs";
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.
@@ -744,7 +744,7 @@ async function executeSyncTable(facts, safe, deps, exec) {
 					};
 				} else {
 					if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
-						const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fk.desired.fields))];
+						const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fkColumns(fk.desired).fields))];
 						if (keysToDrop.length > 0) {
 							await adapter.dropForeignKeys(keysToDrop);
 							droppedFks.push(...keysToDrop);
@@ -1610,7 +1610,7 @@ var SchemaSync = class {
 			const fkDiff = facts.fkDiff;
 			init.status = "alter";
 			init.fkAdded = fkDiff.added.map((fk) => ({
-				fields: fk.fields,
+				fields: fkColumns(fk).fields,
 				targetTable: fk.targetTable
 			}));
 			init.fkRemoved = fkDiff.removed.map((fk) => ({
@@ -1618,9 +1618,12 @@ var SchemaSync = class {
 				targetTable: fk.targetTable
 			}));
 			init.fkChanged = fkDiff.changed.map((fk) => ({
-				fields: fk.desired.fields,
+				fields: fkColumns(fk.desired).fields,
 				targetTable: fk.desired.targetTable,
-				details: buildFkChangeDetails(fk.desired, fk.existing)
+				details: buildFkChangeDetails({
+					...fk.desired,
+					targetFields: fkColumns(fk.desired).targetFields
+				}, fk.existing)
 			}));
 		}
 		if (facts.diff?.primaryKeyChanged) facts.populated = await adapter.hasRows(pendingRename ? dbName : void 0) ?? "unknown";
@@ -1658,7 +1661,7 @@ var SchemaSync = class {
 							addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the referencing table "${child.name}" is renamed in the same run (from "${child.pendingRename}") — rename it in a separate run first, then retarget the foreign key and re-run.`);
 							continue;
 						}
-						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && fkKey(desired.fields) === fkKey(fk.fields) && fkKey(desired.targetFields) === fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
+						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && fkKey(fkColumns(desired).fields) === fkKey(fk.fields) && fkKey(fkColumns(desired).targetFields) === fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
 					}
 					for (const f of t.readable.fieldDescriptors) if (!f.ignored && !f.isPrimaryKey && f.defaultValue?.kind === "fn" && f.defaultValue.fn === "increment") addRefusal(refusals, t.name, `"${t.name}.${f.physicalName}" is auto-increment but no longer part of the primary key; auto-increment columns must be primary-key columns.`);
 				}
@@ -1673,6 +1676,7 @@ var SchemaSync = class {
 			if (d.viewObjectKinds.get(view.tableName) === "table") addRefusal(refusals, view.tableName, `A physical table "${view.tableName}" exists where managed view "${view.tableName}" is declared — drop or rename it`);
 			const fns = view.dbAdapter.aggregateFns();
 			for (const col of view.getViewColumnMappings()) if (col.aggFn && !fns.has(col.aggFn)) addRefusal(refusals, view.tableName, `View "${view.tableName}" field "${col.viewPath}": aggregate "${col.aggFn}" is not supported by this adapter (aggregateFns())`);
+			for (const problem of view.viewCapabilityProblems()) addRefusal(refusals, view.tableName, problem);
 			for (const source of d.viewSources.get(view.tableName)) if (d.externalTargets.get(source) === false) addRefusal(refusals, view.tableName, `View "${view.tableName}" reads "${source}" which is neither in the sync inventory nor present in the database`);
 		}
 		if (!safe) for (const r of d.removed) {