@prisma-next/target-postgres 0.16.0-dev.25 → 0.16.0-dev.26

package/dist/nodes-04EILM-z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes-04EILM-z.mjs","names":[],"sources":["../src/core/ddl/nodes.ts"],"sourcesContent":["import {\n  type DdlColumn,\n  DdlNode,\n  type DdlTableConstraint,\n} from '@prisma-next/sql-relational-core/ast';\nimport type { RlsPolicyOperation } from '../rls/canonicalize';\n\n// ---------------------------------------------------------------------------\n// AlterTableAction — nested polymorphic hierarchy\n// ---------------------------------------------------------------------------\n\nexport interface AlterTableActionVisitor<R> {\n  addColumn(action: AddColumnAction): R;\n  dropDefault(action: DropDefaultAction): R;\n}\n\nexport abstract class AlterTableAction {\n  abstract readonly kind: string;\n  abstract accept<R>(visitor: AlterTableActionVisitor<R>): R;\n}\n\nexport class AddColumnAction extends AlterTableAction {\n  readonly kind = 'add-column' as const;\n  readonly column: DdlColumn;\n\n  constructor(column: DdlColumn) {\n    super();\n    this.column = column;\n    Object.freeze(this);\n  }\n\n  override accept<R>(visitor: AlterTableActionVisitor<R>): R {\n    return visitor.addColumn(this);\n  }\n}\n\nexport class DropDefaultAction extends AlterTableAction {\n  readonly kind = 'drop-default' as const;\n  readonly columnName: string;\n\n  constructor(columnName: string) {\n    super();\n    this.columnName = columnName;\n    Object.freeze(this);\n  }\n\n  override accept<R>(visitor: AlterTableActionVisitor<R>): R {\n    return visitor.dropDefault(this);\n  }\n}\n\n/**\n * The set of ALTER TABLE subactions currently expressible as typed DDL.\n *\n * The remaining actions — SetDefault, SetNotNull, DropNotNull,\n * AlterColumnType — are still emitted as raw SQL by `operations/columns.ts`\n * and join this union as they are converted to typed DDL. Until then it is\n * intentionally partial: only the ALTER subactions used by the\n * already-converted ops (AddColumn, DropDefault) appear here.\n */\nexport type AnyAlterTableAction = AddColumnAction | DropDefaultAction;\n\n// ---------------------------------------------------------------------------\n// Top-level DDL visitor\n// ---------------------------------------------------------------------------\n\nexport interface PostgresDdlVisitor<R> {\n  createTable(node: PostgresCreateTable): R;\n  createSchema(node: PostgresCreateSchema): R;\n  createType(node: PostgresCreateType): R;\n  dropType(node: PostgresDropType): R;\n  alterTable(node: PostgresAlterTable): R;\n  createPolicy(node: PostgresCreatePolicy): R;\n  dropPolicy(node: PostgresDropPolicy): R;\n  alterPolicyRename(node: PostgresAlterPolicyRename): R;\n  createIndex(node: PostgresCreateIndex): R;\n  dropIndex(node: PostgresDropIndex): R;\n  alterIndexRename(node: PostgresAlterIndexRename): R;\n  disableRowLevelSecurity(node: PostgresDisableRowLevelSecurity): R;\n}\n\nexport abstract class PostgresDdlNode extends DdlNode {\n  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;\n}\n\nfunction freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColumn> {\n  return Object.freeze([...columns]);\n}\n\nfunction freezeConstraints(\n  constraints: readonly DdlTableConstraint[] | undefined,\n): ReadonlyArray<DdlTableConstraint> | undefined {\n  return constraints ? Object.freeze([...constraints]) : undefined;\n}\n\nexport class PostgresCreateTable extends PostgresDdlNode {\n  readonly kind = 'create-table' as const;\n  readonly table: string;\n  readonly schema: string | undefined;\n  readonly ifNotExists: boolean | undefined;\n  readonly columns: ReadonlyArray<DdlColumn>;\n  readonly constraints: ReadonlyArray<DdlTableConstraint> | undefined;\n\n  constructor(options: {\n    readonly table: string;\n    readonly schema?: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }) {\n    super();\n    this.table = options.table;\n    this.schema = options.schema;\n    this.ifNotExists = options.ifNotExists;\n    this.columns = freezeDdlColumns(options.columns);\n    this.constraints = freezeConstraints(options.constraints);\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createTable(this);\n  }\n}\n\nexport class PostgresCreateSchema extends PostgresDdlNode {\n  readonly kind = 'create-schema' as const;\n  readonly schema: string;\n  readonly ifNotExists: boolean | undefined;\n\n  constructor(options: { readonly schema: string; readonly ifNotExists?: boolean }) {\n    super();\n    this.schema = options.schema;\n    this.ifNotExists = options.ifNotExists;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createSchema(this);\n  }\n}\n\nexport class PostgresCreateType extends PostgresDdlNode {\n  readonly kind = 'create-type' as const;\n  readonly schema: string | undefined;\n  readonly name: string;\n  readonly values: ReadonlyArray<string>;\n\n  constructor(options: {\n    readonly schema?: string;\n    readonly name: string;\n    readonly values: readonly string[];\n  }) {\n    super();\n    this.schema = options.schema;\n    this.name = options.name;\n    this.values = Object.freeze([...options.values]);\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createType(this);\n  }\n}\n\nexport class PostgresDropType extends PostgresDdlNode {\n  readonly kind = 'drop-type' as const;\n  readonly schema: string | undefined;\n  readonly name: string;\n\n  constructor(options: { readonly schema?: string; readonly name: string }) {\n    super();\n    this.schema = options.schema;\n    this.name = options.name;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.dropType(this);\n  }\n}\n\nexport class PostgresAlterTable extends PostgresDdlNode {\n  readonly kind = 'alter-table' as const;\n  readonly table: string;\n  readonly schema: string | undefined;\n  readonly actions: ReadonlyArray<AnyAlterTableAction>;\n\n  constructor(options: {\n    readonly table: string;\n    readonly schema?: string;\n    readonly actions: readonly AnyAlterTableAction[];\n  }) {\n    super();\n    this.table = options.table;\n    this.schema = options.schema;\n    this.actions = Object.freeze([...options.actions]);\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.alterTable(this);\n  }\n}\n\nexport type { RlsPolicyOperation };\n\nexport class PostgresCreatePolicy extends PostgresDdlNode {\n  readonly kind = 'create-policy' as const;\n  readonly schema: string;\n  readonly table: string;\n  readonly name: string;\n  readonly permissive: boolean;\n  readonly operation: RlsPolicyOperation;\n  readonly roles: ReadonlyArray<string>;\n  readonly using: string | undefined;\n  readonly withCheck: string | undefined;\n\n  constructor(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly name: string;\n    readonly permissive: boolean;\n    readonly operation: RlsPolicyOperation;\n    readonly roles: readonly string[];\n    readonly using?: string;\n    readonly withCheck?: string;\n  }) {\n    super();\n    this.schema = options.schema;\n    this.table = options.table;\n    this.name = options.name;\n    this.permissive = options.permissive;\n    this.operation = options.operation;\n    this.roles = Object.freeze([...options.roles]);\n    this.using = options.using;\n    this.withCheck = options.withCheck;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createPolicy(this);\n  }\n}\n\nexport class PostgresDropPolicy extends PostgresDdlNode {\n  readonly kind = 'drop-policy' as const;\n  readonly schema: string;\n  readonly table: string;\n  readonly name: string;\n\n  constructor(options: { readonly schema: string; readonly table: string; readonly name: string }) {\n    super();\n    this.schema = options.schema;\n    this.table = options.table;\n    this.name = options.name;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.dropPolicy(this);\n  }\n}\n\nexport class PostgresAlterPolicyRename extends PostgresDdlNode {\n  readonly kind = 'alter-policy-rename' as const;\n  readonly schema: string;\n  readonly table: string;\n  readonly name: string;\n  readonly newName: string;\n\n  constructor(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly name: string;\n    readonly newName: string;\n  }) {\n    super();\n    this.schema = options.schema;\n    this.table = options.table;\n    this.name = options.name;\n    this.newName = options.newName;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.alterPolicyRename(this);\n  }\n}\n\n/**\n * The element list between the parens of CREATE INDEX: either a column\n * tuple (each identifier quoted by the renderer) or one opaque expression\n * string covering the entire list, inserted verbatim — the same opaque-SQL\n * stance as RLS policy predicates (ADR 234).\n */\nexport type DdlIndexElements =\n  | { readonly columns: readonly string[] }\n  | { readonly expression: string };\n\nexport class PostgresCreateIndex extends PostgresDdlNode {\n  readonly kind = 'create-index' as const;\n  /** Absent ⇔ unqualified (the unbound namespace — `search_path` decides). */\n  readonly schema: string | undefined;\n  readonly table: string;\n  readonly name: string;\n  readonly unique: boolean;\n  readonly elements: DdlIndexElements;\n  readonly type: string | undefined;\n  readonly options: Record<string, unknown> | undefined;\n  /**\n   * Partial-index predicate (WHERE body, without the keyword). Inserted\n   * verbatim, never quoted or escaped.\n   */\n  readonly where: string | undefined;\n\n  constructor(options: {\n    readonly schema: string | undefined;\n    readonly table: string;\n    readonly name: string;\n    readonly unique: boolean;\n    readonly elements: DdlIndexElements;\n    readonly type: string | undefined;\n    readonly options: Record<string, unknown> | undefined;\n    readonly where: string | undefined;\n  }) {\n    super();\n    this.schema = options.schema;\n    this.table = options.table;\n    this.name = options.name;\n    this.unique = options.unique;\n    this.elements =\n      'columns' in options.elements\n        ? { columns: Object.freeze([...options.elements.columns]) }\n        : { expression: options.elements.expression };\n    this.type = options.type;\n    this.options = options.options;\n    this.where = options.where;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createIndex(this);\n  }\n}\n\nexport class PostgresDropIndex extends PostgresDdlNode {\n  readonly kind = 'drop-index' as const;\n  /** Absent ⇔ unqualified (the unbound namespace). */\n  readonly schema: string | undefined;\n  readonly name: string;\n\n  constructor(options: { readonly schema: string | undefined; readonly name: string }) {\n    super();\n    this.schema = options.schema;\n    this.name = options.name;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.dropIndex(this);\n  }\n}\n\nexport class PostgresAlterIndexRename extends PostgresDdlNode {\n  readonly kind = 'alter-index-rename' as const;\n  /** Absent ⇔ unqualified (the unbound namespace). */\n  readonly schema: string | undefined;\n  readonly from: string;\n  readonly to: string;\n\n  constructor(options: {\n    readonly schema: string | undefined;\n    readonly from: string;\n    readonly to: string;\n  }) {\n    super();\n    this.schema = options.schema;\n    this.from = options.from;\n    this.to = options.to;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.alterIndexRename(this);\n  }\n}\n\nexport class PostgresDisableRowLevelSecurity extends PostgresDdlNode {\n  readonly kind = 'disable-row-level-security' as const;\n  readonly schema: string;\n  readonly table: string;\n\n  constructor(options: { readonly schema: string; readonly table: string }) {\n    super();\n    this.schema = options.schema;\n    this.table = options.table;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.disableRowLevelSecurity(this);\n  }\n}\n\nexport type AnyPostgresDdlNode =\n  | PostgresCreateTable\n  | PostgresCreateSchema\n  | PostgresCreateType\n  | PostgresDropType\n  | PostgresAlterTable\n  | PostgresCreatePolicy\n  | PostgresDropPolicy\n  | PostgresAlterPolicyRename\n  | PostgresCreateIndex\n  | PostgresDropIndex\n  | PostgresAlterIndexRename\n  | PostgresDisableRowLevelSecurity;\n"],"mappings":";;AAgBA,IAAsB,mBAAtB,MAAuC,CAGvC;AAEA,IAAa,kBAAb,cAAqC,iBAAiB;CACpD,OAAgB;CAChB;CAEA,YAAY,QAAmB;EAC7B,MAAM;EACN,KAAK,SAAS;EACd,OAAO,OAAO,IAAI;CACpB;CAEA,OAAmB,SAAwC;EACzD,OAAO,QAAQ,UAAU,IAAI;CAC/B;AACF;AAEA,IAAa,oBAAb,cAAuC,iBAAiB;CACtD,OAAgB;CAChB;CAEA,YAAY,YAAoB;EAC9B,MAAM;EACN,KAAK,aAAa;EAClB,OAAO,OAAO,IAAI;CACpB;CAEA,OAAmB,SAAwC;EACzD,OAAO,QAAQ,YAAY,IAAI;CACjC;AACF;AAgCA,IAAsB,kBAAtB,cAA8C,QAAQ,CAEtD;AAEA,SAAS,iBAAiB,SAAyD;CACjF,OAAO,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC;AACnC;AAEA,SAAS,kBACP,aAC+C;CAC/C,OAAO,cAAc,OAAO,OAAO,CAAC,GAAG,WAAW,CAAC,IAAI,KAAA;AACzD;AAEA,IAAa,sBAAb,cAAyC,gBAAgB;CACvD,OAAgB;CAChB;CACA;CACA;CACA;CACA;CAEA,YAAY,SAMT;EACD,MAAM;EACN,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,cAAc,QAAQ;EAC3B,KAAK,UAAU,iBAAiB,QAAQ,OAAO;EAC/C,KAAK,cAAc,kBAAkB,QAAQ,WAAW;EACxD,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,YAAY,IAAI;CACjC;AACF;AAEA,IAAa,uBAAb,cAA0C,gBAAgB;CACxD,OAAgB;CAChB;CACA;CAEA,YAAY,SAAsE;EAChF,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,cAAc,QAAQ;EAC3B,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,aAAa,IAAI;CAClC;AACF;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACtD,OAAgB;CAChB;CACA;CACA;CAEA,YAAY,SAIT;EACD,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO,QAAQ;EACpB,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;EAC/C,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,WAAW,IAAI;CAChC;AACF;AAEA,IAAa,mBAAb,cAAsC,gBAAgB;CACpD,OAAgB;CAChB;CACA;CAEA,YAAY,SAA8D;EACxE,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,SAAS,IAAI;CAC9B;AACF;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACtD,OAAgB;CAChB;CACA;CACA;CAEA,YAAY,SAIT;EACD,MAAM;EACN,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,WAAW,IAAI;CAChC;AACF;AAIA,IAAa,uBAAb,cAA0C,gBAAgB;CACxD,OAAgB;CAChB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,SAST;EACD,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,QAAQ;EAC1B,KAAK,YAAY,QAAQ;EACzB,KAAK,QAAQ,OAAO,OAAO,CAAC,GAAG,QAAQ,KAAK,CAAC;EAC7C,KAAK,QAAQ,QAAQ;EACrB,KAAK,YAAY,QAAQ;EACzB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,aAAa,IAAI;CAClC;AACF;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACtD,OAAgB;CAChB;CACA;CACA;CAEA,YAAY,SAAqF;EAC/F,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,WAAW,IAAI;CAChC;AACF;AAEA,IAAa,4BAAb,cAA+C,gBAAgB;CAC7D,OAAgB;CAChB;CACA;CACA;CACA;CAEA,YAAY,SAKT;EACD,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,kBAAkB,IAAI;CACvC;AACF;AAYA,IAAa,sBAAb,cAAyC,gBAAgB;CACvD,OAAgB;;CAEhB;CACA;CACA;CACA;CACA;CACA;CACA;;;;;CAKA;CAEA,YAAY,SAST;EACD,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO,QAAQ;EACpB,KAAK,SAAS,QAAQ;EACtB,KAAK,WACH,aAAa,QAAQ,WACjB,EAAE,SAAS,OAAO,OAAO,CAAC,GAAG,QAAQ,SAAS,OAAO,CAAC,EAAE,IACxD,EAAE,YAAY,QAAQ,SAAS,WAAW;EAChD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,YAAY,IAAI;CACjC;AACF;AAEA,IAAa,oBAAb,cAAuC,gBAAgB;CACrD,OAAgB;;CAEhB;CACA;CAEA,YAAY,SAAyE;EACnF,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,UAAU,IAAI;CAC/B;AACF;AAEA,IAAa,2BAAb,cAA8C,gBAAgB;CAC5D,OAAgB;;CAEhB;CACA;CACA;CAEA,YAAY,SAIT;EACD,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO,QAAQ;EACpB,KAAK,KAAK,QAAQ;EAClB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,iBAAiB,IAAI;CACtC;AACF;AAEA,IAAa,kCAAb,cAAqD,gBAAgB;CACnE,OAAgB;CAChB;CACA;CAEA,YAAY,SAA8D;EACxE,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,wBAAwB,IAAI;CAC7C;AACF"}

package/dist/{nodes-CQzM2hR0.d.mts → nodes-DjCsN-uv.d.mts}

@@ -1,4 +1,4 @@
-import { r as RlsPolicyOperation } from "./canonicalize-D1F4vUnP.mjs";
+import { r as RlsPolicyOperation } from "./canonicalize-CQlxSR4D.mjs";
 import { DdlColumn, DdlNode, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
 //#region src/core/ddl/nodes.d.ts
 interface AlterTableActionVisitor<R> {
@@ -40,6 +40,9 @@ interface PostgresDdlVisitor<R> {
   createPolicy(node: PostgresCreatePolicy): R;
   dropPolicy(node: PostgresDropPolicy): R;
   alterPolicyRename(node: PostgresAlterPolicyRename): R;
+  createIndex(node: PostgresCreateIndex): R;
+  dropIndex(node: PostgresDropIndex): R;
+  alterIndexRename(node: PostgresAlterIndexRename): R;
   disableRowLevelSecurity(node: PostgresDisableRowLevelSecurity): R;
 }
 declare abstract class PostgresDdlNode extends DdlNode {
@@ -153,6 +156,68 @@ declare class PostgresAlterPolicyRename extends PostgresDdlNode {
   });
   accept<R>(visitor: PostgresDdlVisitor<R>): R;
 }
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted by the renderer) or one opaque expression
+ * string covering the entire list, inserted verbatim — the same opaque-SQL
+ * stance as RLS policy predicates (ADR 234).
+ */
+type DdlIndexElements = {
+  readonly columns: readonly string[];
+} | {
+  readonly expression: string;
+};
+declare class PostgresCreateIndex extends PostgresDdlNode {
+  readonly kind: "create-index";
+  /** Absent ⇔ unqualified (the unbound namespace — `search_path` decides). */
+  readonly schema: string | undefined;
+  readonly table: string;
+  readonly name: string;
+  readonly unique: boolean;
+  readonly elements: DdlIndexElements;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped.
+   */
+  readonly where: string | undefined;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly table: string;
+    readonly name: string;
+    readonly unique: boolean;
+    readonly elements: DdlIndexElements;
+    readonly type: string | undefined;
+    readonly options: Record<string, unknown> | undefined;
+    readonly where: string | undefined;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresDropIndex extends PostgresDdlNode {
+  readonly kind: "drop-index";
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly name: string;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly name: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresAlterIndexRename extends PostgresDdlNode {
+  readonly kind: "alter-index-rename";
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly from: string;
+  readonly to: string;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly from: string;
+    readonly to: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
 declare class PostgresDisableRowLevelSecurity extends PostgresDdlNode {
   readonly kind: "disable-row-level-security";
   readonly schema: string;
@@ -163,7 +228,7 @@ declare class PostgresDisableRowLevelSecurity extends PostgresDdlNode {
   });
   accept<R>(visitor: PostgresDdlVisitor<R>): R;
 }
-type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema | PostgresCreateType | PostgresDropType | PostgresAlterTable | PostgresCreatePolicy | PostgresDropPolicy | PostgresAlterPolicyRename | PostgresDisableRowLevelSecurity;
+type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema | PostgresCreateType | PostgresDropType | PostgresAlterTable | PostgresCreatePolicy | PostgresDropPolicy | PostgresAlterPolicyRename | PostgresCreateIndex | PostgresDropIndex | PostgresAlterIndexRename | PostgresDisableRowLevelSecurity;
 //#endregion
-export { DropDefaultAction as a, PostgresCreatePolicy as c, PostgresCreateType as d, PostgresDdlNode as f, PostgresDropType as g, PostgresDropPolicy as h, AnyPostgresDdlNode as i, PostgresCreateSchema as l, PostgresDisableRowLevelSecurity as m, AlterTableActionVisitor as n, PostgresAlterPolicyRename as o, PostgresDdlVisitor as p, AnyAlterTableAction as r, PostgresAlterTable as s, AddColumnAction as t, PostgresCreateTable as u };
-//# sourceMappingURL=nodes-CQzM2hR0.d.mts.map
+export { PostgresDisableRowLevelSecurity as _, DdlIndexElements as a, PostgresDropType as b, PostgresAlterPolicyRename as c, PostgresCreatePolicy as d, PostgresCreateSchema as f, PostgresDdlVisitor as g, PostgresDdlNode as h, AnyPostgresDdlNode as i, PostgresAlterTable as l, PostgresCreateType as m, AlterTableActionVisitor as n, DropDefaultAction as o, PostgresCreateTable as p, AnyAlterTableAction as r, PostgresAlterIndexRename as s, AddColumnAction as t, PostgresCreateIndex as u, PostgresDropIndex as v, PostgresDropPolicy as y };
+//# sourceMappingURL=nodes-DjCsN-uv.d.mts.map

package/dist/nodes-DjCsN-uv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes-DjCsN-uv.d.mts","names":[],"sources":["../src/core/ddl/nodes.ts"],"mappings":";;;UAWiB,wBAAwB;EACvC,UAAU,QAAQ,kBAAkB;EACpC,YAAY,QAAQ,oBAAoB;;uBAGpB;oBACF;WACT,OAAO,GAAG,SAAS,wBAAwB,KAAK;;cAG9C,wBAAwB;WAC1B;WACA,QAAQ;cAEL,QAAQ;EAMX,OAAO,GAAG,SAAS,wBAAwB,KAAK;;cAK9C,0BAA0B;WAC5B;WACA;cAEG;EAMH,OAAO,GAAG,SAAS,wBAAwB,KAAK;;;;;;;;;;;KAc/C,sBAAsB,kBAAkB;UAMnC,mBAAmB;EAClC,YAAY,MAAM,sBAAsB;EACxC,aAAa,MAAM,uBAAuB;EAC1C,WAAW,MAAM,qBAAqB;EACtC,SAAS,MAAM,mBAAmB;EAClC,WAAW,MAAM,qBAAqB;EACtC,aAAa,MAAM,uBAAuB;EAC1C,WAAW,MAAM,qBAAqB;EACtC,kBAAkB,MAAM,4BAA4B;EACpD,YAAY,MAAM,sBAAsB;EACxC,UAAU,MAAM,oBAAoB;EACpC,iBAAiB,MAAM,2BAA2B;EAClD,wBAAwB,MAAM,kCAAkC;;uBAG5C,wBAAwB;WACnC,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAazC,4BAA4B;WAC9B;WACA;WACA;WACA;WACA,SAAS,cAAc;WACvB,aAAa,cAAc;cAExB;aACD;aACA;aACA;aACA,kBAAkB;aAClB,uBAAuB;;EAWzB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,6BAA6B;WAC/B;WACA;WACA;cAEG;aAAoB;aAAyB;;EAOhD,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,2BAA2B;WAC7B;WACA;WACA;WACA,QAAQ;cAEL;aACD;aACA;aACA;;EASF,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,yBAAyB;WAC3B;WACA;WACA;cAEG;aAAoB;aAA0B;;EAOjD,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,2BAA2B;WAC7B;WACA;WACA;WACA,SAAS,cAAc;cAEpB;aACD;aACA;aACA,kBAAkB;;EASpB,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAOzC,6BAA6B;WAC/B;WACA;WACA;WACA;WACA;WACA,WAAW;WACX,OAAO;WACP;WACA;cAEG;aACD;aACA;aACA;aACA;aACA,WAAW;aACX;aACA;aACA;;EAcF,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,2BAA2B;WAC7B;WACA;WACA;WACA;cAEG;aAAoB;aAAyB;aAAwB;;EAQxE,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,kCAAkC;WACpC;WACA;WACA;WACA;WACA;cAEG;aACD;aACA;aACA;aACA;;EAUF,OAAO,GAAG,SAAS,mBAAmB,KAAK;;;;;;;;KAW1C;WACG;;WACA;;cAEF,4BAA4B;WAC9B;;WAEA;WACA;WACA;WACA;WACA,UAAU;WACV;WACA,SAAS;;;;;WAKT;cAEG;aACD;aACA;aACA;aACA;aACA,UAAU;aACV;aACA,SAAS;aACT;;EAiBF,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,0BAA0B;WAC5B;;WAEA;WACA;cAEG;aAAoB;aAAqC;;EAO5D,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,iCAAiC;WACnC;;WAEA;WACA;WACA;cAEG;aACD;aACA;aACA;;EASF,OAAO,GAAG,SAAS,mBAAmB,KAAK;;cAKzC,wCAAwC;WAC1C;WACA;WACA;cAEG;aAAoB;aAAyB;;EAOhD,OAAO,GAAG,SAAS,mBAAmB,KAAK;;KAK1C,qBACR,sBACA,uBACA,qBACA,mBACA,qBACA,uBACA,qBACA,4BACA,sBACA,oBACA,2BACA"}

package/dist/{op-factory-call-DT7kdjVP.d.mts → op-factory-call-0TB5XNij.d.mts}

@@ -26,6 +26,29 @@ interface ForeignKeySpec {
   readonly onUpdate?: ReferentialAction;
 }
 //#endregion
+//#region src/core/migrations/operations/indexes.d.ts
+interface CreateIndexExtras {
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped — the same opaque-SQL stance as RLS
+   * policy predicates.
+   */
+  readonly where?: string;
+  readonly unique?: boolean;
+}
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted) or one opaque expression string covering
+ * the entire list, inserted verbatim.
+ */
+type CreateIndexElements = {
+  readonly columns: readonly string[];
+} | {
+  readonly expression: string;
+};
+//#endregion
 //#region src/core/migrations/op-factory-call.d.ts
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 declare abstract class PostgresOpFactoryCallNode extends TsExpression implements OpFactoryCall {
@@ -288,14 +311,29 @@ declare class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly schemaName: string;
   readonly tableName: string;
   readonly indexName: string;
-  readonly columns: readonly string[];
+  /** Column tuple when the index is column-based; absent for expression indexes. */
+  readonly columns: readonly string[] | undefined;
+  /** Opaque whole element list when the index is expression-based. */
+  readonly expression: string | undefined;
   readonly indexType: string | undefined;
   readonly options: Record<string, unknown> | undefined;
+  readonly where: string | undefined;
+  readonly unique: boolean;
   readonly label: string;
-  constructor(schemaName: string, tableName: string, indexName: string, columns: readonly string[], extras?: {
-    readonly type?: string;
-    readonly options?: Record<string, unknown>;
-  });
+  constructor(schemaName: string, tableName: string, indexName: string, elements: CreateIndexElements, extras?: CreateIndexExtras);
+  toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+declare class RenameIndexCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "renameIndex";
+  readonly operationClass: "widening";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly oldIndexName: string;
+  readonly newIndexName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, oldIndexName: string, newIndexName: string);
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
@@ -476,7 +514,7 @@ declare class RenamePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
 }
-type PostgresOpFactoryCall = CreateTableCall | DropTableCall | AddColumnCall | DropColumnCall | AlterColumnTypeCall | SetNotNullCall | DropNotNullCall | SetDefaultCall | DropDefaultCall | AddNotNullColumnDirectCall | AddNotNullColumnWithTempDefaultCall | AddPrimaryKeyCall | AddForeignKeyCall | AddUniqueCall | AddCheckConstraintCall | DropCheckConstraintCall | CreateIndexCall | DropIndexCall | DropConstraintCall | RawSqlCall | CreateExtensionCall | CreateSchemaCall | CreateNativeEnumTypeCall | DropNativeEnumTypeCall | AddNativeEnumValueCall | CreatePostgresRlsPolicyCall | DropPostgresRlsPolicyCall | EnableRowLevelSecurityCall | DisableRowLevelSecurityCall | RenamePostgresRlsPolicyCall | DataTransformCall;
+type PostgresOpFactoryCall = CreateTableCall | DropTableCall | AddColumnCall | DropColumnCall | AlterColumnTypeCall | SetNotNullCall | DropNotNullCall | SetDefaultCall | DropDefaultCall | AddNotNullColumnDirectCall | AddNotNullColumnWithTempDefaultCall | AddPrimaryKeyCall | AddForeignKeyCall | AddUniqueCall | AddCheckConstraintCall | DropCheckConstraintCall | CreateIndexCall | RenameIndexCall | DropIndexCall | DropConstraintCall | RawSqlCall | CreateExtensionCall | CreateSchemaCall | CreateNativeEnumTypeCall | DropNativeEnumTypeCall | AddNativeEnumValueCall | CreatePostgresRlsPolicyCall | DropPostgresRlsPolicyCall | EnableRowLevelSecurityCall | DisableRowLevelSecurityCall | RenamePostgresRlsPolicyCall | DataTransformCall;
 //#endregion
-export { RenamePostgresRlsPolicyCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, SetNotNullCall as M, ForeignKeySpec as N, PostgresOpFactoryCall as O, Op$1 as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnWithTempDefaultCall as a, DropConstraintCall as b, AlterColumnTypeCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, SetDefaultCall as j, RawSqlCall as k, AlterColumnTypeOptions as l, CreateSchemaCall as m, AddColumnCall as n, AddPrimaryKeyCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddUniqueCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
-//# sourceMappingURL=op-factory-call-DT7kdjVP.d.mts.map
+export { RenameIndexCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, ForeignKeySpec as F, Op$1 as I, SetDefaultCall as M, SetNotNullCall as N, PostgresOpFactoryCall as O, CreateIndexExtras as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnWithTempDefaultCall as a, DropConstraintCall as b, AlterColumnTypeCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, RenamePostgresRlsPolicyCall as j, RawSqlCall as k, AlterColumnTypeOptions as l, CreateSchemaCall as m, AddColumnCall as n, AddPrimaryKeyCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddUniqueCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
+//# sourceMappingURL=op-factory-call-0TB5XNij.d.mts.map

package/dist/op-factory-call-0TB5XNij.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-0TB5XNij.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts","../src/core/migrations/operations/indexes.ts","../src/core/migrations/op-factory-call.ts"],"mappings":";;;;;;;;;;KAKY,OAAK,0BAA0B;;;;;;UAO1B;WACN;WACA;WACA;aACE;aACA;aACA;;WAEF,WAAW;WACX,WAAW;;;;UCOL;WACN;WACA,UAAU;;;;;;WAMV;WACA;;;;;;;KAQC;WACG;;WACA;;;;KCkDV,KAAK,0BAA0B;uBAgBrB,kCAAkC,wBAAwB;oBACrD;oBACA,gBAAgB;oBAChB;WACT,KAAK,UAAU,UAAU,KAAK,QAAQ;EAE/C,+BAA+B;YAIrB;;cAuGC,wBAAwB;WAC1B;WACA;WACA;WACA;WACA,kBAAkB;WAClB,sBAAsB;WACtB;cAGP,oBACA,mBACA,kBAAkB,aAClB,uBAAuB;EAWnB,KAAK,UAAU,wBAAwB,QAAQ;EAsCrD;EAiBS,+BAA+B;;cAe7B,sBAAsB;WACxB;WACA;WACA;WACA;WACA;cAEG,oBAAoB;EAQ1B,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EASS,+BAA+B;;cAS7B,sBAAsB;WACxB;WACA;WACA;WACA;WACA,QAAQ;WACR;cAEG,oBAAoB,mBAAmB,QAAQ;EASrD,KAAK,UAAU,wBAAwB,QAAQ;EA+BrD;EAUS,+BAA+B;;cAW7B,uBAAuB;WACzB;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;UAKzB;WACN;WACA;WACA;WACA;;cAGE,4BAA4B;WAC9B;WACA;WACA;WACA;WACA;WACA,SAAS;WACT;cAGP,oBACA,mBACA,oBACA,SAAS;EAWL,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAWS,+BAA+B;;cAK7B,uBAAuB;WACzB;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;cAK7B,wBAAwB;WAC1B;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;cAK7B,uBAAuB;WACzB;WACA;WACA;WACA;WACA;WACA;WACA;cAGP,oBACA,mBACA,oBACA,oBACA;EAYI,KAAK,UAAU,wBAAwB,QAAQ;EAkBrD;EAcS,+BAA+B;;cAK7B,wBAAwB;WAC1B;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;;;;;;;;;cAiB7B,mCAAmC;WACrC;WACA;WACA;WACA;WACA;WACA,QAAQ;WACR;cAEG,oBAAoB,mBAAmB,oBAAoB,QAAQ;EAUzE,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;;;;;;;;;;;;cAeW,4CAA4C;WAC9C;WACA;WACA;WACA;WACA;WACA,QAAQ;WACR,YAAY,YAAY;WACxB,cAAc,eAAe;WAC7B;WACA;cAEG;aACD;aACA;aACA;aACA,QAAQ;aACR,YAAY,YAAY;aACxB,cAAc,eAAe;aAC7B;;EAcL,KAAK,UAAU,wBAAwB,QAAQ;EAoBrD;;cAuBW,0BAA0B;WAC5B;WACA;WACA;WACA;WACA;WACA;WACA;cAGP,oBACA,mBACA,wBACA;EAWI,KAAK,UAAU,wBAAwB,QAAQ;EAiBrD;EAIS,+BAA+B;;cAK7B,sBAAsB;WACxB;WACA;WACA;WACA;WACA;WACA;WACA;cAGP,oBACA,mBACA,wBACA;EAWI,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAIS,+BAA+B;;cAK7B,0BAA0B;WAC5B;WACA;WACA;WACA;WACA,IAAI;WACJ;cAEG,oBAAoB,mBAAmB,IAAI;EASjD,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;cAK7B,2BAA2B;WAC7B;WACA;WACA;WACA;WACA;WACA;WACA;cAGP,oBACA,mBACA,wBACA;EAWI,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAQS,+BAA+B;;cAK7B,+BAA+B;WACjC;WACA;WACA;WACA;WACA;WACA;WACA;WACA;cAGP,oBACA,mBACA,wBACA,gBACA;EAYI,KAAK,UAAU,wBAAwB,QAAQ;EAkBrD;EAIS,+BAA+B;;cAK7B,gCAAgC;WAClC;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAIS,+BAA+B;;cAS7B,wBAAwB;WAC1B;WACA;WACA;WACA;WACA;;WAEA;;WAEA;WAGA;WACA,SAAS;WACT;WACA;WACA;cAGP,oBACA,mBACA,mBACA,UAAU,qBACV,SAAS;EAgBL,KAAK,UAAU,wBAAwB,QAAQ;EA8BrD;EA4BS,+BAA+B;;cAK7B,wBAAwB;WAC1B;WAKA;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB,sBAAsB;EAUnE,KAAK,UAAU,wBAAwB,QAAQ;EAiBrD;EAWS,+BAA+B;;cAK7B,sBAAsB;WACxB;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAUS,+BAA+B;;;;;;;;;;;;;;;cAsB7B,mBAAmB;WACrB;WACA,gBAAgB;WAChB;WACA,IAAI;cAED,IAAI;EAQhB,QAAQ;EAIR;;cASW,4BAA4B;WAC9B;WACA;WACA;WACA;cAEG;EAOZ,QAAQ;EAIR;;cAKW,yBAAyB;WAC3B;WACA;WACA;WACA;cAEG;EAON,KAAK,UAAU,wBAAwB,QAAQ;EA4BrD;EAIS,+BAA+B;;cAS7B,iCAAiC;WACnC;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,kBAAkB;EAS5C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EASS,+BAA+B;;cAK7B,+BAA+B;WACjC;WACA;WACA;WACA;WACA;cAEG,oBAAoB;EAQ1B,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAQS,+BAA+B;;;;;;;;;;;;cAyB7B,+BAA+B;WACjC;WACA;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,kBAAkB;EAW5C,KAAK,UAAU,wBAAwB,QAAQ;EA6CrD;EASS,+BAA+B;;;;;;;;;cAgB7B,0BAA0B;WAC5B;WACA,gBAAgB;WAChB;WACA;WACA;cAGP,eACA,mBACA,iBACA,iBAAgB;EAUlB,QAAQ;EAIR;EASS,+BAA+B;;cAQ7B,oCAAoC;WACtC;WACA;WACA;WACA;WACA,QAAQ;WACR;cAEG,oBAAoB,mBAAmB,QAAQ;EASrD,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAgBS,+BAA+B;;cAK7B,kCAAkC;WACpC;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB;EAS7C,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAIS,+BAA+B;;cAK7B,mCAAmC;WACrC;WACA;WACA;WACA;WACA;cAEG,oBAAoB;EAQ1B,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAIS,+BAA+B;;cAK7B,oCAAoC;WACtC;WACA;WACA;WACA;WACA;cAEG,oBAAoB;EAQ1B,KAAK,UAAU,wBAAwB,QAAQ;EAWrD;EAIS,+BAA+B;;cAK7B,oCAAoC;WACtC;WAKA;WACA;WACA;WACA;WACA;WACA;cAEG,oBAAoB,mBAAmB,uBAAuB;EAUpE,KAAK,UAAU,wBAAwB,QAAQ;EAiBrD;EAIS,+BAA+B;;KAK9B,wBACR,kBACA,gBACA,gBACA,iBACA,sBACA,iBACA,kBACA,iBACA,kBACA,6BACA,sCACA,oBACA,oBACA,gBACA,yBACA,0BACA,kBACA,kBACA,gBACA,qBACA,aACA,sBACA,mBACA,2BACA,yBACA,yBACA,8BACA,4BACA,6BACA,8BACA,8BACA"}

package/dist/{op-factory-call-BVYLIojV.mjs → op-factory-call-CIaPDDUc.mjs}

@@ -1,7 +1,7 @@
 import { n as postgresError } from "./errors-DBSNx7EJ.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
 import { a as validateEnumValueLength, i as quoteQualifiedName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-B2lzkKfP.mjs";
-import { C as rlsPolicyExistsAst, S as rlsEnabledAst, T as tableIsEmptyAst, _ as extensionExistsAst, a as createSchema, b as nativeEnumValueExistsAst, c as disableRowLevelSecurity$1, d as dropType, f as columnDefaultAst, g as constraintExistsAst, h as columnTypeAst, i as createPolicy, l as dropDefaultAction, m as columnNullabilityAst, n as alterPolicyRename, o as createTable, p as columnExistsAst, r as alterTable, s as createType, t as addColumnAction, u as dropPolicy, v as indexExistsAst, w as tableExistsAst, x as noNullValuesAst, y as nativeEnumTypeExistsAst } from "./ddl-DYEob9xQ.mjs";
+import { C as nativeEnumValueExistsAst, D as tableExistsAst, E as rlsPolicyExistsAst, O as tableIsEmptyAst, S as nativeEnumTypeExistsAst, T as rlsEnabledAst, _ as columnNullabilityAst, a as createIndex$1, b as extensionExistsAst, c as createTable, d as dropDefaultAction, f as dropIndex$1, g as columnExistsAst, h as columnDefaultAst, i as alterTable, l as createType, m as dropType, n as alterIndexRename, o as createPolicy, p as dropPolicy, r as alterPolicyRename, s as createSchema, t as addColumnAction, u as disableRowLevelSecurity$1, v as columnTypeAst, w as noNullValuesAst, x as indexExistsAst, y as constraintExistsAst } from "./ddl-BQC6u-L9.mjs";
 import { n as qualifyTableName } from "./planner-sql-checks-CmiQ6Nei.mjs";
 import { n as buildColumnTypeSql } from "./planner-ddl-builders-CVo3L7Nd.mjs";
 import { FunctionColumnDefault, LiteralColumnDefault } from "@prisma-next/sql-relational-core/ast";
@@ -448,24 +448,22 @@ async function indexExistsSteps(lowerer, schemaName, indexName) {
 		absent: await lowerer.lowerToExecuteRequest(checks.indexAbsent())
 	};
 }
-function renderIndexOptionValue(key, value) {
-	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (typeof value === "boolean") return value ? "true" : "false";
-	throw postgresError("CONTRACT.INDEX_INVALID", `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`, { meta: {
-		key,
-		valueType: typeof value
-	} });
-}
-function renderIndexOptions(options) {
-	return Object.entries(options).map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`).join(", ");
+/** An unbound-namespace object renders unqualified: the DDL node takes no schema. */
+function ddlSchemaOf(schemaName) {
+	return schemaName === UNBOUND_NAMESPACE_ID ? void 0 : schemaName;
 }
-async function createIndex(schemaName, tableName, indexName, columns, lowerer, extras) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : "";
-	const options = extras?.options;
-	const withClause = options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : "";
+async function createIndex(schemaName, tableName, indexName, elements, lowerer, extras) {
+	const ddlNode = createIndex$1({
+		schema: ddlSchemaOf(schemaName),
+		table: tableName,
+		name: indexName,
+		unique: extras?.unique === true,
+		elements,
+		type: extras?.type,
+		options: extras?.options,
+		where: extras?.where
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
 	const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
 	return {
 		id: `index.${tableName}.${indexName}`,
@@ -473,11 +471,44 @@ async function createIndex(schemaName, tableName, indexName, columns, lowerer, e
 		operationClass: "additive",
 		target: targetDetails("index", indexName, schemaName, tableName),
 		precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
-		execute: [step(`create index "${indexName}"`, `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`)],
+		execute: [step(`create index "${indexName}"`, execute.sql, execute.params)],
 		postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)]
 	};
 }
+/**
+* `ALTER INDEX … RENAME TO`. `widening` for the same typology reason as the
+* RLS policy rename: a rename is neither additive creation nor destructive,
+* and the class vocabulary has no neutral middle class — it is NOT that a
+* rename widens anything.
+*/
+async function renameIndex(schemaName, tableName, fromName, toName, lowerer) {
+	const fromChecks = indexExistsAst(schemaName, fromName);
+	const toChecks = indexExistsAst(schemaName, toName);
+	const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.indexPresent());
+	const toAbsent = await lowerer.lowerToExecuteRequest(toChecks.indexAbsent());
+	const toPresent = await lowerer.lowerToExecuteRequest(toChecks.indexPresent());
+	const ddlNode = alterIndexRename({
+		schema: ddlSchemaOf(schemaName),
+		from: fromName,
+		to: toName
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+	return {
+		id: `index.${schemaName}.${tableName}.${fromName}.rename`,
+		label: `Rename index "${fromName}" to "${toName}" on "${tableName}"`,
+		operationClass: "widening",
+		target: targetDetails("index", toName, schemaName, tableName),
+		precheck: [step(`ensure index "${fromName}" exists`, fromPresent.sql, fromPresent.params), step(`ensure index "${toName}" does not exist`, toAbsent.sql, toAbsent.params)],
+		execute: [step(`rename index "${fromName}" to "${toName}"`, execute.sql, execute.params)],
+		postcheck: [step(`verify index "${toName}" exists`, toPresent.sql, toPresent.params)]
+	};
+}
 async function dropIndex(schemaName, tableName, indexName, lowerer) {
+	const ddlNode = dropIndex$1({
+		schema: ddlSchemaOf(schemaName),
+		name: indexName
+	});
+	const execute = await lowerer.lowerToExecuteRequest(ddlNode);
 	const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
 	return {
 		id: `dropIndex.${tableName}.${indexName}`,
@@ -485,7 +516,7 @@ async function dropIndex(schemaName, tableName, indexName, lowerer) {
 		operationClass: "destructive",
 		target: targetDetails("index", indexName, schemaName, tableName),
 		precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
-		execute: [step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`)],
+		execute: [step(`drop index "${indexName}"`, execute.sql, execute.params)],
 		postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)]
 	};
 }
@@ -1486,18 +1517,26 @@ var CreateIndexCall = class extends PostgresOpFactoryCallNode {
 	schemaName;
 	tableName;
 	indexName;
+	/** Column tuple when the index is column-based; absent for expression indexes. */
 	columns;
+	/** Opaque whole element list when the index is expression-based. */
+	expression;
 	indexType;
 	options;
+	where;
+	unique;
 	label;
-	constructor(schemaName, tableName, indexName, columns, extras) {
+	constructor(schemaName, tableName, indexName, elements, extras) {
 		super();
 		this.schemaName = schemaName;
 		this.tableName = tableName;
 		this.indexName = indexName;
-		this.columns = columns;
+		this.columns = "columns" in elements ? elements.columns : void 0;
+		this.expression = "expression" in elements ? elements.expression : void 0;
 		this.indexType = extras?.type;
 		this.options = extras?.options;
+		this.where = extras?.where;
+		this.unique = extras?.unique === true;
 		this.label = `Create index "${indexName}" on "${tableName}"`;
 		this.freeze();
 	}
@@ -1506,18 +1545,23 @@ var CreateIndexCall = class extends PostgresOpFactoryCallNode {
 		const extras = {};
 		if (this.indexType !== void 0) extras.type = this.indexType;
 		if (this.options !== void 0) extras.options = this.options;
-		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns, lowerer, extras);
+		if (this.where !== void 0) extras.where = this.where;
+		if (this.unique) extras.unique = true;
+		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns !== void 0 ? { columns: this.columns } : { expression: this.expression ?? "" }, lowerer, extras);
 	}
 	renderTypeScript() {
 		const opts = [];
 		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
 		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
 		opts.push(`index: ${jsonToTsSource(this.indexName)}`);
-		opts.push(`columns: ${jsonToTsSource(this.columns)}`);
-		if (this.indexType !== void 0 || this.options !== void 0) {
+		if (this.columns !== void 0) opts.push(`columns: ${jsonToTsSource(this.columns)}`);
+		else opts.push(`expression: ${jsonToTsSource(this.expression ?? "")}`);
+		if (this.indexType !== void 0 || this.options !== void 0 || this.where !== void 0 || this.unique) {
 			const extrasParts = [];
 			if (this.indexType !== void 0) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
 			if (this.options !== void 0) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+			if (this.where !== void 0) extrasParts.push(`where: ${jsonToTsSource(this.where)}`);
+			if (this.unique) extrasParts.push("unique: true");
 			opts.push(`extras: { ${extrasParts.join(", ")} }`);
 		}
 		return `this.createIndex({ ${opts.join(", ")} })`;
@@ -1526,6 +1570,39 @@ var CreateIndexCall = class extends PostgresOpFactoryCallNode {
 		return [];
 	}
 };
+var RenameIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "renameIndex";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	oldIndexName;
+	newIndexName;
+	label;
+	constructor(schemaName, tableName, oldIndexName, newIndexName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.oldIndexName = oldIndexName;
+		this.newIndexName = newIndexName;
+		this.label = `Rename index "${oldIndexName}" to "${newIndexName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `RenameIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.oldIndexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "RenameIndexCall" } });
+		return renameIndex(this.schemaName, this.tableName, this.oldIndexName, this.newIndexName, lowerer);
+	}
+	renderTypeScript() {
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`from: ${jsonToTsSource(this.oldIndexName)}`);
+		opts.push(`to: ${jsonToTsSource(this.newIndexName)}`);
+		return `this.renameIndex({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
 var DropIndexCall = class extends PostgresOpFactoryCallNode {
 	factoryName = "dropIndex";
 	operationClass = "destructive";
@@ -1949,6 +2026,6 @@ var RenamePostgresRlsPolicyCall = class extends PostgresOpFactoryCallNode {
 	}
 };
 //#endregion
-export { SetDefaultCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, installExtension as F, postgresDefaultToDdlColumnDefault as M, buildTargetDetails as N, RawSqlCall as O, createExtension as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, SetNotNullCall as j, RenamePostgresRlsPolicyCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
+export { RenamePostgresRlsPolicyCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, createExtension as F, installExtension as I, SetNotNullCall as M, postgresDefaultToDdlColumnDefault as N, RawSqlCall as O, buildTargetDetails as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, SetDefaultCall as j, RenameIndexCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
 
-//# sourceMappingURL=op-factory-call-BVYLIojV.mjs.map
+//# sourceMappingURL=op-factory-call-CIaPDDUc.mjs.map