@prisma-next/target-postgres 0.15.0-dev.9 → 0.16.0-dev.1

package/dist/control.d.mts

@@ -2,7 +2,6 @@ import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrR
 import { StorageColumn } from "@prisma-next/sql-contract/types";
 import { SqlControlTargetDescriptor } from "@prisma-next/family-sql/control";
 import { ColumnDefault } from "@prisma-next/contract/types";
-
 //#region src/exports/control.d.ts
 declare function postgresRenderDefault(def: ColumnDefault, column: StorageColumn): string;
 declare const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails>;

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;;;;iBA4BgB,qBAAA,CAAsB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAa;AAAA,cAOzE,wBAAA,EAA0B,0BAA0B,aAAa,yBAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;;;iBA6BgB,sBAAsB,KAAK,eAAe,QAAQ;cAO5D,0BAA0B,uCAAuC"}

package/dist/control.mjs

@@ -1,10 +1,11 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CFQKLXl_.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-47526Pv2.mjs";
+import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-C-hnJ5mr.mjs";
 import { r as renderDefaultLiteral } from "./planner-ddl-builders-BKlmGDJl.mjs";
-import { n as PostgresContractSerializer } from "./postgres-contract-view-DM8sN1Ot.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-uHcFFWkx.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-DebHMqGR.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-DPGxFcXo.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";
@@ -87,7 +88,7 @@ var PostgresMigrationRunner = class {
 				strict: options.strictVerification ?? true,
 				frameworkComponents: options.frameworkComponents
 			});
-			if (!schemaVerifyResult.ok) return runnerFailure("SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
+			if (!schemaVerifyResult.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
 				why: "The resulting database schema does not satisfy the destination contract.",
 				meta: { issues: schemaVerifyResult.schema.issues }
 			});
@@ -191,7 +192,7 @@ var PostgresMigrationRunner = class {
 		if (result.rows.length === 0) return okVoid();
 		const columns = new Set(result.rows.map((row) => row.column_name));
 		if (columns.has("space")) return okVoid();
-		return runnerFailure("LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
+		return runnerFailure("MIGRATION.LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
 			table: "prisma_contract.marker",
 			columns: [...columns].sort()
 		} });
@@ -199,7 +200,7 @@ var PostgresMigrationRunner = class {
 	async runExpectationSteps(driver, steps, operation, phase) {
 		for (const step of steps) {
 			const result = await driver.query(step.sql, step.params ?? []);
-			if (!this.stepResultIsTrue(result.rows)) return runnerFailure(phase === "precheck" ? "PRECHECK_FAILED" : "POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, { meta: {
+			if (!this.stepResultIsTrue(result.rows)) return runnerFailure(phase === "precheck" ? "MIGRATION.PRECHECK_FAILED" : "MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, { meta: {
 				operationId: operation.id,
 				phase,
 				stepDescription: step.description
@@ -211,7 +212,7 @@ var PostgresMigrationRunner = class {
 		for (const step of steps) try {
 			await driver.query(step.sql, step.params ?? []);
 		} catch (error) {
-			if (SqlQueryError.is(error)) return runnerFailure("EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
+			if (SqlQueryError.is(error)) return runnerFailure("MIGRATION.EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
 				why: error.message,
 				meta: {
 					operationId: operation.id,
@@ -281,7 +282,7 @@ var PostgresMigrationRunner = class {
 	}
 	enforcePolicyCompatibility(policy, operations) {
 		const allowedClasses = new Set(policy.allowedOperationClasses);
-		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
+		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
 			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
 			meta: {
 				operationId: operation.id,
@@ -294,23 +295,23 @@ var PostgresMigrationRunner = class {
 	ensureMarkerCompatibility(marker, plan) {
 		const origin = plan.origin ?? null;
 		if (!origin) return okVoid();
-		if (!marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
-		if (marker.storageHash !== origin.storageHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+		if (!marker) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
 			markerStorageHash: marker.storageHash,
 			expectedOriginStorageHash: origin.storageHash
 		} });
-		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
+		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
 			markerProfileHash: marker.profileHash,
 			expectedOriginProfileHash: origin.profileHash
 		} });
 		return okVoid();
 	}
 	ensurePlanMatchesDestinationContract(destination, contract) {
-		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
+		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
 			planStorageHash: destination.storageHash,
 			contractStorageHash: contract.storage.storageHash
 		} });
-		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
+		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
 			planProfileHash: destination.profileHash,
 			contractProfileHash: contract.profileHash
 		} });
@@ -335,7 +336,7 @@ var PostgresMigrationRunner = class {
 			space,
 			expectedFrom: existingMarker.storageHash,
 			destination
-		})) return runnerFailure("MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+		})) return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
 			space,
 			expectedStorageHash: existingMarker.storageHash,
 			destinationStorageHash: options.plan.destination.storageHash
@@ -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
 			});
 		}
 	},