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

package/dist/postgres-role-schema-node-BiSTCTNg.mjs

@@ -0,0 +1,195 @@
+import { n as PostgresSchemaNodeKind } from "./postgres-table-schema-node-9FCtCUz2.mjs";
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { SqlSchemaIRNode, assertNode } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/schema-ir/postgres-database-schema-node.ts
+/**
+* The root of the Postgres schema-diff tree: one node per database.
+*
+* `id` is the fixed sentinel `'database'` — the root has no siblings and
+* the value is never emitted into migration paths. `isEqualTo` is identity
+* (roots always share the `'database'` id). `children()` returns namespace
+* nodes only; roles are held on the root but not yielded (role diffing is a
+* later slice).
+*/
+var PostgresDatabaseSchemaNode = class PostgresDatabaseSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.database;
+	namespaces;
+	roles;
+	existingSchemas;
+	pgVersion;
+	constructor(input) {
+		super();
+		this.namespaces = Object.freeze({ ...input.namespaces });
+		this.roles = Object.freeze([...input.roles]);
+		this.existingSchemas = Object.freeze([...input.existingSchemas]);
+		this.pgVersion = input.pgVersion;
+		freezeNode(this);
+	}
+	get id() {
+		return "database";
+	}
+	isEqualTo(other) {
+		return this.id === other.id;
+	}
+	children() {
+		return Object.values(this.namespaces);
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.database;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresDatabaseSchemaNode", PostgresDatabaseSchemaNode.is);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-namespace-schema-node.ts
+/**
+* One-per-Postgres-schema diff-tree node. Groups the tables belonging to a
+* single namespace. Per-schema consumers (the relational planner,
+* toSchemaView) read this node's `tables` field structurally via
+* `blindCast`/`SqlSchemaIRNode` — not through a static `SqlSchemaIR`
+* assignment — because `nodeKind` now carries this node's own literal
+* (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).
+*
+* `id` is the schema name. `isEqualTo` is identity — two namespace nodes are
+* equal iff their ids (schema names) match. `children()` returns the table
+* nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`
+* field, not an annotations bag.
+*
+* `nativeEnums` carries the same enum types with their ordered member
+* values (`{ typeName, values }`), for consumers that need the values
+* (PSL inference, the printer). `nativeEnumTypeNames` stays a plain name
+* list read independently by existing consumers (codec `planTypeOperations`
+* hooks, the infer throw) so none of them need the values to keep working.
+*/
+var PostgresNamespaceSchemaNode = class PostgresNamespaceSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.namespace;
+	schemaName;
+	tables;
+	nativeEnumTypeNames;
+	nativeEnums;
+	constructor(input) {
+		super();
+		this.schemaName = input.schemaName;
+		this.tables = Object.freeze({ ...input.tables });
+		this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+		this.nativeEnums = Object.freeze((input.nativeEnums ?? []).map((entry) => Object.freeze({
+			typeName: entry.typeName,
+			values: Object.freeze([...entry.values])
+		})));
+		freezeNode(this);
+	}
+	get id() {
+		return this.schemaName;
+	}
+	isEqualTo(other) {
+		return this.id === other.id;
+	}
+	children() {
+		return Object.values(this.tables);
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.namespace;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresNamespaceSchemaNode", PostgresNamespaceSchemaNode.is);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-policy-schema-node.ts
+/**
+* Schema-diff leaf node for a Postgres row-level security policy.
+*
+* This is a derived, transient node walked by the differ — it is NEVER serialized.
+* Built by project-from-contract and project-from-database from their respective
+* `PostgresRlsPolicy` contract entities / introspected rows.
+*
+* `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is
+* body-equality. `isEqualTo` compares names only — never byte-compare predicate
+* bodies, because Postgres reprints them.
+*/
+var PostgresPolicySchemaNode = class PostgresPolicySchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.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);
+	}
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresPolicySchemaNode.assert(node);
+		return this.id === node.id;
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.policy;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresPolicySchemaNode", PostgresPolicySchemaNode.is);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-role-schema-node.ts
+/**
+* Schema-diff leaf node for a Postgres database role.
+*
+* This is a derived, transient node walked by the differ — it is NEVER serialized.
+* Built by project-from-contract and project-from-database from their respective
+* `PostgresRole` contract entities / introspected rows.
+*
+* Roles are cluster-scoped, so `id` is the role name alone. `isEqualTo` compares
+* names — name-equality is role-equality for cluster-scoped objects.
+*/
+var PostgresRoleSchemaNode = class PostgresRoleSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.role;
+	name;
+	namespaceId;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.namespaceId = input.namespaceId;
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresRoleSchemaNode.assert(node);
+		return this.id === node.id;
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.role;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresRoleSchemaNode", PostgresRoleSchemaNode.is);
+	}
+};
+//#endregion
+export { PostgresDatabaseSchemaNode as i, PostgresPolicySchemaNode as n, PostgresNamespaceSchemaNode as r, PostgresRoleSchemaNode as t };
+
+//# sourceMappingURL=postgres-role-schema-node-BiSTCTNg.mjs.map

package/dist/postgres-role-schema-node-BiSTCTNg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-role-schema-node-BiSTCTNg.mjs","names":[],"sources":["../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"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, 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\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    assertNode(node, 'PostgresDatabaseSchemaNode', PostgresDatabaseSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresTableSchemaNode } from './postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\n/** One introspected native Postgres enum type, in `pg_enum.enumsortorder` (declaration) order. */\nexport interface PostgresNativeEnumIntrospection {\n  readonly typeName: string;\n  readonly values: readonly string[];\n}\n\nexport interface PostgresNamespaceSchemaNodeInput {\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n  readonly nativeEnums?: readonly PostgresNativeEnumIntrospection[];\n}\n\n/**\n * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a\n * single namespace. Per-schema consumers (the relational planner,\n * toSchemaView) read this node's `tables` field structurally via\n * `blindCast`/`SqlSchemaIRNode` — not through a static `SqlSchemaIR`\n * assignment — because `nodeKind` now carries this node's own literal\n * (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).\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 *\n * `nativeEnums` carries the same enum types with their ordered member\n * values (`{ typeName, values }`), for consumers that need the values\n * (PSL inference, the printer). `nativeEnumTypeNames` stays a plain name\n * list read independently by existing consumers (codec `planTypeOperations`\n * hooks, the infer throw) so none of them need the values to keep working.\n */\nexport class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.namespace;\n\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n  readonly nativeEnums: readonly PostgresNativeEnumIntrospection[];\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    this.nativeEnums = Object.freeze(\n      (input.nativeEnums ?? []).map((entry) =>\n        Object.freeze({ typeName: entry.typeName, values: Object.freeze([...entry.values]) }),\n      ),\n    );\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    assertNode(node, 'PostgresNamespaceSchemaNode', PostgresNamespaceSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, 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\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    assertNode(node, 'PostgresPolicySchemaNode', PostgresPolicySchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, 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\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    assertNode(node, 'PostgresRoleSchemaNode', PostgresRoleSchemaNode.is);\n  }\n}\n"],"mappings":"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"}

package/dist/postgres-schema-CU4gF6QZ.d.mts

@@ -0,0 +1,257 @@
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
+import { SqlNamespaceBase, SqlNamespaceEntries, SqlNamespaceInput, SqlNode, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
+import { Contract, ControlPolicy } from "@prisma-next/contract/types";
+
+//#region src/core/postgres-role.d.ts
+interface PostgresRoleInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; pass `UNBOUND_NAMESPACE_ID`
+   * from `@prisma-next/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+}
+/**
+ * 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).
+ */
+declare class PostgresRole extends SqlNode {
+  readonly kind: "role";
+  readonly name: string;
+  readonly namespaceId: string;
+  constructor(input: PostgresRoleInput);
+}
+//#endregion
+//#region src/core/postgres-rls-enablement.d.ts
+interface PostgresRlsEnablementInput {
+  /** Name of the table this marker declares RLS-controlled. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). Markers are schema-scoped like policies. */
+  readonly namespaceId: string;
+}
+/**
+ * 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).
+ */
+declare class PostgresRlsEnablement extends SqlNode {
+  readonly kind: "rls";
+  readonly tableName: string;
+  readonly namespaceId: string;
+  constructor(input: PostgresRlsEnablementInput);
+}
+//#endregion
+//#region src/core/postgres-native-enum.d.ts
+interface PostgresNativeEnumInput {
+  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */
+  readonly typeName: string;
+  /** Member values in declaration order — this is the Postgres enum sort order. */
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+}
+/**
+ * Postgres contract-IR class for a native enum type (`CREATE TYPE … AS ENUM (…)`).
+ *
+ * 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 will use `PostgresNativeEnumSchemaNode` when the managed phase
+ * builds it.
+ *
+ * A member is a value, not a name→value pair — matching `CREATE TYPE … AS ENUM
+ * ('a', 'b')`, which has no separate member name.
+ *
+ * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly,
+ * frozen at construction via `freezeNode(this)`. The `kind: 'postgres-enum'`
+ * discriminant is enumerable so it survives JSON. Lives at
+ * `storage.namespaces[ns].entries.native_enum[HandleName]`; the entries key
+ * (`native_enum`) is the entity-kind descriptor's `kind`, decoupled from this
+ * node's own `kind` literal — the same shape as `table`/`StorageTable` and
+ * `valueSet`/`StorageValueSet`.
+ */
+declare class PostgresNativeEnum extends SqlNode {
+  static is(node: unknown): node is PostgresNativeEnum;
+  readonly kind: "postgres-enum";
+  readonly typeName: string;
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+  constructor(input: PostgresNativeEnumInput);
+}
+//#endregion
+//#region src/core/postgres-schema.d.ts
+type PostgresContract = Contract<SqlStorage> & {
+  readonly target: 'postgres';
+};
+type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+  readonly rls?: Readonly<Record<string, PostgresRlsEnablement>>;
+  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;
+};
+interface PostgresSchemaInput {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/**
+ * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
+ * SCHEMA …`). Each Postgres `SqlStorage` carries a
+ * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
+ * the Postgres PSL interpreter from `namespace { … }` AST buckets.
+ *
+ * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
+ * emission is the rendering seam: DDL / SQL emission asks the namespace
+ * for its qualifier (`"<schema>"`) or for a qualified table name
+ * (`"<schema>"."<table>"`) and consumes the result polymorphically.
+ * The unbound singleton below overrides these methods to elide the
+ * prefix entirely — call sites stay polymorphic and never branch on
+ * `id === UNBOUND_NAMESPACE_ID`.
+ */
+declare class PostgresSchema extends SqlNamespaceBase {
+  /**
+   * Stable singleton reference for the late-bound slot. Materialised
+   * lazily below the singleton subclass declaration so the static
+   * initialiser sees the subclass before assigning. Consumers always
+   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
+   * — same identity).
+   */
+  static unbound: PostgresUnboundSchema;
+  readonly kind: 'schema';
+  readonly id: string;
+  readonly entries: PostgresNamespaceEntries;
+  constructor(input: PostgresSchemaInput);
+  get table(): Readonly<Record<string, StorageTable>>;
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>>;
+  get role(): Readonly<Record<string, PostgresRole>>;
+  get rls(): Readonly<Record<string, PostgresRlsEnablement>>;
+  /**
+   * The bare schema qualifier as it would appear in a rendered SQL
+   * fragment (already quoted). The unbound-schema singleton overrides
+   * this to return `''`.
+   */
+  qualifier(): string;
+  /**
+   * Qualify a table name with the schema prefix
+   * (`"<schema>"."<table>"`). The unbound-schema singleton overrides
+   * this to emit just `"<table>"` so the resolved DDL is unqualified
+   * and `search_path` decides where the object lands at runtime.
+   */
+  qualifyTable(tableName: string): string;
+  /**
+   * Render a SQL string-literal containing the qualified-name form
+   * suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
+   * The unbound singleton overrides this to elide the schema prefix
+   * (`'"user"'`) so `search_path` resolves the object at runtime.
+   */
+  regclassLiteral(name: string): string;
+  /**
+   * Render a SQL expression that evaluates to this namespace's schema
+   * name at runtime, ready to drop into a `WHERE table_schema = …` /
+   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
+   * literal (`'public'`); the unbound singleton overrides this to emit
+   * `current_schema()` so catalog queries match whichever schema the
+   * connection's `search_path` resolved at runtime.
+   */
+  schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+  /**
+   * The bare schema name a DDL planner should target when emitting
+   * statements that need to identify this namespace in the live
+   * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
+   * catalog filters, planner conflict lookups). Named schemas resolve
+   * to their own id. The `PostgresUnboundSchema` singleton inherits
+   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
+   */
+  ddlSchemaName(_storage: SqlStorage): string;
+}
+/**
+ * Singleton subclass for the reserved sentinel namespace id
+ * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
+ * the connection's `search_path` resolves at runtime. Overrides
+ * qualifier emission to elide the schema prefix; call sites that consume
+ * `qualifier()` / `qualifyTable()` get unqualified output without
+ * branching on the namespace id.
+ *
+ * This is the target-side materialization of "the framework provides
+ * affordances; targets implement specifics": the framework names the
+ * sentinel; Postgres decides what late-bound means here (the table
+ * name, naked — the schema is supplied by the live connection's
+ * `search_path`).
+ *
+ * `ddlSchemaName` is inherited from `PostgresSchema` and returns
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
+ */
+declare class PostgresUnboundSchema extends PostgresSchema {
+  static readonly instance: PostgresUnboundSchema;
+  constructor(input?: PostgresSchemaInput);
+  qualifier(): string;
+  qualifyTable(tableName: string): string;
+  schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+}
+/**
+ * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`
+ * so callers can dispatch to the polymorphic emission methods without
+ * branching at the call site. Uses the structural `kind` discriminator
+ * (`'schema'`) rather than `instanceof` so the check survives realm /
+ * bundle / hot-reload boundaries — matching the rest of the IR's
+ * narrowing convention. `PostgresUnboundSchema` passes through because
+ * it inherits the same `kind: 'schema'` from `PostgresSchema`.
+ */
+declare function isPostgresSchema(ns: unknown): ns is PostgresSchema;
+/**
+ * Target-supplied `Namespace` factory the Postgres target plumbs
+ * through `defineContract({ createNamespace })` and the SQL PSL
+ * interpreter. Returns the unbound singleton for the framework
+ * sentinel and a fresh `PostgresSchema` for any other coordinate.
+ *
+ * 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. 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.
+ */
+declare function postgresCreateNamespace(input: SqlNamespaceInput): PostgresSchema;
+//#endregion
+export { postgresCreateNamespace as a, PostgresRlsEnablement as c, PostgresRoleInput as d, isPostgresSchema as i, PostgresRlsEnablementInput as l, PostgresSchema as n, PostgresNativeEnum as o, PostgresUnboundSchema as r, PostgresNativeEnumInput as s, PostgresContract as t, PostgresRole as u };
+//# sourceMappingURL=postgres-schema-CU4gF6QZ.d.mts.map

package/dist/postgres-schema-CU4gF6QZ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-CU4gF6QZ.d.mts","names":[],"sources":["../src/core/postgres-role.ts","../src/core/postgres-rls-enablement.ts","../src/core/postgres-native-enum.ts","../src/core/postgres-schema.ts"],"mappings":";;;;;;;UAGiB,iBAAA;EAAA,SACN,IAAA;;;;;WAKA,WAAW;AAAA;;;AAAA;AAgBtB;;;;;;;;;;cAAa,YAAA,SAAqB,OAAO;EAAA,SACrB,IAAA;EAAA,SACT,IAAA;EAAA,SACA,WAAA;cAEG,KAAA,EAAO,iBAAA;AAAA;;;UC3BJ,0BAAA;;WAEN,SAAA;;WAEA,WAAW;AAAA;ADJtB;;;;AAMsB;AAgBtB;;;;;;;AAtBA,cCmBa,qBAAA,SAA8B,OAAO;EAAA,SAC9B,IAAA;EAAA,SACT,SAAA;EAAA,SACA,WAAA;cAEG,KAAA,EAAO,0BAAA;AAAA;;;UCvBJ,uBAAA;;WAEN,QAAA;;WAEA,OAAA;EAAA,SACA,OAAA,GAAU,aAAa;AAAA;;;AFAZ;AAgBtB;;;;;;;;;;;;AAKsC;;;;cECzB,kBAAA,SAA2B,OAAA;EAAA,OAC/B,EAAA,CAAG,IAAA,YAAgB,IAAA,IAAQ,kBAAA;EAAA,SAMhB,IAAA;EAAA,SACT,QAAA;EAAA,SACA,OAAA;EAAA,SACQ,OAAA,GAAU,aAAA;cAEf,KAAA,EAAO,uBAAA;AAAA;;;KCVT,gBAAA,GAAmB,QAAQ,CAAC,UAAA;EAAA,SAAyB,MAAA;AAAA;AAAA,KAErD,wBAAA,GAA2B,mBAAA;EAAA,SAC5B,MAAA,GAAS,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,SACjC,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAC/B,GAAA,GAAM,QAAA,CAAS,MAAA,SAAe,qBAAA;EAAA,SAC9B,WAAA,GAAc,QAAA,CAAS,MAAA,SAAe,kBAAA;AAAA;AAAA,UAGhC,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;AHdf;;;;AC3BtC;;;;AAIsB;AAetB;;cEuCa,cAAA,SAAuB,gBAAA;EFvCc;;;;;;;EAAA,OE+CzC,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,wBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IAyCf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA,IAIpC,MAAA,IAAU,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,IAIlC,IAAA,IAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIhC,GAAA,IAAO,QAAA,CAAS,MAAA,SAAe,qBAAA;ED9H1B;;;;;ECuIT,SAAA;ED9GW;;;;;;ECwHX,YAAA,CAAa,SAAA;EDxHgC;;;;;;ECkI7C,eAAA,CAAgB,IAAA;ED3HE;;;;;;;;ECuIlB,mBAAA;EDlI0C;;;;ACV5C;;;EAuJE,sBAAA,IAA0B,MAAA;EAvJG;;;;AAAwC;AAEvE;;EAgKE,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EAhKX;;;;;;;;;;;EAmLrC,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAwBb,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;iBAmB3C,gBAAA,CAAiB,EAAA,YAAc,EAAA,IAAM,cAAc;AA3NnE;;;;;;;;;;;;;;AAAA,iBA6OgB,uBAAA,CAAwB,KAAA,EAAO,iBAAA,GAAoB,cAAc"}