@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/postgres-schema-Xsjt3RKO-Buv2X8ai.d.mts

@@ -0,0 +1,269 @@
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-CnDxf3z9-C3LIHAIG.mjs";
+import { t as PostgresTableSource } from "./table-source-ikHOZmhD-DriY1Lcr.mjs";
+import { SqlNamespaceBase, SqlNamespaceEntries, SqlNamespaceInput, SqlNode, SqlStorage, StorageTable, StorageValueSet } from "@prisma/orm-family-sql/contract/types";
+import { CfExpr } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/3-targets/postgres/dist/postgres-schema-Xsjt3RKO.d.mts
+//#region src/core/postgres-native-enum.d.ts
+interface PostgresNativeEnumInput<Members extends readonly string[] = readonly string[]> {
+  /** 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: Members;
+  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<Members extends readonly string[] = readonly string[]> extends SqlNode {
+  static is(node: unknown): node is PostgresNativeEnum;
+  readonly kind: "postgres-enum";
+  readonly typeName: string;
+  readonly members: Members;
+  readonly control?: ControlPolicy;
+  constructor(input: PostgresNativeEnumInput<Members>);
+}
+//#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-role.d.ts
+interface PostgresRoleInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; pass `UNBOUND_NAMESPACE_ID`
+   * from `@internal/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+  /**
+   * Defaults to {@link ROLE_DEFAULT_CONTROL_POLICY} when omitted. Roles are
+   * referenced but never owned, so `'external'` is the only allowed value.
+   */
+  readonly control?: 'external';
+}
+/**
+ * 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).
+ *
+ * `control` always carries a value (never omitted): it defaults to
+ * {@link ROLE_DEFAULT_CONTROL_POLICY} in the constructor, so both a
+ * freshly-authored role and one hydrated from an older `contract.json`
+ * lacking the field resolve the same way — the control-policy resolver
+ * reads it directly off the entity instead of special-casing role issues.
+ */
+declare class PostgresRole extends SqlNode {
+  readonly kind: "role";
+  readonly name: string;
+  readonly namespaceId: string;
+  readonly control: 'external';
+  constructor(input: PostgresRoleInput);
+}
+//#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 { PostgresRlsEnablementInput as a, PostgresSchema as c, postgresCreateNamespace as d, PostgresRlsEnablement as i, PostgresUnboundSchema as l, PostgresNativeEnum as n, PostgresRole as o, PostgresNativeEnumInput as r, PostgresRoleInput as s, PostgresContract as t, isPostgresSchema as u };
+//# sourceMappingURL=postgres-schema-Xsjt3RKO-Buv2X8ai.d.mts.map

package/dist/postgres-schema-Xsjt3RKO-Buv2X8ai.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-Xsjt3RKO-Buv2X8ai.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/postgres-schema-Xsjt3RKO.d.mts"],"mappings":";;;;;;;UAMU,wBAAwB;;WAEvB;;WAEA,SAAS;WACT,UAAU;;;;;;;;;;;;;;;;;;;;;cAqBP,mBAAmB,+DAA+D;SACvF,GAAG,gBAAgB,QAAQ;WACzB;WACA;WACA,SAAS;WACT,UAAU;EACnB,YAAY,OAAO,wBAAwB;;;;UAInC;;WAEC;;WAEA;;;;;;;;;;;;;;cAcG,8BAA8B;WACjC;WACA;WACA;EACT,YAAY,OAAO;;;;UAIX;WACC;;;;;WAKA;;;;;WAKA;;;;;;;;;;;;;;;;;;;;;cAqBG,qBAAqB;WACxB;WACA;WACA;WACA;EACT,YAAY,OAAO;;;;KAIhB,mBAAmB,SAAS;WACtB;;KAEN,2BAA2B;WACrB,SAAS,SAAS,eAAe;WACjC,OAAO,SAAS,eAAe;WAC/B,MAAM,SAAS,eAAe;WAC9B,cAAc,SAAS,eAAe;;UAEvC;WACC;WACA,SAAS,SAAS,eAAe,SAAS;;;;;;;;;;;;;;;;cAgBvC,uBAAuB;;;;;;;;SAQ5B,SAAS;WACP;WACA;WACA,SAAS;EAClB,YAAY,OAAO;MACf,SAAS,SAAS,eAAe;MACjC,YAAY,SAAS,eAAe;MACpC,UAAU,SAAS,eAAe;MAClC,QAAQ,SAAS,eAAe;MAChC,OAAO,SAAS,eAAe;;;;;;EAMnC;;;;;;;EAOA,aAAa;;;;;;;EAOb,gBAAgB;;;;;;;;;EAShB;;;;;;;;EAQA,0BAA0B;;;;;;;;EAQ1B,YAAY,mBAAmB,iBAAiB;;;;;;;;;;;;EAYhD,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;;cAqBZ,8BAA8B;kBAC1B,UAAU;EAC1B,YAAY,QAAQ;EACpB;EACA,aAAa;EACb;EACA,0BAA0B;EAC1B,YAAY,mBAAmB,iBAAiB;;;;;;;;;;;iBAWjC,iBAAiB,cAAc,MAAM;;;;;;;;;;;;;;;iBAerC,wBAAwB,OAAO,oBAAoB"}

package/dist/postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs

@@ -0,0 +1,212 @@
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { freezeNode } from "@prisma/orm-framework/components/ir";
+import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR, assertNode, relationalNodeEntityKind, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
+//#region ../../../3-targets/3-targets/postgres/dist/postgres-table-schema-node-BBkitBQh.mjs
+/**
+* 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",
+	nativeEnum: "postgres-native-enum"
+};
+/**
+* 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",
+	[PostgresSchemaNodeKind.nativeEnum]: "entity"
+};
+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('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+* capability) — never stamped onto the issue or the node.
+*/
+function postgresDiffSubjectGranularity(nodeKind) {
+	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeGranularity(nodeKind) : relationalNodeGranularity(nodeKind);
+}
+/**
+* The map from a Postgres-specific `nodeKind` to its storage `entityKind` — the
+* same vocabulary the contract storage's `entries` dictionary keys use. The
+* whole-table and native-enum kinds each have an entity of their 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).
+*
+* The native enum keys under its PHYSICAL type name in `entries.native_enum`
+* (ADR 221), so its diff node's `typeName` addresses the entity on the generic
+* coordinate directly — no by-type-name walk needed. This lets the framework's
+* unclaimed-elements sweep classify enum ownership the same coordinate way it
+* classifies tables.
+*/
+const POSTGRES_NODE_ENTITY_KIND = {
+	[PostgresSchemaNodeKind.table]: "table",
+	[PostgresSchemaNodeKind.nativeEnum]: "native_enum"
+};
+/** 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('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+* capability — never stamped onto the issue or the node.
+*/
+function postgresDiffSubjectEntityKind(nodeKind) {
+	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeEntityKind(nodeKind) : relationalNodeEntityKind(nodeKind);
+}
+/**
+* Schema-diff leaf node for a native Postgres enum type.
+*
+* This is a derived, transient node walked by the differ — it is NEVER
+* serialized. Both sides derive it on the namespace node: the expected side
+* from the contract's hydrated `entries.native_enum` entities, the actual
+* side from the adapter's introspected `nativeEnums`.
+*
+* Enum types are schema-scoped, so identity is (namespace, type name): the
+* namespace coordinate comes from tree position (the differ pairs enum nodes
+* only inside an already-paired namespace) and `id` carries the type name,
+* prefixed with the entries-kind vocabulary (`native_enum:<typeName>`) so it
+* cannot collide with a sibling table of the same name — the same
+* sibling-prefix convention relational column nodes use (`column:<name>`).
+*
+* `isEqualTo` compares members POSITIONALLY — `['a','b'] ≠ ['b','a']` —
+* because Postgres enum sort order is semantic. `control` is contract
+* metadata, not database state, and does not participate in equality.
+*/
+var PostgresNativeEnumSchemaNode = class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.nativeEnum;
+	typeName;
+	namespaceId;
+	members;
+	constructor(input) {
+		super();
+		this.typeName = input.typeName;
+		this.namespaceId = input.namespaceId;
+		this.members = Object.freeze([...input.members]);
+		if (input.control !== void 0) this.control = input.control;
+		freezeNode(this);
+	}
+	get id() {
+		return `native_enum:${this.typeName}`;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresNativeEnumSchemaNode.assert(node);
+		return this.typeName === node.typeName && this.members.length === node.members.length && this.members.every((member, index) => member === node.members[index]);
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.nativeEnum;
+	}
+	static assert(node) {
+		assertNode(node, "PostgresNativeEnumSchemaNode", PostgresNativeEnumSchemaNode.is);
+	}
+};
+/**
+* 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 a, postgresDiffSubjectEntityKind as i, PostgresSchemaNodeKind as n, postgresNodeEntityKind as o, PostgresTableSchemaNode as r, PostgresNativeEnumSchemaNode as t };
+
+//# sourceMappingURL=postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs.map

package/dist/postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/postgres-table-schema-node-BBkitBQh.mjs"],"sourcesContent":["import { blindCast } from \"@internal/utils/casts\";\nimport { freezeNode } from \"@internal/framework-components/ir\";\nimport { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR, assertNode, relationalNodeEntityKind, relationalNodeGranularity } from \"@internal/sql-schema-ir/types\";\n//#region src/core/schema-ir/schema-node-kinds.ts\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*/\nconst PostgresSchemaNodeKind = {\n\tdatabase: \"postgres-database\",\n\tnamespace: \"postgres-namespace\",\n\ttable: \"postgres-table\",\n\tpolicy: \"postgres-policy\",\n\trole: \"postgres-role\",\n\tnativeEnum: \"postgres-native-enum\"\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 = {\n\t[PostgresSchemaNodeKind.database]: \"structural\",\n\t[PostgresSchemaNodeKind.namespace]: \"namespace\",\n\t[PostgresSchemaNodeKind.table]: \"entity\",\n\t[PostgresSchemaNodeKind.policy]: \"structural\",\n\t[PostgresSchemaNodeKind.role]: \"structural\",\n\t[PostgresSchemaNodeKind.nativeEnum]: \"entity\"\n};\nfunction isPostgresSchemaNodeKind(nodeKind) {\n\treturn Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);\n}\n/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */\nfunction postgresNodeGranularity(nodeKind) {\n\treturn POSTGRES_NODE_GRANULARITY[nodeKind];\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('@internal/framework-components/control').SchemaSubjectClassifierCapable}\n* capability) — never stamped onto the issue or the node.\n*/\nfunction postgresDiffSubjectGranularity(nodeKind) {\n\treturn isPostgresSchemaNodeKind(nodeKind) ? postgresNodeGranularity(nodeKind) : relationalNodeGranularity(nodeKind);\n}\n/**\n* The map from a Postgres-specific `nodeKind` to its storage `entityKind` — the\n* same vocabulary the contract storage's `entries` dictionary keys use. The\n* whole-table and native-enum kinds each have an entity of their 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*\n* The native enum keys under its PHYSICAL type name in `entries.native_enum`\n* (ADR 221), so its diff node's `typeName` addresses the entity on the generic\n* coordinate directly — no by-type-name walk needed. This lets the framework's\n* unclaimed-elements sweep classify enum ownership the same coordinate way it\n* classifies tables.\n*/\nconst POSTGRES_NODE_ENTITY_KIND = {\n\t[PostgresSchemaNodeKind.table]: \"table\",\n\t[PostgresSchemaNodeKind.nativeEnum]: \"native_enum\"\n};\n/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */\nfunction postgresNodeEntityKind(nodeKind) {\n\treturn POSTGRES_NODE_ENTITY_KIND[nodeKind];\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('@internal/framework-components/control').SchemaSubjectClassifierCapable}\n* capability — never stamped onto the issue or the node.\n*/\nfunction postgresDiffSubjectEntityKind(nodeKind) {\n\treturn isPostgresSchemaNodeKind(nodeKind) ? postgresNodeEntityKind(nodeKind) : relationalNodeEntityKind(nodeKind);\n}\n//#endregion\n//#region src/core/schema-ir/postgres-native-enum-schema-node.ts\n/**\n* Schema-diff leaf node for a native Postgres enum type.\n*\n* This is a derived, transient node walked by the differ — it is NEVER\n* serialized. Both sides derive it on the namespace node: the expected side\n* from the contract's hydrated `entries.native_enum` entities, the actual\n* side from the adapter's introspected `nativeEnums`.\n*\n* Enum types are schema-scoped, so identity is (namespace, type name): the\n* namespace coordinate comes from tree position (the differ pairs enum nodes\n* only inside an already-paired namespace) and `id` carries the type name,\n* prefixed with the entries-kind vocabulary (`native_enum:<typeName>`) so it\n* cannot collide with a sibling table of the same name — the same\n* sibling-prefix convention relational column nodes use (`column:<name>`).\n*\n* `isEqualTo` compares members POSITIONALLY — `['a','b'] ≠ ['b','a']` —\n* because Postgres enum sort order is semantic. `control` is contract\n* metadata, not database state, and does not participate in equality.\n*/\nvar PostgresNativeEnumSchemaNode = class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode {\n\tnodeKind = PostgresSchemaNodeKind.nativeEnum;\n\ttypeName;\n\tnamespaceId;\n\tmembers;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.typeName = input.typeName;\n\t\tthis.namespaceId = input.namespaceId;\n\t\tthis.members = Object.freeze([...input.members]);\n\t\tif (input.control !== void 0) this.control = input.control;\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn `native_enum:${this.typeName}`;\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tPostgresNativeEnumSchemaNode.assert(node);\n\t\treturn this.typeName === node.typeName && this.members.length === node.members.length && this.members.every((member, index) => member === node.members[index]);\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === PostgresSchemaNodeKind.nativeEnum;\n\t}\n\tstatic assert(node) {\n\t\tassertNode(node, \"PostgresNativeEnumSchemaNode\", PostgresNativeEnumSchemaNode.is);\n\t}\n};\n//#endregion\n//#region src/core/schema-ir/postgres-table-schema-node.ts\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*/\nvar PostgresTableSchemaNode = class PostgresTableSchemaNode extends SqlSchemaIRNode {\n\tnodeKind = PostgresSchemaNodeKind.table;\n\tname;\n\tcolumns;\n\tforeignKeys;\n\tuniques;\n\tindexes;\n\tpolicies;\n\trlsEnabled;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.name = input.name;\n\t\tthis.rlsEnabled = input.rlsEnabled;\n\t\tthis.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));\n\t\tthis.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));\n\t\tthis.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));\n\t\tthis.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));\n\t\tif (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tif (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));\n\t\tthis.policies = Object.freeze([...input.policies ?? []]);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn this.name;\n\t}\n\t/**\n\t* Equal iff the ids (names) match AND `rlsEnabled` matches — the table's\n\t* one own attribute in the diff; all other structural drift is expressed\n\t* by children. A paired `not-equal` therefore always means enablement\n\t* drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tPostgresTableSchemaNode.assert(node);\n\t\treturn this.id === node.id && this.rlsEnabled === node.rlsEnabled;\n\t}\n\tchildren() {\n\t\treturn [\n\t\t\t...Object.values(this.columns),\n\t\t\t...this.primaryKey ? [this.primaryKey] : [],\n\t\t\t...this.foreignKeys,\n\t\t\t...this.uniques,\n\t\t\t...this.indexes,\n\t\t\t...this.checks ?? [],\n\t\t\t...this.policies\n\t\t];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === PostgresSchemaNodeKind.table;\n\t}\n\tstatic assert(node) {\n\t\tassertNode(node, \"PostgresTableSchemaNode\", PostgresTableSchemaNode.is);\n\t}\n};\n//#endregion\nexport { postgresDiffSubjectGranularity as a, postgresDiffSubjectEntityKind as i, PostgresNativeEnumSchemaNode as n, postgresNodeEntityKind as o, PostgresSchemaNodeKind as r, PostgresTableSchemaNode as t };\n\n//# sourceMappingURL=postgres-table-schema-node-BBkitBQh.mjs.map"],"mappings":";;;;;;;;;;AAUA,MAAM,yBAAyB;CAC9B,UAAU;CACV,WAAW;CACX,OAAO;CACP,QAAQ;CACR,MAAM;CACN,YAAY;AACb;;;;;;;AAOA,MAAM,4BAA4B;EAChC,uBAAuB,WAAW;EAClC,uBAAuB,YAAY;EACnC,uBAAuB,QAAQ;EAC/B,uBAAuB,SAAS;EAChC,uBAAuB,OAAO;EAC9B,uBAAuB,aAAa;AACtC;AACA,SAAS,yBAAyB,UAAU;CAC3C,OAAO,OAAO,OAAO,2BAA2B,QAAQ;AACzD;;AAEA,SAAS,wBAAwB,UAAU;CAC1C,OAAO,0BAA0B;AAClC;;;;;;;;;;;AAWA,SAAS,+BAA+B,UAAU;CACjD,OAAO,yBAAyB,QAAQ,IAAI,wBAAwB,QAAQ,IAAI,0BAA0B,QAAQ;AACnH;;;;;;;;;;;;;;;AAeA,MAAM,4BAA4B;EAChC,uBAAuB,QAAQ;EAC/B,uBAAuB,aAAa;AACtC;;AAEA,SAAS,uBAAuB,UAAU;CACzC,OAAO,0BAA0B;AAClC;;;;;;;;;AASA,SAAS,8BAA8B,UAAU;CAChD,OAAO,yBAAyB,QAAQ,IAAI,uBAAuB,QAAQ,IAAI,yBAAyB,QAAQ;AACjH;;;;;;;;;;;;;;;;;;;;AAsBA,IAAI,+BAA+B,MAAM,qCAAqC,gBAAgB;CAC7F,WAAW,uBAAuB;CAClC;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,WAAW,MAAM;EACtB,KAAK,cAAc,MAAM;EACzB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC;EAC/C,IAAI,MAAM,YAAY,KAAK,GAAG,KAAK,UAAU,MAAM;EACnD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,eAAe,KAAK;CAC5B;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,6BAA6B,OAAO,IAAI;EACxC,OAAO,KAAK,aAAa,KAAK,YAAY,KAAK,QAAQ,WAAW,KAAK,QAAQ,UAAU,KAAK,QAAQ,OAAO,QAAQ,UAAU,WAAW,KAAK,QAAQ,MAAM;CAC9J;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,uBAAuB;CACjD;CACA,OAAO,OAAO,MAAM;EACnB,WAAW,MAAM,gCAAgC,6BAA6B,EAAE;CACjF;AACD;;;;;;;;;;;;;;;;;;;AAqBA,IAAI,0BAA0B,MAAM,gCAAgC,gBAAgB;CACnF,WAAW,uBAAuB;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM;EACxB,KAAK,UAAU,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,MAAM,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,KAAK,eAAe,cAAc,MAAM,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;EAClK,KAAK,cAAc,OAAO,OAAO,MAAM,YAAY,KAAK,OAAO,cAAc,kBAAkB,KAAK,IAAI,gBAAgB,EAAE,CAAC,CAAC;EAC5H,KAAK,UAAU,OAAO,OAAO,MAAM,QAAQ,KAAK,MAAM,aAAa,cAAc,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC;EACxG,KAAK,UAAU,OAAO,OAAO,MAAM,QAAQ,KAAK,MAAM,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;EACtG,IAAI,MAAM,eAAe,KAAK,GAAG,KAAK,aAAa,MAAM,sBAAsB,aAAa,MAAM,aAAa,IAAI,WAAW,MAAM,UAAU;EAC9I,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,IAAI,MAAM,WAAW,KAAK,KAAK,MAAM,OAAO,SAAS,GAAG,KAAK,SAAS,OAAO,OAAO,MAAM,OAAO,KAAK,MAAM,aAAa,uBAAuB,IAAI,IAAI,qBAAqB,CAAC,CAAC,CAAC;EAChL,KAAK,WAAW,OAAO,OAAO,CAAC,GAAG,MAAM,YAAY,CAAC,CAAC,CAAC;EACvD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,KAAK;CACb;;;;;;;CAOA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,wBAAwB,OAAO,IAAI;EACnC,OAAO,KAAK,OAAO,KAAK,MAAM,KAAK,eAAe,KAAK;CACxD;CACA,WAAW;EACV,OAAO;GACN,GAAG,OAAO,OAAO,KAAK,OAAO;GAC7B,GAAG,KAAK,aAAa,CAAC,KAAK,UAAU,IAAI,CAAC;GAC1C,GAAG,KAAK;GACR,GAAG,KAAK;GACR,GAAG,KAAK;GACR,GAAG,KAAK,UAAU,CAAC;GACnB,GAAG,KAAK;EACT;CACD;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,uBAAuB;CACjD;CACA,OAAO,OAAO,MAAM;EACnB,WAAW,MAAM,2BAA2B,wBAAwB,EAAE;CACvE;AACD"}

package/dist/render-ops-DPwhZt2W.d.mts

@@ -0,0 +1,11 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO-_xPQVPF0.mjs";
+import { OpFactoryCall } from "@prisma/orm-framework/components/control";
+import { SqlMigrationPlanOperation } from "@prisma/orm-family-sql/family/control";
+import { ExecuteRequestLowerer } from "@prisma/orm-family-sql/family/control-adapter";
+//#region ../../../3-targets/3-targets/postgres/dist/render-ops.d.mts
+//#region src/core/migrations/render-ops.d.ts
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+declare function renderOps(calls: readonly OpFactoryCall[], lowerer?: ExecuteRequestLowerer): (Op | Promise<Op>)[];
+//#endregion
+export { renderOps as t };
+//# sourceMappingURL=render-ops-DPwhZt2W.d.mts.map

package/dist/render-ops-DPwhZt2W.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-DPwhZt2W.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/render-ops.d.mts"],"mappings":";;;;;;KAKK,KAAK,0BAA0B;iBACnB,UAAU,gBAAgB,iBAAiB,UAAU,yBAAyB,KAAK,QAAQ"}

package/dist/render-ops-DxzTxSsv-Bz85uUHk.mjs

@@ -0,0 +1,34 @@
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { isThenable } from "@prisma/orm-framework/utils/promise";
+//#region ../../../3-targets/3-targets/postgres/dist/render-ops-DxzTxSsv.mjs
+/**
+* Asserts an op materialised by an `OpFactoryCall` targets postgres. The
+* extension surface lets any contributor emit calls, so this is the
+* integration boundary where a stray non-postgres op would otherwise
+* silently flow through to postgres-shaped renderers — exactly the
+* place to fail loudly with op metadata (`id` + `target.id`).
+*/
+function assertPostgresOp(op, callFactoryName) {
+	const targetId = blindCast(op).target?.id;
+	if (targetId !== "postgres") throw postgresError("MIGRATION.TARGET_MISMATCH", `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`, { meta: {
+		opId: op.id,
+		targetId: String(targetId),
+		factoryName: callFactoryName
+	} });
+}
+function renderOps(calls, lowerer) {
+	return calls.map((c) => {
+		const opOrPromise = blindCast(c).toOp(lowerer);
+		if (isThenable(opOrPromise)) return opOrPromise.then((op) => {
+			assertPostgresOp(op, c.factoryName);
+			return op;
+		});
+		assertPostgresOp(opOrPromise, c.factoryName);
+		return opOrPromise;
+	});
+}
+//#endregion
+export { renderOps as t };
+
+//# sourceMappingURL=render-ops-DxzTxSsv-Bz85uUHk.mjs.map

package/dist/render-ops-DxzTxSsv-Bz85uUHk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-DxzTxSsv-Bz85uUHk.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/render-ops-DxzTxSsv.mjs"],"sourcesContent":["import { n as postgresError } from \"./errors-kYxOQjdD.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { isThenable } from \"@internal/utils/promise\";\n//#region src/core/migrations/render-ops.ts\n/**\n* Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n* extension surface lets any contributor emit calls, so this is the\n* integration boundary where a stray non-postgres op would otherwise\n* silently flow through to postgres-shaped renderers — exactly the\n* place to fail loudly with op metadata (`id` + `target.id`).\n*/\nfunction assertPostgresOp(op, callFactoryName) {\n\tconst targetId = blindCast(op).target?.id;\n\tif (targetId !== \"postgres\") throw postgresError(\"MIGRATION.TARGET_MISMATCH\", `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`, { meta: {\n\t\topId: op.id,\n\t\ttargetId: String(targetId),\n\t\tfactoryName: callFactoryName\n\t} });\n}\nfunction renderOps(calls, lowerer) {\n\treturn calls.map((c) => {\n\t\tconst opOrPromise = blindCast(c).toOp(lowerer);\n\t\tif (isThenable(opOrPromise)) return opOrPromise.then((op) => {\n\t\t\tassertPostgresOp(op, c.factoryName);\n\t\t\treturn op;\n\t\t});\n\t\tassertPostgresOp(opOrPromise, c.factoryName);\n\t\treturn opOrPromise;\n\t});\n}\n//#endregion\nexport { renderOps as t };\n\n//# sourceMappingURL=render-ops-DxzTxSsv.mjs.map"],"mappings":";;;;;;;;;;;AAWA,SAAS,iBAAiB,IAAI,iBAAiB;CAC9C,MAAM,WAAW,UAAU,EAAE,CAAC,CAAC,QAAQ;CACvC,IAAI,aAAa,YAAY,MAAM,cAAc,6BAA6B,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,4HAA4H,EAAE,MAAM;EAC/U,MAAM,GAAG;EACT,UAAU,OAAO,QAAQ;EACzB,aAAa;CACd,EAAE,CAAC;AACJ;AACA,SAAS,UAAU,OAAO,SAAS;CAClC,OAAO,MAAM,KAAK,MAAM;EACvB,MAAM,cAAc,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO;EAC7C,IAAI,WAAW,WAAW,GAAG,OAAO,YAAY,MAAM,OAAO;GAC5D,iBAAiB,IAAI,EAAE,WAAW;GAClC,OAAO;EACR,CAAC;EACD,iBAAiB,aAAa,EAAE,WAAW;EAC3C,OAAO;CACR,CAAC;AACF"}

package/dist/render-typescript-6sCFvMBh.d.mts

@@ -0,0 +1,21 @@
+import { OpFactoryCall } from "@prisma/orm-framework/components/control";
+import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
+//#region ../../../3-targets/3-targets/postgres/dist/render-typescript.d.mts
+//#region src/core/migrations/render-typescript.d.ts
+interface RenderMigrationMeta {
+  readonly from: string | null;
+  readonly to: string;
+  /** POSIX-relative path from the migration package dir to `migrations/snapshots`, e.g. '../../snapshots'. */
+  readonly snapshotsImportPath: string;
+  /**
+   * Rewrites the package names the scaffold imports from, for the import root
+   * the consuming application installed. Applied once to the assembled
+   * requirement list rather than at each `OpFactoryCall`, so a new operation
+   * cannot forget it. Defaults to leaving specifiers as authored.
+   */
+  readonly resolveImportSpecifier?: ImportSpecifierResolver;
+}
+declare function renderCallsToTypeScript(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigrationMeta): string;
+//#endregion
+export { renderCallsToTypeScript as t };
+//# sourceMappingURL=render-typescript-6sCFvMBh.d.mts.map

package/dist/render-typescript-6sCFvMBh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-6sCFvMBh.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/render-typescript.d.mts"],"mappings":";;;;UAGU;WACC;WACA;;WAEA;;;;;;;WAOA,yBAAyB;;iBAEnB,wBAAwB,OAAO,cAAc,gBAAgB,MAAM"}