@prisma-next/target-postgres 0.14.0-dev.4 → 0.14.0-dev.40

package/dist/control.mjs

@@ -1,18 +1,18 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CpGygXpI.mjs";
-import { t as parsePostgresDefault } from "./default-normalizer-DyyCHQWs.mjs";
-import { t as normalizeSchemaNativeType } from "./native-type-normalizer-Bc9XJzWC.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-Bs_baQax.mjs";
-import { a as renderDefaultLiteral } from "./planner-ddl-builders-B2wOwLqI.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k3TAcPMY.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-tjatyhtZ.mjs";
+import { a as PostgresDatabaseSchemaNode } from "./postgres-table-schema-node-1nNc8XDT.mjs";
+import { i as contractToPostgresDatabaseSchemaNode, n as diffPostgresDatabaseSchema, r as verifyPostgresDatabaseSchema, t as createPostgresMigrationPlanner } from "./planner-CG2pLHk-.mjs";
+import { r as renderDefaultLiteral } from "./planner-ddl-builders-B8Nn6nHN.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-BegduLr6.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
-import { contractToSchemaIR, extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
+import { extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { SqlQueryError } from "@prisma-next/sql-errors";
+import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { SqlSchemaVerifierBase } from "@prisma-next/family-sql/ir";
+import { SqlQueryError } from "@prisma-next/sql-errors";
+import { inferRelations, mapDefault, parseRawDefault, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
+import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
 //#region src/core/migrations/runner.ts
 const LOCK_DOMAIN = "prisma_next.contract.marker";
 /**
@@ -74,23 +74,19 @@ var PostgresMigrationRunner = class {
 			applyValue = applyResult.value;
 		}
 		if (space === APP_SPACE_ID) {
-			const schemaIR = await this.family.introspect({
+			const schemaNode = await this.family.introspect({
 				driver,
 				contract: options.destinationContract
 			});
-			const schemaVerifyResult = verifySqlSchema({
+			const schemaVerifyResult = this.family.verifySchema({
 				contract: options.destinationContract,
-				schema: schemaIR,
+				schema: schemaNode,
 				strict: options.strictVerification ?? true,
-				context: options.context ?? {},
-				typeMetadataRegistry: this.family.typeMetadataRegistry,
-				frameworkComponents: options.frameworkComponents,
-				normalizeDefault: parsePostgresDefault,
-				normalizeNativeType: normalizeSchemaNativeType
+				frameworkComponents: options.frameworkComponents
 			});
 			if (!schemaVerifyResult.ok) return runnerFailure("SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
 				why: "The resulting database schema does not satisfy the destination contract.",
-				meta: { issues: schemaVerifyResult.schema.issues }
+				meta: { issues: [...schemaVerifyResult.schema.issues, ...schemaVerifyResult.schema.schemaDiffIssues] }
 			});
 		}
 		const incomingInvariants = options.plan.providedInvariants ?? [];
@@ -408,6 +404,605 @@ var PostgresSchemaVerifier = class extends SqlSchemaVerifierBase {
 	}
 };
 //#endregion
+//#region src/core/psl-infer/postgres-default-mapping.ts
+const POSTGRES_FUNCTION_ATTRIBUTES = { "gen_random_uuid()": "@default(dbgenerated(\"gen_random_uuid()\"))" };
+function formatDbGeneratedAttribute(expression) {
+	return `@default(dbgenerated(${JSON.stringify(expression)}))`;
+}
+function createPostgresDefaultMapping() {
+	return {
+		functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
+		fallbackFunctionAttribute: formatDbGeneratedAttribute
+	};
+}
+//#endregion
+//#region src/core/psl-infer/postgres-type-map.ts
+const POSTGRES_TO_PSL = {
+	text: "String",
+	bool: "Boolean",
+	boolean: "Boolean",
+	int4: "Int",
+	integer: "Int",
+	int8: "BigInt",
+	bigint: "BigInt",
+	float8: "Float",
+	"double precision": "Float",
+	numeric: "Decimal",
+	decimal: "Decimal",
+	timestamptz: "DateTime",
+	"timestamp with time zone": "DateTime",
+	jsonb: "Json",
+	bytea: "Bytes"
+};
+const PRESERVED_NATIVE_TYPES = {
+	"character varying": {
+		pslType: "String",
+		attributeName: "db.VarChar"
+	},
+	character: {
+		pslType: "String",
+		attributeName: "db.Char"
+	},
+	char: {
+		pslType: "String",
+		attributeName: "db.Char"
+	},
+	varchar: {
+		pslType: "String",
+		attributeName: "db.VarChar"
+	},
+	uuid: {
+		pslType: "String",
+		attributeName: "db.Uuid"
+	},
+	int2: {
+		pslType: "Int",
+		attributeName: "db.SmallInt"
+	},
+	smallint: {
+		pslType: "Int",
+		attributeName: "db.SmallInt"
+	},
+	float4: {
+		pslType: "Float",
+		attributeName: "db.Real"
+	},
+	real: {
+		pslType: "Float",
+		attributeName: "db.Real"
+	},
+	timestamp: {
+		pslType: "DateTime",
+		attributeName: "db.Timestamp"
+	},
+	"timestamp without time zone": {
+		pslType: "DateTime",
+		attributeName: "db.Timestamp"
+	},
+	date: {
+		pslType: "DateTime",
+		attributeName: "db.Date"
+	},
+	time: {
+		pslType: "DateTime",
+		attributeName: "db.Time"
+	},
+	"time without time zone": {
+		pslType: "DateTime",
+		attributeName: "db.Time"
+	},
+	timetz: {
+		pslType: "DateTime",
+		attributeName: "db.Timetz"
+	},
+	"time with time zone": {
+		pslType: "DateTime",
+		attributeName: "db.Timetz"
+	},
+	json: {
+		pslType: "Json",
+		attributeName: "db.Json"
+	}
+};
+const PARAMETERIZED_NATIVE_TYPES = {
+	"character varying": {
+		pslType: "String",
+		attributeName: "db.VarChar"
+	},
+	character: {
+		pslType: "String",
+		attributeName: "db.Char"
+	},
+	char: {
+		pslType: "String",
+		attributeName: "db.Char"
+	},
+	varchar: {
+		pslType: "String",
+		attributeName: "db.VarChar"
+	},
+	numeric: {
+		pslType: "Decimal",
+		attributeName: "db.Numeric"
+	},
+	timestamp: {
+		pslType: "DateTime",
+		attributeName: "db.Timestamp"
+	},
+	timestamptz: {
+		pslType: "DateTime",
+		attributeName: "db.Timestamptz"
+	},
+	time: {
+		pslType: "DateTime",
+		attributeName: "db.Time"
+	},
+	timetz: {
+		pslType: "DateTime",
+		attributeName: "db.Timetz"
+	}
+};
+const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
+function getOwnMappingValue(map, key) {
+	return Object.hasOwn(map, key) ? map[key] : void 0;
+}
+function getOwnRecordValue(map, key) {
+	return Object.hasOwn(map, key) ? map[key] : void 0;
+}
+function createNativeTypeAttribute(name, args) {
+	return args && args.length > 0 ? {
+		name,
+		args
+	} : { name };
+}
+function splitTypeParameterList(params) {
+	return params.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function createPostgresTypeMap(enumTypeNames) {
+	return { resolve(nativeType) {
+		if (enumTypeNames?.has(nativeType)) return {
+			pslType: nativeType,
+			nativeType
+		};
+		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
+		if (paramMatch) {
+			const [, baseType = nativeType, params = ""] = paramMatch;
+			const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+			if (template) return {
+				pslType: template.pslType,
+				nativeType,
+				typeParams: {
+					baseType,
+					params
+				},
+				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
+			};
+		}
+		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+		if (preservedType) return {
+			pslType: preservedType.pslType,
+			nativeType,
+			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
+		};
+		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
+		if (pslType) return {
+			pslType,
+			nativeType
+		};
+		return {
+			unsupported: true,
+			nativeType
+		};
+	} };
+}
+//#endregion
+//#region src/core/psl-infer/infer-psl-contract.ts
+const SYNTHETIC_SPAN = {
+	start: {
+		offset: 0,
+		line: 1,
+		column: 1
+	},
+	end: {
+		offset: 0,
+		line: 1,
+		column: 1
+	}
+};
+const PSL_SCALAR_TYPE_NAMES = new Set([
+	"String",
+	"Boolean",
+	"Int",
+	"BigInt",
+	"Float",
+	"Decimal",
+	"DateTime",
+	"Json",
+	"Bytes"
+]);
+/**
+* Infers a PSL AST (for `printPsl`) from an introspected Postgres schema tree.
+*
+* Target-owned inference: it walks the `PostgresDatabaseSchemaNode` tree and
+* owns the Postgres dialect knowledge — the native type map and default map.
+* Relation inference, name transforms, generic default mapping, and raw-default
+* parsing are shape-neutral utilities imported from the SQL family.
+*
+* This slice emits relational-only PSL, byte-identical to the prior flat
+* inference: the tree's tables (across its namespaces — `contract infer`
+* introspects a single live namespace) are gathered into the model set and
+* emitted as one `UNSPECIFIED_PSL_NAMESPACE_ID` bucket. Top-level entities
+* (policies/roles → PSL extension blocks) are a later slice.
+*/
+function inferPostgresPslContract(tree) {
+	const namespaces = Object.values(tree.namespaces);
+	const enumTypeNames = [...new Set(namespaces.flatMap((ns) => ns.nativeEnumTypeNames))];
+	if (enumTypeNames.length > 0) {
+		const names = enumTypeNames.join(", ");
+		throw new Error(`contract infer: the database contains native Postgres enum type(s): ${names}. Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. Drop the native type and replace each column with a text column carrying a CHECK constraint, then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring surface generates the required check automatically.`);
+	}
+	const tables = {};
+	for (const namespace of namespaces) for (const [tableName, table] of Object.entries(namespace.tables)) {
+		if (tables[tableName] !== void 0) throw new Error(`contract infer: duplicate table name "${tableName}" across schemas is not yet supported (single-namespace PSL inference emits one flat bucket; multi-namespace \`namespace { … }\` output is a later slice).`);
+		tables[tableName] = table;
+	}
+	return buildPslDocumentAst({ tables }, {
+		typeMap: createPostgresTypeMap(/* @__PURE__ */ new Set()),
+		defaultMapping: createPostgresDefaultMapping(),
+		parseRawDefault
+	});
+}
+function buildPslDocumentAst(schemaIR, options) {
+	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
+	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
+	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
+	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
+	const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
+	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
+	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, /* @__PURE__ */ new Map(), reservedNamedTypeNames);
+	const models = [];
+	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, /* @__PURE__ */ new Map(), fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationsByTable.get(table.name) ?? []));
+	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
+	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
+	const types = namedTypeEntries.length > 0 ? {
+		kind: "types",
+		declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
+		span: SYNTHETIC_SPAN
+	} : void 0;
+	return {
+		kind: "document",
+		sourceId: "<sql-schema-ir>",
+		namespaces: [makePslNamespace({
+			kind: "namespace",
+			name: UNSPECIFIED_PSL_NAMESPACE_ID,
+			entries: makePslNamespaceEntries(sortedModels, [], []),
+			span: SYNTHETIC_SPAN
+		})],
+		...types ? { types } : {},
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildModel(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 = [];
+	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
+	const usedFieldNames = new Set(fields.map((field) => field.name));
+	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
+	const modelAttributes = [];
+	if (table.primaryKey && table.primaryKey.columns.length > 1) {
+		const pkFieldNames = table.primaryKey.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(buildModelConstraintAttribute("id", pkFieldNames, table.primaryKey.name));
+	}
+	for (const unique of table.uniques) if (unique.columns.length > 1) {
+		const uniqueFieldNames = unique.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(buildModelConstraintAttribute("unique", uniqueFieldNames, unique.name));
+	}
+	for (const index of table.indexes) if (!index.unique) {
+		const indexFieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name));
+	}
+	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
+	const comment = table.primaryKey ? void 0 : "// WARNING: This table has no primary key in the database";
+	return {
+		kind: "model",
+		name: modelName,
+		fields,
+		attributes: modelAttributes,
+		span: SYNTHETIC_SPAN,
+		...comment !== void 0 ? { comment } : {}
+	};
+}
+function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
+	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) {
+		const attrs = [];
+		if (fieldMap !== void 0) attrs.push(buildMapAttribute("field", fieldMap));
+		return {
+			kind: "field",
+			name: fieldName,
+			typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
+			optional: column.nullable,
+			list: column.many === true,
+			attributes: attrs,
+			span: SYNTHETIC_SPAN
+		};
+	}
+	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(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
+	if (column.default !== void 0) {
+		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
+		if (parsed) {
+			const result = mapDefault(parsed, defaultMapping);
+			if ("attribute" in result) attributes.push(parseDefaultAttributeString(result.attribute));
+		}
+	}
+	if (uniqueColumns.has(column.name) && !isId) {
+		const uniqueConstraintName = uniqueColumns.get(column.name);
+		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
+	}
+	if (fieldMap !== void 0) attributes.push(buildMapAttribute("field", fieldMap));
+	return {
+		kind: "field",
+		name: fieldName,
+		typeName,
+		optional: column.nullable,
+		list: column.many === true,
+		attributes,
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldNames) {
+	const fieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
+	usedFieldNames.add(fieldName);
+	const args = [];
+	if (rel.fields && rel.references) {
+		if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
+		args.push(namedArg("fields", `[${rel.fields.map((columnName) => resolveColumnFieldName(fieldNamesByTable, hostTableName, columnName)).join(", ")}]`));
+		args.push(namedArg("references", `[${rel.references.map((columnName) => resolveColumnFieldName(fieldNamesByTable, rel.referencedTableName ?? "", columnName)).join(", ")}]`));
+		if (rel.onDelete) args.push(namedArg("onDelete", rel.onDelete));
+		if (rel.onUpdate) args.push(namedArg("onUpdate", rel.onUpdate));
+		if (rel.fkName) args.push(namedArg("map", `"${escapePslString(rel.fkName)}"`));
+	} else if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
+	const attrs = args.length > 0 ? [buildAttribute("field", "relation", args)] : [];
+	return {
+		kind: "field",
+		name: fieldName,
+		typeName: rel.typeName,
+		optional: rel.optional,
+		list: rel.list,
+		attributes: attrs,
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildModelConstraintAttribute(name, fields, constraintName) {
+	const args = [positionalArg(`[${fields.join(", ")}]`)];
+	if (constraintName !== void 0) args.push(namedArg("map", `"${escapePslString(constraintName)}"`));
+	return buildAttribute("model", name, args);
+}
+function buildSimpleConstraintFieldAttribute(name, constraintName) {
+	if (constraintName === void 0) return buildAttribute("field", name, []);
+	return buildAttribute("field", name, [namedArg("map", `"${escapePslString(constraintName)}"`)]);
+}
+function parseDefaultAttributeString(attributeText) {
+	return buildAttribute("field", "default", [positionalArg(attributeText.replace(/^@default\(/, "").replace(/\)$/, ""))]);
+}
+function buildMapAttribute(target, mapName) {
+	return buildAttribute(target, "map", [positionalArg(`"${escapePslString(mapName)}"`)]);
+}
+function buildAttribute(target, name, args) {
+	return {
+		kind: "attribute",
+		target,
+		name,
+		args,
+		span: SYNTHETIC_SPAN
+	};
+}
+function positionalArg(value) {
+	return {
+		kind: "positional",
+		value,
+		span: SYNTHETIC_SPAN
+	};
+}
+function namedArg(name, value) {
+	return {
+		kind: "named",
+		name,
+		value,
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildNamedTypeDeclaration(entry) {
+	const attribute = buildAttribute("namedType", entry.nativeTypeAttribute.name, (entry.nativeTypeAttribute.args ?? []).map(positionalArg));
+	return {
+		kind: "namedType",
+		name: entry.name,
+		baseType: entry.baseType,
+		attributes: [attribute],
+		span: SYNTHETIC_SPAN
+	};
+}
+function escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+/**
+* Resolves a `SqlColumnIR.default` value into a normalized {@link ColumnDefault}.
+*
+* `SqlSchemaIR` types the column default as `string` (a raw database default
+* expression). Some legacy fixtures and tests still pass already-normalized
+* `ColumnDefault` objects in the same slot, so we accept either shape
+* defensively at runtime.
+*/
+function parseColumnDefault(value, nativeType, rawDefaultParser) {
+	if (typeof value === "string") return rawDefaultParser ? rawDefaultParser(value, nativeType) : void 0;
+	if (value !== null && typeof value === "object" && "kind" in value) return value;
+}
+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 createReservedNamedTypeNames(modelNames) {
+	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
+	for (const result of modelNames.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),
+				nativeTypeAttribute: 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,
+			nativeTypeAttribute: seed.nativeTypeAttribute
+		});
+		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 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;
+}
+//#endregion
 //#region src/exports/control.ts
 function buildNativeTypeExpander(frameworkComponents) {
 	if (!frameworkComponents) return;
@@ -428,6 +1023,28 @@ const postgresTargetDescriptor = {
 	...postgresTargetDescriptorMeta,
 	contractSerializer: new PostgresContractSerializer(),
 	schemaVerifier: new PostgresSchemaVerifier(),
+	inferPslContract(schema) {
+		PostgresDatabaseSchemaNode.assert(schema);
+		return inferPostgresPslContract(schema);
+	},
+	diffDatabaseSchema(input) {
+		return diffPostgresDatabaseSchema({
+			contract: input.contract,
+			actualSchema: input.schema,
+			strict: input.strict,
+			typeMetadataRegistry: input.typeMetadataRegistry,
+			frameworkComponents: input.frameworkComponents
+		});
+	},
+	verifyDatabaseSchema(input) {
+		return verifyPostgresDatabaseSchema({
+			contract: input.contract,
+			actualSchema: input.schema,
+			strict: input.strict,
+			typeMetadataRegistry: input.typeMetadataRegistry,
+			frameworkComponents: input.frameworkComponents
+		});
+	},
 	migrations: {
 		createPlanner(adapter) {
 			return createPostgresMigrationPlanner(adapter);
@@ -436,9 +1053,10 @@ const postgresTargetDescriptor = {
 			return createPostgresMigrationRunner(family);
 		},
 		contractToSchema(contract, frameworkComponents) {
-			return contractToSchemaIR(contract, {
+			const expander = buildNativeTypeExpander(frameworkComponents);
+			return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
 				annotationNamespace: "pg",
-				...ifDefined("expandNativeType", buildNativeTypeExpander(frameworkComponents)),
+				...ifDefined("expandNativeType", expander),
 				renderDefault: postgresRenderDefault
 			});
 		}