@prisma-next/target-postgres 0.14.0-dev.60 → 0.14.0-dev.62

package/dist/{control-policy-Co_13Hxa.mjs → control-policy-DKp0HKpY.mjs}

@@ -1,9 +1,9 @@
-import { r as isPostgresSchema } from "./postgres-schema-DTLA_aRi.mjs";
-import { i as quoteIdentifier } from "./sql-utils-DcfMz4MQ.mjs";
-import { n as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-9FCtCUz2.mjs";
-import { A as buildTargetDetails, C as DropTableCall, D as SetDefaultCall, O as SetNotNullCall, T as RawSqlCall, _ as DropColumnCall, a as AddNotNullColumnWithTempDefaultCall, b as DropIndexCall, c as AlterColumnTypeCall, f as CreateSchemaCall, g as DropCheckConstraintCall, h as DisableRowLevelSecurityCall, i as AddNotNullColumnDirectCall, k as postgresDefaultToDdlColumnDefault, m as DataTransformCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateTableCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropConstraintCall, w as EnableRowLevelSecurityCall, x as DropNotNullCall, y as DropDefaultCall } from "./op-factory-call-DxNNKUeZ.mjs";
-import { t as buildExpectedFormatType } from "./planner-sql-checks-AXoxB1Jl.mjs";
-import { n as buildColumnTypeSql, t as buildColumnDefaultSql } from "./planner-ddl-builders-B8Nn6nHN.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-DWQ0-CPb.mjs";
+import { i as quoteIdentifier } from "./sql-utils-SU4FDvIV.mjs";
+import { n as PostgresNativeEnumSchemaNode, o as postgresNodeEntityKind, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
+import { A as SetNotNullCall, C as DropNotNullCall, D as RawSqlCall, E as EnableRowLevelSecurityCall, M as buildTargetDetails, S as DropNativeEnumTypeCall, T as DropTableCall, _ as DropCheckConstraintCall, a as AddNotNullColumnWithTempDefaultCall, b as DropDefaultCall, c as AlterColumnTypeCall, d as CreateNativeEnumTypeCall, g as DisableRowLevelSecurityCall, h as DataTransformCall, i as AddNotNullColumnDirectCall, j as postgresDefaultToDdlColumnDefault, k as SetDefaultCall, m as CreateTableCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateSchemaCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropColumnCall, x as DropIndexCall, y as DropConstraintCall } from "./op-factory-call-C4flTtTG.mjs";
+import { t as buildExpectedFormatType } from "./planner-sql-checks-Br1c_QsH.mjs";
+import { n as buildColumnTypeSql, t as buildColumnDefaultSql } from "./planner-ddl-builders-BKlmGDJl.mjs";
 import { n as resolveIdentityValue } from "./planner-identity-values-CJPha2Sz.mjs";
 import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-CiVaAQP-.mjs";
 import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma-next/framework-components/ir";
@@ -15,6 +15,31 @@ import * as contractFree from "@prisma-next/sql-relational-core/contract-free";
 import { RelationalSchemaNodeKind, SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { notOk, ok } from "@prisma-next/utils/result";
+//#region src/core/schema-ir/node-storage-coordinate.ts
+/**
+* The storage-`entries` coordinate `(entityKind, entityName)` a Postgres diff
+* node addresses — a table by its name, a native enum by its physical type
+* name. `undefined` for a node that is not a whole storage entity (a namespace,
+* a column, a policy). Lets ownership/subject resolution treat every entity kind
+* uniformly, the node self-describing its storage identity.
+*/
+function postgresNodeStorageCoordinate(node) {
+	if (PostgresTableSchemaNode.is(node)) {
+		const entityKind = postgresNodeEntityKind(node.nodeKind);
+		return entityKind === void 0 ? void 0 : {
+			entityKind,
+			entityName: node.name
+		};
+	}
+	if (PostgresNativeEnumSchemaNode.is(node)) {
+		const entityKind = postgresNodeEntityKind(node.nodeKind);
+		return entityKind === void 0 ? void 0 : {
+			entityKind,
+			entityName: node.typeName
+		};
+	}
+}
+//#endregion
 //#region src/core/migrations/column-ddl-rendering.ts
 /**
 * Reconstructs the `StorageColumn`-shaped fields the DDL builder functions
@@ -542,8 +567,10 @@ function issueConflict(kind, summary, location) {
 function classifyCall(call) {
 	switch (call.factoryName) {
 		case "createExtension":
-		case "createSchema": return "dep";
+		case "createSchema":
+		case "createNativeEnumType": return "dep";
 		case "dropTable":
+		case "dropNativeEnumType":
 		case "dropColumn":
 		case "dropConstraint":
 		case "dropCheckConstraint":
@@ -594,11 +621,16 @@ function conflictKindForCall(call) {
 function locationForCall(call) {
 	const anyCall = call;
 	const location = {};
-	if (anyCall.tableName) location.table = anyCall.tableName;
+	if (anyCall.tableName) {
+		location.entityKind = "table";
+		location.entityName = anyCall.tableName;
+	} else if (anyCall.typeName) {
+		location.entityKind = "native_enum";
+		location.entityName = anyCall.typeName;
+	}
 	if (anyCall.columnName) location.column = anyCall.columnName;
 	if (anyCall.indexName) location.index = anyCall.indexName;
 	if (anyCall.constraintName) location.constraint = anyCall.constraintName;
-	if (anyCall.typeName) location.type = anyCall.typeName;
 	return Object.keys(location).length > 0 ? location : void 0;
 }
 function conflictForDisallowedCall(call, allowed) {
@@ -674,6 +706,7 @@ function nodeIssueOrder(issue) {
 	if (node === void 0) return 99;
 	switch (node.nodeKind) {
 		case PostgresSchemaNodeKind.namespace: return 1;
+		case PostgresSchemaNodeKind.nativeEnum: return issue.reason === "not-expected" ? 17 : 2;
 		case RelationalSchemaNodeKind.foreignKey: return issue.reason === "not-expected" ? 10 : 60;
 		case RelationalSchemaNodeKind.unique: return issue.reason === "not-expected" ? 11 : 51;
 		case RelationalSchemaNodeKind.primaryKey: return issue.reason === "not-expected" ? 12 : 50;
@@ -759,6 +792,27 @@ function buildCreateTableCallsFromNode(schemaName, ddlSchemaName, table, codecHo
 function nodeConflict(kind, message) {
 	return issueConflict(kind, message);
 }
+/**
+* Managed native-enum issue -> op lowering. A missing declared type creates
+* it; an unclaimed live type drops it (ownership-scoped upstream by
+* `retainUnownedExtras`, destructiveness gated by the operation-class
+* policy); a paired member-value mismatch is a NAMED unsupported diagnostic
+* — never a silent no-op and never a drop-and-recreate. Slice B replaces the
+* diagnostic with order-aware `ALTER TYPE ... ADD VALUE` / refusal semantics.
+*/
+function mapNativeEnumNodeIssue(issue, ctx) {
+	const ddlSchemaName = issueSchemaName(issue);
+	if (ddlSchemaName === void 0) return notOk(nodeConflict("unsupportedOperation", `Enum issue has no schema in its path: ${issue.path.join("/")}`));
+	const schemaName = emissionSchemaName(ctx, ddlSchemaName);
+	if (issue.reason === "not-found") {
+		const expected = blindCast(issue.expected);
+		return ok([new CreateNativeEnumTypeCall(schemaName, expected.typeName, expected.members)]);
+	}
+	if (issue.reason === "not-expected") return ok([new DropNativeEnumTypeCall(schemaName, blindCast(issue.actual).typeName)]);
+	const expected = blindCast(issue.expected);
+	const actualMembers = blindCast(issue.actual).members;
+	return notOk(nodeConflict("unsupportedOperation", `Native enum type "${ddlSchemaName}"."${expected.typeName}" member values changed (contract declares [${expected.members.join(", ")}], database has [${actualMembers.join(", ")}]); enum value changes are not auto-migrated yet. Author the change manually with \`migration new\`.`));
+}
 function mapTableNodeIssue(issue, schemaName, ddlSchemaName, codecHooks) {
 	if (issue.reason === "not-found") return ok(buildCreateTableCallsFromNode(schemaName, ddlSchemaName, blindCast(issue.expected), codecHooks));
 	if (issue.reason === "not-expected") return ok([new DropTableCall(schemaName, blindCast(issue.actual).name)]);
@@ -853,6 +907,7 @@ function mapNodeIssueToCall(issue, ctx) {
 		if (issue.reason !== "not-found") return notOk(nodeConflict("unsupportedOperation", `Unexpected namespace drift: ${issue.path.join("/")}`));
 		return ok([new CreateSchemaCall(blindCast(issue.expected).schemaName)]);
 	}
+	if (node.nodeKind === PostgresSchemaNodeKind.nativeEnum) return mapNativeEnumNodeIssue(issue, ctx);
 	const ddlSchemaName = issueSchemaName(issue);
 	const tableName = issueTableName(issue);
 	if (ddlSchemaName === void 0 || tableName === void 0) return notOk(nodeConflict("unsupportedOperation", `Issue has no schema/table in its path: ${issue.path.join("/")}`));
@@ -972,13 +1027,16 @@ function planIssues(options) {
 * and is fail-closed. Any call not listed here — including future or
 * extension-contributed factories — is treated as NOT object-creation, so it
 * is suppressed under `tolerated` rather than permissively emitted.
+*
+* Lists the creation factories that actually reach the call-side resolver
+* (`resolvePostgresCallControlPolicySubject`) — today only RLS policy
+* creation, from `planPostgresSchemaDiff`. Every other whole-object create
+* (table, schema, native enum, and RLS enablement) is constructed inside
+* `planIssues` and graded on the node side by
+* `resolvePostgresNodeIssueCreationFactoryName`, so none of them are listed
+* here.
 */
-const OBJECT_CREATION_FACTORIES = new Set([
-	"createTable",
-	"createSchema",
-	"createRlsPolicy",
-	"enableRowLevelSecurity"
-]);
+const OBJECT_CREATION_FACTORIES = new Set(["createRlsPolicy"]);
 function createsNewTopLevelObject(call) {
 	return OBJECT_CREATION_FACTORIES.has(call.factoryName);
 }
@@ -986,17 +1044,33 @@ function ddlSchemaNameForNamespace(contract, namespaceId) {
 	const namespace = contract.storage.namespaces[namespaceId];
 	return isPostgresSchema(namespace) ? namespace.ddlSchemaName(contract.storage) : namespaceId;
 }
-function resolveNamespaceIdForTable(contract, tableName, ddlSchemaName) {
+/**
+* Resolve the namespace a declared storage entity lives in by walking every
+* namespace for one whose `entries` map actually contains the coordinate —
+* a table by its name, a native enum by its physical type name (see
+* {@link postgresNodeStorageCoordinate}). When `ddlSchemaName` is given, the
+* match must also land in that DDL schema (disambiguates same-named entities
+* declared under different namespaces); when omitted, the first namespace
+* that declares the entity wins. Falls back to {@link UNBOUND_NAMESPACE_ID}
+* when no namespace declares it — e.g. an extra/dropped entity the contract
+* doesn't claim at all.
+*/
+function resolveNamespaceIdForEntity(contract, coordinate, ddlSchemaName) {
 	for (const namespaceId of Object.keys(contract.storage.namespaces)) {
 		if (!entityAt(contract.storage, {
 			namespaceId,
-			entityKind: "table",
-			entityName: tableName
+			...coordinate
 		})) continue;
 		if (ddlSchemaName === void 0 || ddlSchemaNameForNamespace(contract, namespaceId) === ddlSchemaName) return namespaceId;
 	}
 	return UNBOUND_NAMESPACE_ID;
 }
+function resolveNamespaceIdForTable(contract, tableName, ddlSchemaName) {
+	return resolveNamespaceIdForEntity(contract, {
+		entityKind: "table",
+		entityName: tableName
+	}, ddlSchemaName);
+}
 function resolveNamespaceIdForDdlSchema(contract, ddlSchemaName) {
 	for (const namespaceId of Object.keys(contract.storage.namespaces)) {
 		const ns = contract.storage.namespaces[namespaceId];
@@ -1012,9 +1086,42 @@ function postgresCallFields(call) {
 		...ifDefined("columnName", "columnName" in call ? call.columnName : void 0)
 	};
 }
-function formatPostgresControlPolicySubjectLabel(factoryName, subject, contract) {
-	if (subject?.table) return `${factoryName}(${ddlSchemaNameForNamespace(contract, subject.namespaceId)}.${subject.table})`;
-	return factoryName;
+function formatSuppressionSubjectLabel(subject, contract) {
+	if (subject === void 0) return "unknown";
+	const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
+	if (subject.entityKind !== void 0 && subject.entityName !== void 0) return `${subject.entityKind} "${ddlSchema}.${subject.entityName}"`;
+	return `namespace "${ddlSchema}"`;
+}
+function postgresSuppressionSummary(subjectLabel, subject, policy) {
+	const namespace = subject?.namespaceId ?? "unknown";
+	const declared = subject?.explicitNodeControlPolicy;
+	if (policy === "external" && declared === "managed") return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control 'external' but declared 'managed'`;
+	return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control '${policy}'${declared ? ` but declared '${declared}'` : ""}`;
+}
+/**
+* Render one family {@link SuppressionRecord} into a target `SqlPlannerConflict`.
+* The family decides *that* a subject is suppressed and hands over the raw
+* coordinate + policy; the label, message, and location are rendered here,
+* driven entirely by the subject's own `(entityKind, entityName)` coordinate
+* — no target-owned table-vs-enum vocabulary.
+*/
+function renderPostgresSuppression(record, contract) {
+	const subject = record.subject;
+	return {
+		kind: "controlPolicySuppressedCall",
+		summary: postgresSuppressionSummary(formatSuppressionSubjectLabel(subject, contract), subject, record.policy),
+		location: {
+			...ifDefined("namespaceId", subject?.namespaceId),
+			...ifDefined("entityKind", subject?.entityKind),
+			...ifDefined("entityName", subject?.entityName),
+			...ifDefined("column", subject?.column)
+		},
+		meta: {
+			controlPolicy: record.policy,
+			...ifDefined("factoryName", record.factoryName),
+			...ifDefined("declaredControlPolicy", subject?.explicitNodeControlPolicy)
+		}
+	};
 }
 function resolvePostgresCallControlPolicySubject(call, contract) {
 	const callFields = postgresCallFields(call);
@@ -1032,9 +1139,10 @@ function resolvePostgresCallControlPolicySubject(call, contract) {
 		})?.control;
 		return {
 			namespaceId,
-			...ifDefined("explicitNodeControlPolicy", tableControlPolicy),
-			table: callFields.tableName,
+			entityKind: "table",
+			entityName: callFields.tableName,
 			...ifDefined("column", callFields.columnName),
+			...ifDefined("explicitNodeControlPolicy", tableControlPolicy),
 			createsNewObject
 		};
 	}
@@ -1044,10 +1152,10 @@ function resolvePostgresCallControlPolicySubject(call, contract) {
 	};
 }
 /**
-* Node kinds that describe the absence of a whole, top-level Postgres
-* object — the same objects `createsNewTopLevelObject` recognises for calls.
-* Used by {@link resolvePostgresNodeIssueCreationFactoryName} to decide
-* whether a `tolerated` subject permits the issue to flow into the planner
+* Node kinds whose *absence* is the creation of a whole, top-level Postgres
+* object: a namespace, a table, or a native enum. Used by
+* {@link resolvePostgresNodeIssueCreationFactoryName} to decide whether a
+* `tolerated` subject permits the issue to flow into the planner
 * (create-if-absent) and to seed the suppressed-subject warning's
 * `factoryName` when the planner is skipped. RLS policy creation is not
 * listed here — policy issues never reach this issue-based partition (they
@@ -1056,13 +1164,15 @@ function resolvePostgresCallControlPolicySubject(call, contract) {
 */
 const POSTGRES_NODE_CREATION_FACTORY = Object.freeze({
 	[PostgresSchemaNodeKind.namespace]: "createSchema",
-	[PostgresSchemaNodeKind.table]: "createTable"
+	[PostgresSchemaNodeKind.table]: "createTable",
+	[PostgresSchemaNodeKind.nativeEnum]: "createNativeEnumType"
 });
 /**
 * A table `not-equal` issue whose `rlsEnabled` flips OFF→ON (expected on,
-* actual off) is enablement toward `ENABLE ROW LEVEL SECURITY` —
-* creation-class per `OBJECT_CREATION_FACTORIES` ('enableRowLevelSecurity'
-* is a member): enabling RLS establishes the fail-closed guard the declared
+* actual off) is enablement toward `ENABLE ROW LEVEL SECURITY`. It is
+* creation-class on the node side because `isEnablementCreationIssue` and
+* {@link resolvePostgresNodeIssueCreationFactoryName} treat this OFF→ON delta
+* as a creation: enabling RLS establishes the fail-closed guard the declared
 * policy set attaches to, the same grant `tolerated` extends to creating the
 * policies themselves. The opposite direction (`DISABLE`) is a modification
 * and stays managed-only. Keying on the actual delta (not just the expected
@@ -1087,15 +1197,36 @@ function resolvePostgresNodeIssueCreationFactoryName(issue) {
 * {@link SchemaDiffIssue}. Mirrors the resolution
 * `resolvePostgresCallControlPolicySubject` performs for a generated DDL
 * call, but works *off the issue* — so the planner can partition issues by
-* effective policy before the diff engine runs. `createsNewObject` is
-* derived from the node kind + reason: a `not-found` schema/table describes
-* a brand-new top-level object; everything else touches an existing object.
+* effective policy before the diff engine runs.
+*
+* A whole storage entity (table or native enum) resolves generically off
+* {@link postgresNodeStorageCoordinate} — the node self-describes its
+* `(entityKind, entityName)`, so table and enum issues share one code path
+* with no per-kind branch. A sub-entity issue (a column/constraint drift
+* inside an owned table) carries no such coordinate on its own node, so it
+* falls back to reading the enclosing table name off the issue path.
+*
+* `createsNewObject` is delegated to {@link resolvePostgresNodeIssueCreationFactoryName}
+* in every branch below — that function already encodes exactly which
+* node-kind/reason combinations describe a brand-new top-level object
+* (a `not-found` table/enum, or an RLS-enablement `not-equal`).
+*
+* A `not-expected` (extra/dropped) entity carries no contract namespace
+* coordinate — the live object isn't claimed by any contract namespace — so
+* the subject's `namespaceId` falls back to {@link UNBOUND_NAMESPACE_ID} via
+* `resolveNamespaceIdForEntity`'s own fallback, matching how the call-side
+* resolver treats the `DropTableCall`/`DropNativeEnumTypeCall` it produces.
 *
-* A `not-expected` table carries no contract namespace coordinate (the live
-* table isn't claimed by any contract namespace), so the subject's
-* `namespaceId` falls back to {@link UNBOUND_NAMESPACE_ID} via
-* `resolveNamespaceIdForTable`'s own fallback — the call-side resolver does
-* the same for the `DropTableCall` it produces.
+* A role node resolves against the `PostgresRole` contract entity at that
+* role's name (roles are root-level diff subjects, so the name is the
+* second path segment after the tree root). A `not-found` role is declared,
+* so the entity is always found and its `control` read directly — which is
+* always {@link ROLE_DEFAULT_CONTROL_POLICY} today, since no authoring
+* surface sets it otherwise. A `not-expected` role has no contract entity
+* (an undeclared live role, by definition), so the subject falls back to
+* the same default — roles are referenced but never owned, so an
+* undeclared role gets exactly the same governance as a declared one.
+* Never creates a new object: role provisioning is a non-goal.
 */
 function resolvePostgresNodeIssueControlPolicySubject(issue, contract) {
 	const node = issue.expected ?? issue.actual;
@@ -1104,6 +1235,33 @@ function resolvePostgresNodeIssueControlPolicySubject(issue, contract) {
 		namespaceId: resolveNamespaceIdForDdlSchema(contract, blindCast(node).schemaName),
 		createsNewObject: issue.reason === "not-found"
 	};
+	if (node.nodeKind === PostgresSchemaNodeKind.role) {
+		const roleName = issue.path[1];
+		return {
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			explicitNodeControlPolicy: (roleName === void 0 ? void 0 : entityAt(contract.storage, {
+				namespaceId: UNBOUND_NAMESPACE_ID,
+				entityKind: "role",
+				entityName: roleName
+			}))?.control ?? "external",
+			createsNewObject: false
+		};
+	}
+	const coordinate = postgresNodeStorageCoordinate(node);
+	if (coordinate !== void 0) {
+		const namespaceId = resolveNamespaceIdForEntity(contract, coordinate, issue.path[1]);
+		const entityControl = entityAt(contract.storage, {
+			namespaceId,
+			...coordinate
+		})?.control;
+		return {
+			namespaceId,
+			...coordinate,
+			...ifDefined("column", issueColumnName(issue)),
+			...ifDefined("explicitNodeControlPolicy", entityControl),
+			createsNewObject: resolvePostgresNodeIssueCreationFactoryName(issue) !== void 0
+		};
+	}
 	const tableName = issue.path[2];
 	if (tableName === void 0) return void 0;
 	const ddlSchemaName = issue.path[1];
@@ -1113,16 +1271,16 @@ function resolvePostgresNodeIssueControlPolicySubject(issue, contract) {
 		entityKind: "table",
 		entityName: tableName
 	});
-	const createsNewObject = node.nodeKind === PostgresSchemaNodeKind.table && issue.reason === "not-found" || isEnablementCreationIssue(issue);
 	return {
 		namespaceId,
-		...ifDefined("explicitNodeControlPolicy", table?.control),
-		table: tableName,
+		entityKind: "table",
+		entityName: tableName,
 		...ifDefined("column", issueColumnName(issue)),
-		createsNewObject
+		...ifDefined("explicitNodeControlPolicy", table?.control),
+		createsNewObject: resolvePostgresNodeIssueCreationFactoryName(issue) !== void 0
 	};
 }
 //#endregion
-export { resolvePostgresNodeIssueCreationFactoryName as a, issueSchemaName as c, postgresPlannerStrategies as d, resolvePostgresNodeIssueControlPolicySubject as i, issueTableName as l, resolveNamespaceIdForDdlSchema as n, coalesceSubtreeIssues as o, resolvePostgresCallControlPolicySubject as r, issueNode as s, formatPostgresControlPolicySubjectLabel as t, planIssues as u };
+export { resolvePostgresNodeIssueCreationFactoryName as a, issueSchemaName as c, postgresNodeStorageCoordinate as d, resolvePostgresNodeIssueControlPolicySubject as i, planIssues as l, resolveNamespaceIdForDdlSchema as n, coalesceSubtreeIssues as o, resolvePostgresCallControlPolicySubject as r, issueNode as s, renderPostgresSuppression as t, postgresPlannerStrategies as u };
 
-//# sourceMappingURL=control-policy-Co_13Hxa.mjs.map
+//# sourceMappingURL=control-policy-DKp0HKpY.mjs.map