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

package/dist/{postgres-schema-COGZ1ark.mjs → postgres-schema-DTLA_aRi.mjs}

@@ -1,11 +1,133 @@
-import { _ as PG_TEXT_CODEC_ID } from "./codec-ids-BvytN2P8.mjs";
+import { v as PG_TEXT_CODEC_ID } from "./codec-ids-C_-Hj6bL.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-xdiqmBf_.mjs";
 import { n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
 import { TableSource } from "@prisma-next/sql-relational-core/ast";
+import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
+import { type } from "arktype";
+import { SqlNamespaceBase, SqlNode } from "@prisma-next/sql-contract/types";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { composeSqlEntityKinds } from "@prisma-next/sql-contract/entity-kinds";
 import { cfExpr } from "@prisma-next/sql-relational-core/contract-free";
+//#region src/core/postgres-rls-enablement.ts
+/**
+* Postgres contract-IR marker for `@@rls` on a model: the table named here is
+* RLS-controlled (`ENABLE ROW LEVEL SECURITY` is driven by this marker, never
+* by the policy set).
+*
+* This is an authored, serialized Contract-IR entity — it is registered as an
+* entity kind, extends `SqlNode`, and is stored in `contract.json` under
+* `entries.rls[tableName]`. Target-only concept — no SQL-family abstract.
+* Frozen at construction via `freezeNode(this)`. The `kind: 'rls'`
+* discriminant is enumerable so it survives JSON serialization; the literal
+* matches the entries key (one-string rule).
+*/
+var PostgresRlsEnablement = class extends SqlNode {
+	kind = "rls";
+	tableName;
+	namespaceId;
+	constructor(input) {
+		super();
+		this.tableName = input.tableName;
+		this.namespaceId = input.namespaceId;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/core/postgres-rls-policy.ts
+/**
+* Postgres contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).
+*
+* This is an authored, serialized Contract-IR entity — it is registered as an entity
+* kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+* the schema-diff tree uses `PostgresPolicySchemaNode` for that role.
+*
+* Target-only concept — no SQL-family abstract. Extends `SqlNode` directly.
+* Frozen at construction via `freezeNode(this)`. The `kind: 'policy'`
+* discriminant is enumerable (overrides SqlNode's non-enumerable `'sql'`) so it
+* survives JSON serialization and enables dispatch. The literal matches the
+* entries key (one-string rule: node.kind === entries key === entity kind).
+*/
+var PostgresRlsPolicy = class extends SqlNode {
+	kind = "policy";
+	name;
+	prefix;
+	tableName;
+	namespaceId;
+	operation;
+	roles;
+	permissive;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.prefix = input.prefix;
+		this.tableName = input.tableName;
+		this.namespaceId = input.namespaceId;
+		this.operation = input.operation;
+		this.roles = Object.freeze([...input.roles]);
+		if (input.using !== void 0) this.using = input.using;
+		if (input.withCheck !== void 0) this.withCheck = input.withCheck;
+		this.permissive = input.permissive;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/core/postgres-role.ts
+/**
+* Postgres contract-IR class for a database role (`CREATE ROLE …`).
+*
+* This is an authored, serialized Contract-IR entity — it is registered as an entity
+* kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+* the schema-diff tree uses `PostgresRoleSchemaNode` for that role.
+*
+* Roles are cluster-scoped, so their namespace coordinate is always
+* `UNBOUND_NAMESPACE_ID`. Target-only concept — no SQL-family abstract.
+* Extends `SqlNode` directly, frozen at construction via `freezeNode(this)`.
+* The `kind: 'role'` discriminant is enumerable so it survives JSON.
+* Matches the entries key (one-string rule).
+*/
+var PostgresRole = class extends SqlNode {
+	kind = "role";
+	name;
+	namespaceId;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.namespaceId = input.namespaceId;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/core/postgres-validators.ts
+const PostgresRoleSchema = type({
+	kind: "'role'",
+	name: "string",
+	namespaceId: "string"
+});
+const PostgresRlsPolicySchema = type({
+	kind: "'policy'",
+	name: "string",
+	prefix: "string",
+	tableName: "string",
+	namespaceId: "string",
+	operation: "'select' | 'insert' | 'update' | 'delete' | 'all'",
+	roles: type.string.array().readonly(),
+	"using?": "string",
+	"withCheck?": "string",
+	permissive: "boolean"
+});
+const PostgresRlsEnablementSchema = type({
+	kind: "'rls'",
+	tableName: "string",
+	namespaceId: "string"
+});
+const PostgresNativeEnumSchema = type({
+	kind: "'postgres-enum'",
+	typeName: "string",
+	members: type.string.array().readonly(),
+	"control?": "'managed' | 'tolerated' | 'external' | 'observed'"
+});
+//#endregion
 //#region src/core/ast/table-source.ts
 var PostgresTableSource = class extends TableSource {
 	schema;
@@ -19,6 +141,28 @@ var PostgresTableSource = class extends TableSource {
 	}
 };
 //#endregion
+//#region src/core/entity-kinds.ts
+const policyEntityKind = {
+	kind: "policy",
+	schema: PostgresRlsPolicySchema,
+	construct: (input) => new PostgresRlsPolicy(input)
+};
+const roleEntityKind = {
+	kind: "role",
+	schema: PostgresRoleSchema,
+	construct: (input) => new PostgresRole(input)
+};
+const rlsEnablementEntityKind = {
+	kind: "rls",
+	schema: PostgresRlsEnablementSchema,
+	construct: (input) => new PostgresRlsEnablement(input)
+};
+const nativeEnumEntityKind = {
+	kind: "native_enum",
+	schema: PostgresNativeEnumSchema,
+	construct: (input) => new PostgresNativeEnum(input)
+};
+//#endregion
 //#region src/core/postgres-schema.ts
 /**
 * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -34,7 +178,7 @@ var PostgresTableSource = class extends TableSource {
 * prefix entirely — call sites stay polymorphic and never branch on
 * `id === UNBOUND_NAMESPACE_ID`.
 */
-var PostgresSchema = class extends NamespaceBase {
+var PostgresSchema = class extends SqlNamespaceBase {
 	/**
 	* Stable singleton reference for the late-bound slot. Materialised
 	* lazily below the singleton subclass declaration so the static
@@ -48,13 +192,18 @@ var PostgresSchema = class extends NamespaceBase {
 	constructor(input) {
 		super();
 		this.id = input.id;
-		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), "carry");
+		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds([
+			policyEntityKind,
+			roleEntityKind,
+			rlsEnablementEntityKind,
+			nativeEnumEntityKind
+		]), "carry");
 		const valueSetRaw = dispatched["valueSet"];
-		const withPresence = valueSetRaw !== void 0 && Object.keys(valueSetRaw).length === 0 ? {
+		const entriesInput = { ...valueSetRaw !== void 0 && Object.keys(valueSetRaw).length === 0 ? {
 			...dispatched,
 			valueSet: void 0
-		} : dispatched;
-		this.entries = Object.freeze(blindCast(withPresence));
+		} : dispatched };
+		this.entries = Object.freeze(blindCast(entriesInput));
 		Object.defineProperty(this, "kind", {
 			value: "schema",
 			writable: false,
@@ -69,6 +218,15 @@ var PostgresSchema = class extends NamespaceBase {
 	get valueSet() {
 		return this.entries.valueSet;
 	}
+	get policy() {
+		return this.entries.policy ?? Object.freeze({});
+	}
+	get role() {
+		return this.entries.role ?? Object.freeze({});
+	}
+	get rls() {
+		return this.entries.rls ?? Object.freeze({});
+	}
 	/**
 	* The bare schema qualifier as it would appear in a rendered SQL
 	* fragment (already quoted). The unbound-schema singleton overrides
@@ -216,7 +374,10 @@ function isPostgresSchema(ns) {
 * The factory has no per-call state — every named id deterministically
 * maps to a distinct schema instance — so callers can pass it through
 * by reference and trust the resulting `SqlStorage.namespaces` map to
-* be value-stable for a given input set.
+* be value-stable for a given input set. Native-enum column type names are
+* schema-qualified earlier, at column construction, via the target's
+* `authoring.qualifyColumnType` hook (`postgresQualifyColumnType`), so this
+* factory just materialises the namespace from already-qualified entries.
 */
 function postgresCreateNamespace(input) {
 	const schemaInput = {
@@ -230,6 +391,6 @@ function postgresCreateNamespace(input) {
 	return new PostgresSchema(schemaInput);
 }
 //#endregion
-export { PostgresTableSource as a, postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+export { nativeEnumEntityKind as a, roleEntityKind as c, PostgresRlsEnablementSchema as d, PostgresRlsPolicySchema as f, PostgresRlsEnablement as g, PostgresRlsPolicy as h, postgresCreateNamespace as i, PostgresTableSource as l, PostgresRole as m, PostgresUnboundSchema as n, policyEntityKind as o, PostgresRoleSchema as p, isPostgresSchema as r, rlsEnablementEntityKind as s, PostgresSchema as t, PostgresNativeEnumSchema as u };
 
-//# sourceMappingURL=postgres-schema-COGZ1ark.mjs.map
+//# sourceMappingURL=postgres-schema-DTLA_aRi.mjs.map

package/dist/postgres-schema-DTLA_aRi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-DTLA_aRi.mjs","names":[],"sources":["../src/core/postgres-rls-enablement.ts","../src/core/postgres-rls-policy.ts","../src/core/postgres-role.ts","../src/core/postgres-validators.ts","../src/core/ast/table-source.ts","../src/core/entity-kinds.ts","../src/core/postgres-schema.ts"],"sourcesContent":["import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresRlsEnablementInput {\n  /** Name of the table this marker declares RLS-controlled. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). Markers are schema-scoped like policies. */\n  readonly namespaceId: string;\n}\n\n/**\n * Postgres contract-IR marker for `@@rls` on a model: the table named here is\n * RLS-controlled (`ENABLE ROW LEVEL SECURITY` is driven by this marker, never\n * by the policy set).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an\n * entity kind, extends `SqlNode`, and is stored in `contract.json` under\n * `entries.rls[tableName]`. Target-only concept — no SQL-family abstract.\n * Frozen at construction via `freezeNode(this)`. The `kind: 'rls'`\n * discriminant is enumerable so it survives JSON serialization; the literal\n * matches the entries key (one-string rule).\n */\nexport class PostgresRlsEnablement extends SqlNode {\n  override readonly kind = 'rls' as const;\n  readonly tableName: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRlsEnablementInput) {\n    super();\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';\n\nexport interface PostgresRlsPolicyInput {\n  /** Full wire name: `<prefix>_<8hex>`. Stored as-is; hashing is not this class's job. */\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). Policies are schema-scoped. */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. Plain strings in this slice. */\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 * Postgres contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresPolicySchemaNode` for that role.\n *\n * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly.\n * Frozen at construction via `freezeNode(this)`. The `kind: 'policy'`\n * discriminant is enumerable (overrides SqlNode's non-enumerable `'sql'`) so it\n * survives JSON serialization and enables dispatch. The literal matches the\n * entries key (one-string rule: node.kind === entries key === entity kind).\n */\nexport class PostgresRlsPolicy extends SqlNode {\n  override readonly kind = 'policy' as const;\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: PostgresRlsPolicyInput) {\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","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresRoleInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; pass `UNBOUND_NAMESPACE_ID`\n   * from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Postgres contract-IR class for a database role (`CREATE ROLE …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresRoleSchemaNode` for that role.\n *\n * Roles are cluster-scoped, so their namespace coordinate is always\n * `UNBOUND_NAMESPACE_ID`. Target-only concept — no SQL-family abstract.\n * Extends `SqlNode` directly, frozen at construction via `freezeNode(this)`.\n * The `kind: 'role'` discriminant is enumerable so it survives JSON.\n * Matches the entries key (one-string rule).\n */\nexport class PostgresRole extends SqlNode {\n  override readonly kind = 'role' as const;\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n}\n","import { type } from 'arktype';\n\nexport const PostgresRoleSchema = type({\n  kind: \"'role'\",\n  name: 'string',\n  namespaceId: 'string',\n});\n\nexport const PostgresRlsPolicySchema = type({\n  kind: \"'policy'\",\n  name: 'string',\n  prefix: 'string',\n  tableName: 'string',\n  namespaceId: 'string',\n  operation: \"'select' | 'insert' | 'update' | 'delete' | 'all'\",\n  roles: type.string.array().readonly(),\n  'using?': 'string',\n  'withCheck?': 'string',\n  permissive: 'boolean',\n});\n\nexport const PostgresRlsEnablementSchema = type({\n  kind: \"'rls'\",\n  tableName: 'string',\n  namespaceId: 'string',\n});\n\nexport const PostgresNativeEnumSchema = type({\n  kind: \"'postgres-enum'\",\n  typeName: 'string',\n  members: type.string.array().readonly(),\n  'control?': \"'managed' | 'tolerated' | 'external' | 'observed'\",\n});\n","import {\n  type AnyFromSource,\n  type AstRewriter,\n  TableSource,\n} from '@prisma-next/sql-relational-core/ast';\n\nexport class PostgresTableSource extends TableSource {\n  readonly schema: string | undefined;\n\n  constructor(options: {\n    readonly name: string;\n    readonly schema?: string;\n    readonly alias?: string;\n  }) {\n    super(options.name, options.alias);\n    this.schema = options.schema;\n    this.freeze();\n  }\n\n  override rewrite(rewriter: AstRewriter): AnyFromSource {\n    return rewriter.tableSource ? rewriter.tableSource(this) : this;\n  }\n}\n","import type { EntityKindDescriptor } from '@prisma-next/framework-components/ir';\nimport { PostgresNativeEnum, type PostgresNativeEnumInput } from './postgres-native-enum';\nimport { PostgresRlsEnablement, type PostgresRlsEnablementInput } from './postgres-rls-enablement';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport {\n  PostgresNativeEnumSchema,\n  PostgresRlsEnablementSchema,\n  PostgresRlsPolicySchema,\n  PostgresRoleSchema,\n} from './postgres-validators';\n\nexport const policyEntityKind: EntityKindDescriptor<PostgresRlsPolicyInput, PostgresRlsPolicy> = {\n  kind: 'policy',\n  schema: PostgresRlsPolicySchema,\n  construct: (input) => new PostgresRlsPolicy(input),\n};\n\nexport const roleEntityKind: EntityKindDescriptor<PostgresRoleInput, PostgresRole> = {\n  kind: 'role',\n  schema: PostgresRoleSchema,\n  construct: (input) => new PostgresRole(input),\n};\n\nexport const rlsEnablementEntityKind: EntityKindDescriptor<\n  PostgresRlsEnablementInput,\n  PostgresRlsEnablement\n> = {\n  kind: 'rls',\n  schema: PostgresRlsEnablementSchema,\n  construct: (input) => new PostgresRlsEnablement(input),\n};\n\nexport const nativeEnumEntityKind: EntityKindDescriptor<\n  PostgresNativeEnumInput,\n  PostgresNativeEnum\n> = {\n  kind: 'native_enum',\n  schema: PostgresNativeEnumSchema,\n  construct: (input) => new PostgresNativeEnum(input),\n};\n","import type { Contract } from '@prisma-next/contract/types';\nimport {\n  freezeNode,\n  hydrateNamespaceEntities,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  SqlNamespaceBase,\n  type SqlNamespaceEntries,\n  type SqlNamespaceInput,\n  type SqlStorage,\n  type StorageTable,\n  type StorageValueSet,\n} from '@prisma-next/sql-contract/types';\n\nimport { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresTableSource } from './ast/table-source';\nimport { PG_TEXT_CODEC_ID } from './codec-ids';\nimport {\n  nativeEnumEntityKind,\n  policyEntityKind,\n  rlsEnablementEntityKind,\n  roleEntityKind,\n} from './entity-kinds';\nimport type { PostgresNativeEnum } from './postgres-native-enum';\nimport type { PostgresRlsEnablement } from './postgres-rls-enablement';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\nimport { escapeLiteral } from './sql-utils';\n\nexport type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };\n\nexport type PostgresNamespaceEntries = SqlNamespaceEntries & {\n  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;\n  readonly role?: Readonly<Record<string, PostgresRole>>;\n  readonly rls?: Readonly<Record<string, PostgresRlsEnablement>>;\n  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;\n};\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier\n * emission is the rendering seam: DDL / SQL emission asks the namespace\n * for its qualifier (`\"<schema>\"`) or for a qualified table name\n * (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends SqlNamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  declare readonly kind: 'schema';\n  readonly id: string;\n  readonly entries: PostgresNamespaceEntries;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(\n      input.entries,\n      composeSqlEntityKinds([\n        policyEntityKind,\n        roleEntityKind,\n        rlsEnablementEntityKind,\n        nativeEnumEntityKind,\n      ]),\n      'carry',\n    );\n\n    // Drop an empty valueSet so presence signals non-emptiness.\n    const valueSetRaw = dispatched['valueSet'];\n    const withPresence =\n      valueSetRaw !== undefined && Object.keys(valueSetRaw).length === 0\n        ? { ...dispatched, valueSet: undefined }\n        : dispatched;\n\n    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {\n      ...withPresence,\n    };\n\n    this.entries = Object.freeze(\n      blindCast<\n        PostgresNamespaceEntries,\n        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, rlsEnablementEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, rls→PostgresRlsEnablement, native_enum→PostgresNativeEnum descriptors'\n      >(entriesInput),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: 'schema',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries.valueSet;\n  }\n\n  get policy(): Readonly<Record<string, PostgresRlsPolicy>> {\n    return this.entries.policy ?? Object.freeze({});\n  }\n\n  get role(): Readonly<Record<string, PostgresRole>> {\n    return this.entries.role ?? Object.freeze({});\n  }\n\n  get rls(): Readonly<Record<string, PostgresRlsEnablement>> {\n    return this.entries.rls ?? Object.freeze({});\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a\n   * builder-built catalog check compares `n.nspname` / `table_schema`\n   * against. Named schemas bind the schema name as a text parameter; the\n   * unbound singleton overrides this to the opaque `current_schema()`\n   * expression so the live connection's `search_path` decides at runtime.\n   */\n  schemaFilterExpression(): CfExpr {\n    return cfExpr.param(this.id, PG_TEXT_CODEC_ID);\n  }\n\n  /**\n   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a\n   * builder-built check uses to address a user table in this namespace.\n   * Named schemas qualify (`\"schema\".\"table\"`); the unbound singleton\n   * overrides this to leave the table unqualified so `search_path`\n   * resolves it at runtime.\n   */\n  tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      schema: this.id,\n      ...ifDefined('alias', alias),\n    });\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id. The `PostgresUnboundSchema` singleton inherits\n   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch\n   * through `qualifyTableName` route through the polymorphic\n   * `PostgresUnboundSchema` overrides and produce unqualified\n   * (search-path-resolved) output automatically.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n *\n * `ddlSchemaName` is inherited from `PostgresSchema` and returns\n * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`\n * route through the polymorphic factory and produce unqualified output\n * automatically.\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n\n  override schemaFilterExpression(): CfExpr {\n    return cfExpr.raw('current_schema()', { codecId: PG_TEXT_CODEC_ID, nullable: false });\n  }\n\n  override tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      ...ifDefined('alias', alias),\n    });\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set. Native-enum column type names are\n * schema-qualified earlier, at column construction, via the target's\n * `authoring.qualifyColumnType` hook (`postgresQualifyColumnType`), so this\n * factory just materialises the namespace from already-qualified entries.\n */\nexport function postgresCreateNamespace(input: SqlNamespaceInput): PostgresSchema {\n  const schemaInput: PostgresSchemaInput = {\n    id: input.id,\n    entries: {\n      ...input.entries,\n      table: input.entries['table'] ?? {},\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,wBAAb,cAA2C,QAAQ;CACjD,OAAyB;CACzB;CACA;CAEA,YAAY,OAAmC;EAC7C,MAAM;EACN,KAAK,YAAY,MAAM;EACvB,KAAK,cAAc,MAAM;EACzB,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;;;;;;ACKA,IAAa,oBAAb,cAAuC,QAAQ;CAC7C,OAAyB;CACzB;CACA;CACA;CACA;CACA;CACA;CAGA;CAEA,YAAY,OAA+B;EACzC,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,SAAS,MAAM;EACpB,KAAK,YAAY,MAAM;EACvB,KAAK,cAAc,MAAM;EACzB,KAAK,YAAY,MAAM;EACvB,KAAK,QAAQ,OAAO,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC;EAC3C,IAAI,MAAM,UAAU,KAAA,GAAW,KAAK,QAAQ,MAAM;EAClD,IAAI,MAAM,cAAc,KAAA,GAAW,KAAK,YAAY,MAAM;EAC1D,KAAK,aAAa,MAAM;EACxB,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;;;;;;ACtCA,IAAa,eAAb,cAAkC,QAAQ;CACxC,OAAyB;CACzB;CACA;CAEA,YAAY,OAA0B;EACpC,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,cAAc,MAAM;EACzB,WAAW,IAAI;CACjB;AACF;;;AClCA,MAAa,qBAAqB,KAAK;CACrC,MAAM;CACN,MAAM;CACN,aAAa;AACf,CAAC;AAED,MAAa,0BAA0B,KAAK;CAC1C,MAAM;CACN,MAAM;CACN,QAAQ;CACR,WAAW;CACX,aAAa;CACb,WAAW;CACX,OAAO,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACpC,UAAU;CACV,cAAc;CACd,YAAY;AACd,CAAC;AAED,MAAa,8BAA8B,KAAK;CAC9C,MAAM;CACN,WAAW;CACX,aAAa;AACf,CAAC;AAED,MAAa,2BAA2B,KAAK;CAC3C,MAAM;CACN,UAAU;CACV,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACtC,YAAY;AACd,CAAC;;;AC1BD,IAAa,sBAAb,cAAyC,YAAY;CACnD;CAEA,YAAY,SAIT;EACD,MAAM,QAAQ,MAAM,QAAQ,KAAK;EACjC,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO;CACd;CAEA,QAAiB,UAAsC;EACrD,OAAO,SAAS,cAAc,SAAS,YAAY,IAAI,IAAI;CAC7D;AACF;;;ACVA,MAAa,mBAAoF;CAC/F,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,kBAAkB,KAAK;AACnD;AAEA,MAAa,iBAAwE;CACnF,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,aAAa,KAAK;AAC9C;AAEA,MAAa,0BAGT;CACF,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,sBAAsB,KAAK;AACvD;AAEA,MAAa,uBAGT;CACF,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,mBAAmB,KAAK;AACpD;;;;;;;;;;;;;;;;;ACqBA,IAAa,iBAAb,cAAoC,iBAAiB;;;;;;;;CAQnD,OAAO;CAGP;CACA;CAEA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAEhB,MAAM,aAAa,yBACjB,MAAM,SACN,sBAAsB;GACpB;GACA;GACA;GACA;EACF,CAAC,GACD,OACF;EAGA,MAAM,cAAc,WAAW;EAM/B,MAAM,eAA8E,EAClF,GALA,gBAAgB,KAAA,KAAa,OAAO,KAAK,WAAW,CAAC,CAAC,WAAW,IAC7D;GAAE,GAAG;GAAY,UAAU,KAAA;EAAU,IACrC,WAIN;EAEA,KAAK,UAAU,OAAO,OACpB,UAGE,YAAY,CAChB;EACA,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;CAEA,IAAI,QAAgD;EAClD,OAAO,KAAK,QAAQ,SAAS,OAAO,OAAO,CAAC,CAAC;CAC/C;CAEA,IAAI,WAAkE;EACpE,OAAO,KAAK,QAAQ;CACtB;CAEA,IAAI,SAAsD;EACxD,OAAO,KAAK,QAAQ,UAAU,OAAO,OAAO,CAAC,CAAC;CAChD;CAEA,IAAI,OAA+C;EACjD,OAAO,KAAK,QAAQ,QAAQ,OAAO,OAAO,CAAC,CAAC;CAC9C;CAEA,IAAI,MAAuD;EACzD,OAAO,KAAK,QAAQ,OAAO,OAAO,OAAO,CAAC,CAAC;CAC7C;;;;;;CAOA,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;CACrB;;;;;;;CAQA,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;CACpC;;;;;;;CAQA,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,IAAI,CAAC,EAAE;CACpD;;;;;;;;;CAUA,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,EAAE,EAAE;CACpC;;;;;;;;CASA,yBAAiC;EAC/B,OAAO,OAAO,MAAM,KAAK,IAAI,gBAAgB;CAC/C;;;;;;;;CASA,YAAY,WAAmB,OAAqC;EAClE,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,QAAQ,KAAK;GACb,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;;;;;;;;;;;;CAaA,cAAc,UAA8B;EAC1C,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,YAAY,OAA6B;EACvC,MAAM,SAAS;GAAE,IAAI;GAAsB,SAAS,EAAE,OAAO,CAAC,EAAE;EAAE,CAAC;CACrE;CAEA,YAA6B;EAC3B,OAAO;CACT;CAEA,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;CACvB;CAEA,sBAAuC;EACrC,OAAO;CACT;CAEA,yBAA0C;EACxC,OAAO,OAAO,IAAI,oBAAoB;GAAE,SAAS;GAAkB,UAAU;EAAM,CAAC;CACtF;CAEA,YAAqB,WAAmB,OAAqC;EAC3E,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;AACF;AAEA,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;AACjE;;;;;;;;;;;;;;;AAgBA,SAAgB,wBAAwB,OAA0C;CAChF,MAAM,cAAmC;EACvC,IAAI,MAAM;EACV,SAAS;GACP,GAAG,MAAM;GACT,OAAO,MAAM,QAAQ,YAAY,CAAC;EACpC;CACF;CACA,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,WAAW;CAE9C,OAAO,IAAI,eAAe,WAAW;AACvC"}

package/dist/postgres-table-schema-node-9FCtCUz2.mjs

@@ -0,0 +1,153 @@
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR, assertNode, relationalNodeEntityKind, relationalNodeGranularity } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/schema-ir/schema-node-kinds.ts
+/**
+* The `nodeKind` discriminant for each Postgres schema-diff node. Each node
+* carries a unique value; the static `is`/`assert` guards compare against these
+* identifiers rather than spelling the string inline or using `instanceof`. The
+* field is an enumerable own property carried on every node instance.
+*/
+const PostgresSchemaNodeKind = {
+	database: "postgres-database",
+	namespace: "postgres-namespace",
+	table: "postgres-table",
+	policy: "postgres-policy",
+	role: "postgres-role"
+};
+/**
+* The one real map from a Postgres-specific `nodeKind` to the
+* framework-neutral {@link DiffSubjectGranularity} its diff issues carry —
+* resolution is by `nodeKind` equality against this map, never a
+* `nodeKind`-suffix string match and never anything stamped on the node.
+*/
+const POSTGRES_NODE_GRANULARITY = {
+	[PostgresSchemaNodeKind.database]: "structural",
+	[PostgresSchemaNodeKind.namespace]: "namespace",
+	[PostgresSchemaNodeKind.table]: "entity",
+	[PostgresSchemaNodeKind.policy]: "structural",
+	[PostgresSchemaNodeKind.role]: "structural"
+};
+function isPostgresSchemaNodeKind(nodeKind) {
+	return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);
+}
+/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */
+function postgresNodeGranularity(nodeKind) {
+	return POSTGRES_NODE_GRANULARITY[nodeKind];
+}
+/**
+* The subject granularity for any node kind that appears in a Postgres diff
+* tree — the tree mixes Postgres-specific kinds (database/namespace/table/
+* policy/role) with the relational leaf kinds (columns, constraints, indexes,
+* …), so this dispatches to whichever family/target map owns the kind. Called
+* on demand by consumers (the family verdict, the framework aggregate's
+* unclaimed-elements sweep, via the {@link
+* import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+* capability) — never stamped onto the issue or the node.
+*/
+function postgresDiffSubjectGranularity(nodeKind) {
+	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeGranularity(nodeKind) : relationalNodeGranularity(nodeKind);
+}
+/**
+* The one real map from a Postgres-specific `nodeKind` to its storage
+* `entityKind` — the same vocabulary the contract storage's `entries`
+* dictionary keys use. Only the whole-table kind has an entity of its own;
+* database/namespace/policy/role nodes map to nothing here (a namespace is
+* addressed by id, not by an `entries` kind; policies and roles are
+* structural, never a sibling space's unclaimed entity).
+*/
+const POSTGRES_NODE_ENTITY_KIND = { [PostgresSchemaNodeKind.table]: "table" };
+/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */
+function postgresNodeEntityKind(nodeKind) {
+	return POSTGRES_NODE_ENTITY_KIND[nodeKind];
+}
+/**
+* The storage `entityKind` for any node kind that appears in a Postgres diff
+* tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the
+* same way to whichever family/target map owns the kind. Called on demand by
+* the framework aggregate's unclaimed-elements sweep via the {@link
+* import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+* capability — never stamped onto the issue or the node.
+*/
+function postgresDiffSubjectEntityKind(nodeKind) {
+	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeEntityKind(nodeKind) : relationalNodeEntityKind(nodeKind);
+}
+//#endregion
+//#region src/core/schema-ir/postgres-table-schema-node.ts
+/**
+* Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields
+* plus `policies`, and implements `DiffableNode` so the table instance is
+* directly the diff-tree node — no separate wrapper needed.
+*
+* Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because
+* `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
+* subclass field initialisation.
+*
+* `id` is the table name. `isEqualTo` compares id + `rlsEnabled` — the
+* table's one own diffable attribute; all other structural drift is
+* expressed by its children. `children()` returns every column, the primary
+* key (when present), every foreign key, unique, index, and check constraint,
+* plus the policy nodes — one flat list, so a drifted column and a drifted
+* policy are both reported by the same walk. Order is deterministic (object
+* key order for columns, array order for the rest) so two structurally equal
+* tables always produce the same child list.
+*/
+var PostgresTableSchemaNode = class PostgresTableSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.table;
+	name;
+	columns;
+	foreignKeys;
+	uniques;
+	indexes;
+	policies;
+	rlsEnabled;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.rlsEnabled = input.rlsEnabled;
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));
+		this.policies = Object.freeze([...input.policies ?? []]);
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	/**
+	* Equal iff the ids (names) match AND `rlsEnabled` matches — the table's
+	* one own attribute in the diff; all other structural drift is expressed
+	* by children. A paired `not-equal` therefore always means enablement
+	* drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.
+	*/
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresTableSchemaNode.assert(node);
+		return this.id === node.id && this.rlsEnabled === node.rlsEnabled;
+	}
+	children() {
+		return [
+			...Object.values(this.columns),
+			...this.primaryKey ? [this.primaryKey] : [],
+			...this.foreignKeys,
+			...this.uniques,
+			...this.indexes,
+			...this.checks ?? [],
+			...this.policies
+		];
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.table;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresTableSchemaNode", PostgresTableSchemaNode.is);
+	}
+};
+//#endregion
+export { postgresDiffSubjectGranularity as i, PostgresSchemaNodeKind as n, postgresDiffSubjectEntityKind as r, PostgresTableSchemaNode as t };
+
+//# sourceMappingURL=postgres-table-schema-node-9FCtCUz2.mjs.map

package/dist/postgres-table-schema-node-9FCtCUz2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-table-schema-node-9FCtCUz2.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/schema-ir/postgres-table-schema-node.ts"],"sourcesContent":["import type {\n  DiffableNode,\n  DiffSubjectGranularity,\n} from '@prisma-next/framework-components/control';\nimport {\n  relationalNodeEntityKind,\n  relationalNodeGranularity,\n  type SqlSchemaIRNode,\n} 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\n/**\n * The one real map from a Postgres-specific `nodeKind` to the\n * framework-neutral {@link DiffSubjectGranularity} its diff issues carry —\n * resolution is by `nodeKind` equality against this map, never a\n * `nodeKind`-suffix string match and never anything stamped on the node.\n */\nconst POSTGRES_NODE_GRANULARITY: Readonly<Record<PostgresSchemaNodeKind, DiffSubjectGranularity>> =\n  {\n    [PostgresSchemaNodeKind.database]: 'structural',\n    [PostgresSchemaNodeKind.namespace]: 'namespace',\n    [PostgresSchemaNodeKind.table]: 'entity',\n    [PostgresSchemaNodeKind.policy]: 'structural',\n    [PostgresSchemaNodeKind.role]: 'structural',\n  };\n\nfunction isPostgresSchemaNodeKind(nodeKind: string): nodeKind is PostgresSchemaNodeKind {\n  return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);\n}\n\n/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */\nexport function postgresNodeGranularity(nodeKind: PostgresSchemaNodeKind): DiffSubjectGranularity {\n  return POSTGRES_NODE_GRANULARITY[nodeKind];\n}\n\n/**\n * The subject granularity for any node kind that appears in a Postgres diff\n * tree — the tree mixes Postgres-specific kinds (database/namespace/table/\n * policy/role) with the relational leaf kinds (columns, constraints, indexes,\n * …), so this dispatches to whichever family/target map owns the kind. Called\n * on demand by consumers (the family verdict, the framework aggregate's\n * unclaimed-elements sweep, via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability) — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectGranularity(nodeKind: string): DiffSubjectGranularity {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeGranularity(nodeKind)\n    : relationalNodeGranularity(nodeKind);\n}\n\n/**\n * The one real map from a Postgres-specific `nodeKind` to its storage\n * `entityKind` — the same vocabulary the contract storage's `entries`\n * dictionary keys use. Only the whole-table kind has an entity of its own;\n * database/namespace/policy/role nodes map to nothing here (a namespace is\n * addressed by id, not by an `entries` kind; policies and roles are\n * structural, never a sibling space's unclaimed entity).\n */\nconst POSTGRES_NODE_ENTITY_KIND: Partial<Readonly<Record<PostgresSchemaNodeKind, string>>> = {\n  [PostgresSchemaNodeKind.table]: 'table',\n};\n\n/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */\nexport function postgresNodeEntityKind(nodeKind: PostgresSchemaNodeKind): string | undefined {\n  return POSTGRES_NODE_ENTITY_KIND[nodeKind];\n}\n\n/**\n * The storage `entityKind` for any node kind that appears in a Postgres diff\n * tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the\n * same way to whichever family/target map owns the kind. Called on demand by\n * the framework aggregate's unclaimed-elements sweep via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectEntityKind(nodeKind: string): string | undefined {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeEntityKind(nodeKind)\n    : relationalNodeEntityKind(nodeKind);\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  assertNode,\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 { blindCast } from '@prisma-next/utils/casts';\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   * Whether row-level security is enabled on this table. Expected side:\n   * stamped from the contract's `entries.rls` marker (never from the\n   * policy set). Actual side: stamped from `pg_class.relrowsecurity` at\n   * introspection. Required with no default so every construction site\n   * supplies a deliberate value.\n   */\n  readonly rlsEnabled: boolean;\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. `isEqualTo` compares id + `rlsEnabled` — the\n * table's one own diffable attribute; all other structural drift is\n * expressed by its children. `children()` returns every column, the primary\n * key (when present), every foreign key, unique, index, and check constraint,\n * plus the policy nodes — one flat list, so a drifted column and a drifted\n * policy are both reported by the same walk. Order is deterministic (object\n * key order for columns, array order for the rest) so two structurally equal\n * tables always produce the same child list.\n */\nexport class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.table;\n\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  readonly rlsEnabled: boolean;\n\n  constructor(input: PostgresTableSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.rlsEnabled = input.rlsEnabled;\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  /**\n   * Equal iff the ids (names) match AND `rlsEnabled` matches — the table's\n   * one own attribute in the diff; all other structural drift is expressed\n   * by children. A paired `not-equal` therefore always means enablement\n   * drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.\n   */\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode'\n    >(other);\n    PostgresTableSchemaNode.assert(node);\n    return this.id === node.id && this.rlsEnabled === node.rlsEnabled;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [\n      ...Object.values(this.columns),\n      ...(this.primaryKey ? [this.primaryKey] : []),\n      ...this.foreignKeys,\n      ...this.uniques,\n      ...this.indexes,\n      ...(this.checks ?? []),\n      ...this.policies,\n    ];\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    assertNode(node, 'PostgresTableSchemaNode', PostgresTableSchemaNode.is);\n  }\n}\n"],"mappings":"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"}

package/dist/render-ops.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
 import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";

package/dist/{render-typescript-KMgosran.mjs → render-typescript-7yqILcwr.mjs}

@@ -27,14 +27,18 @@ const BASE_IMPORTS = [{
 	symbol: "MigrationCLI"
 }];
 function renderCallsToTypeScript(calls, meta) {
-	const imports = buildImports(calls);
+	const imports = buildImports(calls, meta);
 	const operationsBody = calls.map((c) => renderCall(c)).join(",\n");
+	const hasStart = meta.from !== null;
+	const startField = hasStart ? ["  override readonly startContractJson = startContract;"] : [];
 	return [
 		shebangLineFor(detectScaffoldRuntime()),
 		imports,
 		"",
-		"export default class M extends Migration {",
-		buildDescribeMethod(meta),
+		`export default class M extends Migration<${hasStart ? "Start" : "never"}, End> {`,
+		...startField,
+		"  override readonly endContractJson = endContract;",
+		"",
 		"  override get operations() {",
 		"    return [",
 		indent(operationsBody, 6),
@@ -49,21 +53,46 @@ function renderCallsToTypeScript(calls, meta) {
 function renderCall(call) {
 	return call.renderTypeScript();
 }
-function buildImports(calls) {
-	const requirements = [...BASE_IMPORTS];
+function buildImports(calls, meta) {
+	const requirements = [...BASE_IMPORTS, ...contractImports(meta)];
 	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
 	return renderImports(requirements);
 }
-function buildDescribeMethod(meta) {
-	const lines = [];
-	lines.push("  override describe() {");
-	lines.push("    return {");
-	lines.push(`      from: ${JSON.stringify(meta.from)},`);
-	lines.push(`      to: ${JSON.stringify(meta.to)},`);
-	lines.push("    };");
-	lines.push("  }");
-	lines.push("");
-	return lines.join("\n");
+/**
+* The committed contract-JSON imports the scaffold reads its from/to identity
+* from. `end-contract.json` is always present; `start-contract.json` is added
+* only for a non-baseline migration (`meta.from !== null`). The matching
+* `Contract` type imports (aliased `Start`/`End`) feed the
+* `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with
+* no start imports — `never` is the honest "no prior contract" Start.
+*/
+function contractImports(meta) {
+	const reqs = [{
+		moduleSpecifier: "./end-contract.json",
+		symbol: "endContract",
+		kind: "default",
+		attributes: { type: "json" }
+	}, {
+		moduleSpecifier: "./end-contract",
+		symbol: "Contract",
+		alias: "End",
+		typeOnly: true
+	}];
+	if (meta.from !== null) {
+		reqs.push({
+			moduleSpecifier: "./start-contract.json",
+			symbol: "startContract",
+			kind: "default",
+			attributes: { type: "json" }
+		});
+		reqs.push({
+			moduleSpecifier: "./start-contract",
+			symbol: "Contract",
+			alias: "Start",
+			typeOnly: true
+		});
+	}
+	return reqs;
 }
 function indent(text, spaces) {
 	const pad = " ".repeat(spaces);
@@ -72,4 +101,4 @@ function indent(text, spaces) {
 //#endregion
 export { renderCallsToTypeScript as t };
 
-//# sourceMappingURL=render-typescript-KMgosran.mjs.map
+//# sourceMappingURL=render-typescript-7yqILcwr.mjs.map

package/dist/render-typescript-7yqILcwr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-7yqILcwr.mjs","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `OpFactoryCall` renders itself via `renderTypeScript()` and\n * declares its own `importRequirements()`; this file just composes the module\n * source around those contributions. The design mirrors the Mongo target's\n * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n * (different factory module specifiers, different base-class name) but the\n * shape is, so future consolidation to a framework-level helper is mechanical.\n */\n\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, renderImports } from '@prisma-next/ts-render';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/postgres/migration` so an authored Postgres\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint:\n *\n * - `Migration` — the facade re-export fixes the `SqlMigration`\n *   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n *   to `'postgres'`, so user-authored migrations don't need to thread\n *   target-details or redeclare `targetId`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n *   The migration file owns this dependency directly: pulling CLI\n *   machinery in at script run time is acceptable because the script's\n *   whole purpose is to be invoked from the project that owns the\n *   config.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<OpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls, meta);\n  const operationsBody = calls.map((c) => renderCall(c)).join(',\\n');\n  const hasStart = meta.from !== null;\n  const startField = hasStart ? ['  override readonly startContractJson = startContract;'] : [];\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    `export default class M extends Migration<${hasStart ? 'Start' : 'never'}, End> {`,\n    ...startField,\n    '  override readonly endContractJson = endContract;',\n    '',\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction renderCall(call: OpFactoryCall): string {\n  return call.renderTypeScript();\n}\n\nfunction buildImports(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigrationMeta): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS, ...contractImports(meta)];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\n/**\n * The committed contract-JSON imports the scaffold reads its from/to identity\n * from. `end-contract.json` is always present; `start-contract.json` is added\n * only for a non-baseline migration (`meta.from !== null`). The matching\n * `Contract` type imports (aliased `Start`/`End`) feed the\n * `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with\n * no start imports — `never` is the honest \"no prior contract\" Start.\n */\nfunction contractImports(meta: RenderMigrationMeta): readonly ImportRequirement[] {\n  const reqs: ImportRequirement[] = [\n    {\n      moduleSpecifier: './end-contract.json',\n      symbol: 'endContract',\n      kind: 'default',\n      attributes: { type: 'json' },\n    },\n    { moduleSpecifier: './end-contract', symbol: 'Contract', alias: 'End', typeOnly: true },\n  ];\n  if (meta.from !== null) {\n    reqs.push({\n      moduleSpecifier: './start-contract.json',\n      symbol: 'startContract',\n      kind: 'default',\n      attributes: { type: 'json' },\n    });\n    reqs.push({\n      moduleSpecifier: './start-contract',\n      symbol: 'Contract',\n      alias: 'Start',\n      typeOnly: true,\n    });\n  }\n  return reqs;\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,eAA6C,CACjD;CAAE,iBAAiB;CAAmC,QAAQ;AAAY,GAC1E;CAAE,iBAAiB;CAAmC,QAAQ;AAAe,CAC/E;AAEA,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,OAAO,IAAI;CACxC,MAAM,iBAAiB,MAAM,KAAK,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;CACjE,MAAM,WAAW,KAAK,SAAS;CAC/B,MAAM,aAAa,WAAW,CAAC,wDAAwD,IAAI,CAAC;CAE5F,OAAO;EACL,eAAe,sBAAsB,CAAC;EACtC;EACA;EACA,4CAA4C,WAAW,UAAU,QAAQ;EACzE,GAAG;EACH;EACA;EACA;EACA;EACA,OAAO,gBAAgB,CAAC;EACxB;EACA;EACA;EACA;EACA;EACA;CACF,CAAC,CAAC,KAAK,IAAI;AACb;AAEA,SAAS,WAAW,MAA6B;CAC/C,OAAO,KAAK,iBAAiB;AAC/B;AAEA,SAAS,aAAa,OAAqC,MAAmC;CAC5F,MAAM,eAAoC,CAAC,GAAG,cAAc,GAAG,gBAAgB,IAAI,CAAC;CACpF,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,OAAO,KAAK,mBAAmB,GACxC,aAAa,KAAK,GAAG;CAGzB,OAAO,cAAc,YAAY;AACnC;;;;;;;;;AAUA,SAAS,gBAAgB,MAAyD;CAChF,MAAM,OAA4B,CAChC;EACE,iBAAiB;EACjB,QAAQ;EACR,MAAM;EACN,YAAY,EAAE,MAAM,OAAO;CAC7B,GACA;EAAE,iBAAiB;EAAkB,QAAQ;EAAY,OAAO;EAAO,UAAU;CAAK,CACxF;CACA,IAAI,KAAK,SAAS,MAAM;EACtB,KAAK,KAAK;GACR,iBAAiB;GACjB,QAAQ;GACR,MAAM;GACN,YAAY,EAAE,MAAM,OAAO;EAC7B,CAAC;EACD,KAAK,KAAK;GACR,iBAAiB;GACjB,QAAQ;GACR,OAAO;GACP,UAAU;EACZ,CAAC;CACH;CACA,OAAO;AACT;AAEA,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,MAAM;CAC7B,OAAO,KACJ,MAAM,IAAI,CAAC,CACX,KAAK,SAAU,KAAK,KAAK,IAAI,GAAG,MAAM,SAAS,IAAK,CAAC,CACrD,KAAK,IAAI;AACd"}

package/dist/render-typescript.mjs

@@ -1,2 +1,2 @@
-import { t as renderCallsToTypeScript } from "./render-typescript-KMgosran.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-7yqILcwr.mjs";
 export { renderCallsToTypeScript };

package/dist/resolve-ddl-schema-Ca88Tg6W.mjs

@@ -0,0 +1,22 @@
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-DTLA_aRi.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+//#region src/core/migrations/resolve-ddl-schema.ts
+/**
+* Given the contract's storage and a namespace id, returns the live Postgres
+* DDL schema name that namespace maps to. A named Postgres namespace dispatches
+* to its `ddlSchemaName(storage)`; the unbound sentinel resolves to
+* `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a
+* bare object payload (used by some tests) falls back to the namespace id
+* itself.
+*/
+function resolveDdlSchemaForNamespaceStorage(storage, namespaceId) {
+	if (namespaceId === UNBOUND_NAMESPACE_ID) return DEFAULT_NAMESPACE_ID;
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+
+//# sourceMappingURL=resolve-ddl-schema-Ca88Tg6W.mjs.map

package/dist/resolve-ddl-schema-Ca88Tg6W.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-ddl-schema-Ca88Tg6W.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/rls-canonicalize.d.mts

@@ -0,0 +1,20 @@
+import { i as normalizePredicate, n as RlsPolicyOperation, r as computeContentHash, t as ContentHashParts } from "./canonicalize-CAbXtVtB.mjs";
+
+//#region src/core/rls/wire-name.d.ts
+interface RlsPolicyWireName {
+  /** The user-supplied part before the `_<8hex>` suffix. */
+  readonly prefix: string;
+  /** The 8-lowercase-hex content-hash suffix. */
+  readonly hash: string;
+}
+/**
+ * Splits an RLS policy wire name (`<prefix>_<8hex>`) into its prefix and
+ * content-hash suffix. Returns `undefined` when the name does not follow the
+ * wire-name shape (e.g. a policy created outside the toolchain) — callers
+ * treat such names as all-prefix. Consumed by introspection (prefix
+ * extraction) and by rename pairing (same hash, different prefix).
+ */
+declare function parseRlsPolicyWireName(name: string): RlsPolicyWireName | undefined;
+//#endregion
+export { type ContentHashParts, type RlsPolicyOperation, type RlsPolicyWireName, computeContentHash, normalizePredicate, parseRlsPolicyWireName };
+//# sourceMappingURL=rls-canonicalize.d.mts.map

package/dist/rls-canonicalize.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rls-canonicalize.d.mts","names":[],"sources":["../src/core/rls/wire-name.ts"],"mappings":";;;UAAiB,iBAAA;;WAEN,MAAA;EAFM;EAAA,SAIN,IAAI;AAAA;;;;;;;;iBAsBC,sBAAA,CAAuB,IAAA,WAAe,iBAAiB"}