@prisma-next/target-postgres 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/planner-Bq0Z2sVO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-Bq0Z2sVO.mjs","names":["#lowerer"],"sources":["../src/core/migrations/contract-to-postgres-database-schema-node.ts","../src/core/migrations/diff-database-schema.ts","../src/core/migrations/control-policy.ts","../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';\nimport { contractNamespaceToSchemaIR } from '@prisma-next/family-sql/control';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport type { PostgresContract } from '../postgres-schema';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport { PostgresRoleSchemaNode } from '../schema-ir/postgres-role-schema-node';\nimport { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\n\nfunction toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresPolicySchemaNode {\n  return new PostgresPolicySchemaNode({\n    name: policy.name,\n    prefix: policy.prefix,\n    tableName: policy.tableName,\n    namespaceId,\n    operation: policy.operation,\n    roles: [...policy.roles],\n    ...ifDefined('using', policy.using),\n    ...ifDefined('withCheck', policy.withCheck),\n    permissive: policy.permissive,\n  });\n}\n\n/**\n * Projects a Postgres contract into the expected schema-diff tree: a\n * `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`\n * per Postgres namespace, each holding its `PostgresTableSchemaNode`s with\n * their `PostgresPolicySchemaNode`s, plus the database roles on the root.\n *\n * Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,\n * single `{ tables }` map (and throws on cross-namespace name collisions, with\n * no RLS/role concept) for SQLite's single-schema world. This is the\n * Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.\n * It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)\n * for column/FK/index building and only adds the Postgres tree/policy/role shape.\n *\n * Tables are grouped by their owning namespace (resolved DDL schema name) so\n * the tree mirrors Postgres's object hierarchy. The DDL schema name is\n * resolved once per namespace.\n *\n * A policy that references a table absent from its namespace is a malformed\n * contract — the loop throws rather than fabricating a stub table.\n */\nexport function contractToPostgresDatabaseSchemaNode(\n  contract: PostgresContract | null,\n  options: ContractToSchemaIROptions,\n): PostgresDatabaseSchemaNode {\n  if (contract === null) {\n    return new PostgresDatabaseSchemaNode({\n      namespaces: {},\n      roles: [],\n      existingSchemas: [],\n      pgVersion: '',\n    });\n  }\n\n  const namespaces: Record<string, PostgresNamespaceSchemaNode> = {};\n  const roles: PostgresRoleSchemaNode[] = [];\n  const ownedSchemas: string[] = [];\n\n  for (const ns of Object.values(contract.storage.namespaces)) {\n    if (!isPostgresSchema(ns)) continue;\n    const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);\n    ownedSchemas.push(ddlSchema);\n\n    // Convert only THIS namespace's tables (passing the full storage for\n    // type/value-set/enum resolution that spans namespaces), so the same table\n    // name can exist in two schemas without colliding in a bare-keyed record.\n    const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;\n\n    const policiesByTable = new Map<string, PostgresPolicySchemaNode[]>();\n    for (const policy of Object.values(ns.policy)) {\n      const list = policiesByTable.get(policy.tableName) ?? [];\n      list.push(toPolicyNode(policy, ddlSchema));\n      policiesByTable.set(policy.tableName, list);\n    }\n\n    const tables: Record<string, PostgresTableSchemaNode> = {};\n    for (const tableName of Object.keys(ns.table)) {\n      const sqlTable = sqlTables[tableName];\n      if (sqlTable === undefined) continue;\n      tables[tableName] = new PostgresTableSchemaNode({\n        name: sqlTable.name,\n        columns: sqlTable.columns,\n        foreignKeys: sqlTable.foreignKeys,\n        uniques: sqlTable.uniques,\n        indexes: sqlTable.indexes,\n        ...ifDefined('primaryKey', sqlTable.primaryKey),\n        ...ifDefined('annotations', sqlTable.annotations),\n        ...ifDefined('checks', sqlTable.checks),\n        policies: policiesByTable.get(tableName) ?? [],\n      });\n    }\n\n    for (const [tableName, tablePolicies] of policiesByTable) {\n      if (!(tableName in tables)) {\n        const policyName = tablePolicies[0]?.name ?? '(unknown)';\n        throw new Error(\n          `contract-to-postgres-database-schema-node: policy \"${policyName}\" references table \"${tableName}\" not present in namespace \"${ddlSchema}\"`,\n        );\n      }\n    }\n\n    namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({\n      schemaName: ddlSchema,\n      tables,\n      nativeEnumTypeNames: [],\n    });\n\n    for (const role of Object.values(ns.role)) {\n      roles.push(new PostgresRoleSchemaNode({ name: role.name, namespaceId: role.namespaceId }));\n    }\n  }\n\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles,\n    existingSchemas: ownedSchemas,\n    pgVersion: '',\n  });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { verifySqlSchemaTree } from '@prisma-next/family-sql/diff';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  SchemaDiffIssue,\n  VerifyDatabaseSchemaResult,\n} from '@prisma-next/framework-components/control';\nimport { diffSchemas, SchemaDiff } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport type { PostgresContract } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\nimport { contractToPostgresDatabaseSchemaNode } from './contract-to-postgres-database-schema-node';\n\ninterface PostgresDiffDatabaseSchemaInput {\n  readonly contract: Contract<SqlStorage>;\n  readonly actualSchema: SqlSchemaIRNode;\n  readonly strict: boolean;\n  readonly typeMetadataRegistry: ReadonlyMap<string, { readonly nativeType?: string }>;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}\n\n/**\n * The single combined database-schema comparison — the one computation the\n * migration planner and the family schema verify both consume. Composes,\n * once each:\n *\n * - the per-namespace-paired relational diff (`verifySqlSchemaTree`) → table /\n *   column / constraint findings as framework `SchemaIssue`s (with the\n *   verification-tree `root` and pass/warn/fail counts);\n * - the policy diff (`diffPostgresSchema` over the two trees) → RLS policy\n *   presence as `SchemaDiffIssue`s, ownership-filtered to the contract's owned\n *   schemas.\n *\n * `diffPostgresDatabaseSchema` and `verifyPostgresDatabaseSchema` both read\n * this single result, so the relational walk runs once per caller — never\n * once for the diff and again for the verify tree.\n */\nfunction computePostgresSchemaComparison(input: PostgresDiffDatabaseSchemaInput): {\n  readonly relational: VerifyDatabaseSchemaResult;\n  readonly schemaDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];\n} {\n  const postgresContract = blindCast<\n    PostgresContract,\n    'diffPostgresDatabaseSchema is only called with a postgres contract'\n  >(input.contract);\n\n  // Relational diff: per-namespace-paired so a multi-schema database checks each\n  // contract namespace against its own actual node.\n  const relational = verifySqlSchemaTree({\n    contract: input.contract,\n    actualSchema: input.actualSchema,\n    buildExpectedSchema: (scopedContract) =>\n      contractToPostgresDatabaseSchemaNode(\n        blindCast<\n          PostgresContract | null,\n          'the relational pairing projects a scoped postgres contract'\n        >(scopedContract),\n        { annotationNamespace: 'pg' },\n      ),\n    strict: input.strict,\n    typeMetadataRegistry: input.typeMetadataRegistry,\n    frameworkComponents: input.frameworkComponents,\n    normalizeDefault: parsePostgresDefault,\n    normalizeNativeType: normalizeSchemaNativeType,\n  });\n\n  // Policy diff: the generic node differ over the expected/actual policy trees,\n  // ownership-filtered to the schemas the contract owns (so unowned-namespace\n  // policies are not reported as extras). The actual schema is always the\n  // Postgres database root in production — assert it, matching the prior\n  // `collectSchemaDiffIssues` / `planPostgresSchemaDiff` behaviour.\n  PostgresDatabaseSchemaNode.assert(input.actualSchema);\n  const expected = contractToPostgresDatabaseSchemaNode(postgresContract, {\n    annotationNamespace: 'pg',\n  });\n  const schemaDiffIssues = filterIssuesByOwnership(\n    diffPostgresSchema(expected, input.actualSchema),\n    ownedSchemaNames(expected),\n  );\n\n  return { relational, schemaDiffIssues };\n}\n\n/**\n * The `SchemaDiffer` for Postgres: the target's black-box comparison,\n * projected to the two issue lists. Namespace presence (`missing_schema` →\n * `CREATE SCHEMA`) is intentionally NOT composed here: it is a planner-only\n * op-generation concern (verify rejects on the relational `missing_table` a\n * missing schema already produces), so the planner stitches it in around this\n * diff. Control-policy suppression of the policy issues is likewise a\n * per-consumer post-step (verify filters the issues; the planner filters the\n * calls).\n */\nexport function diffPostgresDatabaseSchema(\n  input: PostgresDiffDatabaseSchemaInput,\n): SchemaDiff<SqlSchemaDiffNode> {\n  const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);\n  return new SchemaDiff(relational.schema.issues, schemaDiffIssues);\n}\n\n/**\n * The same combined comparison as {@link diffPostgresDatabaseSchema}, wrapped\n * in the verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the\n * pass/warn/fail tree the CLI renders — i.e. exactly the existing verify-result\n * schema shape, so nothing downstream changes.\n */\nexport function verifyPostgresDatabaseSchema(\n  input: PostgresDiffDatabaseSchemaInput,\n): VerifyDatabaseSchemaResult {\n  const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);\n  return {\n    ...relational,\n    schema: { ...relational.schema, schemaDiffIssues },\n  };\n}\n\nfunction ownedSchemaNames(expected: PostgresDatabaseSchemaNode): ReadonlySet<string> {\n  const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) =>\n    Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)),\n  );\n  return new Set([...policyNamespaces, ...expected.existingSchemas]);\n}\n\n// Renders a display-only reference string for the diff message. If policy\n// rendering grows, route it through the adapter's SQL renderer so the message\n// can't diverge from the emitted policy SQL.\nfunction renderPostgresPolicyReference(policy: PostgresPolicySchemaNode): string {\n  return `policy \"${policy.name}\" on \"${policy.namespaceId}\".\"${policy.tableName}\"`;\n}\n\n/**\n * The policy node-diff — the structural half of the combined comparison above.\n * Computes RLS-policy drift between two derived schema trees:\n *\n * 1. Runs the framework total diff over the two `PostgresDatabaseSchemaNode`\n *    roots (database → namespace → table → policy).\n * 2. Filters to policy-subject issues only — this is transitional: the generic\n *    differ walks the whole tree, but the legacy relational verifier still owns\n *    table/column drift, so non-policy issues are dropped here.\n * 3. Remaps the message to a human-readable policy reference.\n *\n * Both trees are `PostgresDatabaseSchemaNode`s, so every issue node is a\n * `SqlSchemaDiffNode` — narrow the framework's `SchemaDiffIssue<DiffableNode>`\n * output once here (the single boundary cast), so every downstream consumer\n * (the ownership filter, the planner) reads the concrete node with no cast.\n *\n * Ownership filtering (dropping `extra` issues in namespaces a contract doesn't\n * own) is the caller's responsibility — use `filterIssuesByOwnership`.\n */\nexport function diffPostgresSchema(\n  expected: PostgresDatabaseSchemaNode,\n  actual: PostgresDatabaseSchemaNode,\n): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  const issues = blindCast<\n    readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n    'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'\n  >(diffSchemas(expected, actual));\n\n  return issues\n    .filter((i) => {\n      const node = i.expected ?? i.actual;\n      return node !== undefined && PostgresPolicySchemaNode.is(node);\n    })\n    .map((i) => {\n      const node = i.expected ?? i.actual;\n      if (node === undefined || !PostgresPolicySchemaNode.is(node)) return i;\n      return { ...i, message: `${i.outcome}: ${renderPostgresPolicyReference(node)}` };\n    });\n}\n\n/**\n * Filters `extra` policy issues to those in owned namespaces. Call after\n * `diffPostgresSchema` with the union of namespace ids from the expected tree's\n * policies and its `existingSchemas`.\n */\nexport function filterIssuesByOwnership(\n  issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ownedSchemaNameSet: ReadonlySet<string>,\n): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  return issues.filter((i) => {\n    if (i.outcome !== 'extra') return true;\n    if (i.actual === undefined) return false;\n    return PostgresPolicySchemaNode.is(i.actual) && ownedSchemaNameSet.has(i.actual.namespaceId);\n  });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { ControlPolicySubject } from '@prisma-next/family-sql/control';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { isPostgresSchema } from '../postgres-schema';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\n\n/**\n * Factory calls that create a whole, previously-absent top-level storage\n * object. Used to decide whether `tolerated` permits a call (it only allows\n * creating absent objects, never modifying existing ones).\n *\n * Deliberately an explicit, closed set rather than a `factoryName`\n * create/alter/drop classification: it answers exactly one yes/no question\n * and is fail-closed. Any call not listed here — including future or\n * extension-contributed factories — is treated as NOT object-creation, so it\n * is suppressed under `tolerated` rather than permissively emitted.\n */\nconst OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([\n  'createTable',\n  'createSchema',\n  'createRlsPolicy',\n  'enableRowLevelSecurity',\n]);\n\nfunction createsNewTopLevelObject(call: PostgresOpFactoryCall): boolean {\n  return OBJECT_CREATION_FACTORIES.has(call.factoryName);\n}\n\nfunction ddlSchemaNameForNamespace(contract: Contract<SqlStorage>, namespaceId: string): string {\n  const namespace = contract.storage.namespaces[namespaceId];\n  return isPostgresSchema(namespace) ? namespace.ddlSchemaName(contract.storage) : namespaceId;\n}\n\nfunction resolveNamespaceIdForTable(\n  contract: Contract<SqlStorage>,\n  tableName: string,\n  ddlSchemaName: string | undefined,\n): string {\n  for (const namespaceId of Object.keys(contract.storage.namespaces)) {\n    const table = entityAt<StorageTable>(contract.storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    if (!table) continue;\n    if (\n      ddlSchemaName === undefined ||\n      ddlSchemaNameForNamespace(contract, namespaceId) === ddlSchemaName\n    ) {\n      return namespaceId;\n    }\n  }\n  return UNBOUND_NAMESPACE_ID;\n}\n\nfunction resolveNamespaceIdForDdlSchema(\n  contract: Contract<SqlStorage>,\n  ddlSchemaName: string,\n): string {\n  for (const namespaceId of Object.keys(contract.storage.namespaces)) {\n    const ns = contract.storage.namespaces[namespaceId];\n    if (isPostgresSchema(ns) && ns.ddlSchemaName(contract.storage) === ddlSchemaName) {\n      return namespaceId;\n    }\n    if (namespaceId === ddlSchemaName) {\n      return namespaceId;\n    }\n  }\n  return UNBOUND_NAMESPACE_ID;\n}\n\ninterface PostgresCallFields {\n  readonly schemaName?: string;\n  readonly tableName?: string;\n  readonly columnName?: string;\n}\n\nfunction postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {\n  return {\n    ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),\n    ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),\n    ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),\n  };\n}\n\nexport function formatPostgresControlPolicySubjectLabel(\n  factoryName: string,\n  subject: ControlPolicySubject | undefined,\n  contract: Contract<SqlStorage>,\n): string {\n  if (subject?.table) {\n    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);\n    return `${factoryName}(${ddlSchema}.${subject.table})`;\n  }\n  return factoryName;\n}\n\nexport function resolvePostgresCallControlPolicySubject(\n  call: PostgresOpFactoryCall,\n  contract: Contract<SqlStorage>,\n): ControlPolicySubject | undefined {\n  const callFields = postgresCallFields(call);\n  const createsNewObject = createsNewTopLevelObject(call);\n\n  if (call.factoryName === 'createSchema' && callFields.schemaName) {\n    return {\n      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),\n      createsNewObject,\n    };\n  }\n\n  if (callFields.tableName) {\n    const namespaceId = resolveNamespaceIdForTable(\n      contract,\n      callFields.tableName,\n      callFields.schemaName,\n    );\n    const tableControlPolicy = entityAt<StorageTable>(contract.storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: callFields.tableName,\n    })?.control;\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),\n      table: callFields.tableName,\n      ...ifDefined('column', callFields.columnName),\n      createsNewObject,\n    };\n  }\n\n  if (callFields.schemaName) {\n    return {\n      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),\n      createsNewObject,\n    };\n  }\n\n  return undefined;\n}\n\n/**\n * Issue kinds that describe the absence of a whole, top-level Postgres\n * object — the same kinds `createsNewTopLevelObject` recognises for calls.\n * Used by {@link resolvePostgresIssueCreationFactoryName} to decide whether\n * a `tolerated` subject permits the issue to flow into the planner\n * (create-if-absent) and to seed the suppressed-subject warning's\n * `factoryName` when the planner is skipped.\n */\nconst POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({\n  missing_schema: 'createSchema',\n  missing_table: 'createTable',\n  missing_rls_policy: 'createRlsPolicy',\n});\n\nexport function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {\n  return POSTGRES_ISSUE_CREATION_FACTORY[issue.kind];\n}\n\n/**\n * Resolve the control-policy subject coordinate for a single\n * {@link SchemaIssue}. Mirrors the resolution `resolvePostgresCallControlPolicySubject`\n * performs for a generated DDL call, but works *off the issue* — so the\n * planner can partition issues by effective policy before the diff engine\n * runs. `createsNewObject` is derived from the issue's kind: schema/table/\n * type-missing issues describe a brand-new top-level object; everything else\n * touches an existing object.\n *\n * An `extra_table` issue carries no contract namespace coordinate (the table\n * isn't in any contract namespace), so the subject's `namespaceId` falls\n * back to {@link UNBOUND_NAMESPACE_ID}; the call-side resolver does the same\n * for the `DropTableCall` it produces.\n */\nexport function resolvePostgresIssueControlPolicySubject(\n  issue: SchemaIssue,\n  contract: Contract<SqlStorage>,\n): ControlPolicySubject | undefined {\n  const createsNewObject = POSTGRES_ISSUE_CREATION_FACTORY[issue.kind] !== undefined;\n\n  if (issue.kind === 'missing_schema' && issue.namespaceId) {\n    return { namespaceId: issue.namespaceId, createsNewObject };\n  }\n\n  if ('table' in issue && issue.table) {\n    const namespaceId =\n      'namespaceId' in issue && issue.namespaceId\n        ? issue.namespaceId\n        : resolveNamespaceIdForTable(contract, issue.table, undefined);\n    const table = entityAt<StorageTable>(contract.storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: issue.table,\n    });\n    return {\n      namespaceId,\n      ...ifDefined('explicitNodeControlPolicy', table?.control),\n      table: issue.table,\n      ...ifDefined('column', 'column' in issue ? issue.column : undefined),\n      createsNewObject,\n    };\n  }\n\n  return undefined;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\n\n/**\n * Resolves the live-database schema name for a given namespace\n * coordinate. Mirrors `resolveDdlSchemaForNamespace` in\n * `planner-strategies.ts` so the verifier's projection and the\n * planner's projection always agree — Postgres-aware namespaces (the\n * production path) dispatch to `ddlSchemaName(storage)`, and bare\n * object payloads (used by some tests) fall back to the coordinate\n * itself.\n */\nfunction resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string {\n  const namespace = storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/**\n * Reads the introspected list of schema names from the database-root schema\n * node. `existingSchemas` is database-level, so it lives on the\n * `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.\n *\n * Defaults to the always-present `public` schema when the node is not the\n * database root — a fresh Postgres database always carries `public` (unless an\n * operator dropped it manually), so any verifier path that runs without an\n * enriched introspection still suppresses the redundant `CREATE SCHEMA\n * \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and sets `existingSchemas`\n * on the returned root. Tests that want to assert against a richer initial\n * state construct a `PostgresDatabaseSchemaNode` explicitly.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {\n  if (PostgresDatabaseSchemaNode.is(schema)) {\n    return schema.existingSchemas;\n  }\n  return [DEFAULT_NAMESPACE_ID];\n}\n\n/**\n * Emits a `missing_schema` issue for every contract-declared Postgres\n * namespace whose live container does not yet exist. The planner's\n * `collectSchemaIssues` prepends these to the relational findings so a\n * multi-schema plan emits `CREATE SCHEMA` before the tables that need it —\n * a planner-only concern (verify already rejects via the `missing_table` a\n * missing schema produces), so this is not part of the shared diff.\n *\n * A namespace's live container is the schema returned by its\n * polymorphic `ddlSchemaName(storage)` method — named schemas resolve\n * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`\n * and is skipped explicitly (late-bound namespaces have no fixed DDL\n * schema). Issues are emitted only when the resolved name is a real,\n * creatable schema (not the unbound sentinel) and is missing from the\n * introspected list. `public` is suppressed implicitly because the\n * introspection (or its sensible default) always carries it.\n *\n * Each emitted issue stamps `namespaceId` with the contract namespace\n * coordinate so the downstream `mapIssueToCall` re-resolves the DDL\n * schema name through the same polymorphic path — keeping the\n * coordinate, not the resolved name, as the issue's stable identity.\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n}): readonly SchemaIssue[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaIssue[] = [];\n  const namespaceIds = Object.keys(contract.storage.namespaces).sort();\n  for (const namespaceId of namespaceIds) {\n    if (namespaceId === UNBOUND_NAMESPACE_ID) continue;\n    const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);\n    if (ddlName === UNBOUND_NAMESPACE_ID) continue;\n    if (existing.has(ddlName)) continue;\n    issues.push({\n      kind: 'missing_schema',\n      reason: 'not-found',\n      namespaceId,\n      message: `Schema \"${ddlName}\" is missing from database`,\n    });\n  }\n  return issues;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerConflict,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\n  partitionCallsByControlPolicy,\n  partitionIssuesByControlPolicy,\n  planFieldEventOperations,\n  plannerFailure,\n} from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaDiffIssue,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\nimport {\n  formatPostgresControlPolicySubjectLabel,\n  resolvePostgresCallControlPolicySubject,\n  resolvePostgresIssueControlPolicySubject,\n  resolvePostgresIssueCreationFactoryName,\n} from './control-policy';\nimport { diffPostgresDatabaseSchema } from './diff-database-schema';\nimport { planIssues } from './issue-planner';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport {\n  CreatePostgresRlsPolicyCall,\n  DropPostgresRlsPolicyCall,\n  EnableRowLevelSecurityCall,\n} from './op-factory-call';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\nimport { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(\n  lowerer: ExecuteRequestLowerer,\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner(lowerer);\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | {\n      readonly kind: 'success';\n      readonly plan: TypeScriptRenderablePostgresMigration;\n      readonly warnings?: readonly SqlPlannerConflict[];\n    }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n\n  constructor(lowerer?: ExecuteRequestLowerer) {\n    this.#lowerer = lowerer;\n  }\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(\n    context: MigrationScaffoldContext,\n    spaceId: string,\n  ): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration(\n      [],\n      {\n        from: context.fromHash,\n        to: context.toHash,\n      },\n      spaceId,\n      this.#lowerer,\n    );\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName =\n      options.schemaName ??\n      Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ??\n      UNBOUND_NAMESPACE_ID;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    // One combined database-schema diff drives the whole plan: the relational\n    // findings (+ namespace presence) become structural DDL via `planIssues`,\n    // the policy findings become RLS ops via `planPostgresSchemaDiff`. Verify\n    // runs the same underlying comparison (via `verifyDatabaseSchema`) and\n    // rejects on non-empty. The caller-supplied `keepDiffIssue` predicate is\n    // applied blindly — any scoping (e.g. multi-space ownership) is the\n    // orchestration's, never worked out here.\n    PostgresDatabaseSchemaNode.assert(options.schema);\n    const rawDiff = diffPostgresDatabaseSchema({\n      contract: options.contract,\n      actualSchema: options.schema,\n      strict:\n        options.policy.allowedOperationClasses.includes('widening') ||\n        options.policy.allowedOperationClasses.includes('destructive'),\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n    });\n    const databaseDiff = options.keepDiffIssue ? rawDiff.filter(options.keepDiffIssue) : rawDiff;\n    const schemaIssues = this.collectSchemaIssues(options, databaseDiff.issues);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n    // The strategy layer reads the live schema by bare table name for existence\n    // checks (shared-temp-default safety, FK/unique probes), so it takes one\n    // per-schema namespace node — never the whole tree root, and never a flat\n    // merge of every namespace (which would collide same-named tables across\n    // schemas). Probing more than one namespace at once is future work.\n    const relationalSchema = relationalNamespaceNode(options.schema, schemaName);\n\n    // Input-side control-policy partition. `external` / `observed` subjects\n    // — and non-creation issues for `tolerated` subjects — are dropped from\n    // the planner's input entirely; the planner never observes them, never\n    // diffs them, never generates DDL for them. Suppression warnings are\n    // built directly from the suppressed partition (one per subject), so the\n    // user-visible message survives even when the planner would have failed\n    // to model the subject's live shape.\n    const issuePartition = partitionIssuesByControlPolicy({\n      issues: schemaIssues,\n      contract: options.contract,\n      resolveControlPolicySubject: (issue) =>\n        resolvePostgresIssueControlPolicySubject(issue, options.contract),\n      resolveCreationFactoryName: resolvePostgresIssueCreationFactoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    const result = planIssues({\n      issues: issuePartition.plannable,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      ...ifDefined('schema', relationalSchema),\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    const schemaDiffCalls = this.planPostgresSchemaDiff(options, databaseDiff.schemaDiffIssues);\n    const schemaDiffPartition = partitionCallsByControlPolicy({\n      calls: schemaDiffCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n\n    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed\n    // ordering is `structural → added → dropped → altered`, with\n    // within-group sorting by `(tableName, fieldName)` so re-emits are\n    // byte-stable. The hook fires only at the application emitter —\n    // extension-space planning never reaches this helper.\n    const fieldEventOps = planFieldEventOperations({\n      priorContract: options.fromContract,\n      newContract: options.contract,\n      codecHooks,\n    });\n    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning\n    // lifts them at this integration boundary (see field-event-planner JSDoc).\n    const fieldEventPostgresCalls = blindCast<\n      readonly PostgresOpFactoryCall[],\n      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'\n    >(fieldEventOps);\n    const fieldEventPartition = partitionCallsByControlPolicy({\n      calls: fieldEventPostgresCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n      formatSubjectLabel: (factoryName, subject) =>\n        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),\n    });\n    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];\n    const warnings: SqlPlannerConflict[] = [\n      ...issuePartition.warnings,\n      ...schemaDiffPartition.warnings,\n      ...fieldEventPartition.warnings,\n    ];\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(\n        calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        options.spaceId,\n        this.#lowerer,\n      ),\n      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),\n    });\n  }\n\n  /**\n   * Maps the RLS policy presence findings of the shared\n   * `diffPostgresDatabaseSchema` (already ownership-filtered) into\n   * `ENABLE RLS` / `CREATE POLICY` / `DROP POLICY` ops. It no longer re-diffs —\n   * it consumes the `schemaDiffIssues` of the one combined diff.\n   */\n  private planPostgresSchemaDiff(\n    options: PlannerOptionsWithComponents,\n    filteredDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ): readonly PostgresOpFactoryCall[] {\n    const allowsDestructive = options.policy.allowedOperationClasses.includes('destructive');\n    const calls: PostgresOpFactoryCall[] = [];\n    const seenEnableTables = new Set<string>();\n\n    for (const issue of filteredDiffIssues) {\n      // 'mismatch' is unreachable for content-addressed policies: the wire name\n      // encodes the body hash, so two policies sharing a local key (same name)\n      // are always equal and isEqualTo never returns false.\n      if (issue.outcome === 'missing') {\n        const expected = issue.expected;\n        PostgresPolicySchemaNode.assert(expected);\n        // expected.namespaceId is the DDL schema name (resolved during projection);\n        // this re-resolution is a no-op as long as PostgresSchema.ddlSchemaName() returns this.id.\n        const schemaForTable = resolveDdlSchemaForNamespaceStorage(\n          options.contract.storage,\n          expected.namespaceId,\n        );\n        const tableKey = `${schemaForTable}.${expected.tableName}`;\n        if (!seenEnableTables.has(tableKey)) {\n          seenEnableTables.add(tableKey);\n          calls.push(new EnableRowLevelSecurityCall(schemaForTable, expected.tableName));\n        }\n        calls.push(\n          new CreatePostgresRlsPolicyCall(\n            schemaForTable,\n            expected.tableName,\n            policyNodeToContractPolicy(expected),\n          ),\n        );\n      } else if (issue.outcome === 'extra' && allowsDestructive) {\n        const actual = issue.actual;\n        PostgresPolicySchemaNode.assert(actual);\n        const schemaForTable = resolveDdlSchemaForNamespaceStorage(\n          options.contract.storage,\n          actual.namespaceId,\n        );\n        calls.push(new DropPostgresRlsPolicyCall(schemaForTable, actual.tableName, actual.name));\n      }\n    }\n\n    return calls;\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  /**\n   * The structural issue list `planIssues` consumes: the relational findings\n   * from the shared `diffPostgresDatabaseSchema` plus namespace presence.\n   *\n   * Schema presence (`missing_schema` → `CREATE SCHEMA`) is a planner-only\n   * op-generation concern, so it is stitched in here rather than inside the\n   * shared diff — verify never needs it (a missing schema already surfaces as\n   * `missing_table` in the relational findings). It reads `existingSchemas` off\n   * the database root, so it takes the whole tree. Policy drift is handled\n   * separately via `planPostgresSchemaDiff` from the same shared diff's\n   * `schemaDiffIssues`.\n   */\n  private collectSchemaIssues(\n    options: PlannerOptionsWithComponents,\n    relationalIssues: readonly SchemaIssue[],\n  ): readonly SchemaIssue[] {\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    if (namespaceIssues.length === 0) {\n      return relationalIssues;\n    }\n    return [...namespaceIssues, ...relationalIssues];\n  }\n}\n\n/**\n * Returns the one namespace node whose tables the relational strategy layer\n * probes for live-table existence — the node matching the planner's resolved\n * schema name, or the first namespace when none matches. `undefined` when the\n * tree has no namespaces, so the strategy context uses its empty-schema default.\n *\n * The relational strategies key tables by bare name, so they can only probe one\n * namespace at a time; probing across every namespace at once is future work.\n */\nfunction relationalNamespaceNode(\n  schema: PostgresDatabaseSchemaNode,\n  schemaName: string,\n): SqlSchemaIR | undefined {\n  const namespaceNodes = Object.values(schema.namespaces);\n  const byName = namespaceNodes.find((node) => node.schemaName === schemaName);\n  return byName ?? namespaceNodes[0];\n}\n\n/**\n * Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`\n * carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole\n * entity, `namespaceId` included). This reconstructs rather than looking the\n * original up in the contract on purpose: the diff node's `namespaceId` is the\n * *resolved DDL schema* (set when the expected tree was built), which is the\n * value the emitted op must carry; the contract-stored entity holds the raw,\n * pre-resolution coordinate, so a lookup would change the migration output.\n */\nfunction policyNodeToContractPolicy(node: PostgresPolicySchemaNode): PostgresRlsPolicy {\n  return new PostgresRlsPolicy({\n    name: node.name,\n    prefix: node.prefix,\n    tableName: node.tableName,\n    namespaceId: node.namespaceId,\n    operation: node.operation,\n    roles: [...node.roles],\n    ...ifDefined('using', node.using),\n    ...ifDefined('withCheck', node.withCheck),\n    permissive: node.permissive,\n  });\n}\n"],"mappings":"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"}

package/dist/postgres-database-schema-node-os8ogEap.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-database-schema-node-os8ogEap.d.mts","names":[],"sources":["../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts","../src/core/schema-ir/postgres-database-schema-node.ts"],"mappings":"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"}

package/dist/postgres-table-schema-node-Clei_xel.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-table-schema-node-Clei_xel.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/schema-ir/postgres-database-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements\n * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`\n * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)\n * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node\n * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).\n */\nexport type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;\n\n/**\n * The `nodeKind` discriminant for each Postgres schema-diff node. Each node\n * carries a unique value; the static `is`/`assert` guards compare against these\n * identifiers rather than spelling the string inline or using `instanceof`. The\n * field is an enumerable own property carried on every node instance.\n */\nexport const PostgresSchemaNodeKind = {\n  database: 'postgres-database',\n  namespace: 'postgres-namespace',\n  table: 'postgres-table',\n  policy: 'postgres-policy',\n  role: 'postgres-role',\n} as const;\n\nexport type PostgresSchemaNodeKind =\n  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNamespaceSchemaNode } from './postgres-namespace-schema-node';\nimport type { PostgresRoleSchemaNode } from './postgres-role-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresDatabaseSchemaNodeInput {\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n}\n\n/**\n * The root of the Postgres schema-diff tree: one node per database.\n *\n * `id` is the fixed sentinel `'database'` — the root has no siblings and\n * the value is never emitted into migration paths. `isEqualTo` is identity\n * (roots always share the `'database'` id). `children()` returns namespace\n * nodes only; roles are held on the root but not yielded (role diffing is a\n * later slice).\n */\nexport class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.database;\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n\n  constructor(input: PostgresDatabaseSchemaNodeInput) {\n    super();\n    this.namespaces = Object.freeze({ ...input.namespaces });\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.pgVersion = input.pgVersion;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return 'database';\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.namespaces);\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.database;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode {\n    if (!PostgresDatabaseSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresDatabaseSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresTableSchemaNode } from './postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNamespaceSchemaNodeInput {\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n}\n\n/**\n * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a\n * single namespace and satisfies the `SqlSchemaIR` shape so legacy per-schema\n * consumers (verifySqlSchema, the relational planner, toSchemaView) can\n * accept it unchanged in Unit 6.\n *\n * `id` is the schema name. `isEqualTo` is identity — two namespace nodes are\n * equal iff their ids (schema names) match. `children()` returns the table\n * nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`\n * field, not an annotations bag.\n */\nexport class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.namespace;\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n\n  constructor(input: PostgresNamespaceSchemaNodeInput) {\n    super();\n    this.schemaName = input.schemaName;\n    this.tables = Object.freeze({ ...input.tables });\n    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.schemaName;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.tables);\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.namespace;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode {\n    if (!PostgresNamespaceSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresNamespaceSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { RlsPolicyOperation } from '../postgres-rls-policy';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresPolicySchemaNodeInput {\n  /** Full wire name: `<prefix>_<8hex>`. */\n  readonly name: string;\n  /** User-supplied prefix (the part before the `_<8hex>` suffix). */\n  readonly prefix: string;\n  /** Name of the table this policy attaches to, by name within the same schema. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. */\n  readonly roles: readonly string[];\n  /** USING predicate SQL string, if present. */\n  readonly using?: string;\n  /** WITH CHECK predicate SQL string, if present. */\n  readonly withCheck?: string;\n  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */\n  readonly permissive: boolean;\n}\n\n/**\n * Schema-diff leaf node for a Postgres row-level security policy.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRlsPolicy` contract entities / introspected rows.\n *\n * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is\n * body-equality. `isEqualTo` compares names only — never byte-compare predicate\n * bodies, because Postgres reprints them.\n */\nexport class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.policy;\n  readonly name: string;\n  readonly prefix: string;\n  readonly tableName: string;\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  readonly roles: readonly string[];\n  declare readonly using?: string;\n  declare readonly withCheck?: string;\n  readonly permissive: boolean;\n\n  constructor(input: PostgresPolicySchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.prefix = input.prefix;\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    this.operation = input.operation;\n    this.roles = Object.freeze([...input.roles]);\n    if (input.using !== undefined) this.using = input.using;\n    if (input.withCheck !== undefined) this.withCheck = input.withCheck;\n    this.permissive = input.permissive;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-policy kinds'\n    >(other);\n    PostgresPolicySchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.policy;\n  }\n\n  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode {\n    if (node === undefined || !PostgresPolicySchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresPolicySchemaNode but got nodeKind=${node?.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresRoleSchemaNodeInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; callers pass\n   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Schema-diff leaf node for a Postgres database role.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRole` contract entities / introspected rows.\n *\n * Roles are cluster-scoped, so `id` is the role name alone. `isEqualTo` compares\n * names — name-equality is role-equality for cluster-scoped objects.\n */\nexport class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.role;\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-role kinds'\n    >(other);\n    PostgresRoleSchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.role;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {\n    if (!PostgresRoleSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresRoleSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  PrimaryKey,\n  type SqlAnnotations,\n  SqlCheckConstraintIR,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIRNode,\n  type SqlTableIRInput,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresPolicySchemaNode } from './postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresTableSchemaNodeInput extends SqlTableIRInput {\n  readonly policies?: readonly PostgresPolicySchemaNode[];\n}\n\n/**\n * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields\n * plus `policies`, and implements `DiffableNode` so the table instance is\n * directly the diff-tree node — no separate wrapper needed.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because\n * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents\n * subclass field initialisation.\n *\n * `id` is the table name. `children()` returns the policy nodes on this table.\n * `isEqualTo` is identity — two table nodes are equal iff their ids (names)\n * match. Columns are not compared here; they become child nodes later.\n */\nexport class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.table;\n  readonly name: string;\n  readonly columns: Readonly<Record<string, SqlColumnIR>>;\n  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;\n  readonly uniques: ReadonlyArray<SqlUniqueIR>;\n  readonly indexes: ReadonlyArray<SqlIndexIR>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly annotations?: SqlAnnotations;\n  declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;\n  readonly policies: readonly PostgresPolicySchemaNode[];\n\n  constructor(input: PostgresTableSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([key, col]) => [\n          key,\n          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),\n        ]),\n      ),\n    );\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),\n    );\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),\n    );\n    this.indexes = Object.freeze(\n      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(\n        input.checks.map((c) =>\n          c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c),\n        ),\n      );\n    }\n    this.policies = Object.freeze([...(input.policies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return this.policies;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.table;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {\n    if (!PostgresTableSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresTableSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}