@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/core/objects/materialized-view/changes/materialized-view.alter.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import {
+  MaterializedView,
+  type MaterializedViewProps,
+} from "../materialized-view.model.ts";
+import {
+  AlterMaterializedViewChangeOwner,
+  AlterMaterializedViewSetStorageParams,
+} from "./materialized-view.alter.ts";
+
+describe.concurrent("materialized-view", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: Omit<MaterializedViewProps, "owner"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        options: null,
+        partition_bound: null,
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterMaterializedViewChangeOwner({
+        materializedView,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER MATERIALIZED VIEW public.test_mv OWNER TO new_owner",
+      );
+    });
+
+    test("set storage params", async () => {
+      const props: Omit<MaterializedViewProps, "options"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        partition_bound: null,
+        owner: "test",
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        options: [],
+      });
+
+      const change = new AlterMaterializedViewSetStorageParams({
+        materializedView,
+        paramsToSet: ["fillfactor=90"],
+        keysToReset: [],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER MATERIALIZED VIEW public.test_mv SET (fillfactor=90)",
+      );
+    });
+
+    test("reset and set storage params", async () => {
+      const props: Omit<MaterializedViewProps, "options"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        partition_bound: null,
+        owner: "test",
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        options: ["fillfactor=70", "autovacuum_enabled=false"],
+      });
+
+      const change = new AlterMaterializedViewSetStorageParams({
+        materializedView,
+        paramsToSet: ["fillfactor=90", "user_catalog_table=true"],
+        keysToReset: ["autovacuum_enabled"],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        [
+          "ALTER MATERIALIZED VIEW public.test_mv RESET (autovacuum_enabled)",
+          "ALTER MATERIALIZED VIEW public.test_mv SET (fillfactor=90, user_catalog_table=true)",
+        ].join(";\n"),
+      );
+    });
+  });
+});

package/src/core/objects/materialized-view/changes/materialized-view.alter.ts

@@ -0,0 +1,113 @@
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { AlterMaterializedViewChange } from "./materialized-view.base.ts";
+
+/**
+ * Alter a materialized view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altermaterializedview.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ *     action [, ... ]
+ * where action is one of:
+ *     ALTER [ COLUMN ] column_name SET STATISTICS integer
+ *     ALTER [ COLUMN ] column_name SET ( attribute_option = value [, ... ] )
+ *     ALTER [ COLUMN ] column_name RESET ( attribute_option [, ... ] )
+ *     ALTER [ COLUMN ] column_name SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
+ *     CLUSTER ON index_name
+ *     SET WITHOUT CLUSTER
+ *     SET ( storage_parameter [= value] [, ... ] )
+ *     RESET ( storage_parameter [, ... ] )
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ *     RENAME TO new_name
+ *     SET SCHEMA new_schema
+ * ```
+ *
+ * Notes for diff-based generation:
+ * - We currently only emit OWNER TO when owner differs.
+ * - Name/schema changes are treated as identity changes; handled as drop/create by the diff engine.
+ * - Column attribute changes, CLUSTER are not modeled and thus not emitted.
+ * - Changes to definition, options, and other non-alterable properties trigger a replace (drop + create).
+ */
+
+export type AlterMaterializedView =
+  | AlterMaterializedViewChangeOwner
+  | AlterMaterializedViewSetStorageParams;
+
+/**
+ * ALTER MATERIALIZED VIEW ... OWNER TO ...
+ */
+export class AlterMaterializedViewChangeOwner extends AlterMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { materializedView: MaterializedView; owner: string }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER MATERIALIZED VIEW ... SET/RESET ( storage_parameter ... )
+ * Accepts main and branch, computes differences, and emits RESET then SET statements.
+ */
+export class AlterMaterializedViewSetStorageParams extends AlterMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly paramsToSet: string[];
+  public readonly keysToReset: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    paramsToSet: string[];
+    keysToReset: string[];
+  }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.paramsToSet = props.paramsToSet;
+    this.keysToReset = props.keysToReset;
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(): string {
+    const head = [
+      "ALTER MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+    ].join(" ");
+
+    const statements: string[] = [];
+    if (this.keysToReset.length > 0) {
+      statements.push(`${head} RESET (${this.keysToReset.join(", ")})`);
+    }
+    if (this.paramsToSet.length > 0) {
+      statements.push(`${head} SET (${this.paramsToSet.join(", ")})`);
+    }
+
+    return statements.join(";\n");
+  }
+}
+
+/**
+ * Replace a materialized view by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER MATERIALIZED VIEW change.
+ */
+// NOTE: ReplaceMaterializedView removed. Non-alterable changes are emitted as Drop + Create in materialized-view.diff.ts.

package/src/core/objects/materialized-view/changes/materialized-view.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+
+abstract class BaseMaterializedViewChange extends BaseChange {
+  abstract readonly materializedView: MaterializedView;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "materialized_view" = "materialized_view";
+}
+
+export abstract class CreateMaterializedViewChange extends BaseMaterializedViewChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterMaterializedViewChange extends BaseMaterializedViewChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropMaterializedViewChange extends BaseMaterializedViewChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/materialized-view/changes/materialized-view.comment.ts

@@ -0,0 +1,176 @@
+import { quoteLiteral } from "../../base.change.ts";
+import type { ColumnProps } from "../../base.model.ts";
+import { stableId } from "../../utils.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+import {
+  CreateMaterializedViewChange,
+  DropMaterializedViewChange,
+} from "./materialized-view.base.ts";
+
+export type CommentMaterializedView =
+  | CreateCommentOnMaterializedView
+  | CreateCommentOnMaterializedViewColumn
+  | DropCommentOnMaterializedView
+  | DropCommentOnMaterializedViewColumn;
+
+/**
+ * Create/drop comments on materialized view columns.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-comment.html
+ */
+
+export class CreateCommentOnMaterializedView extends CreateMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    super();
+    this.materializedView = props.materializedView;
+  }
+
+  get creates() {
+    return [stableId.comment(this.materializedView.stableId)];
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: mv comment is not nullable in this case
+      quoteLiteral(this.materializedView.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnMaterializedView extends DropMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    super();
+    this.materializedView = props.materializedView;
+  }
+
+  get drops() {
+    return [stableId.comment(this.materializedView.stableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(this.materializedView.stableId),
+      this.materializedView.stableId,
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}
+
+export class CreateCommentOnMaterializedViewColumn extends CreateMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    column: ColumnProps;
+  }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.column = props.column;
+  }
+
+  get creates() {
+    return [
+      stableId.comment(
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          this.column.name,
+        ),
+      ),
+    ];
+  }
+
+  get requires() {
+    return [
+      stableId.column(
+        this.materializedView.schema,
+        this.materializedView.name,
+        this.column.name,
+      ),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON COLUMN",
+      `${this.materializedView.schema}.${this.materializedView.name}.${this.column.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: column comment is not nullable in this case
+      quoteLiteral(this.column.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnMaterializedViewColumn extends DropMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    column: ColumnProps;
+  }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.column = props.column;
+  }
+
+  get drops() {
+    return [
+      stableId.comment(
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          this.column.name,
+        ),
+      ),
+    ];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          this.column.name,
+        ),
+      ),
+      stableId.column(
+        this.materializedView.schema,
+        this.materializedView.name,
+        this.column.name,
+      ),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON COLUMN",
+      `${this.materializedView.schema}.${this.materializedView.name}.${this.column.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

package/src/core/objects/materialized-view/changes/materialized-view.create.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedView } from "./materialized-view.create.ts";
+
+describe("materialized-view", () => {
+  test("create minimal", async () => {
+    const mv = new MaterializedView({
+      schema: "public",
+      name: "test_mv",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      // Default is WITH NO DATA -> omitted
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "test",
+      columns: [],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateMaterializedView({ materializedView: mv });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE MATERIALIZED VIEW public.test_mv AS SELECT * FROM test_table WITH NO DATA",
+    );
+  });
+
+  test("create with all options", async () => {
+    const mv = new MaterializedView({
+      schema: "public",
+      name: "test_mv",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: true,
+      replica_identity: "d",
+      is_partition: false,
+      options: ["fillfactor=90", "autovacuum_enabled=false"],
+      partition_bound: null,
+      owner: "test",
+      columns: [],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateMaterializedView({ materializedView: mv });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE MATERIALIZED VIEW public.test_mv WITH (fillfactor=90, autovacuum_enabled=false) AS SELECT * FROM test_table WITH DATA",
+    );
+  });
+});

package/src/core/objects/materialized-view/changes/materialized-view.create.ts

@@ -0,0 +1,93 @@
+import { stableId } from "../../utils.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedViewChange } from "./materialized-view.base.ts";
+
+/**
+ * Create a materialized view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-creatematerializedview.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] table_name
+ *     [ (column_name [, ...] ) ]
+ *     [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ *     [ TABLESPACE tablespace_name ]
+ *     AS query
+ *     [ WITH [ NO ] DATA ]
+ * ```
+ *
+ * Notes for diff-based generation:
+ * - IF NOT EXISTS is omitted: diffs are deterministic and explicit.
+ * - (column_name, ...) list is derived from the SELECT query; we don't emit it.
+ * - TABLESPACE is not currently modeled/extracted and is not emitted.
+ * - WITH (options) is emitted only when non-empty.
+ * - WITH NO DATA is always emitted when is_populated is false to ensure correct state.
+ * - WITH DATA is emitted when is_populated is true.
+ */
+export class CreateMaterializedView extends CreateMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "object" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    super();
+    this.materializedView = props.materializedView;
+  }
+
+  get creates() {
+    return [
+      this.materializedView.stableId,
+      ...this.materializedView.columns.map((column) =>
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          column.name,
+        ),
+      ),
+    ];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.materializedView.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.materializedView.owner));
+
+    // Note: Materialized view definition dependencies are handled via pg_depend
+    // for existing objects. For new objects, parsing the SQL definition would be complex.
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE MATERIALIZED VIEW"];
+
+    // Add schema and name
+    parts.push(`${this.materializedView.schema}.${this.materializedView.name}`);
+
+    // Add storage parameters if specified
+    if (
+      this.materializedView.options &&
+      this.materializedView.options.length > 0
+    ) {
+      parts.push("WITH", `(${this.materializedView.options.join(", ")})`);
+    }
+
+    // Add AS query (definition is required)
+    parts.push("AS", this.materializedView.definition.trim());
+
+    // Add population clause to match the desired state
+    // PostgreSQL defaults to WITH NO DATA, but we need to be explicit to ensure
+    // the created view matches the expected is_populated state
+    if (this.materializedView.is_populated) {
+      parts.push("WITH DATA");
+    } else {
+      parts.push("WITH NO DATA");
+    }
+
+    return parts.join(" ");
+  }
+}

package/src/core/objects/materialized-view/changes/materialized-view.drop.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { MaterializedView } from "../materialized-view.model.ts";
+import { DropMaterializedView } from "./materialized-view.drop.ts";
+
+describe("materialized-view", () => {
+  test("drop", async () => {
+    const materializedView = new MaterializedView({
+      schema: "public",
+      name: "test_mv",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: true,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new DropMaterializedView({
+      materializedView,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP MATERIALIZED VIEW public.test_mv");
+  });
+});

package/src/core/objects/materialized-view/changes/materialized-view.drop.ts

@@ -0,0 +1,60 @@
+import { stableId } from "../../utils.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { DropMaterializedViewChange } from "./materialized-view.base.ts";
+
+/**
+ * Drop a materialized view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropmaterializedview.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP MATERIALIZED VIEW [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ *
+ * Notes for diff-based generation:
+ * - IF EXISTS is omitted for deterministic diffs; the object must exist in the source.
+ * - We do not emit CASCADE; dependency ordering ensures safe drops, and RESTRICT is default.
+ */
+export class DropMaterializedView extends DropMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "object" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    super();
+    this.materializedView = props.materializedView;
+  }
+
+  get drops() {
+    return [
+      this.materializedView.stableId,
+      ...this.materializedView.columns.map((column) =>
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          column.name,
+        ),
+      ),
+    ];
+  }
+
+  get requires() {
+    return [
+      this.materializedView.stableId,
+      ...this.materializedView.columns.map((column) =>
+        stableId.column(
+          this.materializedView.schema,
+          this.materializedView.name,
+          column.name,
+        ),
+      ),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "DROP MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+    ].join(" ");
+  }
+}