@prisma-next/psl-printer 0.0.1

package/dist/index.mjs

@@ -0,0 +1,972 @@
+//#region src/default-mapping.ts
+const DEFAULT_FUNCTION_ATTRIBUTES = {
+	"autoincrement()": "@default(autoincrement())",
+	"now()": "@default(now())"
+};
+/**
+* Maps a normalized ColumnDefault to a PSL @default(...) attribute string,
+* or a comment for unrecognized expressions.
+*/
+function mapDefault(columnDefault, options) {
+	switch (columnDefault.kind) {
+		case "literal": return { attribute: `@default(${formatLiteralValue(columnDefault.value)})` };
+		case "function": {
+			const attribute = options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? options?.fallbackFunctionAttribute?.(columnDefault.expression);
+			return attribute ? { attribute } : { comment: `// Raw default: ${columnDefault.expression.replace(/[\r\n]+/g, " ")}` };
+		}
+	}
+}
+/**
+* Formats a literal value for use in @default(...).
+*/
+function formatLiteralValue(value) {
+	if (value === null) return "null";
+	if (isTaggedBigInt(value)) return value.value;
+	switch (typeof value) {
+		case "boolean":
+		case "number":
+		case "bigint": return String(value);
+		case "string": return quoteString(value);
+		default: return quoteString(JSON.stringify(value));
+	}
+}
+function isTaggedBigInt(value) {
+	return typeof value === "object" && value !== null && "$type" in value && value["$type"] === "bigint";
+}
+function quoteString(str) {
+	return `"${escapeString(str)}"`;
+}
+function escapeString(str) {
+	return JSON.stringify(str).slice(1, -1);
+}
+
+//#endregion
+//#region src/name-transforms.ts
+/**
+* PSL reserved words that cannot be used as identifiers without escaping.
+*/
+const PSL_RESERVED_WORDS = new Set([
+	"model",
+	"enum",
+	"types",
+	"type",
+	"generator",
+	"datasource"
+]);
+const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
+/**
+* Checks whether normalization needs to split or sanitize the identifier.
+*/
+function hasSeparators(input) {
+	return /[^A-Za-z0-9]/.test(input);
+}
+function extractIdentifierParts(input) {
+	return input.match(IDENTIFIER_PART_PATTERN) ?? [];
+}
+function createSyntheticIdentifier(input) {
+	let hash = 2166136261;
+	for (const char of input) {
+		hash ^= char.codePointAt(0) ?? 0;
+		hash = Math.imul(hash, 16777619);
+	}
+	return `x${(hash >>> 0).toString(16)}`;
+}
+function sanitizeIdentifierCharacters(input) {
+	const sanitized = input.replace(/[^\w]/g, "");
+	return sanitized.length > 0 ? sanitized : createSyntheticIdentifier(input);
+}
+function capitalize(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/**
+* Converts a normalized identifier to PascalCase.
+*/
+function snakeToPascalCase(input) {
+	const parts = extractIdentifierParts(input);
+	if (parts.length === 0) return capitalize(sanitizeIdentifierCharacters(input));
+	return parts.map(capitalize).join("");
+}
+/**
+* Converts a normalized identifier to camelCase.
+*/
+function snakeToCamelCase(input) {
+	const parts = extractIdentifierParts(input);
+	if (parts.length === 0) return sanitizeIdentifierCharacters(input);
+	const [firstPart = input, ...rest] = parts;
+	return firstPart.charAt(0).toLowerCase() + firstPart.slice(1) + rest.map(capitalize).join("");
+}
+/**
+* Checks if a name needs escaping (reserved word or starts with digit).
+*/
+function needsEscaping(name) {
+	return PSL_RESERVED_WORDS.has(name.toLowerCase()) || /^\d/.test(name);
+}
+/**
+* Escapes a name by prefixing with underscore.
+*/
+function escapeName(name) {
+	return `_${name}`;
+}
+function escapeIfNeeded(name) {
+	return needsEscaping(name) ? escapeName(name) : name;
+}
+/**
+* Converts a database table name to a PSL model name.
+* snake_case → PascalCase, with @@map("db_name") when the name was transformed.
+* Names that are already PascalCase (no separators, start with uppercase) are kept as-is.
+*/
+function toModelName(tableName) {
+	let name;
+	if (hasSeparators(tableName)) name = snakeToPascalCase(tableName);
+	else name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: tableName
+	};
+	if (name !== tableName) return {
+		name,
+		map: tableName
+	};
+	return { name };
+}
+/**
+* Converts a database column name to a PSL field name.
+* snake_case → camelCase, with @map("db_col") when the name was transformed.
+* Names that are already camelCase (no separators, start with lowercase) are kept as-is.
+*/
+function toFieldName(columnName) {
+	let name;
+	if (hasSeparators(columnName)) name = snakeToCamelCase(columnName);
+	else name = columnName.charAt(0).toLowerCase() + columnName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: columnName
+	};
+	if (name !== columnName) return {
+		name,
+		map: columnName
+	};
+	return { name };
+}
+/**
+* Converts a Postgres enum type name to a PSL enum name.
+* snake_case → PascalCase, with @@map when transformed.
+*/
+function toEnumName(pgTypeName) {
+	let name;
+	if (hasSeparators(pgTypeName)) name = snakeToPascalCase(pgTypeName);
+	else name = pgTypeName.charAt(0).toUpperCase() + pgTypeName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: pgTypeName
+	};
+	if (name !== pgTypeName) return {
+		name,
+		map: pgTypeName
+	};
+	return { name };
+}
+/**
+* Simple English pluralization for back-relation field names.
+* Handles: s→ses, y→ies, default→s
+*/
+function pluralize(word) {
+	if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) return `${word}es`;
+	if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
+	return `${word}s`;
+}
+/**
+* Derives a relation field name from FK column names.
+*
+* For single-column FKs: strip _id/Id suffix, camelCase the result.
+* For composite FKs: use the referenced table name (lowercased, camelCased).
+*/
+function deriveRelationFieldName(fkColumns, referencedTableName) {
+	if (fkColumns.length === 1) {
+		const [col = referencedTableName] = fkColumns;
+		const stripped = col.replace(/_id$/i, "").replace(/Id$/, "");
+		if (stripped.length > 0 && stripped !== col) return escapeIfNeeded(snakeToCamelCase(stripped));
+		return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+	}
+	return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+}
+/**
+* Derives a back-relation field name.
+* For 1:N: pluralize the child model name (lowercased first char).
+* For 1:1: lowercase first char of child model name.
+*/
+function deriveBackRelationFieldName(childModelName, isOneToOne) {
+	const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
+	return isOneToOne ? base : pluralize(base);
+}
+/**
+* Converts a column name to a named type name for the types block.
+* E.g., column "email" with type "character varying(255)" → "Email"
+*/
+function toNamedTypeName(columnName) {
+	let name;
+	if (hasSeparators(columnName)) name = snakeToPascalCase(columnName);
+	else name = columnName.charAt(0).toUpperCase() + columnName.slice(1);
+	return escapeIfNeeded(name);
+}
+
+//#endregion
+//#region src/relation-inference.ts
+/**
+* Default referential actions — when the FK uses these, we omit them from the PSL output.
+*/
+const DEFAULT_ON_DELETE = "noAction";
+const DEFAULT_ON_UPDATE = "noAction";
+/**
+* Maps SqlReferentialAction to PSL-compatible casing.
+*/
+const REFERENTIAL_ACTION_PSL = {
+	noAction: "NoAction",
+	restrict: "Restrict",
+	cascade: "Cascade",
+	setNull: "SetNull",
+	setDefault: "SetDefault"
+};
+/**
+* Infers relation fields from foreign keys across all tables.
+*
+* For each FK:
+* 1. Creates a relation field on the child table (the table with the FK)
+* 2. Creates a back-relation field on the parent table (the referenced table)
+* 3. Detects 1:1 vs 1:N cardinality
+* 4. Handles multiple FKs to the same parent (named relations)
+* 5. Handles self-referencing FKs
+*/
+function inferRelations(tables, modelNameMap) {
+	const relationsByTable = /* @__PURE__ */ new Map();
+	const fkCountByPair = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
+		const pairKey = `${table.name}→${fk.referencedTable}`;
+		fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
+	}
+	const usedFieldNames = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) {
+		const names = /* @__PURE__ */ new Set();
+		for (const col of Object.values(table.columns)) names.add(col.name);
+		usedFieldNames.set(table.name, names);
+	}
+	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
+		const childTableName = table.name;
+		const parentTableName = fk.referencedTable;
+		const childUsed = usedFieldNames.get(childTableName);
+		const childModelName = modelNameMap.get(childTableName) ?? childTableName;
+		const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
+		const pairKey = `${childTableName}→${parentTableName}`;
+		const isSelfRelation = childTableName === parentTableName;
+		const needsRelationName = fkCountByPair.get(pairKey) > 1 || isSelfRelation;
+		const isOneToOne = detectOneToOne(fk, table);
+		const childRelFieldName = resolveUniqueFieldName(deriveRelationFieldName(fk.columns, parentTableName), childUsed, parentModelName);
+		const relationName = needsRelationName ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation) : void 0;
+		addRelationField(relationsByTable, childTableName, buildChildRelationField(childRelFieldName, parentModelName, fk, fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false), relationName));
+		childUsed.add(childRelFieldName);
+		const parentUsed = usedFieldNames.get(parentTableName) ?? /* @__PURE__ */ new Set();
+		usedFieldNames.set(parentTableName, parentUsed);
+		const backRelFieldName = resolveUniqueFieldName(deriveBackRelationFieldName(childModelName, isOneToOne), parentUsed, childModelName);
+		addRelationField(relationsByTable, parentTableName, {
+			fieldName: backRelFieldName,
+			typeName: childModelName,
+			optional: isOneToOne,
+			list: !isOneToOne,
+			relationName
+		});
+		parentUsed.add(backRelFieldName);
+	}
+	return { relationsByTable };
+}
+/**
+* Detects whether a FK represents a 1:1 relationship.
+* A FK is 1:1 if:
+* - The FK columns exactly match the table's PK columns, OR
+* - The FK columns exactly match a unique constraint
+*/
+function detectOneToOne(fk, table) {
+	const fkCols = [...fk.columns].sort();
+	if (table.primaryKey) {
+		const pkCols = [...table.primaryKey.columns].sort();
+		if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) return true;
+	}
+	for (const unique of table.uniques) {
+		const uniqueCols = [...unique.columns].sort();
+		if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) return true;
+	}
+	return false;
+}
+/**
+* Derives a relation name for disambiguation.
+* Uses the FK constraint name if available, otherwise generates one from the relation shape.
+*/
+function deriveRelationName(fk, childRelationFieldName, parentModelName, isSelfRelation) {
+	if (fk.name) return fk.name;
+	if (isSelfRelation) return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
+	return fk.columns.join("_");
+}
+/**
+* Builds a child-side relation field with @relation attributes.
+*/
+function buildChildRelationField(fieldName, parentModelName, fk, optional, relationName) {
+	const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : void 0;
+	const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : void 0;
+	return {
+		fieldName,
+		typeName: parentModelName,
+		referencedTableName: fk.referencedTable,
+		optional,
+		list: false,
+		relationName,
+		fkName: fk.name,
+		fields: fk.columns,
+		references: fk.referencedColumns,
+		onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : void 0,
+		onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : void 0
+	};
+}
+/**
+* Resolves a unique field name by appending the model name if there's a collision.
+*/
+function resolveUniqueFieldName(desired, usedNames, fallbackSuffix) {
+	if (!usedNames.has(desired)) return desired;
+	const withSuffix = `${desired}${fallbackSuffix}`;
+	if (!usedNames.has(withSuffix)) return withSuffix;
+	let counter = 2;
+	while (usedNames.has(`${desired}${counter}`)) counter++;
+	return `${desired}${counter}`;
+}
+function addRelationField(map, tableName, field) {
+	const existing = map.get(tableName);
+	if (existing) existing.push(field);
+	else map.set(tableName, [field]);
+}
+
+//#endregion
+//#region src/print-psl.ts
+const DEFAULT_HEADER = "// This file was introspected from the database. Do not edit manually.";
+/**
+* Escapes a string for use inside a PSL double-quoted context (e.g., @map("..."), @relation(name: "...")).
+* Prevents malformed PSL when database identifiers contain `"` or newlines.
+*/
+function escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+const PSL_IDENTIFIER_PATTERN = /^[A-Za-z_]\w*$/;
+const ENUM_MEMBER_RESERVED_WORDS = new Set([
+	"datasource",
+	"default",
+	"enum",
+	"generator",
+	"model",
+	"type",
+	"types"
+]);
+const PSL_SCALAR_TYPE_NAMES = new Set([
+	"String",
+	"Boolean",
+	"Int",
+	"BigInt",
+	"Float",
+	"Decimal",
+	"DateTime",
+	"Json",
+	"Bytes"
+]);
+/**
+* Converts a SqlSchemaIR to a PSL (Prisma Schema Language) string.
+*
+* The output follows PSL formatting conventions:
+* - Header comment
+* - `types` block (if parameterized types exist)
+* - `enum` blocks (alphabetical)
+* - `model` blocks (topologically sorted by FK deps, alphabetical fallback)
+*
+* @param schemaIR - The introspected schema IR
+* @param options - Printer configuration (type map, header)
+* @returns A valid PSL string
+*/
+function printPsl(schemaIR, options) {
+	const { typeMap, header, defaultMapping, enumInfo, parseRawDefault } = options;
+	const headerComment = header ?? DEFAULT_HEADER;
+	const { typeNames: enumTypeNames, definitions: enumDefinitions } = enumInfo ?? {
+		typeNames: /* @__PURE__ */ new Set(),
+		definitions: /* @__PURE__ */ new Map()
+	};
+	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
+	const enumNames = buildTopLevelNameMap(enumTypeNames, toEnumName, "enum", "enum type");
+	assertNoCrossKindNameCollisions(modelNames, enumNames);
+	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
+	const enumNameMap = new Map([...enumNames].map(([pgTypeName, result]) => [pgTypeName, result.name]));
+	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNames);
+	const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
+	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
+	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
+	const models = [];
+	for (const table of Object.values(schemaIR.tables)) {
+		const model = processTable(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, parseRawDefault, relationsByTable.get(table.name) ?? []);
+		models.push(model);
+	}
+	const enums = [];
+	for (const [pgTypeName, values] of enumDefinitions) {
+		const enumName = enumNames.get(pgTypeName);
+		enums.push({
+			name: enumName.name,
+			mapName: enumName.map,
+			values
+		});
+	}
+	enums.sort((a, b) => a.name.localeCompare(b.name));
+	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
+	const sections = [];
+	sections.push(headerComment);
+	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
+	if (namedTypeEntries.length > 0) sections.push(serializeTypesBlock(namedTypeEntries));
+	for (const e of enums) sections.push(serializeEnum(e));
+	for (const model of sortedModels) sections.push(serializeModel(model));
+	return `${sections.join("\n\n")}\n`;
+}
+/**
+* Processes a SQL table into a PrinterModel.
+*/
+function processTable(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields) {
+	const { name: modelName, map: mapName } = toModelName(table.name);
+	const fieldNameMap = fieldNamesByTable.get(table.name);
+	const pkColumns = new Set(table.primaryKey?.columns ?? []);
+	const isSinglePk = pkColumns.size === 1;
+	const singlePkConstraintName = isSinglePk ? table.primaryKey?.name : void 0;
+	const uniqueColumns = /* @__PURE__ */ new Map();
+	for (const unique of table.uniques) if (unique.columns.length === 1) {
+		const [columnName = ""] = unique.columns;
+		const existingConstraintName = uniqueColumns.get(columnName);
+		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
+	}
+	const fields = [];
+	const columnEntries = Object.values(table.columns);
+	for (const column of columnEntries) {
+		const resolvedField = fieldNameMap?.get(column.name);
+		const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
+		const fieldMap = resolvedField?.fieldMap;
+		const resolution = typeMap.resolve(column.nativeType, table.annotations);
+		if ("unsupported" in resolution) {
+			fields.push({
+				name: fieldName,
+				typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
+				optional: column.nullable,
+				list: false,
+				attributes: fieldMap ? [`@map("${escapePslString(fieldMap)}")`] : [],
+				mapName: fieldMap ?? void 0,
+				isId: false,
+				isRelation: false,
+				isUnsupported: true
+			});
+			continue;
+		}
+		let typeName = resolution.pslType;
+		const enumPslName = enumNameMap.get(column.nativeType);
+		if (enumPslName) typeName = enumPslName;
+		if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
+		const attributes = [];
+		const isId = isSinglePk && pkColumns.has(column.name);
+		if (isId) attributes.push(formatFieldConstraintAttribute("@id", singlePkConstraintName));
+		let comment;
+		if (column.default !== void 0) {
+			const parsed = parseDefaultIfNeeded(column.default, column.nativeType, rawDefaultParser);
+			if (parsed) {
+				const result = mapDefault(parsed, defaultMapping);
+				if ("attribute" in result) attributes.push(result.attribute);
+				else comment = result.comment;
+			}
+		}
+		const uniqueConstraintName = uniqueColumns.get(column.name);
+		if (uniqueConstraintName !== void 0 || uniqueColumns.has(column.name)) {
+			if (!isId) attributes.push(formatFieldConstraintAttribute("@unique", uniqueConstraintName));
+		}
+		if (fieldMap) attributes.push(`@map("${escapePslString(fieldMap)}")`);
+		fields.push({
+			name: fieldName,
+			typeName,
+			optional: column.nullable,
+			list: false,
+			attributes,
+			mapName: fieldMap ?? void 0,
+			isId,
+			isRelation: false,
+			isUnsupported: false,
+			comment
+		});
+	}
+	const usedFieldNames = new Set(fields.map((field) => field.name));
+	for (const rel of relationFields) {
+		const relationFieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
+		const relAttributes = [];
+		if (rel.fields && rel.references) {
+			const parts = [];
+			if (rel.relationName) parts.push(`name: "${escapePslString(rel.relationName)}"`);
+			parts.push(`fields: [${rel.fields.map((fieldName) => resolveColumnFieldName(fieldNamesByTable, table.name, fieldName)).join(", ")}]`);
+			parts.push(`references: [${rel.references.map((fieldName) => resolveColumnFieldName(fieldNamesByTable, rel.referencedTableName ?? "", fieldName)).join(", ")}]`);
+			if (rel.onDelete) parts.push(`onDelete: ${rel.onDelete}`);
+			if (rel.onUpdate) parts.push(`onUpdate: ${rel.onUpdate}`);
+			if (rel.fkName) parts.push(`map: "${escapePslString(rel.fkName)}"`);
+			relAttributes.push(`@relation(${parts.join(", ")})`);
+		} else if (rel.relationName) relAttributes.push(`@relation(name: "${escapePslString(rel.relationName)}")`);
+		fields.push({
+			name: relationFieldName,
+			typeName: rel.typeName,
+			optional: rel.optional,
+			list: rel.list,
+			attributes: relAttributes,
+			isId: false,
+			isRelation: true,
+			isUnsupported: false
+		});
+		usedFieldNames.add(relationFieldName);
+	}
+	const modelAttributes = [];
+	if (table.primaryKey && table.primaryKey.columns.length > 1) {
+		const pkFieldNames = table.primaryKey.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(formatModelConstraintAttribute("@@id", pkFieldNames, table.primaryKey.name));
+	}
+	for (const unique of table.uniques) if (unique.columns.length > 1) {
+		const fieldNames = unique.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(formatModelConstraintAttribute("@@unique", fieldNames, unique.name));
+	}
+	for (const index of table.indexes) if (!index.unique) {
+		const fieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(formatModelConstraintAttribute("@@index", fieldNames, index.name));
+	}
+	if (mapName) modelAttributes.push(`@@map("${escapePslString(mapName)}")`);
+	const tableComment = !table.primaryKey ? "// WARNING: This table has no primary key in the database" : void 0;
+	return {
+		name: modelName,
+		mapName: mapName ?? void 0,
+		fields,
+		modelAttributes,
+		comment: tableComment
+	};
+}
+function parseDefaultIfNeeded(value, nativeType, rawDefaultParser) {
+	if (typeof value === "string") return rawDefaultParser ? rawDefaultParser(value, nativeType) : void 0;
+	return value;
+}
+function formatFieldConstraintAttribute(attribute, constraintName) {
+	return constraintName ? `${attribute}(map: "${escapePslString(constraintName)}")` : attribute;
+}
+function formatModelConstraintAttribute(attribute, fields, constraintName) {
+	const parts = [`[${fields.join(", ")}]`];
+	if (constraintName) parts.push(`map: "${escapePslString(constraintName)}"`);
+	return `${attribute}(${parts.join(", ")})`;
+}
+function buildFieldNamesByTable(tables) {
+	const fieldNamesByTable = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) {
+		const assignmentOrder = [...Object.values(table.columns).map((column, index) => {
+			const { name, map } = toFieldName(column.name);
+			return {
+				columnName: column.name,
+				desiredFieldName: name,
+				fieldMap: map,
+				index
+			};
+		})].sort((left, right) => {
+			const mapComparison = Number(left.fieldMap !== void 0) - Number(right.fieldMap !== void 0);
+			if (mapComparison !== 0) return mapComparison;
+			return left.index - right.index;
+		});
+		const usedFieldNames = /* @__PURE__ */ new Set();
+		const tableFieldNames = /* @__PURE__ */ new Map();
+		for (const column of assignmentOrder) {
+			const fieldName = createUniqueFieldName(column.desiredFieldName, usedFieldNames);
+			usedFieldNames.add(fieldName);
+			tableFieldNames.set(column.columnName, {
+				fieldName,
+				fieldMap: column.fieldMap
+			});
+		}
+		fieldNamesByTable.set(table.name, tableFieldNames);
+	}
+	return fieldNamesByTable;
+}
+function resolveColumnFieldName(fieldNamesByTable, tableName, columnName) {
+	return fieldNamesByTable.get(tableName)?.get(columnName)?.fieldName ?? toFieldName(columnName).name;
+}
+function createUniqueFieldName(desiredName, usedFieldNames) {
+	if (!usedFieldNames.has(desiredName)) return desiredName;
+	let counter = 2;
+	while (usedFieldNames.has(`${desiredName}${counter}`)) counter++;
+	return `${desiredName}${counter}`;
+}
+function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
+	const results = /* @__PURE__ */ new Map();
+	const normalizedToSources = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const normalized = normalize(source);
+		results.set(source, normalized);
+		normalizedToSources.set(normalized.name, [...normalizedToSources.get(normalized.name) ?? [], source]);
+	}
+	const duplicates = [...normalizedToSources.entries()].filter(([, conflictingSources]) => conflictingSources.length > 1);
+	if (duplicates.length > 0) {
+		const details = duplicates.map(([normalizedName, conflictingSources]) => `- ${kind} "${normalizedName}" from ${sourceKind}s ${conflictingSources.map((source) => `"${source}"`).join(", ")}`);
+		throw new Error(`PSL ${kind} name collisions detected:\n${details.join("\n")}`);
+	}
+	return results;
+}
+function assertNoCrossKindNameCollisions(modelNames, enumNames) {
+	const enumSourceByName = new Map([...enumNames].map(([source, result]) => [result.name, source]));
+	const collisions = [...modelNames.entries()].map(([tableName, result]) => {
+		const enumSource = enumSourceByName.get(result.name);
+		return enumSource ? `- identifier "${result.name}" from table "${tableName}" collides with enum type "${enumSource}"` : void 0;
+	}).filter((detail) => detail !== void 0);
+	if (collisions.length > 0) throw new Error(`PSL top-level name collisions detected:\n${collisions.join("\n")}`);
+}
+function createReservedNamedTypeNames(modelNames, enumNames) {
+	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
+	for (const result of modelNames.values()) reservedNames.add(result.name);
+	for (const result of enumNames.values()) reservedNames.add(result.name);
+	return reservedNames;
+}
+function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {
+	const seeds = /* @__PURE__ */ new Map();
+	for (const tableName of Object.keys(schemaIR.tables).sort()) {
+		const table = schemaIR.tables[tableName];
+		if (!table) continue;
+		for (const columnName of Object.keys(table.columns).sort()) {
+			const column = table.columns[columnName];
+			if (!column) continue;
+			const resolution = typeMap.resolve(column.nativeType, table.annotations);
+			if ("unsupported" in resolution || enumNameMap.has(column.nativeType) || !resolution.nativeTypeAttribute) continue;
+			const signatureKey = createNamedTypeSignatureKey(resolution);
+			if (!seeds.has(signatureKey)) seeds.set(signatureKey, {
+				baseType: resolution.pslType,
+				desiredName: toNamedTypeName(column.name),
+				attributes: [renderNativeTypeAttribute(resolution.nativeTypeAttribute)]
+			});
+		}
+	}
+	const registry = {
+		entriesByKey: /* @__PURE__ */ new Map(),
+		usedNames: new Set(reservedNames)
+	};
+	const sortedSeeds = [...seeds.entries()].sort((left, right) => {
+		const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
+		if (desiredNameComparison !== 0) return desiredNameComparison;
+		return left[0].localeCompare(right[0]);
+	});
+	for (const [signatureKey, seed] of sortedSeeds) {
+		const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
+		registry.entriesByKey.set(signatureKey, {
+			name,
+			baseType: seed.baseType,
+			attributes: seed.attributes
+		});
+		registry.usedNames.add(name);
+	}
+	return registry;
+}
+function resolveNamedTypeName(registry, resolution) {
+	const key = createNamedTypeSignatureKey(resolution);
+	const existing = registry.entriesByKey.get(key);
+	if (existing) return existing.name;
+	throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
+}
+function createNamedTypeSignatureKey(resolution) {
+	return JSON.stringify({
+		baseType: resolution.pslType,
+		nativeTypeAttribute: resolution.nativeTypeAttribute ? {
+			name: resolution.nativeTypeAttribute.name,
+			args: resolution.nativeTypeAttribute.args ?? null
+		} : null
+	});
+}
+function isNormalizedEnumMemberReservedWord(value) {
+	return ENUM_MEMBER_RESERVED_WORDS.has(value.toLowerCase());
+}
+function normalizeEnumMemberName(value, usedNames) {
+	return createUniqueFieldName(PSL_IDENTIFIER_PATTERN.test(value) && !isNormalizedEnumMemberReservedWord(value) ? value : createNormalizedEnumMemberBaseName(value), usedNames);
+}
+function createNormalizedEnumMemberBaseName(value) {
+	const tokens = value.match(/[A-Za-z0-9]+/g)?.map((token) => token.toLowerCase()) ?? [];
+	let normalized = tokens[0] ?? "value";
+	for (const token of tokens.slice(1)) normalized += token.charAt(0).toUpperCase() + token.slice(1);
+	if (isNormalizedEnumMemberReservedWord(normalized) || /^\d/.test(normalized)) normalized = `_${normalized}`;
+	return normalized;
+}
+/**
+* Topologically sorts models by FK dependencies.
+* Parent tables (those referenced by FKs) come before child tables.
+* Alphabetical fallback for cycles.
+*/
+function topologicalSort(models, tables, modelNameMap) {
+	const modelByName = /* @__PURE__ */ new Map();
+	for (const model of models) modelByName.set(model.name, model);
+	const deps = /* @__PURE__ */ new Map();
+	const tableToModel = /* @__PURE__ */ new Map();
+	for (const tableName of Object.keys(tables)) {
+		const modelName = modelNameMap.get(tableName);
+		tableToModel.set(tableName, modelName);
+		deps.set(modelName, /* @__PURE__ */ new Set());
+	}
+	for (const [tableName, table] of Object.entries(tables)) {
+		const modelName = tableToModel.get(tableName);
+		for (const fk of table.foreignKeys) {
+			const refModelName = tableToModel.get(fk.referencedTable);
+			if (refModelName && refModelName !== modelName) deps.get(modelName).add(refModelName);
+		}
+	}
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const sortedNames = [...deps.keys()].sort();
+	function visit(name) {
+		if (visited.has(name)) return;
+		if (visiting.has(name)) return;
+		visiting.add(name);
+		const sortedDeps = [...deps.get(name)].sort();
+		for (const dep of sortedDeps) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		result.push(modelByName.get(name));
+	}
+	for (const name of sortedNames) visit(name);
+	return result;
+}
+/**
+* Serializes the `types` block.
+*/
+function serializeTypesBlock(namedTypes) {
+	const lines = ["types {"];
+	for (const nt of namedTypes) {
+		const attrStr = nt.attributes.length > 0 ? ` ${nt.attributes.join(" ")}` : "";
+		lines.push(`  ${nt.name} = ${nt.baseType}${attrStr}`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+function renderNativeTypeAttribute(attribute) {
+	if (!attribute.args || attribute.args.length === 0) return `@${attribute.name}`;
+	return `@${attribute.name}(${attribute.args.join(", ")})`;
+}
+/**
+* Serializes an enum block.
+*/
+function serializeEnum(e) {
+	const lines = [`enum ${e.name} {`];
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const value of e.values) {
+		const memberName = normalizeEnumMemberName(value, usedNames);
+		lines.push(`  ${memberName}`);
+		usedNames.add(memberName);
+	}
+	if (e.mapName) {
+		lines.push("");
+		lines.push(`  @@map("${escapePslString(e.mapName)}")`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Serializes a model block with column-aligned fields.
+*/
+function serializeModel(model) {
+	const lines = [];
+	if (model.comment) lines.push(model.comment);
+	lines.push(`model ${model.name} {`);
+	const idFields = model.fields.filter((f) => f.isId);
+	const scalarFields = model.fields.filter((f) => !f.isId && !f.isRelation);
+	const relationFields = model.fields.filter((f) => f.isRelation);
+	const allOrderedFields = [
+		...idFields,
+		...scalarFields,
+		...relationFields
+	];
+	if (allOrderedFields.length > 0) {
+		const maxNameLen = Math.max(...allOrderedFields.map((f) => f.name.length));
+		const maxTypeLen = Math.max(...allOrderedFields.map((f) => formatFieldType(f).length));
+		for (const field of allOrderedFields) {
+			const typePart = formatFieldType(field);
+			const paddedName = field.name.padEnd(maxNameLen);
+			const paddedType = typePart.padEnd(maxTypeLen);
+			if (field.comment) lines.push(`  ${field.comment}`);
+			const attrStr = field.attributes.length > 0 ? ` ${field.attributes.join(" ")}` : "";
+			lines.push(`  ${paddedName} ${paddedType}${attrStr}`.trimEnd());
+		}
+	}
+	if (model.modelAttributes.length > 0) {
+		if (allOrderedFields.length > 0) lines.push("");
+		for (const attr of model.modelAttributes) lines.push(`  ${attr}`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Formats a field type string with optional/list modifiers.
+*/
+function formatFieldType(field) {
+	let type = field.typeName;
+	if (field.list) type += "[]";
+	else if (field.optional) type += "?";
+	return type;
+}
+
+//#endregion
+//#region src/schema-validation.ts
+const REFERENTIAL_ACTIONS = new Set([
+	"noAction",
+	"restrict",
+	"cascade",
+	"setNull",
+	"setDefault"
+]);
+function validatePrintableSqlSchemaIR(value) {
+	const root = expectRecord(value, "schema");
+	return {
+		tables: validateTables(root["tables"], "schema.tables"),
+		dependencies: validateDependencies(root["dependencies"], "schema.dependencies"),
+		...ifDefined("annotations", validateAnnotations(root["annotations"], "schema.annotations"))
+	};
+}
+function validateTables(value, path) {
+	const tables = expectRecord(value, path);
+	const validated = {};
+	for (const [tableName, tableValue] of Object.entries(tables)) {
+		const tablePath = `${path}.${tableName}`;
+		const table = expectRecord(tableValue, tablePath);
+		validated[tableName] = {
+			name: expectString(table["name"], `${tablePath}.name`),
+			columns: validateColumns(table["columns"], `${tablePath}.columns`),
+			foreignKeys: validateForeignKeys(table["foreignKeys"], `${tablePath}.foreignKeys`),
+			uniques: validateUniques(table["uniques"], `${tablePath}.uniques`),
+			indexes: validateIndexes(table["indexes"], `${tablePath}.indexes`),
+			...ifDefined("primaryKey", validatePrimaryKey(table["primaryKey"], `${tablePath}.primaryKey`)),
+			...ifDefined("annotations", validateAnnotations(table["annotations"], `${tablePath}.annotations`))
+		};
+	}
+	return validated;
+}
+function validateColumns(value, path) {
+	const columns = expectRecord(value, path);
+	const validated = {};
+	for (const [columnName, columnValue] of Object.entries(columns)) {
+		const columnPath = `${path}.${columnName}`;
+		const column = expectRecord(columnValue, columnPath);
+		validated[columnName] = {
+			name: expectString(column["name"], `${columnPath}.name`),
+			nativeType: expectString(column["nativeType"], `${columnPath}.nativeType`),
+			nullable: expectBoolean(column["nullable"], `${columnPath}.nullable`),
+			...ifDefined("default", validateColumnDefault(column["default"], `${columnPath}.default`)),
+			...ifDefined("annotations", validateAnnotations(column["annotations"], `${columnPath}.annotations`))
+		};
+	}
+	return validated;
+}
+function validatePrimaryKey(value, path) {
+	if (value === void 0) return;
+	const primaryKey = expectRecord(value, path);
+	return {
+		columns: validateStringArray(primaryKey["columns"], `${path}.columns`),
+		...ifDefined("name", validateOptionalString(primaryKey["name"], `${path}.name`))
+	};
+}
+function validateForeignKeys(value, path) {
+	return expectArray(value, path).map((foreignKey, index) => {
+		const foreignKeyPath = `${path}[${index}]`;
+		const record = expectRecord(foreignKey, foreignKeyPath);
+		return {
+			columns: validateStringArray(record["columns"], `${foreignKeyPath}.columns`),
+			referencedTable: expectString(record["referencedTable"], `${foreignKeyPath}.referencedTable`),
+			referencedColumns: validateStringArray(record["referencedColumns"], `${foreignKeyPath}.referencedColumns`),
+			...ifDefined("name", validateOptionalString(record["name"], `${foreignKeyPath}.name`)),
+			...ifDefined("onDelete", validateReferentialAction(record["onDelete"], `${foreignKeyPath}.onDelete`)),
+			...ifDefined("onUpdate", validateReferentialAction(record["onUpdate"], `${foreignKeyPath}.onUpdate`)),
+			...ifDefined("annotations", validateAnnotations(record["annotations"], `${foreignKeyPath}.annotations`))
+		};
+	});
+}
+function validateUniques(value, path) {
+	return expectArray(value, path).map((uniqueValue, index) => {
+		const uniquePath = `${path}[${index}]`;
+		const unique = expectRecord(uniqueValue, uniquePath);
+		return {
+			columns: validateStringArray(unique["columns"], `${uniquePath}.columns`),
+			...ifDefined("name", validateOptionalString(unique["name"], `${uniquePath}.name`)),
+			...ifDefined("annotations", validateAnnotations(unique["annotations"], `${uniquePath}.annotations`))
+		};
+	});
+}
+function validateIndexes(value, path) {
+	return expectArray(value, path).map((indexValue, index) => {
+		const indexPath = `${path}[${index}]`;
+		const record = expectRecord(indexValue, indexPath);
+		return {
+			columns: validateStringArray(record["columns"], `${indexPath}.columns`),
+			unique: expectBoolean(record["unique"], `${indexPath}.unique`),
+			...ifDefined("name", validateOptionalString(record["name"], `${indexPath}.name`)),
+			...ifDefined("annotations", validateAnnotations(record["annotations"], `${indexPath}.annotations`))
+		};
+	});
+}
+function validateDependencies(value, path) {
+	return expectArray(value, path).map((dependencyValue, index) => {
+		const dependencyPath = `${path}[${index}]`;
+		return { id: expectString(expectRecord(dependencyValue, dependencyPath)["id"], `${dependencyPath}.id`) };
+	});
+}
+function validateAnnotations(value, path) {
+	if (value === void 0) return;
+	return expectRecord(value, path);
+}
+function validateColumnDefault(value, path) {
+	if (value === void 0) return;
+	if (typeof value === "string") return value;
+	const columnDefault = expectRecord(value, path);
+	const kind = expectString(columnDefault["kind"], `${path}.kind`);
+	if (kind === "literal") {
+		if (!Object.hasOwn(columnDefault, "value")) throw new Error(`${path}.value must be present for literal defaults`);
+		return {
+			kind: "literal",
+			value: columnDefault["value"]
+		};
+	}
+	if (kind === "function") return {
+		kind: "function",
+		expression: expectString(columnDefault["expression"], `${path}.expression`)
+	};
+	throw new Error(`${path}.kind must be "literal" or "function"`);
+}
+function validateReferentialAction(value, path) {
+	if (value === void 0) return;
+	const action = expectString(value, path);
+	if (!REFERENTIAL_ACTIONS.has(action)) throw new Error(`${path} must be one of ${[...REFERENTIAL_ACTIONS].map((item) => `"${item}"`).join(", ")}`);
+	return action;
+}
+function validateStringArray(value, path) {
+	return expectArray(value, path).map((item, index) => expectString(item, `${path}[${index}]`));
+}
+function validateOptionalString(value, path) {
+	if (value === void 0) return;
+	return expectString(value, path);
+}
+function expectRecord(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${path} must be an object`);
+	return value;
+}
+function expectArray(value, path) {
+	if (!Array.isArray(value)) throw new Error(`${path} must be an array`);
+	return value;
+}
+function expectString(value, path) {
+	if (typeof value !== "string") throw new Error(`${path} must be a string`);
+	return value;
+}
+function expectBoolean(value, path) {
+	if (typeof value !== "boolean") throw new Error(`${path} must be a boolean`);
+	return value;
+}
+function ifDefined(key, value) {
+	if (value === void 0) return {};
+	return { [key]: value };
+}
+
+//#endregion
+export { printPsl, validatePrintableSqlSchemaIR };
+//# sourceMappingURL=index.mjs.map