@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.4

package/src/core/objects/index/changes/index.create.ts

@@ -0,0 +1,68 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import { stableId } from "../../utils.ts";
+import type { Index } from "../index.model.ts";
+import { CreateIndexChange } from "./index.base.ts";
+import { checkIsSerializable } from "./utils.ts";
+
+/**
+ * Create an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createindex.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ]
+ *     ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
+ *     [ INCLUDE ( column_name [, ...] ) ]
+ *     [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ *     [ TABLESPACE tablespace_name ]
+ *     [ WHERE predicate ]
+ * ```
+ */
+
+export class CreateIndex extends CreateIndexChange {
+  public readonly index: Index;
+  public readonly indexableObject?: TableLikeObject;
+  public readonly scope = "object" as const;
+
+  constructor(props: { index: Index; indexableObject?: TableLikeObject }) {
+    super();
+    checkIsSerializable(props.index, props.indexableObject);
+    this.index = props.index;
+    this.indexableObject = props.indexableObject;
+  }
+
+  get creates() {
+    return [this.index.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.index.schema));
+
+    // Table dependency
+    dependencies.add(stableId.table(this.index.schema, this.index.table_name));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.index.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    let definition = this.index.definition;
+
+    // btree being the default, we can omit it
+    definition = definition.replace(" USING btree", "");
+
+    // Remove "ON ONLY" for partitioned indexes to allow automatic propagation to partitions.
+    // Preserve "ON ONLY" for non-partitioned indexes on partitioned tables (explicit user intent).
+    if (this.index.is_partitioned_index) {
+      definition = definition.replace(/\s+ON\s+ONLY\s+/i, " ON ");
+    }
+
+    return definition;
+  }
+}

package/src/core/objects/index/changes/index.drop.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { Index } from "../index.model.ts";
+import { DropIndex } from "./index.drop.ts";
+
+describe("index", () => {
+  test("drop", () => {
+    const index = new Index({
+      schema: "public",
+      table_name: "test_table",
+      name: "test_index",
+      storage_params: [],
+      statistics_target: [0],
+      index_type: "btree",
+      tablespace: null,
+      is_unique: false,
+      is_primary: false,
+      is_owned_by_constraint: false,
+      is_exclusion: false,
+      nulls_not_distinct: false,
+      immediate: true,
+      is_clustered: false,
+      is_replica_identity: false,
+      key_columns: [1],
+      column_collations: [],
+      operator_classes: [],
+      column_options: [],
+      index_expressions: null,
+      partial_predicate: null,
+      table_relkind: "r",
+      is_partitioned_index: false,
+      is_index_partition: false,
+      parent_index_name: null,
+      definition: "CREATE INDEX test_index ON public.test_table (id)",
+      comment: null,
+      owner: "test",
+    });
+
+    const change = new DropIndex({
+      index,
+    });
+
+    expect(change.serialize()).toBe("DROP INDEX public.test_index");
+  });
+});

package/src/core/objects/index/changes/index.drop.ts

@@ -0,0 +1,34 @@
+import type { Index } from "../index.model.ts";
+import { DropIndexChange } from "./index.base.ts";
+
+/**
+ * Drop an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropindex.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP INDEX [ CONCURRENTLY ] [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropIndex extends DropIndexChange {
+  public readonly index: Index;
+  public readonly scope = "object" as const;
+
+  constructor(props: { index: Index }) {
+    super();
+    this.index = props.index;
+  }
+
+  get drops() {
+    return [this.index.stableId];
+  }
+
+  get requires() {
+    return [this.index.stableId];
+  }
+
+  serialize(): string {
+    return ["DROP INDEX", `${this.index.schema}.${this.index.name}`].join(" ");
+  }
+}

package/src/core/objects/index/changes/index.types.ts

@@ -0,0 +1,6 @@
+import type { AlterIndex } from "./index.alter.ts";
+import type { CommentIndex } from "./index.comment.ts";
+import type { CreateIndex } from "./index.create.ts";
+import type { DropIndex } from "./index.drop.ts";
+
+export type IndexChange = AlterIndex | CommentIndex | CreateIndex | DropIndex;

package/src/core/objects/index/changes/utils.ts

@@ -0,0 +1,16 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Index } from "../index.model.ts";
+
+export function checkIsSerializable(
+  index: Index,
+  indexableObject?: TableLikeObject,
+) {
+  if (
+    index.index_expressions === null &&
+    (indexableObject === undefined || indexableObject.columns.length === 0)
+  ) {
+    throw new Error(
+      "Index requires an indexableObject with columns when key_columns are used",
+    );
+  }
+}

package/src/core/objects/index/index.diff.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test";
+import {
+  AlterIndexSetStatistics,
+  AlterIndexSetStorageParams,
+  AlterIndexSetTablespace,
+} from "./changes/index.alter.ts";
+import { CreateIndex } from "./changes/index.create.ts";
+import { DropIndex } from "./changes/index.drop.ts";
+import { diffIndexes } from "./index.diff.ts";
+import { Index, type IndexProps } from "./index.model.ts";
+
+const base: IndexProps = {
+  schema: "public",
+  table_name: "t",
+  name: "ix",
+  storage_params: [],
+  statistics_target: [0],
+  index_type: "btree",
+  tablespace: null,
+  is_unique: false,
+  is_primary: false,
+  is_exclusion: false,
+  nulls_not_distinct: false,
+  immediate: true,
+  is_clustered: false,
+  is_replica_identity: false,
+  key_columns: [],
+  column_collations: [],
+  operator_classes: [],
+  column_options: [],
+  index_expressions: "expression",
+  partial_predicate: null,
+  table_relkind: "r",
+  is_owned_by_constraint: false,
+  is_partitioned_index: false,
+  is_index_partition: false,
+  parent_index_name: null,
+  definition: "CREATE INDEX ix ON t (expression)",
+  comment: null,
+  owner: "test",
+};
+
+describe.concurrent("index.diff", () => {
+  test("create and drop", () => {
+    const idx = new Index(base);
+    const created = diffIndexes({}, { [idx.stableId]: idx }, {});
+    expect(created[0]).toBeInstanceOf(CreateIndex);
+    const dropped = diffIndexes(
+      { [idx.stableId]: idx },
+      {},
+      {
+        [idx.tableStableId]: {
+          columns: [],
+        },
+      },
+    );
+    expect(dropped[0]).toBeInstanceOf(DropIndex);
+  });
+
+  test("alter storage params, statistics and tablespace", () => {
+    const main = new Index(base);
+    const branch = new Index({
+      ...base,
+      storage_params: ["fillfactor=90"],
+      statistics_target: [100],
+      tablespace: "ts",
+    });
+    const changes = diffIndexes(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+      {},
+    );
+    expect(changes.some((c) => c instanceof AlterIndexSetStorageParams)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof AlterIndexSetStatistics)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof AlterIndexSetTablespace)).toBe(
+      true,
+    );
+  });
+
+  test("create index with key columns and no index_expressions should fail if no indexableObject is provided", () => {
+    const main = new Index(base);
+    const branch = new Index({
+      ...base,
+      key_columns: [1],
+      index_expressions: null,
+    });
+    expect(() =>
+      diffIndexes({ [main.stableId]: main }, { [branch.stableId]: branch }, {}),
+    ).toThrowError(
+      "Index requires an indexableObject with columns when key_columns are used",
+    );
+  });
+
+  test("create index with key columns and valid indexableObject should work", () => {
+    const branch = new Index({
+      ...base,
+      key_columns: [1],
+      index_expressions: null,
+      definition: "CREATE INDEX ix ON t (col1)",
+    });
+    const changes = diffIndexes(
+      {},
+      { [branch.stableId]: branch },
+      {
+        [branch.tableStableId]: {
+          columns: [
+            {
+              name: "col1",
+              position: 1,
+              data_type: "text",
+              data_type_str: "text",
+              is_custom_type: false,
+              custom_type_type: null,
+              custom_type_category: null,
+              custom_type_schema: null,
+              custom_type_name: null,
+              not_null: false,
+              is_identity: false,
+              is_identity_always: false,
+              is_generated: false,
+              collation: null,
+              default: null,
+              comment: null,
+            },
+          ],
+        },
+      },
+    );
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(CreateIndex);
+  });
+
+  test("drop and create when non-alterable property changes", () => {
+    const main = new Index(base);
+    const branch = new Index({
+      ...base,
+      index_type: "hash",
+      is_unique: true,
+    });
+    const changes = diffIndexes(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+      {},
+    );
+    expect(changes).toHaveLength(2);
+    expect(changes[0]).toBeInstanceOf(DropIndex);
+    expect(changes[1]).toBeInstanceOf(CreateIndex);
+  });
+});

package/src/core/objects/index/index.diff.ts

@@ -0,0 +1,243 @@
+import { diffObjects } from "../base.diff.ts";
+import type { TableLikeObject } from "../base.model.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterIndexSetStatistics,
+  AlterIndexSetStorageParams,
+  AlterIndexSetTablespace,
+} from "./changes/index.alter.ts";
+import {
+  CreateCommentOnIndex,
+  DropCommentOnIndex,
+} from "./changes/index.comment.ts";
+import { CreateIndex } from "./changes/index.create.ts";
+import { DropIndex } from "./changes/index.drop.ts";
+import type { IndexChange } from "./changes/index.types.ts";
+import type { Index } from "./index.model.ts";
+
+/**
+ * Diff two sets of indexes from main and branch catalogs.
+ *
+ * @param main - The indexes in the main catalog.
+ * @param branch - The indexes in the branch catalog.
+ * @param branchIndexableObjects - Table-like objects (tables, materialized views) in branch.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffIndexes(
+  main: Record<string, Index>,
+  branch: Record<string, Index>,
+  branchIndexableObjects: Record<string, TableLikeObject>,
+): IndexChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: IndexChange[] = [];
+
+  for (const indexId of created) {
+    const index = branch[indexId];
+    // Skip constraint-owned or primary indexes; they are created by constraint DDL
+    if (index.is_owned_by_constraint || index.is_primary) {
+      continue;
+    }
+
+    // Skip index partitions - they are automatically created when the parent partitioned index is created
+    if (index.is_index_partition) {
+      continue;
+    }
+
+    changes.push(
+      new CreateIndex({
+        index,
+        indexableObject: branchIndexableObjects[index.tableStableId],
+      }),
+    );
+    if (index.comment !== null) {
+      changes.push(new CreateCommentOnIndex({ index }));
+    }
+  }
+
+  for (const indexId of dropped) {
+    const index = main[indexId];
+    // Constraint-owned or primary indexes are handled by constraint/table drops
+    if (
+      index.is_owned_by_constraint ||
+      index.is_primary ||
+      !branchIndexableObjects[index.tableStableId]
+    ) {
+      continue;
+    }
+
+    // Skip index partitions - they are automatically dropped when the parent partitioned index is dropped
+    if (index.is_index_partition) {
+      continue;
+    }
+
+    changes.push(new DropIndex({ index: main[indexId] }));
+  }
+
+  for (const indexId of altered) {
+    const mainIndex = main[indexId];
+    const branchIndex = branch[indexId];
+
+    // Constraint-owned or primary indexes are handled by constraint/table DDL
+    if (mainIndex.is_owned_by_constraint || mainIndex.is_primary) {
+      continue;
+    }
+    if (branchIndex.is_owned_by_constraint || branchIndex.is_primary) {
+      continue;
+    }
+
+    // Skip index partitions - they are automatically updated when the parent partitioned index is updated
+    if (mainIndex.is_index_partition || branchIndex.is_index_partition) {
+      continue;
+    }
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the index
+    // Note: key_columns is excluded because it contains attribute numbers that can differ
+    // between databases even when indexes are logically identical. The definition field
+    // already captures the logical structure using column names, so we compare by definition instead.
+    const NON_ALTERABLE_FIELDS: Array<keyof Index> = [
+      "index_type",
+      "is_unique",
+      "is_primary",
+      "is_exclusion",
+      "nulls_not_distinct",
+      "immediate",
+      "is_clustered",
+      "is_replica_identity",
+      "column_collations",
+      "operator_classes",
+      "column_options",
+      "index_expressions",
+      "partial_predicate",
+      "definition", // Compare by definition instead of key_columns
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainIndex,
+      branchIndex,
+      NON_ALTERABLE_FIELDS,
+      {
+        column_collations: deepEqual,
+        operator_classes: deepEqual,
+        column_options: deepEqual,
+        definition: (a, b) => {
+          // Normalize definitions by removing "USING btree" (default) for comparison
+          const normalize = (def: string) =>
+            def.replace(/\s+USING\s+btree/gi, "");
+          return normalize(a as string) === normalize(b as string);
+        },
+      },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire index (drop + create)
+      changes.push(
+        new DropIndex({ index: mainIndex }),
+        new CreateIndex({
+          index: branchIndex,
+          indexableObject: branchIndexableObjects[branchIndex.tableStableId],
+        }),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // STORAGE PARAMS
+      if (
+        JSON.stringify(mainIndex.storage_params) !==
+        JSON.stringify(branchIndex.storage_params)
+      ) {
+        const parseOptions = (options: string[]) => {
+          const map = new Map<string, string>();
+          for (const opt of options) {
+            const eqIndex = opt.indexOf("=");
+            const key = opt.slice(0, eqIndex);
+            const value = opt.slice(eqIndex + 1);
+            map.set(key, value);
+          }
+          return map;
+        };
+
+        const mainMap = parseOptions(mainIndex.storage_params);
+        const branchMap = parseOptions(branchIndex.storage_params);
+
+        const keysToReset: string[] = [];
+        for (const key of mainMap.keys()) {
+          if (!branchMap.has(key)) {
+            keysToReset.push(key);
+          }
+        }
+
+        const paramsToSet: string[] = [];
+        for (const [key, newValue] of branchMap.entries()) {
+          const oldValue = mainMap.get(key);
+          const changed = oldValue !== newValue;
+          if (changed) {
+            paramsToSet.push(`${key}=${newValue}`);
+          }
+        }
+
+        changes.push(
+          new AlterIndexSetStorageParams({
+            index: mainIndex,
+            paramsToSet,
+            keysToReset,
+          }),
+        );
+      }
+
+      // STATISTICS TARGET
+      if (
+        JSON.stringify(mainIndex.statistics_target) !==
+        JSON.stringify(branchIndex.statistics_target)
+      ) {
+        const columnTargets: Array<{
+          columnNumber: number;
+          statistics: number;
+        }> = [];
+        const mainTargets = mainIndex.statistics_target;
+        const branchTargets = branchIndex.statistics_target;
+        const length = Math.max(mainTargets.length, branchTargets.length);
+        for (let i = 0; i < length; i++) {
+          const oldVal = mainTargets[i];
+          const newVal = branchTargets[i];
+          if (oldVal !== newVal && newVal !== undefined) {
+            columnTargets.push({ columnNumber: i + 1, statistics: newVal });
+          }
+        }
+        if (columnTargets.length > 0) {
+          changes.push(
+            new AlterIndexSetStatistics({ index: mainIndex, columnTargets }),
+          );
+        }
+      }
+
+      // TABLESPACE
+      if (mainIndex.tablespace !== branchIndex.tablespace) {
+        const nextTablespace = branchIndex.tablespace;
+        if (nextTablespace !== null) {
+          changes.push(
+            new AlterIndexSetTablespace({
+              index: mainIndex,
+              tablespace: nextTablespace,
+            }),
+          );
+        }
+      }
+
+      // COMMENT
+      if (mainIndex.comment !== branchIndex.comment) {
+        if (branchIndex.comment === null) {
+          changes.push(new DropCommentOnIndex({ index: mainIndex }));
+        } else {
+          changes.push(new CreateCommentOnIndex({ index: branchIndex }));
+        }
+      }
+
+      // Note: Index renaming would also use ALTER INDEX ... RENAME TO ...
+      // But since our Index model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+    }
+  }
+
+  return changes;
+}