@prisma-next/target-postgres 0.14.0-dev.53 → 0.14.0-dev.55

package/dist/control.mjs

@@ -1,11 +1,12 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-Cok-1QEK.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-xdiqmBf_.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-C-tyS25s.mjs";
 import { n as postgresDiffSubjectEntityKind, r as postgresDiffSubjectGranularity } from "./schema-node-kinds-ClScchhi.mjs";
-import { a as PostgresDatabaseSchemaNode } from "./postgres-table-schema-node-BgaSrxYN.mjs";
-import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-BivMht-X.mjs";
+import { a as PostgresDatabaseSchemaNode } from "./postgres-table-schema-node-BZWWEo7B.mjs";
+import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-ff3ioNtK.mjs";
 import { r as renderDefaultLiteral } from "./planner-ddl-builders-B8Nn6nHN.mjs";
-import { n as PostgresContractSerializer } from "./postgres-contract-view-C5RSIHFm.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-r4iLpxD7.mjs";
-import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma-next/framework-components/ir";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-C-By7rOB.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-DWQYPxP8.mjs";
+import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -14,7 +15,7 @@ import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 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 { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, 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";
@@ -752,42 +753,118 @@ function resolveForeignKeys(tables, owners) {
 function inferPostgresPslContract(tree, describedContracts) {
 	const namespaces = Object.values(tree.namespaces);
 	const owners = describedContractOwners(describedContracts ?? []);
-	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 enumOwners = describedNativeEnumOwnersByTypeName(describedContracts ?? []);
+	const enumDefinitions = /* @__PURE__ */ new Map();
+	const packOwnedEnumTypesByNamespace = /* @__PURE__ */ new Map();
+	const enumNamespaceNames = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) {
+		const definitionsForNamespace = new Set(namespace.nativeEnums.map((e) => e.typeName));
+		for (const typeName of namespace.nativeEnumTypeNames) if (!definitionsForNamespace.has(typeName)) throw new Error(`contract infer: introspection reported native enum type "${typeName}" in schema "${namespace.schemaName}" without member values — the introspected tree's \`nativeEnumTypeNames\` and \`nativeEnums\` are out of sync (internal invariant).`);
+		for (const { typeName, values } of namespace.nativeEnums) {
+			const owner = enumOwners.get(coordinateKey({
+				namespaceId: namespace.schemaName,
+				entityKind: "native_enum",
+				entityName: typeName
+			}));
+			if (owner !== void 0) {
+				const owned = packOwnedEnumTypesByNamespace.get(namespace.schemaName) ?? /* @__PURE__ */ new Map();
+				owned.set(typeName, owner.spaceId);
+				owned.set(`${namespace.schemaName}.${typeName}`, owner.spaceId);
+				packOwnedEnumTypesByNamespace.set(namespace.schemaName, owned);
+				continue;
+			}
+			enumDefinitions.set(typeName, values);
+			enumNamespaceNames.add(namespace.schemaName);
+		}
 	}
 	const tables = {};
-	for (const namespace of namespaces) for (const [tableName, table] of Object.entries(namespace.tables)) {
-		if (owners.has(coordinateKey({
-			namespaceId: namespace.schemaName,
-			entityKind: "table",
-			entityName: tableName
-		}))) continue;
-		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] = new SqlTableIR(table);
+	const tableNamespaceNames = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) {
+		const ownedEnumTypes = packOwnedEnumTypesByNamespace.get(namespace.schemaName);
+		for (const [tableName, table] of Object.entries(namespace.tables)) {
+			if (owners.has(coordinateKey({
+				namespaceId: namespace.schemaName,
+				entityKind: "table",
+				entityName: tableName
+			}))) continue;
+			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).`);
+			if (ownedEnumTypes !== void 0) for (const column of Object.values(table.columns)) {
+				const owningSpaceId = ownedEnumTypes.get(column.nativeType);
+				if (owningSpaceId !== void 0) throw new Error(`contract infer: column "${tableName}"."${column.name}" is typed by native enum type "${column.nativeType}", which extension pack space "${owningSpaceId}" already describes. A cross-space enum-typed column has no authorable PSL form yet; describe the table in that pack's contract or retype the column before re-running contract infer.`);
+			}
+			tables[tableName] = new SqlTableIR(table);
+			tableNamespaceNames.add(namespace.schemaName);
+		}
+	}
+	let wrapNamespaceName;
+	if (enumDefinitions.size > 0) {
+		const contentNamespaces = new Set([...enumNamespaceNames, ...tableNamespaceNames]);
+		if (contentNamespaces.size > 1) throw new Error(`contract infer: native enum adoption with content across multiple schemas is not yet supported (single-namespace PSL inference emits one \`namespace { … }\` block; multi-namespace output is a later slice). Schemas: ${[...contentNamespaces].sort().join(", ")}.`);
+		wrapNamespaceName = [...contentNamespaces][0];
 	}
 	const { tables: resolvedTables, extraRelationsByTable, crossSpaceFieldNamesByTable } = resolveForeignKeys(tables, owners);
-	return buildPslDocumentAst(new SqlSchemaIR({ tables: resolvedTables }), {
-		typeMap: createPostgresTypeMap(/* @__PURE__ */ new Set()),
+	const schemaIR = new SqlSchemaIR({ tables: resolvedTables });
+	const enumTypeNames = new Set(enumDefinitions.keys());
+	if (wrapNamespaceName !== void 0) for (const typeName of enumDefinitions.keys()) enumTypeNames.add(`${wrapNamespaceName}.${typeName}`);
+	const enumInfo = {
+		typeNames: enumTypeNames,
+		definitions: enumDefinitions
+	};
+	return buildPslDocumentAst(schemaIR, {
+		typeMap: createPostgresTypeMap(enumInfo.typeNames),
 		defaultMapping: createPostgresDefaultMapping(),
-		parseRawDefault
+		parseRawDefault,
+		...enumDefinitions.size > 0 ? { enumInfo } : {}
 	}, {
 		extraRelationsByTable,
 		crossSpaceFieldNamesByTable
-	});
+	}, wrapNamespaceName);
 }
-function buildPslDocumentAst(schemaIR, options, foreignKeyExtras) {
+/**
+* Native-enum ownership index for pack subtraction, keyed by TYPE NAME
+* coordinate. A pack contract keys `entries.native_enum` by HANDLE name
+* (`AalLevel`) while introspection sees the Postgres type name (`aal_level`);
+* the entity's `typeName` field carries the mapping, so this walk indexes by
+* it rather than reusing {@link describedContractOwners}' entries-key
+* coordinates.
+*
+* Reads `entries.native_enum` directly: the kind map is carried
+* non-enumerable on `PostgresSchema.entries`, so the generic
+* `elementCoordinates` walk never yields it. Serialized pack contracts do
+* not carry `native_enum` entries at all (`PostgresContractSerializer`
+* strips them; only the derived `valueSet` survives), so this subtraction
+* currently matches in-memory described contracts only.
+*/
+function describedNativeEnumOwnersByTypeName(describedContracts) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const entry of describedContracts) for (const [namespaceId, ns] of Object.entries(entry.contract.storage.namespaces)) {
+		const kindMap = ns.entries["native_enum"];
+		if (!isPlainRecord(kindMap)) continue;
+		for (const entity of Object.values(kindMap)) {
+			if (!PostgresNativeEnum.is(entity)) continue;
+			owners.set(coordinateKey({
+				namespaceId,
+				entityKind: "native_enum",
+				entityName: entity.typeName
+			}), entry);
+		}
+	}
+	return owners;
+}
+function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName) {
 	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
 	const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
 	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 { enumNameMap: bareEnumNameMap, enumBlocks } = buildNativeEnumBlocks(options.enumInfo?.definitions ?? /* @__PURE__ */ new Map(), modelNames);
+	const enumNameMap = new Map(bareEnumNameMap);
+	if (namespaceName !== void 0) for (const [typeName, pslName] of bareEnumNameMap) enumNameMap.set(`${namespaceName}.${typeName}`, pslName);
+	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNameMap);
 	const fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, /* @__PURE__ */ new Map(), reservedNamedTypeNames);
+	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, 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) ?? [], ...extraRelationsByTable.get(table.name) ?? []]));
+	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.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 ? {
@@ -800,14 +877,69 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras) {
 		sourceId: "<sql-schema-ir>",
 		namespaces: [makePslNamespace({
 			kind: "namespace",
-			name: UNSPECIFIED_PSL_NAMESPACE_ID,
-			entries: makePslNamespaceEntries(sortedModels, [], []),
+			name: namespaceName ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+			entries: makePslNamespaceEntries(sortedModels, [], enumBlocks),
 			span: SYNTHETIC_SPAN
 		})],
 		...types ? { types } : {},
 		span: SYNTHETIC_SPAN
 	};
 }
+/**
+* Builds one `native_enum` extension-block AST node per introspected enum
+* definition. Block names go through the shared top-level transform
+* (`toEnumName`, intra-enum collisions throw like model collisions) and are
+* then reserved against the model names — an enum whose PSL name a model
+* already claims gets a numeric suffix, with `@@map` carrying the real type
+* name. Members print as explicit `member = "value"` pairs: the member name
+* is the sanitized value (deduplicated within the block), the JSON-encoded
+* value carries the truth verbatim.
+*/
+function buildNativeEnumBlocks(definitions, modelNames) {
+	const enumNames = buildTopLevelNameMap([...definitions.keys()].sort(), toEnumName, "enum", "enum type");
+	const usedTopLevelNames = new Set(PSL_SCALAR_TYPE_NAMES);
+	for (const result of modelNames.values()) usedTopLevelNames.add(result.name);
+	const enumNameMap = /* @__PURE__ */ new Map();
+	const enumBlocks = [];
+	for (const [typeName, result] of enumNames) {
+		const name = createUniqueFieldName(result.name, usedTopLevelNames);
+		usedTopLevelNames.add(name);
+		enumNameMap.set(typeName, name);
+		enumBlocks.push(buildNativeEnumBlock(name, typeName, definitions.get(typeName) ?? []));
+	}
+	return {
+		enumNameMap,
+		enumBlocks
+	};
+}
+function buildNativeEnumBlock(name, typeName, values) {
+	const usedMemberNames = /* @__PURE__ */ new Set();
+	const parameters = {};
+	for (const value of values) {
+		const memberName = createUniqueFieldName(toEnumMemberName(value), usedMemberNames);
+		usedMemberNames.add(memberName);
+		parameters[memberName] = {
+			kind: "value",
+			raw: JSON.stringify(value),
+			span: SYNTHETIC_SPAN
+		};
+	}
+	return {
+		kind: "native_enum",
+		name,
+		parameters,
+		blockAttributes: name === typeName ? [] : [{
+			name: "map",
+			args: [{
+				kind: "positional",
+				value: `"${escapePslString(typeName)}"`,
+				span: SYNTHETIC_SPAN
+			}],
+			span: SYNTHETIC_SPAN
+		}],
+		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);
@@ -867,8 +999,17 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 		};
 	}
 	let typeName = resolution.pslType;
+	let typeConstructor;
 	const enumPslName = enumNameMap.get(column.nativeType);
-	if (enumPslName) typeName = enumPslName;
+	if (enumPslName) {
+		typeName = enumPslName;
+		typeConstructor = {
+			kind: "typeConstructor",
+			path: ["pg", "enum"],
+			args: [positionalArg(enumPslName)],
+			span: SYNTHETIC_SPAN
+		};
+	}
 	if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
 	const attributes = [];
 	const isId = isSinglePk && pkColumns.has(column.name);
@@ -889,6 +1030,7 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 		kind: "field",
 		name: fieldName,
 		typeName,
+		...ifDefined("typeConstructor", typeConstructor),
 		optional: column.nullable,
 		list: column.many === true,
 		attributes,
@@ -1038,9 +1180,10 @@ function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
 	}
 	return results;
 }
-function createReservedNamedTypeNames(modelNames) {
+function createReservedNamedTypeNames(modelNames, enumNameMap) {
 	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
 	for (const result of modelNames.values()) reservedNames.add(result.name);
+	for (const enumPslName of enumNameMap.values()) reservedNames.add(enumPslName);
 	return reservedNames;
 }
 function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {