appflare 0.2.29 → 0.2.31

package/cli/schema-compiler.ts

@@ -1,1183 +1,1183 @@
-import { mkdir } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import type {
-	ColumnDefinition,
-	ColumnType,
-	ManyRelationDefinition,
-	ManyToManyRelationDefinition,
-	OneRelationDefinition,
-	SchemaDefinition,
-	TableDefinition,
-} from "../schema";
-import { isSchemaDefinition } from "../schema";
-import type { LoadedAppflareConfig } from "./types";
-
-export type CompiledSchemaArtifacts = {
-	schemaPath: string;
-	typesPath: string;
-	zodPath: string;
-	tableNames: string[];
-};
-
-function toSnakeCase(value: string): string {
-	return value
-		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-		.replace(/[\s-]+/g, "_")
-		.toLowerCase();
-}
-
-function toPascalCase(value: string): string {
-	return value
-		.replace(/[_-]+/g, " ")
-		.replace(/\s+(.)/g, (_match, char: string) => char.toUpperCase())
-		.replace(/\s/g, "")
-		.replace(/^(.)/, (_match, char: string) => char.toUpperCase());
-}
-
-function singularize(value: string): string {
-	if (value.endsWith("ies")) {
-		return `${value.slice(0, -3)}y`;
-	}
-	if (value.endsWith("ses")) {
-		return value.slice(0, -2);
-	}
-	if (value.endsWith("s") && value.length > 1) {
-		return value.slice(0, -1);
-	}
-	return value;
-}
-
-function quote(value: string): string {
-	return JSON.stringify(value);
-}
-
-function toSqlLiteral(value: unknown): string {
-	if (typeof value === "string") {
-		return quote(value);
-	}
-	if (typeof value === "number" || typeof value === "boolean") {
-		return String(value);
-	}
-	if (value === null) {
-		return "null";
-	}
-	if (value instanceof Date) {
-		return quote(value.toISOString());
-	}
-	throw new Error(
-		`Unsupported SQL default value '${String(value)}'. Use string, number, boolean, null, or Date.`,
-	);
-}
-
-function cloneSchemaDefinition(definition: SchemaDefinition): SchemaDefinition {
-	return {
-		kind: "schema",
-		tables: Object.fromEntries(
-			Object.entries(definition.tables).map(([tableName, table]) => {
-				return [
-					tableName,
-					{
-						kind: "table",
-						sqlName: table.sqlName,
-						columns: Object.fromEntries(
-							Object.entries(table.columns).map(([columnName, column]) => {
-								return [columnName, { ...column }];
-							}),
-						),
-						relations: Object.fromEntries(
-							Object.entries(table.relations).map(
-								([relationName, relation]) => {
-									return [relationName, { ...relation }];
-								},
-							),
-						),
-					} satisfies TableDefinition,
-				];
-			}),
-		),
-	};
-}
-
-function getLocalReferenceType(
-	definition: SchemaDefinition,
-	targetTable: string,
-	referenceField: string,
-): ColumnType | undefined {
-	const table = definition.tables[targetTable];
-	if (!table) {
-		return undefined;
-	}
-	const targetColumn = table.columns[referenceField];
-	return targetColumn?.type;
-}
-
-function ensureInferredReferenceColumn(
-	tableName: string,
-	table: TableDefinition,
-	columnName: string,
-	referenceTable: string,
-	referenceField: string,
-	options: {
-		fkType?: ColumnType;
-		sqlName?: string;
-		notNull?: boolean;
-		onDelete?: OneRelationDefinition["onDelete"];
-		onUpdate?: OneRelationDefinition["onUpdate"];
-	},
-	inferredType: ColumnType,
-): void {
-	const existing = table.columns[columnName];
-	if (existing) {
-		if (
-			existing.references &&
-			(existing.references.table !== referenceTable ||
-				existing.references.column !== referenceField)
-		) {
-			throw new Error(
-				`Inferred relation '${tableName}.${columnName}' conflicts with explicit references(${existing.references.table}.${existing.references.column}).`,
-			);
-		}
-
-		table.columns[columnName] = {
-			...existing,
-			notNull:
-				existing.notNull ??
-				(existing.nullable === true ? false : options.notNull),
-			nullable:
-				existing.nullable ?? (options.notNull === false ? true : undefined),
-			references: {
-				table: referenceTable,
-				column: referenceField,
-				onDelete: existing.references?.onDelete ?? options.onDelete,
-				onUpdate: existing.references?.onUpdate ?? options.onUpdate,
-			},
-		};
-		return;
-	}
-
-	table.columns[columnName] = {
-		kind: "column",
-		type: options.fkType ?? inferredType,
-		sqlName: options.sqlName,
-		notNull: options.notNull ?? true,
-		nullable: options.notNull === false ? true : undefined,
-		references: {
-			table: referenceTable,
-			column: referenceField,
-			onDelete: options.onDelete,
-			onUpdate: options.onUpdate,
-		},
-	};
-}
-
-function resolveNotNullFromNullableFlags(
-	fieldPath: string,
-	flags: { notNull?: boolean; nullable?: boolean },
-	defaultNotNull: boolean,
-): boolean {
-	if (flags.notNull === true && flags.nullable === true) {
-		throw new Error(
-			`Invalid nullable configuration on '${fieldPath}': cannot set both notNull and nullable to true.`,
-		);
-	}
-
-	if (flags.notNull === true) {
-		return true;
-	}
-
-	if (flags.nullable === true) {
-		return false;
-	}
-
-	if (flags.notNull === false) {
-		return false;
-	}
-
-	return defaultNotNull;
-}
-
-type ManyToManyPair = {
-	leftTable: string;
-	leftReferenceField: string;
-	rightTable: string;
-	rightReferenceField: string;
-	junctionTable: string;
-	leftField: string;
-	rightField: string;
-	leftSqlName?: string;
-	rightSqlName?: string;
-	onDelete?: OneRelationDefinition["onDelete"];
-	onUpdate?: OneRelationDefinition["onUpdate"];
-};
-
-function endpointKey(tableName: string, referenceField: string): string {
-	return `${tableName}:${referenceField}`;
-}
-
-function normalizeManyToManyPairKey(
-	sourceTable: string,
-	sourceReferenceField: string,
-	targetTable: string,
-	targetReferenceField: string,
-): {
-	key: string;
-	leftTable: string;
-	leftReferenceField: string;
-	rightTable: string;
-	rightReferenceField: string;
-	sourceIsLeft: boolean;
-} {
-	const source = endpointKey(sourceTable, sourceReferenceField);
-	const target = endpointKey(targetTable, targetReferenceField);
-	const sourceIsLeft = source <= target;
-
-	if (sourceIsLeft) {
-		return {
-			key: `${source}|${target}`,
-			leftTable: sourceTable,
-			leftReferenceField: sourceReferenceField,
-			rightTable: targetTable,
-			rightReferenceField: targetReferenceField,
-			sourceIsLeft: true,
-		};
-	}
-
-	return {
-		key: `${target}|${source}`,
-		leftTable: targetTable,
-		leftReferenceField: targetReferenceField,
-		rightTable: sourceTable,
-		rightReferenceField: sourceReferenceField,
-		sourceIsLeft: false,
-	};
-}
-
-function defaultManyToManyJunctionTable(
-	leftTable: string,
-	rightTable: string,
-): string {
-	return `${leftTable}${toPascalCase(rightTable)}Links`;
-}
-
-function defaultManyToManyFieldName(
-	ownerTable: string,
-	otherTable: string,
-	suffix: "source" | "target",
-): string {
-	const ownerSingular = singularize(ownerTable);
-	const otherSingular = singularize(otherTable);
-
-	if (ownerSingular === otherSingular) {
-		return `${suffix}${toPascalCase(ownerSingular)}Id`;
-	}
-
-	return `${ownerSingular}Id`;
-}
-
-function mergeManyToManyPairConfig(
-	existing: ManyToManyPair,
-	incoming: ManyToManyPair,
-	pairKey: string,
-): ManyToManyPair {
-	if (existing.junctionTable !== incoming.junctionTable) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting junctionTable values ('${existing.junctionTable}' vs '${incoming.junctionTable}').`,
-		);
-	}
-
-	if (existing.leftField !== incoming.leftField) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting left field values ('${existing.leftField}' vs '${incoming.leftField}').`,
-		);
-	}
-
-	if (existing.rightField !== incoming.rightField) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting right field values ('${existing.rightField}' vs '${incoming.rightField}').`,
-		);
-	}
-
-	if (existing.leftSqlName !== incoming.leftSqlName) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting left sql name values ('${existing.leftSqlName}' vs '${incoming.leftSqlName}').`,
-		);
-	}
-
-	if (existing.rightSqlName !== incoming.rightSqlName) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting right sql name values ('${existing.rightSqlName}' vs '${incoming.rightSqlName}').`,
-		);
-	}
-
-	if (existing.onDelete !== incoming.onDelete) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting onDelete values ('${existing.onDelete}' vs '${incoming.onDelete}').`,
-		);
-	}
-
-	if (existing.onUpdate !== incoming.onUpdate) {
-		throw new Error(
-			`manyToMany pair '${pairKey}' has conflicting onUpdate values ('${existing.onUpdate}' vs '${incoming.onUpdate}').`,
-		);
-	}
-
-	return existing;
-}
-
-function normalizeManyToManyRelations(definition: SchemaDefinition): void {
-	const pairMap = new Map<string, ManyToManyPair>();
-
-	for (const [sourceTableName, sourceTable] of Object.entries(
-		definition.tables,
-	)) {
-		for (const relation of Object.values(sourceTable.relations)) {
-			if (relation.relation !== "manyToMany") {
-				continue;
-			}
-
-			const sourceReferenceField = relation.referenceField ?? "id";
-			const targetReferenceField = relation.targetReferenceField ?? "id";
-
-			const normalizedPair = normalizeManyToManyPairKey(
-				sourceTableName,
-				sourceReferenceField,
-				relation.targetTable,
-				targetReferenceField,
-			);
-
-			const defaultLeftField = defaultManyToManyFieldName(
-				normalizedPair.leftTable,
-				normalizedPair.rightTable,
-				"source",
-			);
-			const defaultRightField = defaultManyToManyFieldName(
-				normalizedPair.rightTable,
-				normalizedPair.leftTable,
-				"target",
-			);
-
-			const pair: ManyToManyPair = {
-				leftTable: normalizedPair.leftTable,
-				leftReferenceField: normalizedPair.leftReferenceField,
-				rightTable: normalizedPair.rightTable,
-				rightReferenceField: normalizedPair.rightReferenceField,
-				junctionTable:
-					relation.junctionTable ??
-					defaultManyToManyJunctionTable(
-						normalizedPair.leftTable,
-						normalizedPair.rightTable,
-					),
-				leftField: normalizedPair.sourceIsLeft
-					? (relation.sourceField ?? defaultLeftField)
-					: (relation.targetField ?? defaultLeftField),
-				rightField: normalizedPair.sourceIsLeft
-					? (relation.targetField ?? defaultRightField)
-					: (relation.sourceField ?? defaultRightField),
-				leftSqlName: normalizedPair.sourceIsLeft
-					? relation.sourceSqlName
-					: relation.targetSqlName,
-				rightSqlName: normalizedPair.sourceIsLeft
-					? relation.targetSqlName
-					: relation.sourceSqlName,
-				onDelete: relation.onDelete,
-				onUpdate: relation.onUpdate,
-			};
-
-			if (pair.leftField === pair.rightField) {
-				throw new Error(
-					`manyToMany pair '${normalizedPair.key}' resolves to duplicate junction fields '${pair.leftField}'. Set sourceField/targetField explicitly.`,
-				);
-			}
-
-			const existing = pairMap.get(normalizedPair.key);
-			if (existing) {
-				mergeManyToManyPairConfig(existing, pair, normalizedPair.key);
-			} else {
-				pairMap.set(normalizedPair.key, pair);
-			}
-
-			relation.referenceField = sourceReferenceField;
-			relation.targetReferenceField = targetReferenceField;
-			relation.junctionTable = pair.junctionTable;
-			relation.sourceField = normalizedPair.sourceIsLeft
-				? pair.leftField
-				: pair.rightField;
-			relation.targetField = normalizedPair.sourceIsLeft
-				? pair.rightField
-				: pair.leftField;
-			relation.sourceSqlName = normalizedPair.sourceIsLeft
-				? pair.leftSqlName
-				: pair.rightSqlName;
-			relation.targetSqlName = normalizedPair.sourceIsLeft
-				? pair.rightSqlName
-				: pair.leftSqlName;
-		}
-	}
-
-	for (const pair of pairMap.values()) {
-		if (pair.junctionTable in definition.tables) {
-			throw new Error(
-				`manyToMany auto junction table '${pair.junctionTable}' conflicts with an existing table. Set a different junctionTable name.`,
-			);
-		}
-
-		const leftType =
-			getLocalReferenceType(
-				definition,
-				pair.leftTable,
-				pair.leftReferenceField,
-			) ?? "string";
-		const rightType =
-			getLocalReferenceType(
-				definition,
-				pair.rightTable,
-				pair.rightReferenceField,
-			) ?? "string";
-
-		definition.tables[pair.junctionTable] = {
-			kind: "table",
-			columns: {
-				[pair.leftField]: {
-					kind: "column",
-					type: leftType,
-					sqlName: pair.leftSqlName,
-					notNull: true,
-					nullable: false,
-					references: {
-						table: pair.leftTable,
-						column: pair.leftReferenceField,
-						onDelete: pair.onDelete,
-						onUpdate: pair.onUpdate,
-					},
-					index: true,
-				},
-				[pair.rightField]: {
-					kind: "column",
-					type: rightType,
-					sqlName: pair.rightSqlName,
-					notNull: true,
-					nullable: false,
-					references: {
-						table: pair.rightTable,
-						column: pair.rightReferenceField,
-						onDelete: pair.onDelete,
-						onUpdate: pair.onUpdate,
-					},
-					index: true,
-				},
-			},
-			relations: {
-				[pair.leftTable]: {
-					kind: "relation",
-					relation: "one",
-					targetTable: pair.leftTable,
-					field: pair.leftField,
-					referenceField: pair.leftReferenceField,
-				},
-				[pair.rightTable]: {
-					kind: "relation",
-					relation: "one",
-					targetTable: pair.rightTable,
-					field: pair.rightField,
-					referenceField: pair.rightReferenceField,
-				},
-			},
-		};
-	}
-}
-
-function validateNullableFlags(definition: SchemaDefinition): void {
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		for (const [columnName, column] of Object.entries(table.columns)) {
-			if (column.notNull === true && column.nullable === true) {
-				throw new Error(
-					`Invalid nullable configuration on '${tableName}.${columnName}': cannot set both notNull and nullable to true.`,
-				);
-			}
-		}
-
-		for (const [relationName, relation] of Object.entries(table.relations)) {
-			if (
-				relation.relation !== "manyToMany" &&
-				relation.notNull === true &&
-				relation.nullable === true
-			) {
-				throw new Error(
-					`Invalid nullable configuration on '${tableName}.${relationName}': cannot set both notNull and nullable to true.`,
-				);
-			}
-		}
-	}
-}
-
-function normalizeSchemaDefinition(
-	definition: SchemaDefinition,
-): SchemaDefinition {
-	validateNullableFlags(definition);
-	const normalized = cloneSchemaDefinition(definition);
-
-	for (const [tableName, table] of Object.entries(normalized.tables)) {
-		for (const [relationName, relation] of Object.entries(table.relations)) {
-			if (relation.relation !== "one") {
-				continue;
-			}
-
-			const referenceField = relation.referenceField ?? "id";
-			const inferredField = relation.field ?? `${relationName}Id`;
-			relation.field = inferredField;
-
-			const inferredType =
-				getLocalReferenceType(
-					normalized,
-					relation.targetTable,
-					referenceField,
-				) ??
-				relation.fkType ??
-				"string";
-
-			ensureInferredReferenceColumn(
-				tableName,
-				table,
-				inferredField,
-				relation.targetTable,
-				referenceField,
-				{
-					fkType: relation.fkType,
-					sqlName: relation.sqlName,
-					notNull: resolveNotNullFromNullableFlags(
-						`${tableName}.${relationName}`,
-						relation,
-						true,
-					),
-					onDelete: relation.onDelete,
-					onUpdate: relation.onUpdate,
-				},
-				inferredType,
-			);
-		}
-	}
-
-	for (const [sourceTableName, sourceTable] of Object.entries(
-		normalized.tables,
-	)) {
-		for (const relation of Object.values(sourceTable.relations)) {
-			if (relation.relation !== "many") {
-				continue;
-			}
-
-			const targetTable = normalized.tables[relation.targetTable];
-			if (!targetTable) {
-				continue;
-			}
-
-			const referenceField = relation.referenceField ?? "id";
-			const inferredField =
-				relation.field ?? `${singularize(sourceTableName)}Id`;
-			relation.field = inferredField;
-			const inferredType =
-				getLocalReferenceType(normalized, sourceTableName, referenceField) ??
-				relation.fkType ??
-				"string";
-
-			ensureInferredReferenceColumn(
-				relation.targetTable,
-				targetTable,
-				inferredField,
-				sourceTableName,
-				referenceField,
-				{
-					fkType: relation.fkType,
-					sqlName: relation.sqlName,
-					notNull: resolveNotNullFromNullableFlags(
-						`${sourceTableName}.${relation.targetTable}`,
-						relation,
-						true,
-					),
-					onDelete: relation.onDelete,
-					onUpdate: relation.onUpdate,
-				},
-				inferredType,
-			);
-		}
-	}
-
-	normalizeManyToManyRelations(normalized);
-
-	return normalized;
-}
-
-function isOptionalInsertColumn(column: ColumnDefinition): boolean {
-	return (
-		column.primaryKey === true ||
-		column.notNull !== true ||
-		column.autoIncrement === true ||
-		column.sqlDefault !== undefined ||
-		column.runtimeDefaultFn !== undefined
-	);
-}
-
-function isNullableSelectColumn(column: ColumnDefinition): boolean {
-	return column.notNull !== true;
-}
-
-function drizzleBaseColumn(
-	fieldName: string,
-	column: ColumnDefinition,
-	strategy: "camelToSnake",
-): string {
-	const resolvedSqlName = column.sqlName ?? toSnakeCase(fieldName);
-	const needsExplicitName = resolvedSqlName !== fieldName;
-
-	if (column.type === "int") {
-		return needsExplicitName ? `t.int(${quote(resolvedSqlName)})` : "t.int()";
-	}
-
-	if (column.type === "string") {
-		if (column.length !== undefined) {
-			if (needsExplicitName) {
-				return `t.text(${quote(resolvedSqlName)}, { length: ${column.length} })`;
-			}
-			return `t.text({ length: ${column.length} })`;
-		}
-
-		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
-	}
-
-	if (column.type === "boolean") {
-		if (needsExplicitName) {
-			return `t.int(${quote(resolvedSqlName)}, { mode: "boolean" })`;
-		}
-		return 't.int({ mode: "boolean" })';
-	}
-
-	if (column.type === "date") {
-		if (needsExplicitName) {
-			return `t.int(${quote(resolvedSqlName)}, { mode: "timestamp_ms" })`;
-		}
-		return 't.int({ mode: "timestamp_ms" })';
-	}
-
-	if (strategy === "camelToSnake") {
-		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
-	}
-
-	return "t.text()";
-}
-
-function resolveOneRelationReference(
-	tableName: string,
-	table: TableDefinition,
-	relation: OneRelationDefinition,
-): { sourceField: string; targetField: string } {
-	const sourceField = relation.field;
-	const targetField = relation.referenceField ?? "id";
-
-	if (!sourceField) {
-		throw new Error(
-			`Relation on '${tableName}' targeting '${relation.targetTable}' is missing a local field.`,
-		);
-	}
-
-	if (!(sourceField in table.columns)) {
-		throw new Error(
-			`Relation '${tableName}.${sourceField}' references missing local field '${sourceField}'.`,
-		);
-	}
-
-	return {
-		sourceField,
-		targetField,
-	};
-}
-
-function buildExternalTableImportLines(externals: Set<string>): string {
-	if (externals.size === 0) {
-		return "";
-	}
-	return `import { ${Array.from(externals).sort().join(", ")} } from \"./auth.schema\";\n`;
-}
-
-function getRelationImports(table: TableDefinition): string[] {
-	return Object.values(table.relations)
-		.filter((relation) => relation.relation === "one")
-		.map((relation) => relation.targetTable);
-}
-
-function resolveColumnReference(
-	fieldName: string,
-	column: ColumnDefinition,
-	table: TableDefinition,
-): { tableName: string; fieldName: string } | undefined {
-	if (column.references) {
-		return {
-			tableName: column.references.table,
-			fieldName: column.references.column,
-		};
-	}
-
-	const matchingOne = Object.values(table.relations).find((relation) => {
-		return relation.relation === "one" && relation.field === fieldName;
-	}) as OneRelationDefinition | undefined;
-
-	if (!matchingOne) {
-		return undefined;
-	}
-
-	return {
-		tableName: matchingOne.targetTable,
-		fieldName: matchingOne.referenceField ?? "id",
-	};
-}
-
-function emitManyToManyRuntimeMetadata(definition: SchemaDefinition): string {
-	const tableEntries: string[] = [];
-
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		const relationEntries: string[] = [];
-
-		for (const [relationName, relation] of Object.entries(table.relations)) {
-			if (relation.relation !== "manyToMany") {
-				continue;
-			}
-
-			if (!relation.junctionTable) {
-				continue;
-			}
-
-			relationEntries.push(
-				`${quote(relationName)}: {
-				targetTable: ${quote(relation.targetTable)},
-				junctionTable: ${quote(relation.junctionTable)},
-				sourceField: ${quote(relation.sourceField ?? "")},
-				targetField: ${quote(relation.targetField ?? "")},
-			},`,
-			);
-		}
-
-		if (relationEntries.length === 0) {
-			continue;
-		}
-
-		tableEntries.push(
-			`${quote(tableName)}: {
-${relationEntries.map((entry) => `\t${entry}`).join("\n")}
-	},`,
-		);
-	}
-
-	if (tableEntries.length === 0) {
-		return "export const __appflareManyToMany = {} as const;\n";
-	}
-
-	return `export const __appflareManyToMany = {
-${tableEntries.map((entry) => `\t${entry}`).join("\n")}
-} as const;
-`;
-}
-
-function emitRuntimeRelationMetadata(definition: SchemaDefinition): string {
-	const tableEntries: string[] = [];
-
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		const relationEntries: string[] = [];
-
-		for (const [relationName, relation] of Object.entries(table.relations)) {
-			if (relation.relation === "one") {
-				relationEntries.push(
-					`${quote(relationName)}: {
-				kind: "one",
-				targetTable: ${quote(relation.targetTable)},
-				sourceField: ${quote(relation.field ?? "")},
-				referenceField: ${quote(relation.referenceField ?? "id")},
-			},`,
-				);
-				continue;
-			}
-
-			if (relation.relation === "many") {
-				relationEntries.push(
-					`${quote(relationName)}: {
-				kind: "many",
-				targetTable: ${quote(relation.targetTable)},
-				sourceField: ${quote(relation.field ?? "")},
-				referenceField: ${quote(relation.referenceField ?? "id")},
-			},`,
-				);
-				continue;
-			}
-
-			relationEntries.push(
-				`${quote(relationName)}: {
-			kind: "manyToMany",
-				targetTable: ${quote(relation.targetTable)},
-				junctionTable: ${quote(relation.junctionTable ?? "")},
-				sourceField: ${quote(relation.sourceField ?? "")},
-				targetField: ${quote(relation.targetField ?? "")},
-				referenceField: ${quote(relation.referenceField ?? "id")},
-				targetReferenceField: ${quote(relation.targetReferenceField ?? "id")},
-			},`,
-			);
-		}
-
-		if (relationEntries.length === 0) {
-			continue;
-		}
-
-		tableEntries.push(
-			`${quote(tableName)}: {
-${relationEntries.map((entry) => `\t${entry}`).join("\n")}
-	},`,
-		);
-	}
-
-	if (tableEntries.length === 0) {
-		return "export const __appflareRelations = {} as const;\n";
-	}
-
-	return `export const __appflareRelations = {
-${tableEntries.map((entry) => `\t${entry}`).join("\n")}
-} as const;
-`;
-}
-
-function emitDrizzleSchema(
-	definition: SchemaDefinition,
-	strategy: "camelToSnake",
-): string {
-	const localTables = new Set(Object.keys(definition.tables));
-	const externalTables = new Set<string>();
-
-	for (const table of Object.values(definition.tables)) {
-		for (const relationTarget of getRelationImports(table)) {
-			if (!localTables.has(relationTarget)) {
-				externalTables.add(relationTarget);
-			}
-		}
-		for (const column of Object.values(table.columns)) {
-			if (column.references && !localTables.has(column.references.table)) {
-				externalTables.add(column.references.table);
-			}
-		}
-	}
-
-	const tableBlocks: string[] = [];
-	const relationBlocks: string[] = [];
-
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		const sqlTableName = table.sqlName ?? toSnakeCase(tableName);
-		const columnLines: string[] = [];
-		const indexes: string[] = [];
-
-		for (const [fieldName, column] of Object.entries(table.columns)) {
-			let expr = drizzleBaseColumn(fieldName, column, strategy);
-
-			if (column.uuidPrimaryKey) {
-				expr += ".$defaultFn(() => crypto.randomUUID())";
-			}
-
-			if (column.primaryKey) {
-				expr += column.autoIncrement
-					? ".primaryKey({ autoIncrement: true })"
-					: ".primaryKey()";
-			}
-			if (column.notNull) {
-				expr += ".notNull()";
-			}
-			if (column.sqlDefault !== undefined) {
-				expr += `.default(${toSqlLiteral(column.sqlDefault)})`;
-			}
-
-			const reference = resolveColumnReference(fieldName, column, table);
-			if (reference) {
-				if (column.references?.onDelete || column.references?.onUpdate) {
-					const actions: string[] = [];
-					if (column.references.onDelete) {
-						actions.push(`onDelete: ${quote(column.references.onDelete)}`);
-					}
-					if (column.references.onUpdate) {
-						actions.push(`onUpdate: ${quote(column.references.onUpdate)}`);
-					}
-					expr += `.references(() => ${reference.tableName}.${reference.fieldName}, { ${actions.join(", ")} })`;
-				} else {
-					expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
-				}
-			}
-
-			if (column.unique) {
-				const uniqueName =
-					typeof column.unique === "object" && column.unique.name
-						? column.unique.name
-						: `${sqlTableName}_${toSnakeCase(fieldName)}_unique_idx`;
-				indexes.push(
-					`\t\tt.uniqueIndex(${quote(uniqueName)}).on(table.${fieldName})`,
-				);
-			}
-
-			if (column.index) {
-				const indexName =
-					typeof column.index === "object" && column.index.name
-						? column.index.name
-						: `${sqlTableName}_${toSnakeCase(fieldName)}_idx`;
-				indexes.push(`\t\tt.index(${quote(indexName)}).on(table.${fieldName})`);
-			}
-
-			columnLines.push(`\t\t${fieldName}: ${expr},`);
-		}
-
-		if (indexes.length > 0) {
-			tableBlocks.push(
-				`export const ${tableName} = table(\n\t${quote(sqlTableName)},\n\t{\n${columnLines.join("\n")}\n\t},\n\t(table) => [\n${indexes.join(",\n")}\n\t],\n);`,
-			);
-		} else {
-			tableBlocks.push(
-				`export const ${tableName} = table(${quote(sqlTableName)}, {\n${columnLines.join("\n")}\n\t});`,
-			);
-		}
-
-		const oneRelations = Object.entries(table.relations).filter(
-			([, relation]) => {
-				return relation.relation === "one";
-			},
-		) as Array<[string, OneRelationDefinition]>;
-		const manyRelations = Object.entries(table.relations).filter(
-			([, relation]) => {
-				return relation.relation === "many";
-			},
-		) as Array<[string, ManyRelationDefinition]>;
-		const manyToManyRelations = Object.entries(table.relations).filter(
-			([, relation]) => {
-				return relation.relation === "manyToMany";
-			},
-		) as Array<[string, ManyToManyRelationDefinition]>;
-
-		if (
-			oneRelations.length === 0 &&
-			manyRelations.length === 0 &&
-			manyToManyRelations.length === 0
-		) {
-			continue;
-		}
-
-		const relationLines: string[] = [];
-		for (const [relationName, relation] of oneRelations) {
-			const resolved = resolveOneRelationReference(tableName, table, relation);
-			relationLines.push(
-				`\t${relationName}: one(${relation.targetTable}, {\n\t\tfields: [${tableName}.${resolved.sourceField}],\n\t\treferences: [${relation.targetTable}.${resolved.targetField}],\n\t}),`,
-			);
-		}
-		for (const [relationName, relation] of manyRelations) {
-			relationLines.push(`\t${relationName}: many(${relation.targetTable}),`);
-		}
-		for (const [relationName, relation] of manyToManyRelations) {
-			if (!relation.junctionTable) {
-				throw new Error(
-					`manyToMany relation '${tableName}.${relationName}' is missing junctionTable after normalization.`,
-				);
-			}
-			relationLines.push(`\t${relationName}: many(${relation.junctionTable}),`);
-		}
-
-		relationBlocks.push(
-			`export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({\n${relationLines.join("\n")}\n}));`,
-		);
-	}
-
-	return `import * as t from "drizzle-orm/sqlite-core";
-import { sqliteTable as table } from "drizzle-orm/sqlite-core";
-import { relations } from "drizzle-orm";
-${buildExternalTableImportLines(externalTables)}
-${tableBlocks.join("\n\n")}
-
-${relationBlocks.join("\n\n")}
-
-${emitManyToManyRuntimeMetadata(definition)}
-
-${emitRuntimeRelationMetadata(definition)}
-`;
-}
-
-function zodSchemaExpression(
-	column: ColumnDefinition,
-	optional: boolean,
-	nullable: boolean,
-): string {
-	let expr = "z.unknown()";
-	if (column.type === "int") {
-		expr = "z.number().int()";
-	} else if (column.type === "string") {
-		expr = "z.string()";
-		if (column.length !== undefined) {
-			expr += `.max(${column.length})`;
-		}
-	} else if (column.type === "boolean") {
-		expr = "z.boolean()";
-	} else if (column.type === "date") {
-		expr = "z.date()";
-	}
-
-	if (optional) {
-		expr += ".optional()";
-	}
-
-	if (nullable) {
-		expr += ".nullable()";
-	}
-
-	return expr;
-}
-
-function emitZodSchemas(definition: SchemaDefinition): string {
-	const blocks: string[] = [];
-
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		const pascal = toPascalCase(tableName);
-		const insertLines: string[] = [];
-		const selectLines: string[] = [];
-
-		for (const [fieldName, column] of Object.entries(table.columns)) {
-			insertLines.push(
-				`\t${fieldName}: ${zodSchemaExpression(column, isOptionalInsertColumn(column), isNullableSelectColumn(column))},`,
-			);
-			selectLines.push(
-				`\t${fieldName}: ${zodSchemaExpression(column, isNullableSelectColumn(column), isNullableSelectColumn(column))},`,
-			);
-		}
-
-		blocks.push(`export const ${tableName}InsertSchema = z.object({\n${insertLines.join("\n")}\n});
-export const ${tableName}SelectSchema = z.object({\n${selectLines.join("\n")}\n});
-
-export type ${pascal}Insert = z.infer<typeof ${tableName}InsertSchema>;
-export type ${pascal}Select = z.infer<typeof ${tableName}SelectSchema>;
-`);
-	}
-
-	return `import { z } from "zod";
-
-${blocks.join("\n")}`;
-}
-
-function toTypeScriptType(column: ColumnDefinition): string {
-	if (column.type === "int") {
-		return "number";
-	}
-	if (column.type === "string") {
-		return "string";
-	}
-	if (column.type === "boolean") {
-		return "boolean";
-	}
-	if (column.type === "date") {
-		return "Date";
-	}
-	return "unknown";
-}
-
-function emitTypes(definition: SchemaDefinition): string {
-	const lines: string[] = [];
-
-	for (const [tableName, table] of Object.entries(definition.tables)) {
-		const pascal = toPascalCase(tableName);
-		const selectFields: string[] = [];
-		const insertFields: string[] = [];
-
-		for (const [fieldName, column] of Object.entries(table.columns)) {
-			const tsType = toTypeScriptType(column);
-			const nullableSuffix = isNullableSelectColumn(column) ? " | null" : "";
-			selectFields.push(
-				`\t${fieldName}${isNullableSelectColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
-			);
-			insertFields.push(
-				`\t${fieldName}${isOptionalInsertColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
-			);
-		}
-
-		lines.push(`export type ${pascal} = {\n${selectFields.join("\n")}\n};
-
-export type New${pascal} = {\n${insertFields.join("\n")}\n};`);
-	}
-
-	return `${lines.join("\n\n")}
-`;
-}
-
-function findSchemaExport(
-	moduleExports: Record<string, unknown>,
-	exportName?: string,
-): SchemaDefinition {
-	if (exportName) {
-		const explicit = moduleExports[exportName];
-		if (!isSchemaDefinition(explicit)) {
-			throw new Error(
-				`schemaDsl.exportName '${exportName}' does not point to a schema() export.`,
-			);
-		}
-		return explicit;
-	}
-
-	for (const candidate of Object.values(moduleExports)) {
-		if (isSchemaDefinition(candidate)) {
-			return candidate;
-		}
-	}
-
-	throw new Error(
-		"No schema() export found in schemaDsl entry module. Set schemaDsl.exportName to the correct export.",
-	);
-}
-
-export async function compileSchemaDsl(
-	loadedConfig: LoadedAppflareConfig,
-): Promise<CompiledSchemaArtifacts | undefined> {
-	const schemaDsl = loadedConfig.config.schemaDsl;
-	if (!schemaDsl) {
-		return undefined;
-	}
-
-	const namingStrategy = schemaDsl.namingStrategy ?? "camelToSnake";
-	const entryPath = resolve(loadedConfig.configDir, schemaDsl.entry);
-	const outSchemaPath = resolve(
-		loadedConfig.configDir,
-		schemaDsl.outFile ?? resolve(loadedConfig.outDirAbs, "schema.compiled.ts"),
-	);
-	const outTypesPath = resolve(
-		loadedConfig.configDir,
-		schemaDsl.typesOutFile ??
-			resolve(loadedConfig.outDirAbs, "schema.types.ts"),
-	);
-	const outZodPath = resolve(
-		loadedConfig.configDir,
-		schemaDsl.zodOutFile ?? resolve(loadedConfig.outDirAbs, "schema.zod.ts"),
-	);
-
-	const moduleUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`;
-	const schemaModule = (await import(moduleUrl)) as Record<string, unknown>;
-	const schemaDefinition = findSchemaExport(schemaModule, schemaDsl.exportName);
-	const normalizedSchema = normalizeSchemaDefinition(schemaDefinition);
-
-	await Promise.all([
-		mkdir(dirname(outSchemaPath), { recursive: true }),
-		mkdir(dirname(outTypesPath), { recursive: true }),
-		mkdir(dirname(outZodPath), { recursive: true }),
-	]);
-
-	const drizzleSchemaSource = emitDrizzleSchema(
-		normalizedSchema,
-		namingStrategy,
-	);
-	const typesSource = emitTypes(normalizedSchema);
-	const zodSource = emitZodSchemas(normalizedSchema);
-
-	await Promise.all([
-		Bun.write(outSchemaPath, drizzleSchemaSource),
-		Bun.write(outTypesPath, typesSource),
-		Bun.write(outZodPath, zodSource),
-	]);
-
-	return {
-		schemaPath: outSchemaPath,
-		typesPath: outTypesPath,
-		zodPath: outZodPath,
-		tableNames: Object.keys(normalizedSchema.tables),
-	};
-}
+import { mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import type {
+	ColumnDefinition,
+	ColumnType,
+	ManyRelationDefinition,
+	ManyToManyRelationDefinition,
+	OneRelationDefinition,
+	SchemaDefinition,
+	TableDefinition,
+} from "../schema";
+import { isSchemaDefinition } from "../schema";
+import type { LoadedAppflareConfig } from "./types";
+
+export type CompiledSchemaArtifacts = {
+	schemaPath: string;
+	typesPath: string;
+	zodPath: string;
+	tableNames: string[];
+};
+
+function toSnakeCase(value: string): string {
+	return value
+		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+		.replace(/[\s-]+/g, "_")
+		.toLowerCase();
+}
+
+function toPascalCase(value: string): string {
+	return value
+		.replace(/[_-]+/g, " ")
+		.replace(/\s+(.)/g, (_match, char: string) => char.toUpperCase())
+		.replace(/\s/g, "")
+		.replace(/^(.)/, (_match, char: string) => char.toUpperCase());
+}
+
+function singularize(value: string): string {
+	if (value.endsWith("ies")) {
+		return `${value.slice(0, -3)}y`;
+	}
+	if (value.endsWith("ses")) {
+		return value.slice(0, -2);
+	}
+	if (value.endsWith("s") && value.length > 1) {
+		return value.slice(0, -1);
+	}
+	return value;
+}
+
+function quote(value: string): string {
+	return JSON.stringify(value);
+}
+
+function toSqlLiteral(value: unknown): string {
+	if (typeof value === "string") {
+		return quote(value);
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	if (value === null) {
+		return "null";
+	}
+	if (value instanceof Date) {
+		return quote(value.toISOString());
+	}
+	throw new Error(
+		`Unsupported SQL default value '${String(value)}'. Use string, number, boolean, null, or Date.`,
+	);
+}
+
+function cloneSchemaDefinition(definition: SchemaDefinition): SchemaDefinition {
+	return {
+		kind: "schema",
+		tables: Object.fromEntries(
+			Object.entries(definition.tables).map(([tableName, table]) => {
+				return [
+					tableName,
+					{
+						kind: "table",
+						sqlName: table.sqlName,
+						columns: Object.fromEntries(
+							Object.entries(table.columns).map(([columnName, column]) => {
+								return [columnName, { ...column }];
+							}),
+						),
+						relations: Object.fromEntries(
+							Object.entries(table.relations).map(
+								([relationName, relation]) => {
+									return [relationName, { ...relation }];
+								},
+							),
+						),
+					} satisfies TableDefinition,
+				];
+			}),
+		),
+	};
+}
+
+function getLocalReferenceType(
+	definition: SchemaDefinition,
+	targetTable: string,
+	referenceField: string,
+): ColumnType | undefined {
+	const table = definition.tables[targetTable];
+	if (!table) {
+		return undefined;
+	}
+	const targetColumn = table.columns[referenceField];
+	return targetColumn?.type;
+}
+
+function ensureInferredReferenceColumn(
+	tableName: string,
+	table: TableDefinition,
+	columnName: string,
+	referenceTable: string,
+	referenceField: string,
+	options: {
+		fkType?: ColumnType;
+		sqlName?: string;
+		notNull?: boolean;
+		onDelete?: OneRelationDefinition["onDelete"];
+		onUpdate?: OneRelationDefinition["onUpdate"];
+	},
+	inferredType: ColumnType,
+): void {
+	const existing = table.columns[columnName];
+	if (existing) {
+		if (
+			existing.references &&
+			(existing.references.table !== referenceTable ||
+				existing.references.column !== referenceField)
+		) {
+			throw new Error(
+				`Inferred relation '${tableName}.${columnName}' conflicts with explicit references(${existing.references.table}.${existing.references.column}).`,
+			);
+		}
+
+		table.columns[columnName] = {
+			...existing,
+			notNull:
+				existing.notNull ??
+				(existing.nullable === true ? false : options.notNull),
+			nullable:
+				existing.nullable ?? (options.notNull === false ? true : undefined),
+			references: {
+				table: referenceTable,
+				column: referenceField,
+				onDelete: existing.references?.onDelete ?? options.onDelete,
+				onUpdate: existing.references?.onUpdate ?? options.onUpdate,
+			},
+		};
+		return;
+	}
+
+	table.columns[columnName] = {
+		kind: "column",
+		type: options.fkType ?? inferredType,
+		sqlName: options.sqlName,
+		notNull: options.notNull ?? true,
+		nullable: options.notNull === false ? true : undefined,
+		references: {
+			table: referenceTable,
+			column: referenceField,
+			onDelete: options.onDelete,
+			onUpdate: options.onUpdate,
+		},
+	};
+}
+
+function resolveNotNullFromNullableFlags(
+	fieldPath: string,
+	flags: { notNull?: boolean; nullable?: boolean },
+	defaultNotNull: boolean,
+): boolean {
+	if (flags.notNull === true && flags.nullable === true) {
+		throw new Error(
+			`Invalid nullable configuration on '${fieldPath}': cannot set both notNull and nullable to true.`,
+		);
+	}
+
+	if (flags.notNull === true) {
+		return true;
+	}
+
+	if (flags.nullable === true) {
+		return false;
+	}
+
+	if (flags.notNull === false) {
+		return false;
+	}
+
+	return defaultNotNull;
+}
+
+type ManyToManyPair = {
+	leftTable: string;
+	leftReferenceField: string;
+	rightTable: string;
+	rightReferenceField: string;
+	junctionTable: string;
+	leftField: string;
+	rightField: string;
+	leftSqlName?: string;
+	rightSqlName?: string;
+	onDelete?: OneRelationDefinition["onDelete"];
+	onUpdate?: OneRelationDefinition["onUpdate"];
+};
+
+function endpointKey(tableName: string, referenceField: string): string {
+	return `${tableName}:${referenceField}`;
+}
+
+function normalizeManyToManyPairKey(
+	sourceTable: string,
+	sourceReferenceField: string,
+	targetTable: string,
+	targetReferenceField: string,
+): {
+	key: string;
+	leftTable: string;
+	leftReferenceField: string;
+	rightTable: string;
+	rightReferenceField: string;
+	sourceIsLeft: boolean;
+} {
+	const source = endpointKey(sourceTable, sourceReferenceField);
+	const target = endpointKey(targetTable, targetReferenceField);
+	const sourceIsLeft = source <= target;
+
+	if (sourceIsLeft) {
+		return {
+			key: `${source}|${target}`,
+			leftTable: sourceTable,
+			leftReferenceField: sourceReferenceField,
+			rightTable: targetTable,
+			rightReferenceField: targetReferenceField,
+			sourceIsLeft: true,
+		};
+	}
+
+	return {
+		key: `${target}|${source}`,
+		leftTable: targetTable,
+		leftReferenceField: targetReferenceField,
+		rightTable: sourceTable,
+		rightReferenceField: sourceReferenceField,
+		sourceIsLeft: false,
+	};
+}
+
+function defaultManyToManyJunctionTable(
+	leftTable: string,
+	rightTable: string,
+): string {
+	return `${leftTable}${toPascalCase(rightTable)}Links`;
+}
+
+function defaultManyToManyFieldName(
+	ownerTable: string,
+	otherTable: string,
+	suffix: "source" | "target",
+): string {
+	const ownerSingular = singularize(ownerTable);
+	const otherSingular = singularize(otherTable);
+
+	if (ownerSingular === otherSingular) {
+		return `${suffix}${toPascalCase(ownerSingular)}Id`;
+	}
+
+	return `${ownerSingular}Id`;
+}
+
+function mergeManyToManyPairConfig(
+	existing: ManyToManyPair,
+	incoming: ManyToManyPair,
+	pairKey: string,
+): ManyToManyPair {
+	if (existing.junctionTable !== incoming.junctionTable) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting junctionTable values ('${existing.junctionTable}' vs '${incoming.junctionTable}').`,
+		);
+	}
+
+	if (existing.leftField !== incoming.leftField) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting left field values ('${existing.leftField}' vs '${incoming.leftField}').`,
+		);
+	}
+
+	if (existing.rightField !== incoming.rightField) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting right field values ('${existing.rightField}' vs '${incoming.rightField}').`,
+		);
+	}
+
+	if (existing.leftSqlName !== incoming.leftSqlName) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting left sql name values ('${existing.leftSqlName}' vs '${incoming.leftSqlName}').`,
+		);
+	}
+
+	if (existing.rightSqlName !== incoming.rightSqlName) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting right sql name values ('${existing.rightSqlName}' vs '${incoming.rightSqlName}').`,
+		);
+	}
+
+	if (existing.onDelete !== incoming.onDelete) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting onDelete values ('${existing.onDelete}' vs '${incoming.onDelete}').`,
+		);
+	}
+
+	if (existing.onUpdate !== incoming.onUpdate) {
+		throw new Error(
+			`manyToMany pair '${pairKey}' has conflicting onUpdate values ('${existing.onUpdate}' vs '${incoming.onUpdate}').`,
+		);
+	}
+
+	return existing;
+}
+
+function normalizeManyToManyRelations(definition: SchemaDefinition): void {
+	const pairMap = new Map<string, ManyToManyPair>();
+
+	for (const [sourceTableName, sourceTable] of Object.entries(
+		definition.tables,
+	)) {
+		for (const relation of Object.values(sourceTable.relations)) {
+			if (relation.relation !== "manyToMany") {
+				continue;
+			}
+
+			const sourceReferenceField = relation.referenceField ?? "id";
+			const targetReferenceField = relation.targetReferenceField ?? "id";
+
+			const normalizedPair = normalizeManyToManyPairKey(
+				sourceTableName,
+				sourceReferenceField,
+				relation.targetTable,
+				targetReferenceField,
+			);
+
+			const defaultLeftField = defaultManyToManyFieldName(
+				normalizedPair.leftTable,
+				normalizedPair.rightTable,
+				"source",
+			);
+			const defaultRightField = defaultManyToManyFieldName(
+				normalizedPair.rightTable,
+				normalizedPair.leftTable,
+				"target",
+			);
+
+			const pair: ManyToManyPair = {
+				leftTable: normalizedPair.leftTable,
+				leftReferenceField: normalizedPair.leftReferenceField,
+				rightTable: normalizedPair.rightTable,
+				rightReferenceField: normalizedPair.rightReferenceField,
+				junctionTable:
+					relation.junctionTable ??
+					defaultManyToManyJunctionTable(
+						normalizedPair.leftTable,
+						normalizedPair.rightTable,
+					),
+				leftField: normalizedPair.sourceIsLeft
+					? (relation.sourceField ?? defaultLeftField)
+					: (relation.targetField ?? defaultLeftField),
+				rightField: normalizedPair.sourceIsLeft
+					? (relation.targetField ?? defaultRightField)
+					: (relation.sourceField ?? defaultRightField),
+				leftSqlName: normalizedPair.sourceIsLeft
+					? relation.sourceSqlName
+					: relation.targetSqlName,
+				rightSqlName: normalizedPair.sourceIsLeft
+					? relation.targetSqlName
+					: relation.sourceSqlName,
+				onDelete: relation.onDelete,
+				onUpdate: relation.onUpdate,
+			};
+
+			if (pair.leftField === pair.rightField) {
+				throw new Error(
+					`manyToMany pair '${normalizedPair.key}' resolves to duplicate junction fields '${pair.leftField}'. Set sourceField/targetField explicitly.`,
+				);
+			}
+
+			const existing = pairMap.get(normalizedPair.key);
+			if (existing) {
+				mergeManyToManyPairConfig(existing, pair, normalizedPair.key);
+			} else {
+				pairMap.set(normalizedPair.key, pair);
+			}
+
+			relation.referenceField = sourceReferenceField;
+			relation.targetReferenceField = targetReferenceField;
+			relation.junctionTable = pair.junctionTable;
+			relation.sourceField = normalizedPair.sourceIsLeft
+				? pair.leftField
+				: pair.rightField;
+			relation.targetField = normalizedPair.sourceIsLeft
+				? pair.rightField
+				: pair.leftField;
+			relation.sourceSqlName = normalizedPair.sourceIsLeft
+				? pair.leftSqlName
+				: pair.rightSqlName;
+			relation.targetSqlName = normalizedPair.sourceIsLeft
+				? pair.rightSqlName
+				: pair.leftSqlName;
+		}
+	}
+
+	for (const pair of pairMap.values()) {
+		if (pair.junctionTable in definition.tables) {
+			throw new Error(
+				`manyToMany auto junction table '${pair.junctionTable}' conflicts with an existing table. Set a different junctionTable name.`,
+			);
+		}
+
+		const leftType =
+			getLocalReferenceType(
+				definition,
+				pair.leftTable,
+				pair.leftReferenceField,
+			) ?? "string";
+		const rightType =
+			getLocalReferenceType(
+				definition,
+				pair.rightTable,
+				pair.rightReferenceField,
+			) ?? "string";
+
+		definition.tables[pair.junctionTable] = {
+			kind: "table",
+			columns: {
+				[pair.leftField]: {
+					kind: "column",
+					type: leftType,
+					sqlName: pair.leftSqlName,
+					notNull: true,
+					nullable: false,
+					references: {
+						table: pair.leftTable,
+						column: pair.leftReferenceField,
+						onDelete: pair.onDelete,
+						onUpdate: pair.onUpdate,
+					},
+					index: true,
+				},
+				[pair.rightField]: {
+					kind: "column",
+					type: rightType,
+					sqlName: pair.rightSqlName,
+					notNull: true,
+					nullable: false,
+					references: {
+						table: pair.rightTable,
+						column: pair.rightReferenceField,
+						onDelete: pair.onDelete,
+						onUpdate: pair.onUpdate,
+					},
+					index: true,
+				},
+			},
+			relations: {
+				[pair.leftTable]: {
+					kind: "relation",
+					relation: "one",
+					targetTable: pair.leftTable,
+					field: pair.leftField,
+					referenceField: pair.leftReferenceField,
+				},
+				[pair.rightTable]: {
+					kind: "relation",
+					relation: "one",
+					targetTable: pair.rightTable,
+					field: pair.rightField,
+					referenceField: pair.rightReferenceField,
+				},
+			},
+		};
+	}
+}
+
+function validateNullableFlags(definition: SchemaDefinition): void {
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		for (const [columnName, column] of Object.entries(table.columns)) {
+			if (column.notNull === true && column.nullable === true) {
+				throw new Error(
+					`Invalid nullable configuration on '${tableName}.${columnName}': cannot set both notNull and nullable to true.`,
+				);
+			}
+		}
+
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (
+				relation.relation !== "manyToMany" &&
+				relation.notNull === true &&
+				relation.nullable === true
+			) {
+				throw new Error(
+					`Invalid nullable configuration on '${tableName}.${relationName}': cannot set both notNull and nullable to true.`,
+				);
+			}
+		}
+	}
+}
+
+function normalizeSchemaDefinition(
+	definition: SchemaDefinition,
+): SchemaDefinition {
+	validateNullableFlags(definition);
+	const normalized = cloneSchemaDefinition(definition);
+
+	for (const [tableName, table] of Object.entries(normalized.tables)) {
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (relation.relation !== "one") {
+				continue;
+			}
+
+			const referenceField = relation.referenceField ?? "id";
+			const inferredField = relation.field ?? `${relationName}Id`;
+			relation.field = inferredField;
+
+			const inferredType =
+				getLocalReferenceType(
+					normalized,
+					relation.targetTable,
+					referenceField,
+				) ??
+				relation.fkType ??
+				"string";
+
+			ensureInferredReferenceColumn(
+				tableName,
+				table,
+				inferredField,
+				relation.targetTable,
+				referenceField,
+				{
+					fkType: relation.fkType,
+					sqlName: relation.sqlName,
+					notNull: resolveNotNullFromNullableFlags(
+						`${tableName}.${relationName}`,
+						relation,
+						true,
+					),
+					onDelete: relation.onDelete,
+					onUpdate: relation.onUpdate,
+				},
+				inferredType,
+			);
+		}
+	}
+
+	for (const [sourceTableName, sourceTable] of Object.entries(
+		normalized.tables,
+	)) {
+		for (const relation of Object.values(sourceTable.relations)) {
+			if (relation.relation !== "many") {
+				continue;
+			}
+
+			const targetTable = normalized.tables[relation.targetTable];
+			if (!targetTable) {
+				continue;
+			}
+
+			const referenceField = relation.referenceField ?? "id";
+			const inferredField =
+				relation.field ?? `${singularize(sourceTableName)}Id`;
+			relation.field = inferredField;
+			const inferredType =
+				getLocalReferenceType(normalized, sourceTableName, referenceField) ??
+				relation.fkType ??
+				"string";
+
+			ensureInferredReferenceColumn(
+				relation.targetTable,
+				targetTable,
+				inferredField,
+				sourceTableName,
+				referenceField,
+				{
+					fkType: relation.fkType,
+					sqlName: relation.sqlName,
+					notNull: resolveNotNullFromNullableFlags(
+						`${sourceTableName}.${relation.targetTable}`,
+						relation,
+						true,
+					),
+					onDelete: relation.onDelete,
+					onUpdate: relation.onUpdate,
+				},
+				inferredType,
+			);
+		}
+	}
+
+	normalizeManyToManyRelations(normalized);
+
+	return normalized;
+}
+
+function isOptionalInsertColumn(column: ColumnDefinition): boolean {
+	return (
+		column.primaryKey === true ||
+		column.notNull !== true ||
+		column.autoIncrement === true ||
+		column.sqlDefault !== undefined ||
+		column.runtimeDefaultFn !== undefined
+	);
+}
+
+function isNullableSelectColumn(column: ColumnDefinition): boolean {
+	return column.notNull !== true;
+}
+
+function drizzleBaseColumn(
+	fieldName: string,
+	column: ColumnDefinition,
+	strategy: "camelToSnake",
+): string {
+	const resolvedSqlName = column.sqlName ?? toSnakeCase(fieldName);
+	const needsExplicitName = resolvedSqlName !== fieldName;
+
+	if (column.type === "int") {
+		return needsExplicitName ? `t.int(${quote(resolvedSqlName)})` : "t.int()";
+	}
+
+	if (column.type === "string") {
+		if (column.length !== undefined) {
+			if (needsExplicitName) {
+				return `t.text(${quote(resolvedSqlName)}, { length: ${column.length} })`;
+			}
+			return `t.text({ length: ${column.length} })`;
+		}
+
+		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
+	}
+
+	if (column.type === "boolean") {
+		if (needsExplicitName) {
+			return `t.int(${quote(resolvedSqlName)}, { mode: "boolean" })`;
+		}
+		return 't.int({ mode: "boolean" })';
+	}
+
+	if (column.type === "date") {
+		if (needsExplicitName) {
+			return `t.int(${quote(resolvedSqlName)}, { mode: "timestamp_ms" })`;
+		}
+		return 't.int({ mode: "timestamp_ms" })';
+	}
+
+	if (strategy === "camelToSnake") {
+		return needsExplicitName ? `t.text(${quote(resolvedSqlName)})` : "t.text()";
+	}
+
+	return "t.text()";
+}
+
+function resolveOneRelationReference(
+	tableName: string,
+	table: TableDefinition,
+	relation: OneRelationDefinition,
+): { sourceField: string; targetField: string } {
+	const sourceField = relation.field;
+	const targetField = relation.referenceField ?? "id";
+
+	if (!sourceField) {
+		throw new Error(
+			`Relation on '${tableName}' targeting '${relation.targetTable}' is missing a local field.`,
+		);
+	}
+
+	if (!(sourceField in table.columns)) {
+		throw new Error(
+			`Relation '${tableName}.${sourceField}' references missing local field '${sourceField}'.`,
+		);
+	}
+
+	return {
+		sourceField,
+		targetField,
+	};
+}
+
+function buildExternalTableImportLines(externals: Set<string>): string {
+	if (externals.size === 0) {
+		return "";
+	}
+	return `import { ${Array.from(externals).sort().join(", ")} } from \"./auth.schema\";\n`;
+}
+
+function getRelationImports(table: TableDefinition): string[] {
+	return Object.values(table.relations)
+		.filter((relation) => relation.relation === "one")
+		.map((relation) => relation.targetTable);
+}
+
+function resolveColumnReference(
+	fieldName: string,
+	column: ColumnDefinition,
+	table: TableDefinition,
+): { tableName: string; fieldName: string } | undefined {
+	if (column.references) {
+		return {
+			tableName: column.references.table,
+			fieldName: column.references.column,
+		};
+	}
+
+	const matchingOne = Object.values(table.relations).find((relation) => {
+		return relation.relation === "one" && relation.field === fieldName;
+	}) as OneRelationDefinition | undefined;
+
+	if (!matchingOne) {
+		return undefined;
+	}
+
+	return {
+		tableName: matchingOne.targetTable,
+		fieldName: matchingOne.referenceField ?? "id",
+	};
+}
+
+function emitManyToManyRuntimeMetadata(definition: SchemaDefinition): string {
+	const tableEntries: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const relationEntries: string[] = [];
+
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (relation.relation !== "manyToMany") {
+				continue;
+			}
+
+			if (!relation.junctionTable) {
+				continue;
+			}
+
+			relationEntries.push(
+				`${quote(relationName)}: {
+				targetTable: ${quote(relation.targetTable)},
+				junctionTable: ${quote(relation.junctionTable)},
+				sourceField: ${quote(relation.sourceField ?? "")},
+				targetField: ${quote(relation.targetField ?? "")},
+			},`,
+			);
+		}
+
+		if (relationEntries.length === 0) {
+			continue;
+		}
+
+		tableEntries.push(
+			`${quote(tableName)}: {
+${relationEntries.map((entry) => `\t${entry}`).join("\n")}
+	},`,
+		);
+	}
+
+	if (tableEntries.length === 0) {
+		return "export const __appflareManyToMany = {} as const;\n";
+	}
+
+	return `export const __appflareManyToMany = {
+${tableEntries.map((entry) => `\t${entry}`).join("\n")}
+} as const;
+`;
+}
+
+function emitRuntimeRelationMetadata(definition: SchemaDefinition): string {
+	const tableEntries: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const relationEntries: string[] = [];
+
+		for (const [relationName, relation] of Object.entries(table.relations)) {
+			if (relation.relation === "one") {
+				relationEntries.push(
+					`${quote(relationName)}: {
+				kind: "one",
+				targetTable: ${quote(relation.targetTable)},
+				sourceField: ${quote(relation.field ?? "")},
+				referenceField: ${quote(relation.referenceField ?? "id")},
+			},`,
+				);
+				continue;
+			}
+
+			if (relation.relation === "many") {
+				relationEntries.push(
+					`${quote(relationName)}: {
+				kind: "many",
+				targetTable: ${quote(relation.targetTable)},
+				sourceField: ${quote(relation.field ?? "")},
+				referenceField: ${quote(relation.referenceField ?? "id")},
+			},`,
+				);
+				continue;
+			}
+
+			relationEntries.push(
+				`${quote(relationName)}: {
+			kind: "manyToMany",
+				targetTable: ${quote(relation.targetTable)},
+				junctionTable: ${quote(relation.junctionTable ?? "")},
+				sourceField: ${quote(relation.sourceField ?? "")},
+				targetField: ${quote(relation.targetField ?? "")},
+				referenceField: ${quote(relation.referenceField ?? "id")},
+				targetReferenceField: ${quote(relation.targetReferenceField ?? "id")},
+			},`,
+			);
+		}
+
+		if (relationEntries.length === 0) {
+			continue;
+		}
+
+		tableEntries.push(
+			`${quote(tableName)}: {
+${relationEntries.map((entry) => `\t${entry}`).join("\n")}
+	},`,
+		);
+	}
+
+	if (tableEntries.length === 0) {
+		return "export const __appflareRelations = {} as const;\n";
+	}
+
+	return `export const __appflareRelations = {
+${tableEntries.map((entry) => `\t${entry}`).join("\n")}
+} as const;
+`;
+}
+
+function emitDrizzleSchema(
+	definition: SchemaDefinition,
+	strategy: "camelToSnake",
+): string {
+	const localTables = new Set(Object.keys(definition.tables));
+	const externalTables = new Set<string>();
+
+	for (const table of Object.values(definition.tables)) {
+		for (const relationTarget of getRelationImports(table)) {
+			if (!localTables.has(relationTarget)) {
+				externalTables.add(relationTarget);
+			}
+		}
+		for (const column of Object.values(table.columns)) {
+			if (column.references && !localTables.has(column.references.table)) {
+				externalTables.add(column.references.table);
+			}
+		}
+	}
+
+	const tableBlocks: string[] = [];
+	const relationBlocks: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const sqlTableName = table.sqlName ?? toSnakeCase(tableName);
+		const columnLines: string[] = [];
+		const indexes: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			let expr = drizzleBaseColumn(fieldName, column, strategy);
+
+			if (column.uuidPrimaryKey) {
+				expr += ".$defaultFn(() => crypto.randomUUID())";
+			}
+
+			if (column.primaryKey) {
+				expr += column.autoIncrement
+					? ".primaryKey({ autoIncrement: true })"
+					: ".primaryKey()";
+			}
+			if (column.notNull) {
+				expr += ".notNull()";
+			}
+			if (column.sqlDefault !== undefined) {
+				expr += `.default(${toSqlLiteral(column.sqlDefault)})`;
+			}
+
+			const reference = resolveColumnReference(fieldName, column, table);
+			if (reference) {
+				if (column.references?.onDelete || column.references?.onUpdate) {
+					const actions: string[] = [];
+					if (column.references.onDelete) {
+						actions.push(`onDelete: ${quote(column.references.onDelete)}`);
+					}
+					if (column.references.onUpdate) {
+						actions.push(`onUpdate: ${quote(column.references.onUpdate)}`);
+					}
+					expr += `.references(() => ${reference.tableName}.${reference.fieldName}, { ${actions.join(", ")} })`;
+				} else {
+					expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
+				}
+			}
+
+			if (column.unique) {
+				const uniqueName =
+					typeof column.unique === "object" && column.unique.name
+						? column.unique.name
+						: `${sqlTableName}_${toSnakeCase(fieldName)}_unique_idx`;
+				indexes.push(
+					`\t\tt.uniqueIndex(${quote(uniqueName)}).on(table.${fieldName})`,
+				);
+			}
+
+			if (column.index) {
+				const indexName =
+					typeof column.index === "object" && column.index.name
+						? column.index.name
+						: `${sqlTableName}_${toSnakeCase(fieldName)}_idx`;
+				indexes.push(`\t\tt.index(${quote(indexName)}).on(table.${fieldName})`);
+			}
+
+			columnLines.push(`\t\t${fieldName}: ${expr},`);
+		}
+
+		if (indexes.length > 0) {
+			tableBlocks.push(
+				`export const ${tableName} = table(\n\t${quote(sqlTableName)},\n\t{\n${columnLines.join("\n")}\n\t},\n\t(table) => [\n${indexes.join(",\n")}\n\t],\n);`,
+			);
+		} else {
+			tableBlocks.push(
+				`export const ${tableName} = table(${quote(sqlTableName)}, {\n${columnLines.join("\n")}\n\t});`,
+			);
+		}
+
+		const oneRelations = Object.entries(table.relations).filter(
+			([, relation]) => {
+				return relation.relation === "one";
+			},
+		) as Array<[string, OneRelationDefinition]>;
+		const manyRelations = Object.entries(table.relations).filter(
+			([, relation]) => {
+				return relation.relation === "many";
+			},
+		) as Array<[string, ManyRelationDefinition]>;
+		const manyToManyRelations = Object.entries(table.relations).filter(
+			([, relation]) => {
+				return relation.relation === "manyToMany";
+			},
+		) as Array<[string, ManyToManyRelationDefinition]>;
+
+		if (
+			oneRelations.length === 0 &&
+			manyRelations.length === 0 &&
+			manyToManyRelations.length === 0
+		) {
+			continue;
+		}
+
+		const relationLines: string[] = [];
+		for (const [relationName, relation] of oneRelations) {
+			const resolved = resolveOneRelationReference(tableName, table, relation);
+			relationLines.push(
+				`\t${relationName}: one(${relation.targetTable}, {\n\t\tfields: [${tableName}.${resolved.sourceField}],\n\t\treferences: [${relation.targetTable}.${resolved.targetField}],\n\t}),`,
+			);
+		}
+		for (const [relationName, relation] of manyRelations) {
+			relationLines.push(`\t${relationName}: many(${relation.targetTable}),`);
+		}
+		for (const [relationName, relation] of manyToManyRelations) {
+			if (!relation.junctionTable) {
+				throw new Error(
+					`manyToMany relation '${tableName}.${relationName}' is missing junctionTable after normalization.`,
+				);
+			}
+			relationLines.push(`\t${relationName}: many(${relation.junctionTable}),`);
+		}
+
+		relationBlocks.push(
+			`export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({\n${relationLines.join("\n")}\n}));`,
+		);
+	}
+
+	return `import * as t from "drizzle-orm/sqlite-core";
+import { sqliteTable as table } from "drizzle-orm/sqlite-core";
+import { relations } from "drizzle-orm";
+${buildExternalTableImportLines(externalTables)}
+${tableBlocks.join("\n\n")}
+
+${relationBlocks.join("\n\n")}
+
+${emitManyToManyRuntimeMetadata(definition)}
+
+${emitRuntimeRelationMetadata(definition)}
+`;
+}
+
+function zodSchemaExpression(
+	column: ColumnDefinition,
+	optional: boolean,
+	nullable: boolean,
+): string {
+	let expr = "z.unknown()";
+	if (column.type === "int") {
+		expr = "z.number().int()";
+	} else if (column.type === "string") {
+		expr = "z.string()";
+		if (column.length !== undefined) {
+			expr += `.max(${column.length})`;
+		}
+	} else if (column.type === "boolean") {
+		expr = "z.boolean()";
+	} else if (column.type === "date") {
+		expr = "z.date()";
+	}
+
+	if (optional) {
+		expr += ".optional()";
+	}
+
+	if (nullable) {
+		expr += ".nullable()";
+	}
+
+	return expr;
+}
+
+function emitZodSchemas(definition: SchemaDefinition): string {
+	const blocks: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const pascal = toPascalCase(tableName);
+		const insertLines: string[] = [];
+		const selectLines: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			insertLines.push(
+				`\t${fieldName}: ${zodSchemaExpression(column, isOptionalInsertColumn(column), isNullableSelectColumn(column))},`,
+			);
+			selectLines.push(
+				`\t${fieldName}: ${zodSchemaExpression(column, isNullableSelectColumn(column), isNullableSelectColumn(column))},`,
+			);
+		}
+
+		blocks.push(`export const ${tableName}InsertSchema = z.object({\n${insertLines.join("\n")}\n});
+export const ${tableName}SelectSchema = z.object({\n${selectLines.join("\n")}\n});
+
+export type ${pascal}Insert = z.infer<typeof ${tableName}InsertSchema>;
+export type ${pascal}Select = z.infer<typeof ${tableName}SelectSchema>;
+`);
+	}
+
+	return `import { z } from "zod";
+
+${blocks.join("\n")}`;
+}
+
+function toTypeScriptType(column: ColumnDefinition): string {
+	if (column.type === "int") {
+		return "number";
+	}
+	if (column.type === "string") {
+		return "string";
+	}
+	if (column.type === "boolean") {
+		return "boolean";
+	}
+	if (column.type === "date") {
+		return "Date";
+	}
+	return "unknown";
+}
+
+function emitTypes(definition: SchemaDefinition): string {
+	const lines: string[] = [];
+
+	for (const [tableName, table] of Object.entries(definition.tables)) {
+		const pascal = toPascalCase(tableName);
+		const selectFields: string[] = [];
+		const insertFields: string[] = [];
+
+		for (const [fieldName, column] of Object.entries(table.columns)) {
+			const tsType = toTypeScriptType(column);
+			const nullableSuffix = isNullableSelectColumn(column) ? " | null" : "";
+			selectFields.push(
+				`\t${fieldName}${isNullableSelectColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
+			);
+			insertFields.push(
+				`\t${fieldName}${isOptionalInsertColumn(column) ? "?" : ""}: ${tsType}${nullableSuffix};`,
+			);
+		}
+
+		lines.push(`export type ${pascal} = {\n${selectFields.join("\n")}\n};
+
+export type New${pascal} = {\n${insertFields.join("\n")}\n};`);
+	}
+
+	return `${lines.join("\n\n")}
+`;
+}
+
+function findSchemaExport(
+	moduleExports: Record<string, unknown>,
+	exportName?: string,
+): SchemaDefinition {
+	if (exportName) {
+		const explicit = moduleExports[exportName];
+		if (!isSchemaDefinition(explicit)) {
+			throw new Error(
+				`schemaDsl.exportName '${exportName}' does not point to a schema() export.`,
+			);
+		}
+		return explicit;
+	}
+
+	for (const candidate of Object.values(moduleExports)) {
+		if (isSchemaDefinition(candidate)) {
+			return candidate;
+		}
+	}
+
+	throw new Error(
+		"No schema() export found in schemaDsl entry module. Set schemaDsl.exportName to the correct export.",
+	);
+}
+
+export async function compileSchemaDsl(
+	loadedConfig: LoadedAppflareConfig,
+): Promise<CompiledSchemaArtifacts | undefined> {
+	const schemaDsl = loadedConfig.config.schemaDsl;
+	if (!schemaDsl) {
+		return undefined;
+	}
+
+	const namingStrategy = schemaDsl.namingStrategy ?? "camelToSnake";
+	const entryPath = resolve(loadedConfig.configDir, schemaDsl.entry);
+	const outSchemaPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.outFile ?? resolve(loadedConfig.outDirAbs, "schema.compiled.ts"),
+	);
+	const outTypesPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.typesOutFile ??
+			resolve(loadedConfig.outDirAbs, "schema.types.ts"),
+	);
+	const outZodPath = resolve(
+		loadedConfig.configDir,
+		schemaDsl.zodOutFile ?? resolve(loadedConfig.outDirAbs, "schema.zod.ts"),
+	);
+
+	const moduleUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`;
+	const schemaModule = (await import(moduleUrl)) as Record<string, unknown>;
+	const schemaDefinition = findSchemaExport(schemaModule, schemaDsl.exportName);
+	const normalizedSchema = normalizeSchemaDefinition(schemaDefinition);
+
+	await Promise.all([
+		mkdir(dirname(outSchemaPath), { recursive: true }),
+		mkdir(dirname(outTypesPath), { recursive: true }),
+		mkdir(dirname(outZodPath), { recursive: true }),
+	]);
+
+	const drizzleSchemaSource = emitDrizzleSchema(
+		normalizedSchema,
+		namingStrategy,
+	);
+	const typesSource = emitTypes(normalizedSchema);
+	const zodSource = emitZodSchemas(normalizedSchema);
+
+	await Promise.all([
+		Bun.write(outSchemaPath, drizzleSchemaSource),
+		Bun.write(outTypesPath, typesSource),
+		Bun.write(outZodPath, zodSource),
+	]);
+
+	return {
+		schemaPath: outSchemaPath,
+		typesPath: outTypesPath,
+		zodPath: outZodPath,
+		tableNames: Object.keys(normalizedSchema.tables),
+	};
+}