@prisma-next/target-postgres 0.15.0-dev.17 → 0.15.0-dev.19

package/dist/control.mjs

@@ -1,10 +1,11 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-Bxw2GNog.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-B9ZUiyUE.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-qubYaxQA.mjs";
 import { a as postgresDiffSubjectGranularity, i as postgresDiffSubjectEntityKind } from "./postgres-table-schema-node-D6LvInCe.mjs";
 import { i as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-bg32e7I-.mjs";
-import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-oY3brcLj.mjs";
+import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-CrYO0j4_.mjs";
 import { r as renderDefaultLiteral } from "./planner-ddl-builders-BKlmGDJl.mjs";
-import { n as PostgresContractSerializer } from "./postgres-contract-view-CWsxTdoA.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-BWmH0NqM.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-DebHMqGR.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-Bj7MTEeR.mjs";
 import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
@@ -691,6 +692,7 @@ function resolveForeignKeys(tables, owners) {
 	const resultTables = {};
 	const extraRelationsByTable = /* @__PURE__ */ new Map();
 	const crossSpaceFieldNamesByTable = /* @__PURE__ */ new Map();
+	const danglingForeignKeysByTable = /* @__PURE__ */ new Map();
 	for (const [tableName, table] of Object.entries(tables)) {
 		const keptForeignKeys = [];
 		for (const fk of table.foreignKeys) {
@@ -718,6 +720,16 @@ function resolveForeignKeys(tables, owners) {
 				}
 			}
 			if (tables[fk.referencedTable] !== void 0) keptForeignKeys.push(fk);
+			else {
+				const dangling = {
+					columns: fk.columns,
+					referencedSchema: fk.referencedSchema,
+					referencedTable: fk.referencedTable
+				};
+				const existingDangling = danglingForeignKeysByTable.get(tableName);
+				if (existingDangling) existingDangling.push(dangling);
+				else danglingForeignKeysByTable.set(tableName, [dangling]);
+			}
 		}
 		resultTables[tableName] = keptForeignKeys.length === table.foreignKeys.length ? table : new SqlTableIR({
 			...table,
@@ -727,7 +739,8 @@ function resolveForeignKeys(tables, owners) {
 	return {
 		tables: resultTables,
 		extraRelationsByTable,
-		crossSpaceFieldNamesByTable
+		crossSpaceFieldNamesByTable,
+		danglingForeignKeysByTable
 	};
 }
 /**
@@ -801,7 +814,7 @@ function inferPostgresPslContract(tree, describedContracts) {
 		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);
+	const { tables: resolvedTables, extraRelationsByTable, crossSpaceFieldNamesByTable, danglingForeignKeysByTable } = resolveForeignKeys(tables, owners);
 	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}`);
@@ -816,12 +829,13 @@ function inferPostgresPslContract(tree, describedContracts) {
 		...enumDefinitions.size > 0 ? { enumInfo } : {}
 	}, {
 		extraRelationsByTable,
-		crossSpaceFieldNamesByTable
+		crossSpaceFieldNamesByTable,
+		danglingForeignKeysByTable
 	}, wrapNamespaceName);
 }
 function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName) {
 	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
-	const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
+	const { extraRelationsByTable, crossSpaceFieldNamesByTable, danglingForeignKeysByTable } = foreignKeyExtras;
 	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
 	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
 	const { enumNameMap: bareEnumNameMap, enumBlocks } = buildNativeEnumBlocks(options.enumInfo?.definitions ?? /* @__PURE__ */ new Map(), modelNames);
@@ -832,7 +846,7 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName)
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
 	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
 	const models = [];
-	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) ?? []]));
+	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) ?? []], danglingForeignKeysByTable.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 ? {
@@ -909,7 +923,7 @@ function buildNativeEnumBlock(name, typeName, values) {
 		span: SYNTHETIC_SPAN
 	};
 }
-function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields) {
+function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys) {
 	const { name: modelName, map: mapName } = toModelName(table.name);
 	const fieldNameMap = fieldNamesByTable.get(table.name);
 	const pkColumns = new Set(table.primaryKey?.columns ?? []);
@@ -939,7 +953,10 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes,
 		modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name, index.type));
 	}
 	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
-	const comment = table.primaryKey ? void 0 : "// WARNING: This table has no primary key in the database";
+	const warnings = [];
+	if (!table.primaryKey) warnings.push("This table has no primary key in the database");
+	if (danglingForeignKeys.length > 0) warnings.push(buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable, table.name));
+	const comment = warnings.length > 0 ? `// WARNING: ${warnings.join(" ")}` : void 0;
 	return {
 		kind: "model",
 		name: modelName,
@@ -949,6 +966,20 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes,
 		...comment !== void 0 ? { comment } : {}
 	};
 }
+/**
+* Explains a foreign key `resolveForeignKeys` dropped as dangling: the
+* database enforces it, but its target lives outside the introspected
+* schema, so infer has no model to point a relation at. The suggested fix
+* targets the common cause — an unconfigured extension pack's schema
+* (e.g. Supabase's `auth`).
+*/
+function buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable, tableName) {
+	return `Foreign key ${danglingForeignKeys.map((fk) => {
+		const fieldNames = fk.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, tableName, columnName));
+		const target = fk.referencedSchema !== void 0 ? `${fk.referencedSchema}.${fk.referencedTable}` : fk.referencedTable;
+		return `"${fieldNames.join(", ")}" -> "${target}"`;
+	}).join(", ")} exists in the database, but its target schema is outside the introspected scope, so no relation field was generated. If the target schema is described by an extension pack, add it to extensionPacks and re-run infer.`;
+}
 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;
@@ -983,7 +1014,11 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 	const attributes = [];
 	const isId = isSinglePk && pkColumns.has(column.name);
 	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
-	if (column.default !== void 0) {
+	if (column.default === void 0 && column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()") attributes.push(parseDefaultAttributeString("@default(autoincrement())"));
+	else if (column.many === true && column.resolvedDefault?.kind === "literal") {
+		const formatted = Array.isArray(column.resolvedDefault.value) ? formatPslListLiteralValue(column.resolvedDefault.value) : void 0;
+		if (formatted !== void 0) attributes.push(parseDefaultAttributeString(`@default(${formatted})`));
+	} else if (column.default !== void 0) {
 		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
 		if (parsed) {
 			const result = mapDefault(parsed, defaultMapping);
@@ -1094,6 +1129,20 @@ function escapePslString(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 }
 /**
+* Formats a resolved literal-default array as PSL literal-list syntax
+* (`[1, 2, 3]`, `["a", "b"]`, `[]`). PSL's list-literal grammar only accepts
+* string/number/boolean elements, so any other element (e.g. `null`, a
+* nested array/object) makes the value unrepresentable and this returns
+* `undefined`.
+*/
+function formatPslListLiteralValue(elements) {
+	const parts = [];
+	for (const element of elements) if (typeof element === "string") parts.push(`"${escapePslString(element)}"`);
+	else if (typeof element === "number" || typeof element === "boolean") parts.push(String(element));
+	else return;
+	return `[${parts.join(", ")}]`;
+}
+/**
 * Resolves a `SqlColumnIR.default` value into a normalized {@link ColumnDefault}.
 *
 * `SqlSchemaIR` types the column default as `string` (a raw database default
@@ -1283,7 +1332,8 @@ const postgresTargetDescriptor = {
 			return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
 				annotationNamespace: "pg",
 				...ifDefined("expandNativeType", expander),
-				renderDefault: postgresRenderDefault
+				renderDefault: postgresRenderDefault,
+				resolveDefault: postgresResolveDefault
 			});
 		}
 	},