@prisma-next/psl-printer 0.5.0-dev.9 → 0.5.0

package/dist/index.mjs

@@ -1,352 +1,4 @@
-//#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";
-	switch (typeof value) {
-		case "boolean":
-		case "number": return String(value);
-		case "string": return quoteString(value);
-		default: return quoteString(JSON.stringify(value));
-	}
-}
-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");
-}
+//#region src/serialize-print-document.ts
 const PSL_IDENTIFIER_PATTERN = /^[A-Za-z_]\w*$/;
 const ENUM_MEMBER_RESERVED_WORDS = new Set([
 	"datasource",
@@ -357,377 +9,19 @@ const ENUM_MEMBER_RESERVED_WORDS = new Set([
 	"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);
+function escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function serializePrintDocument(doc) {
 	const sections = [];
-	sections.push(headerComment);
-	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
+	sections.push(doc.headerComment);
+	const namedTypeEntries = [...doc.namedTypes].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));
+	const enumsSorted = [...doc.enums].sort((a, b) => a.name.localeCompare(b.name));
+	for (const e of enumsSorted) sections.push(serializeEnum(e));
+	for (const model of doc.models) 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) {
@@ -737,19 +31,15 @@ function serializeTypesBlock(namedTypes) {
 	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}`);
+		const memberName = normalizeEnumMemberName(value.name, usedNames);
+		const explicitMap = value.mapName;
+		const storageLabel = explicitMap !== void 0 ? explicitMap : memberName !== value.name ? value.name : void 0;
+		if (storageLabel !== void 0) lines.push(`  ${memberName} @map("${escapePslString(storageLabel)}")`);
+		else lines.push(`  ${memberName}`);
 		usedNames.add(memberName);
 	}
 	if (e.mapName) {
@@ -759,9 +49,6 @@ function serializeEnum(e) {
 	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);
@@ -793,175 +80,220 @@ function serializeModel(model) {
 	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 createUniqueFieldName(desiredName, usedFieldNames) {
+	if (!usedFieldNames.has(desiredName)) return desiredName;
+	let counter = 2;
+	while (usedFieldNames.has(`${desiredName}${counter}`)) counter++;
+	return `${desiredName}${counter}`;
 }
-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 isNormalizedEnumMemberReservedWord(value) {
+	return ENUM_MEMBER_RESERVED_WORDS.has(value.toLowerCase());
 }
-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 normalizeEnumMemberName(value, usedNames) {
+	return createUniqueFieldName(PSL_IDENTIFIER_PATTERN.test(value) && !isNormalizedEnumMemberReservedWord(value) ? value : createNormalizedEnumMemberBaseName(value), usedNames);
 }
-function validatePrimaryKey(value, path) {
-	if (value === void 0) return;
-	const primaryKey = expectRecord(value, path);
+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;
+}
+//#endregion
+//#region src/ast-to-print-document.ts
+const DEFAULT_AST_PRINT_HEADER = "// Contract inferred from the live database schema. Edit as needed, then run `prisma-next contract emit`.";
+function astDocumentToPrintDocument(ast) {
+	const modelNames = new Set(ast.models.map((m) => m.name));
+	const deps = buildModelFkDeps(ast.models, modelNames);
+	const sortedModels = topologicalSortModels(ast.models, deps);
+	const namedTypes = ast.types ? ast.types.declarations.map(namedTypeDeclarationToPrinterNamedType) : [];
+	const enums = ast.enums.map(enumToPrinterEnum);
+	const printerModels = sortedModels.map((m) => modelToPrinterModel(m));
 	return {
-		columns: validateStringArray(primaryKey["columns"], `${path}.columns`),
-		...ifDefined("name", validateOptionalString(primaryKey["name"], `${path}.name`))
+		headerComment: DEFAULT_AST_PRINT_HEADER,
+		namedTypes,
+		enums: enums.map((e) => ({
+			name: e.name,
+			mapName: e.mapName,
+			values: e.values
+		})),
+		models: printerModels
 	};
 }
-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 renderPslAttribute(attr) {
+	const prefix = attr.target === "model" || attr.target === "enum" ? "@@" : "@";
+	if (attr.args.length === 0) return `${prefix}${attr.name}`;
+	const inner = attr.args.map(renderAttributeArgument).join(", ");
+	return `${prefix}${attr.name}(${inner})`;
 }
-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 renderAttributeArgument(arg) {
+	if (arg.kind === "positional") return arg.value;
+	return `${arg.name}: ${arg.value}`;
 }
-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 namedTypeDeclarationToPrinterNamedType(decl) {
+	const base = decl.baseType ?? (decl.typeConstructor !== void 0 ? formatTypeConstructor(decl.typeConstructor) : "");
+	const attributes = decl.attributes.map(renderPslAttribute);
+	return {
+		name: decl.name,
+		baseType: base,
+		attributes
+	};
 }
-function validateAnnotations(value, path) {
-	if (value === void 0) return;
-	return expectRecord(value, path);
+function formatTypeConstructor(tc) {
+	const path = tc.path.join(".");
+	if (tc.args.length === 0) return path;
+	return `${path}(${tc.args.map(renderAttributeArgument).join(", ")})`;
 }
-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"]
-		};
+function enumToPrinterEnum(en) {
+	let mapName;
+	for (const a of en.attributes) if (a.name === "map" && a.target === "enum") {
+		const quoted = getPositionalStringArg(a, 0);
+		if (quoted !== void 0) mapName = quoted;
 	}
-	if (kind === "function") return {
-		kind: "function",
-		expression: expectString(columnDefault["expression"], `${path}.expression`)
+	return {
+		name: en.name,
+		mapName,
+		values: en.values.map((v) => ({
+			name: v.name,
+			...v.mapName !== void 0 ? { mapName: v.mapName } : {}
+		}))
 	};
-	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 getPositionalStringArg(attr, index) {
+	const raw = attr.args.filter((a) => a.kind === "positional")[index]?.value.trim();
+	if (!raw) return void 0;
+	const m = raw.match(/^(['"])(.*)\1$/);
+	if (!m) return void 0;
+	return unescapePslString(m[2]);
 }
-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;
+/**
+* Inverse of `escapePslString`. The parser stores quoted-literal arguments with
+* their PSL escape sequences (`\\`, `\"`, `\n`, `\r`) intact; when we round-trip
+* a value through `getPositionalStringArg` and re-render via `escapePslString`,
+* we must decode it once on extraction to avoid double-escaping the same
+* sequences on output.
+*/
+function unescapePslString(value) {
+	let result = "";
+	for (let i = 0; i < value.length; i++) {
+		if (value.charCodeAt(i) !== 92 || i + 1 >= value.length) {
+			result += value[i];
+			continue;
+		}
+		const next = value[i + 1];
+		if (next === "\\" || next === "\"" || next === "'") result += next;
+		else if (next === "n") result += "\n";
+		else if (next === "r") result += "\r";
+		else {
+			result += "\\";
+			result += next;
+		}
+		i++;
+	}
+	return result;
 }
-function expectArray(value, path) {
-	if (!Array.isArray(value)) throw new Error(`${path} must be an array`);
-	return value;
+function modelToPrinterModel(model) {
+	let mapName;
+	const modelAttrStrings = [];
+	for (const a of model.attributes) {
+		if (a.name === "map" && a.target === "model") {
+			mapName = getPositionalStringArg(a, 0) ?? mapName;
+			continue;
+		}
+		modelAttrStrings.push(renderPslAttribute(a));
+	}
+	if (mapName !== void 0) modelAttrStrings.push(`@@map("${escapePslString(mapName)}")`);
+	const printerFields = model.fields.map((f) => fieldToPrinterField(f));
+	return {
+		name: model.name,
+		mapName,
+		fields: printerFields,
+		modelAttributes: modelAttrStrings,
+		comment: model.comment
+	};
 }
-function expectString(value, path) {
-	if (typeof value !== "string") throw new Error(`${path} must be a string`);
-	return value;
+function fieldToPrinterField(field) {
+	const typeName = field.typeConstructor !== void 0 ? formatTypeConstructor(field.typeConstructor) : field.typeName;
+	let mapName;
+	const attrStrings = [];
+	for (const a of field.attributes) {
+		if (a.name === "map" && a.target === "field") {
+			mapName = getPositionalStringArg(a, 0) ?? mapName;
+			continue;
+		}
+		attrStrings.push(renderPslAttribute(a));
+	}
+	if (mapName !== void 0) attrStrings.push(`@map("${escapePslString(mapName)}")`);
+	const isRelation = field.attributes.some((a) => a.name === "relation" && a.target === "field");
+	const isUnsupported = typeName.startsWith("Unsupported(");
+	const isId = field.attributes.some((a) => a.name === "id" && a.target === "field");
+	return {
+		name: field.name,
+		typeName,
+		optional: field.optional,
+		list: field.list,
+		attributes: attrStrings,
+		mapName,
+		isId,
+		isRelation,
+		isUnsupported,
+		comment: void 0
+	};
 }
-function expectBoolean(value, path) {
-	if (typeof value !== "boolean") throw new Error(`${path} must be a boolean`);
-	return value;
+function buildModelFkDeps(models, modelNames) {
+	const deps = /* @__PURE__ */ new Map();
+	for (const m of models) deps.set(m.name, /* @__PURE__ */ new Set());
+	for (const m of models) for (const field of m.fields) {
+		const refModel = relationReferencedModel(field, modelNames);
+		if (!refModel || refModel === m.name) continue;
+		if (!hasFullRelation(field)) continue;
+		deps.get(m.name).add(refModel);
+	}
+	return deps;
+}
+function hasFullRelation(field) {
+	const rel = field.attributes.find((a) => a.name === "relation" && a.target === "field");
+	if (!rel) return false;
+	const named = Object.fromEntries(rel.args.filter((a) => a.kind === "named").map((a) => [a.name, a.value.trim()]));
+	return named["fields"] !== void 0 && named["references"] !== void 0;
+}
+function relationReferencedModel(field, modelNames) {
+	const raw = field.typeConstructor?.path[0] ?? field.typeName.replace(/\?$/, "").replace(/\[\]$/, "");
+	if (raw.length === 0) return;
+	return modelNames.has(raw) ? raw : void 0;
+}
+function topologicalSortModels(models, deps) {
+	const byName = new Map(models.map((m) => [m.name, m]));
+	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) ?? /* @__PURE__ */ new Set()].sort();
+		for (const dep of sortedDeps) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		const model = byName.get(name);
+		if (model) result.push(model);
+	}
+	for (const name of sortedNames) visit(name);
+	return result;
 }
-function ifDefined(key, value) {
-	if (value === void 0) return {};
-	return { [key]: value };
+//#endregion
+//#region src/print-psl.ts
+function printPslFromAst(ast) {
+	return serializePrintDocument(astDocumentToPrintDocument(ast));
 }
-
 //#endregion
-export { printPsl, validatePrintableSqlSchemaIR };
+export { printPslFromAst as printPsl };
+
 //# sourceMappingURL=index.mjs.map