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

package/dist/postgres-database-schema-node-CyfpHXDr-BqyozkQE.d.mts

@@ -0,0 +1,285 @@
+import { i as RlsPolicyOperation } from "./postgres-rls-policy-CnDxf3z9-C3LIHAIG.mjs";
+import { SqlObjectNaming } from "@prisma/orm-family-sql/schema-ir/naming";
+import { DiffableNode, SchemaNodeRef } from "@prisma/orm-framework/components/control";
+import { PrimaryKey, SqlAnnotations, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlTableIRInput, SqlUniqueIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { ControlPolicy } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/3-targets/postgres/dist/postgres-database-schema-node-CyfpHXDr.d.mts
+//#region src/core/schema-ir/postgres-native-enum-schema-node.d.ts
+interface PostgresNativeEnumSchemaNodeInput {
+  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */
+  readonly typeName: string;
+  /** The owning DDL schema name — enum types are schema-scoped. */
+  readonly namespaceId: string;
+  /** Member values in declaration (`pg_enum.enumsortorder`) order. */
+  readonly members: readonly string[];
+  /** The contract entity's control grade — expected-side nodes only. */
+  readonly control?: ControlPolicy;
+}
+/**
+ * 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.
+ */
+declare class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-native-enum";
+  readonly typeName: string;
+  readonly namespaceId: string;
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+  constructor(input: PostgresNativeEnumSchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresNativeEnumSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresNativeEnumSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-policy-schema-node.d.ts
+interface PostgresPolicySchemaNodeInput {
+  /** The node's identity. Read back off a built node with `namingOf`. */
+  readonly naming: SqlObjectNaming;
+  /** Name of the table this policy attaches to, by name within the same schema. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). */
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  /** Sorted role names rendered in `TO <roles>`. */
+  readonly roles: readonly string[];
+  /** USING predicate SQL string, if present. */
+  readonly using: string | undefined;
+  /** WITH CHECK predicate SQL string, if present. */
+  readonly withCheck: string | undefined;
+  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */
+  readonly permissive: boolean;
+  /**
+   * This policy's table node, plus one entry per role it grants to — each
+   * as the root-anchored chain the differ pairs siblings with. Stamped by
+   * the derivation, which holds the parent (database/namespace) context.
+   * Never compared by `isEqualTo`.
+   */
+  readonly dependsOn: readonly SchemaNodeRef[] | undefined;
+}
+/**
+ * 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 full physical name. `isEqualTo` is mode-selected by the
+ * receiver's `prefix`: a wire-named receiver (`prefix` present) compares ids
+ * only — the wire name encodes a body hash, so name-equality is
+ * body-equality and predicate bodies are never byte-compared (Postgres
+ * reprints them). An exact receiver (`prefix` absent) compares content:
+ * `operation`/`permissive` strict, `roles` sorted, and `using ?? ''` /
+ * `withCheck ?? ''` verbatim byte-for-byte — reliable precisely when the
+ * body text was captured from a Postgres reprint (contract infer).
+ */
+declare class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-policy";
+  readonly name: string;
+  readonly prefix?: string;
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: readonly string[];
+  readonly using?: string;
+  readonly withCheck?: string;
+  readonly permissive: boolean;
+  /** See {@link PostgresPolicySchemaNodeInput.dependsOn}. Non-enumerable so it stays out of JSON and structural equality, matching `SqlColumnIR.codecRef`. */
+  readonly dependsOn?: readonly SchemaNodeRef[];
+  constructor(input: PostgresPolicySchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  /**
+   * The single policy content-equality relation — the exact-mode
+   * {@link isEqualTo} and the planner's rename content-pairing both call
+   * this rather than growing a parallel relation: `operation` and
+   * `permissive` strict, `roles` compared deduplicated-and-sorted (the same
+   * set semantics as the wire-hash tuple, so the two never disagree),
+   * `using`/`withCheck` VERBATIM byte-for-byte with absent ≡ empty —
+   * deliberately NOT the normalized wire-hash bodies.
+   */
+  contentEquals(other: PostgresPolicySchemaNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode;
+  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-table-schema-node.d.ts
+interface PostgresTableSchemaNodeInput extends SqlTableIRInput {
+  readonly policies?: readonly PostgresPolicySchemaNode[];
+  /**
+   * Whether row-level security is enabled on this table. Expected side:
+   * stamped from the contract's `entries.rls` marker (never from the
+   * policy set). Actual side: stamped from `pg_class.relrowsecurity` at
+   * introspection. Required with no default so every construction site
+   * supplies a deliberate value.
+   */
+  readonly rlsEnabled: boolean;
+}
+/**
+ * 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.
+ */
+declare class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-table";
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  readonly primaryKey?: PrimaryKey;
+  readonly annotations?: SqlAnnotations;
+  readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;
+  readonly policies: readonly PostgresPolicySchemaNode[];
+  readonly rlsEnabled: boolean;
+  constructor(input: PostgresTableSchemaNodeInput);
+  get id(): string;
+  /**
+   * 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: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-namespace-schema-node.d.ts
+interface PostgresNamespaceSchemaNodeInput {
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  /**
+   * The native-enum diff nodes belonging to this namespace, member values in
+   * `pg_enum.enumsortorder` (declaration) order. The expected
+   * (contract-projected) side attaches each node's `control` (the contract
+   * entity's grade); introspection builds nodes with no `control`.
+   */
+  readonly nativeEnums?: readonly PostgresNativeEnumSchemaNode[];
+}
+/**
+ * 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` carries this node's own literal
+ * (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).
+ *
+ * `id` is the schema name; `isEqualTo` is identity on it; `children()` returns
+ * the table nodes plus `nativeEnums`.
+ *
+ * `nativeEnums` is the diff-tree representation of native enum types the
+ * differ pairs — the sole enum carrier, built directly by both sides: the
+ * expected (contract-projected) side and introspection alike hand in
+ * `PostgresNativeEnumSchemaNode`s.
+ */
+declare class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-namespace";
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  readonly nativeEnums: readonly PostgresNativeEnumSchemaNode[];
+  constructor(input: PostgresNamespaceSchemaNodeInput);
+  get id(): string;
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-role-schema-node.d.ts
+interface PostgresRoleSchemaNodeInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; callers pass
+   * `UNBOUND_NAMESPACE_ID` from `@internal/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+}
+/**
+ * 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 bare role name. The differ pairs
+ * siblings by `(nodeKind, id)`, so a role and a namespace may share a name
+ * (role `public`, schema `public`) without colliding. `isEqualTo` compares
+ * ids — name-equality is role-equality for cluster-scoped objects.
+ */
+declare class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-role";
+  readonly name: string;
+  readonly namespaceId: string;
+  constructor(input: PostgresRoleSchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-database-schema-node.d.ts
+interface PostgresDatabaseSchemaNodeInput {
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+}
+/**
+ * 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()` yields the namespace
+ * nodes followed by the role nodes — both are root-level diff subjects. The
+ * differ pairs siblings by `(nodeKind, id)`, so a role and a namespace may
+ * share a name without colliding.
+ */
+declare class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-database";
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+  constructor(input: PostgresDatabaseSchemaNodeInput);
+  get id(): string;
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode;
+}
+//#endregion
+export { PostgresNativeEnumSchemaNode as a, PostgresPolicySchemaNodeInput as c, PostgresTableSchemaNode as d, PostgresTableSchemaNodeInput as f, PostgresNamespaceSchemaNodeInput as i, PostgresRoleSchemaNode as l, PostgresDatabaseSchemaNodeInput as n, PostgresNativeEnumSchemaNodeInput as o, PostgresNamespaceSchemaNode as r, PostgresPolicySchemaNode as s, PostgresDatabaseSchemaNode as t, PostgresRoleSchemaNodeInput as u };
+//# sourceMappingURL=postgres-database-schema-node-CyfpHXDr-BqyozkQE.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-database-schema-node-CyfpHXDr-BqyozkQE.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/postgres-database-schema-node-CyfpHXDr.d.mts"],"mappings":";;;;;;;UAMU;;WAEC;;WAEA;;WAEA;;WAEA,UAAU;;;;;;;;;;;;;;;;;;;;;cAqBP,qCAAqC,2BAA2B;WACnE;WACA;WACA;WACA;WACA,UAAU;EACnB,YAAY,OAAO;MACf;EACJ,qBAAqB;EACrB,UAAU,OAAO;SACV,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,0BAA0B,QAAQ;;;;UAI9C;;WAEC,QAAQ;;WAER;;WAEA;WACA,WAAW;;WAEX;;WAEA;;WAEA;;WAEA;;;;;;;WAOA,oBAAoB;;;;;;;;;;;;;;;;;;cAkBjB,iCAAiC,2BAA2B;WAC/D;WACA;WACA;WACA;WACA;WACA,WAAW;WACX;WACA;WACA;WACA;;WAEA,qBAAqB;EAC9B,YAAY,OAAO;MACf;EACJ,qBAAqB;EACrB,UAAU,OAAO;;;;;;;;;;EAUjB,cAAc,OAAO;SACd,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,sCAAsC,QAAQ;;;;UAI1D,qCAAqC;WACpC,oBAAoB;;;;;;;;WAQpB;;;;;;;;;;;;;;;;;;;;cAoBG,gCAAgC,2BAA2B;WAC9D;WACA;WACA,SAAS,SAAS,eAAe;WACjC,aAAa,cAAc;WAC3B,SAAS,cAAc;WACvB,SAAS,cAAc;WACvB,aAAa;WACb,cAAc;WACd,SAAS,cAAc;WACvB,mBAAmB;WACnB;EACT,YAAY,OAAO;MACf;;;;;;;EAOJ,UAAU,OAAO;EACjB,qBAAqB;SACd,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,0BAA0B,QAAQ;;;;UAI9C;WACC;WACA,QAAQ,SAAS,eAAe;;;;;;;WAOhC,uBAAuB;;;;;;;;;;;;;;;;;;cAkBpB,oCAAoC,2BAA2B;WAClE;WACA;WACA,QAAQ,SAAS,eAAe;WAChC,sBAAsB;EAC/B,YAAY,OAAO;MACf;EACJ,UAAU,OAAO;EACjB,qBAAqB;SACd,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,0BAA0B,QAAQ;;;;UAI9C;WACC;;;;;WAKA;;;;;;;;;;;;;;cAcG,+BAA+B,2BAA2B;WAC7D;WACA;WACA;EACT,YAAY,OAAO;MACf;EACJ,qBAAqB;EACrB,UAAU,OAAO;SACV,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,0BAA0B,QAAQ;;;;UAI9C;WACC,YAAY,SAAS,eAAe;WACpC,gBAAgB;WAChB;WACA;;;;;;;;;;;;cAYG,mCAAmC,2BAA2B;WACjE;WACA,YAAY,SAAS,eAAe;WACpC,gBAAgB;WAChB;WACA;EACT,YAAY,OAAO;MACf;EACJ,UAAU,OAAO;EACjB,qBAAqB;SACd,GAAG,MAAM,kBAAkB,QAAQ;SACnC,OAAO,MAAM,0BAA0B,QAAQ"}

package/dist/postgres-migration-CDJj7CvD-Bsqs_fVo.d.mts

@@ -0,0 +1,260 @@
+import { r as RenderedRlsPolicyLiteral } from "./postgres-rls-policy-CnDxf3z9-C3LIHAIG.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO-_xPQVPF0.mjs";
+import { n as DataTransformOptions } from "./data-transform-Ck5FbyNO-BNE7QlAo.mjs";
+import { f as CreateIndexExtras, k as ForeignKeySpec, l as AlterColumnTypeOptions } from "./op-factory-call-jd4cgfjA-CyNT4YVn.mjs";
+import { t as PostgresContractView } from "./postgres-contract-view-2OP5JnXl-D2fpy4-8.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma/orm-family-sql/relational-core/ast";
+import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
+import { ControlStack } from "@prisma/orm-framework/components/control";
+import { SqlMigrationPlanOperation } from "@prisma/orm-family-sql/family/control";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { SqlControlAdapter } from "@prisma/orm-family-sql/family/control-adapter";
+//#region ../../../3-targets/3-targets/postgres/dist/postgres-migration-CDJj7CvD.d.mts
+//#region src/core/migrations/postgres-migration.d.ts
+/**
+ * Target-owned base class for Postgres migrations.
+ *
+ * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
+ * abstract `targetId` to the Postgres target-id string literal, so both
+ * user-authored migrations and renderer-generated scaffolds (the output of
+ * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
+ * redeclaring target-local identity.
+ *
+ * Mirrors `MongoMigration` in `@internal/family-mongo`: the renderer
+ * emits `extends Migration` against a facade re-export of this class
+ * from `@internal/postgres/migration`, keeping the authoring surface
+ * target-scoped rather than family-scoped.
+ *
+ * The constructor materializes a single Postgres `SqlControlAdapter` from
+ * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`
+ * instance method forwards to the free `dataTransform` factory with that
+ * stored adapter, so user migrations can write `this.dataTransform(...)`
+ * without threading the adapter through every call.
+ *
+ * Every method requires an explicit `schema`. Postgres migrations name their
+ * schema deliberately — there is no default and no `search_path`-relative
+ * option. A migration that left the schema unspecified would resolve against
+ * whatever `search_path` the connection happened to carry, and that ambiguity
+ * is an antipattern in a migration. (The unbound/unspecified namespace concept
+ * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
+ */
+declare abstract class PostgresMigration<Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<PostgresPlanTargetDetails, 'postgres', Start, End> {
+  #private;
+  readonly targetId: "postgres";
+  /**
+   * Materialized Postgres control adapter, created once per migration
+   * instance from the injected stack. `undefined` only when the migration
+   * was instantiated without a stack (test fixtures); `controlAdapterFor`
+   * throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'postgres'>);
+  /**
+   * Returns the materialized control adapter, or throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING naming
+   * `operation` when the migration was constructed without a `ControlStack`.
+   * Single home for the null-check that every DDL/DML method shares.
+   */
+  private controlAdapterFor;
+  /**
+   * The typed, schema-qualified Postgres view over this migration's end-state
+   * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws
+   * if no `endContractJson` was provided.
+   */
+  get endContract(): PostgresContractView<End>;
+  /**
+   * The typed Postgres view over this migration's start-state contract, or
+   * `null` for a baseline migration (no `startContractJson`).
+   */
+  get startContract(): PostgresContractView<Start> | null;
+  /**
+   * Instance-method wrapper around the free `dataTransform` factory that
+   * supplies the stored control adapter. Authors call this from inside
+   * `get operations()`; the adapter argument is hidden from the call site.
+   */
+  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createSchema(options: {
+    readonly schema: string;
+    readonly ifNotExists?: boolean;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `CREATE TYPE ... AS ENUM (...)` migration operation for a managed
+   * native enum. Builds a typed DDL node and lowers it through the stored
+   * control adapter (members render in declaration order). Throws if no adapter
+   * is present.
+   */
+  protected createNativeEnumType(options: {
+    readonly schema: string;
+    readonly typeName: string;
+    readonly members: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `DROP TYPE` migration operation for a managed native enum, lowered
+   * through the stored control adapter. Throws if no adapter is present.
+   */
+  protected dropNativeEnumType(options: {
+    readonly schema: string;
+    readonly typeName: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit an `ALTER TYPE ... ADD VALUE` migration operation appending one
+   * member to a managed native enum, lowered through the stored control
+   * adapter. Throws if no adapter is present. Every appended value is its
+   * own operation — call this once per value to append more than one.
+   */
+  protected addNativeEnumValue(options: {
+    readonly schema: string;
+    readonly typeName: string;
+    readonly value: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: DdlColumn;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addPrimaryKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addUnique(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addForeignKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly foreignKey: ForeignKeySpec;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly column: string;
+    readonly values: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropTable(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected alterColumnType(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly options: AlterColumnTypeOptions;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected setNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected setDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly defaultSql: string;
+    readonly operationClass?: 'additive' | 'widening';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected createIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+    readonly extras?: CreateIndexExtras;
+  } & ({
+    readonly columns: readonly string[];
+    readonly expression?: never;
+  } | {
+    readonly expression: string;
+    readonly columns?: never;
+  })): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected renameIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected installExtension(options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected enableRowLevelSecurity(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected disableRowLevelSecurity(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected createRlsPolicy(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly policy: RenderedRlsPolicyLiteral;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropRlsPolicy(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly policy: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected renameRlsPolicy(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+}
+//#endregion
+export { PostgresMigration as t };
+//# sourceMappingURL=postgres-migration-CDJj7CvD-Bsqs_fVo.d.mts.map

package/dist/postgres-migration-CDJj7CvD-Bsqs_fVo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-CDJj7CvD-Bsqs_fVo.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/postgres-migration-CDJj7CvD.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwCuB,kBAAkB,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,uCAAuC,OAAO;;WAElN;;;;;;;qBAOU,gBAAgB;EACnC,YAAY,QAAQ;;;;;;UAMZ;;;;;;MAMJ,eAAe,qBAAqB;;;;;MAKpC,iBAAiB,qBAAqB;;;;;;YAMhC,cAAc,kBAAkB,SAAS,aAAa,UAAU,WAAW,cAAc,SAAS,uBAAuB,QAAQ,0BAA0B;;;;;;YAM3J,YAAY;aACX;aACA;aACA;aACA,kBAAkB;aAClB,uBAAuB;MAC9B,QAAQ,0BAA0B;;;;;;YAM5B,aAAa;aACZ;aACA;MACP,QAAQ,0BAA0B;;;;;;;YAO5B,qBAAqB;aACpB;aACA;aACA;MACP,QAAQ,0BAA0B;;;;;YAK5B,mBAAmB;aAClB;aACA;MACP,QAAQ,0BAA0B;;;;;;;YAO5B,mBAAmB;aAClB;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,UAAU;aACT;aACA;aACA,QAAQ;MACf,QAAQ,0BAA0B;YAC5B,cAAc;aACb;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,UAAU;aACT;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,cAAc;aACb;aACA;aACA,YAAY;MACnB,QAAQ,0BAA0B;YAC5B,mBAAmB;aAClB;aACA;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,oBAAoB;aACnB;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,eAAe;aACd;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,UAAU;aACT;aACA;MACP,QAAQ,0BAA0B;YAC5B,WAAW;aACV;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,gBAAgB;aACf;aACA;aACA;aACA,SAAS;MAChB,QAAQ,0BAA0B;YAC5B,WAAW;aACV;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,YAAY;aACX;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,WAAW;aACV;aACA;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,YAAY;aACX;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,YAAY;aACX;aACA;aACA;aACA,SAAS;;aAET;aACA;;aAEA;aACA;OACN,QAAQ,0BAA0B;YAC7B,YAAY;aACX;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,UAAU;aACT;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,iBAAiB;aAChB;aACA;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,uBAAuB;aACtB;aACA;MACP,QAAQ,0BAA0B;YAC5B,wBAAwB;aACvB;aACA;MACP,QAAQ,0BAA0B;YAC5B,gBAAgB;aACf;aACA;aACA,QAAQ;MACf,QAAQ,0BAA0B;YAC5B,cAAc;aACb;aACA;aACA;MACP,QAAQ,0BAA0B;YAC5B,gBAAgB;aACf;aACA;aACA;aACA;MACP,QAAQ,0BAA0B"}