@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/core/objects/materialized-view/materialized-view.diff.test.ts

@@ -0,0 +1,265 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import {
+  AlterMaterializedViewChangeOwner,
+  AlterMaterializedViewSetStorageParams,
+} from "./changes/materialized-view.alter.ts";
+import {
+  CreateCommentOnMaterializedView,
+  CreateCommentOnMaterializedViewColumn,
+  DropCommentOnMaterializedView,
+  DropCommentOnMaterializedViewColumn,
+} from "./changes/materialized-view.comment.ts";
+import { CreateMaterializedView } from "./changes/materialized-view.create.ts";
+import { DropMaterializedView } from "./changes/materialized-view.drop.ts";
+import {
+  GrantMaterializedViewPrivileges,
+  RevokeGrantOptionMaterializedViewPrivileges,
+  RevokeMaterializedViewPrivileges,
+} from "./changes/materialized-view.privilege.ts";
+import { diffMaterializedViews } from "./materialized-view.diff.ts";
+import {
+  MaterializedView,
+  type MaterializedViewProps,
+} from "./materialized-view.model.ts";
+
+const base: MaterializedViewProps = {
+  schema: "public",
+  name: "mv1",
+  definition: "select 1",
+  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: "o1",
+  comment: null,
+  columns: [],
+  privileges: [],
+};
+
+const baseColumn = {
+  name: "id",
+  position: 1,
+  data_type: "integer",
+  data_type_str: "integer",
+  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,
+};
+
+const makeMaterializedView = (override: Partial<MaterializedViewProps> = {}) =>
+  new MaterializedView({
+    ...base,
+    ...override,
+    privileges: override.privileges ?? [...base.privileges],
+    columns: override.columns ?? [...base.columns],
+  });
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("materialized-view.diff", () => {
+  test("create and drop", () => {
+    const mv = new MaterializedView(base);
+    const created = diffMaterializedViews(
+      testContext,
+      {},
+      { [mv.stableId]: mv },
+    );
+    expect(created[0]).toBeInstanceOf(CreateMaterializedView);
+    const dropped = diffMaterializedViews(
+      testContext,
+      { [mv.stableId]: mv },
+      {},
+    );
+    expect(dropped[0]).toBeInstanceOf(DropMaterializedView);
+  });
+
+  test("alter owner", () => {
+    const main = new MaterializedView(base);
+    const branch = new MaterializedView({ ...base, owner: "o2" });
+    const changes = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterMaterializedViewChangeOwner);
+  });
+
+  test("drop + create with metadata on non-alterable change", () => {
+    const main = new MaterializedView(base);
+    const branch = new MaterializedView({ ...base, definition: "select 2" });
+    const changes = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(3);
+    expect(changes[0]).toBeInstanceOf(DropMaterializedView);
+    expect(changes[1]).toBeInstanceOf(CreateMaterializedView);
+    expect(changes[2]).toBeInstanceOf(AlterMaterializedViewChangeOwner);
+  });
+
+  test("alter storage parameters: set and reset", () => {
+    const main = new MaterializedView({
+      ...base,
+      options: ["fillfactor=90", "autovacuum_enabled=false"],
+    });
+    const branch = new MaterializedView({
+      ...base,
+      options: ["fillfactor=70", "user_catalog_table=true"],
+    });
+    const changes = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterMaterializedViewSetStorageParams),
+    ).toBe(true);
+  });
+
+  test("create with comment and column comments", () => {
+    const mv = makeMaterializedView({
+      comment: "my matview",
+      columns: [
+        { ...baseColumn, comment: "id column" },
+        { ...baseColumn, name: "val", position: 2, comment: null },
+      ],
+    });
+    const changes = diffMaterializedViews(
+      testContext,
+      {},
+      { [mv.stableId]: mv },
+    );
+    expect(changes[0]).toBeInstanceOf(CreateMaterializedView);
+    expect(
+      changes.some((c) => c instanceof CreateCommentOnMaterializedView),
+    ).toBe(true);
+    expect(
+      changes.some((c) => c instanceof CreateCommentOnMaterializedViewColumn),
+    ).toBe(true);
+  });
+
+  test("create with privileges emits grant changes", () => {
+    const mv = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: false },
+      ],
+    });
+    const changes = diffMaterializedViews(
+      testContext,
+      {},
+      { [mv.stableId]: mv },
+    );
+    expect(changes[0]).toBeInstanceOf(CreateMaterializedView);
+    expect(
+      changes.some((c) => c instanceof GrantMaterializedViewPrivileges),
+    ).toBe(true);
+  });
+
+  test("comment changes emit create/drop comment statements", () => {
+    const main = makeMaterializedView();
+    const withComment = makeMaterializedView({ comment: "matview comment" });
+
+    const addComment = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnMaterializedView);
+
+    const dropComment = diffMaterializedViews(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnMaterializedView);
+  });
+
+  test("column comment changes emit create/drop column comment statements", () => {
+    const main = makeMaterializedView({
+      columns: [{ ...baseColumn, comment: null }],
+    });
+    const withColComment = makeMaterializedView({
+      columns: [{ ...baseColumn, comment: "id column" }],
+    });
+
+    const addColComment = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [withColComment.stableId]: withColComment },
+    );
+    expect(
+      addColComment.some(
+        (c) => c instanceof CreateCommentOnMaterializedViewColumn,
+      ),
+    ).toBe(true);
+
+    const dropColComment = diffMaterializedViews(
+      testContext,
+      { [withColComment.stableId]: withColComment },
+      { [main.stableId]: main },
+    );
+    expect(
+      dropColComment.some(
+        (c) => c instanceof DropCommentOnMaterializedViewColumn,
+      ),
+    ).toBe(true);
+  });
+
+  test("privilege diffs emit grant, revoke, and revoke grant option statements", () => {
+    const main = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: false },
+        { grantee: "role_with_option", privilege: "SELECT", grantable: true },
+        { grantee: "role_removed", privilege: "SELECT", grantable: false },
+      ],
+    });
+    const branch = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: true },
+        { grantee: "role_with_option", privilege: "SELECT", grantable: false },
+        { grantee: "role_new", privilege: "SELECT", grantable: false },
+      ],
+    });
+
+    const changes = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    expect(
+      changes.some((c) => c instanceof GrantMaterializedViewPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeMaterializedViewPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some(
+        (c) => c instanceof RevokeGrantOptionMaterializedViewPrivileges,
+      ),
+    ).toBe(true);
+  });
+});

package/src/core/objects/materialized-view/materialized-view.diff.ts

@@ -0,0 +1,345 @@
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  emitColumnPrivilegeChanges,
+} from "../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { diffSecurityLabels } from "../security-label.types.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterMaterializedViewChangeOwner,
+  AlterMaterializedViewSetStorageParams,
+} from "./changes/materialized-view.alter.ts";
+import {
+  CreateCommentOnMaterializedView,
+  CreateCommentOnMaterializedViewColumn,
+  DropCommentOnMaterializedView,
+  DropCommentOnMaterializedViewColumn,
+} from "./changes/materialized-view.comment.ts";
+import { CreateMaterializedView } from "./changes/materialized-view.create.ts";
+import { DropMaterializedView } from "./changes/materialized-view.drop.ts";
+import {
+  GrantMaterializedViewPrivileges,
+  RevokeGrantOptionMaterializedViewPrivileges,
+  RevokeMaterializedViewPrivileges,
+} from "./changes/materialized-view.privilege.ts";
+import {
+  CreateSecurityLabelOnMaterializedView,
+  DropSecurityLabelOnMaterializedView,
+} from "./changes/materialized-view.security-label.ts";
+import type { MaterializedViewChange } from "./changes/materialized-view.types.ts";
+import type { MaterializedView } from "./materialized-view.model.ts";
+
+export function buildCreateMaterializedViewChanges(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  mv: MaterializedView,
+): MaterializedViewChange[] {
+  const changes: MaterializedViewChange[] = [
+    new CreateMaterializedView({
+      materializedView: mv,
+    }),
+  ];
+
+  // OWNER: If the materialized view should be owned by someone other than the current user,
+  // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
+  if (mv.owner !== ctx.currentUser) {
+    changes.push(
+      new AlterMaterializedViewChangeOwner({
+        materializedView: mv,
+        owner: mv.owner,
+      }),
+    );
+  }
+
+  // Materialized view comment on creation
+  if (mv.comment !== null) {
+    changes.push(
+      new CreateCommentOnMaterializedView({
+        materializedView: mv,
+      }),
+    );
+  }
+  // Column comments on creation
+  for (const col of mv.columns) {
+    if (col.comment !== null) {
+      changes.push(
+        new CreateCommentOnMaterializedViewColumn({
+          materializedView: mv,
+          column: col,
+        }),
+      );
+    }
+  }
+
+  // Security labels on the matview itself (columns of matviews are not
+  // supported targets of SECURITY LABEL, so we only label the relation).
+  for (const label of mv.security_labels) {
+    changes.push(
+      new CreateSecurityLabelOnMaterializedView({
+        materializedView: mv,
+        securityLabel: label,
+      }),
+    );
+  }
+
+  // PRIVILEGES: For created objects, compare against default privileges state
+  // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+  // so objects are created with the default privileges state in effect.
+  // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+  // needed to reach the final desired state.
+  const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+    ctx.currentUser,
+    "materialized_view",
+    mv.schema ?? "",
+  );
+  const creatorFilteredDefaults =
+    mv.owner !== ctx.currentUser
+      ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+      : effectiveDefaults;
+  const desiredPrivileges = mv.privileges;
+  // Filter out owner privileges - owner always has ALL privileges implicitly
+  // and shouldn't be compared. Use the materialized view owner as the reference.
+  const privilegeResults = diffPrivileges(
+    creatorFilteredDefaults,
+    desiredPrivileges,
+    mv.owner,
+  );
+
+  changes.push(
+    ...(emitColumnPrivilegeChanges(
+      privilegeResults,
+      mv,
+      mv,
+      "materializedView",
+      {
+        Grant: GrantMaterializedViewPrivileges,
+        Revoke: RevokeMaterializedViewPrivileges,
+        RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+      },
+      effectiveDefaults,
+      ctx.version,
+    ) as MaterializedViewChange[]),
+  );
+
+  return changes;
+}
+
+/**
+ * Diff two sets of materialized views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The materialized views in the main catalog.
+ * @param branch - The materialized views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffMaterializedViews(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, MaterializedView>,
+  branch: Record<string, MaterializedView>,
+): MaterializedViewChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: MaterializedViewChange[] = [];
+
+  for (const materializedViewId of created) {
+    changes.push(
+      ...buildCreateMaterializedViewChanges(ctx, branch[materializedViewId]),
+    );
+  }
+
+  for (const materializedViewId of dropped) {
+    changes.push(
+      new DropMaterializedView({ materializedView: main[materializedViewId] }),
+    );
+  }
+
+  for (const materializedViewId of altered) {
+    const mainMaterializedView = main[materializedViewId];
+    const branchMaterializedView = branch[materializedViewId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the materialized view
+    const NON_ALTERABLE_FIELDS: Array<keyof MaterializedView> = [
+      "definition",
+      "row_security",
+      "force_row_security",
+      "has_indexes",
+      "has_rules",
+      "has_triggers",
+      "has_subclasses",
+      "is_populated",
+      "replica_identity",
+      "is_partition",
+      "partition_bound",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainMaterializedView,
+      branchMaterializedView,
+      NON_ALTERABLE_FIELDS,
+      { options: deepEqual },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire materialized view (drop + create)
+      changes.push(
+        new DropMaterializedView({ materializedView: mainMaterializedView }),
+        ...buildCreateMaterializedViewChanges(ctx, branchMaterializedView),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainMaterializedView.owner !== branchMaterializedView.owner) {
+        changes.push(
+          new AlterMaterializedViewChangeOwner({
+            materializedView: mainMaterializedView,
+            owner: branchMaterializedView.owner,
+          }),
+        );
+      }
+
+      // STORAGE PARAMETERS (reloptions)
+      // Emit a combined SET/RESET change similar to indexes
+      if (
+        !deepEqual(mainMaterializedView.options, branchMaterializedView.options)
+      ) {
+        const parseOptions = (options: string[] | null | undefined) => {
+          const map = new Map<string, string>();
+          if (!options) return map;
+          for (const opt of options) {
+            const eqIndex = opt.indexOf("=");
+            const key = opt.slice(0, eqIndex).trim();
+            const value = opt.slice(eqIndex + 1).trim();
+            map.set(key, value);
+          }
+          return map;
+        };
+        const mainMap = parseOptions(mainMaterializedView.options);
+        const branchMap = parseOptions(branchMaterializedView.options);
+        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(
+              newValue === undefined ? key : `${key}=${newValue}`,
+            );
+          }
+        }
+        changes.push(
+          new AlterMaterializedViewSetStorageParams({
+            materializedView: mainMaterializedView,
+            paramsToSet,
+            keysToReset,
+          }),
+        );
+      }
+
+      // Note: Materialized view renaming would also use ALTER MATERIALIZED VIEW ... RENAME TO ...
+      // But since our MaterializedView model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+      // MATERIALIZED VIEW COMMENT (create/drop when comment changes)
+      if (mainMaterializedView.comment !== branchMaterializedView.comment) {
+        if (branchMaterializedView.comment === null) {
+          changes.push(
+            new DropCommentOnMaterializedView({
+              materializedView: mainMaterializedView,
+            }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnMaterializedView({
+              materializedView: branchMaterializedView,
+            }),
+          );
+        }
+      }
+
+      // SECURITY LABELS
+      changes.push(
+        ...diffSecurityLabels<
+          | CreateSecurityLabelOnMaterializedView
+          | DropSecurityLabelOnMaterializedView
+        >(
+          mainMaterializedView.security_labels,
+          branchMaterializedView.security_labels,
+          (securityLabel) =>
+            new CreateSecurityLabelOnMaterializedView({
+              materializedView: branchMaterializedView,
+              securityLabel,
+            }),
+          (securityLabel) =>
+            new DropSecurityLabelOnMaterializedView({
+              materializedView: mainMaterializedView,
+              securityLabel,
+            }),
+        ),
+      );
+      // COMMENT changes on columns
+      const mainCols = new Map(
+        mainMaterializedView.columns.map((c) => [c.name, c]),
+      );
+      const branchCols = new Map(
+        branchMaterializedView.columns.map((c) => [c.name, c]),
+      );
+      for (const [name, branchCol] of branchCols) {
+        const mainCol = mainCols.get(name);
+        if (!mainCol) continue;
+        if (mainCol.comment !== branchCol.comment) {
+          if (branchCol.comment === null) {
+            changes.push(
+              new DropCommentOnMaterializedViewColumn({
+                materializedView: mainMaterializedView,
+                column: mainCol,
+              }),
+            );
+          } else {
+            changes.push(
+              new CreateCommentOnMaterializedViewColumn({
+                materializedView: branchMaterializedView,
+                column: branchCol,
+              }),
+            );
+          }
+        }
+      }
+
+      // PRIVILEGES (unified object and column privileges)
+      // Filter out owner privileges - owner always has ALL privileges implicitly
+      // and shouldn't be compared. Use branch owner as the reference.
+      const privilegeResults = diffPrivileges(
+        mainMaterializedView.privileges,
+        branchMaterializedView.privileges,
+        branchMaterializedView.owner,
+      );
+
+      changes.push(
+        ...(emitColumnPrivilegeChanges(
+          privilegeResults,
+          branchMaterializedView,
+          mainMaterializedView,
+          "materializedView",
+          {
+            Grant: GrantMaterializedViewPrivileges,
+            Revoke: RevokeMaterializedViewPrivileges,
+            RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+          },
+          mainMaterializedView.privileges,
+          ctx.version,
+        ) as MaterializedViewChange[]),
+      );
+    }
+  }
+
+  return changes;
+}

package/src/core/objects/materialized-view/materialized-view.model.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import {
+  extractMaterializedViews,
+  MaterializedView,
+} from "./materialized-view.model.ts";
+
+const baseRow = {
+  schema: "public",
+  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" as const,
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  owner: "postgres",
+  comment: null,
+  columns: [],
+  privileges: [],
+};
+
+const mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+const mockPoolSequence = (...attempts: unknown[][]): Pool => {
+  let i = 0;
+  return {
+    query: async () => ({
+      rows: attempts[Math.min(i++, attempts.length - 1)],
+    }),
+  } as unknown as Pool;
+};
+
+const NO_BACKOFF = { backoffMs: 0 } as const;
+
+describe("extractMaterializedViews", () => {
+  test("skips rows where pg_get_viewdef returned NULL after exhausting retries", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_mv"',
+          definition: "SELECT 1",
+        },
+        { ...baseRow, name: '"orphan_mv"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(mvs).toHaveLength(1);
+    expect(mvs[0]).toBeInstanceOf(MaterializedView);
+    expect(mvs[0]?.name).toBe('"good_mv"');
+    expect(mvs[0]?.definition).toBe("SELECT 1");
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractMaterializedViews(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all materialized views when every row has a valid definition", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPool([
+        { ...baseRow, name: '"a"', definition: "SELECT 1" },
+        { ...baseRow, name: '"b"', definition: "SELECT 2" },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(mvs.map((m) => m.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_viewdef is NULL on first attempt but resolved on retry", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_mv"', definition: null }],
+        [{ ...baseRow, name: '"racy_mv"', definition: "SELECT 42" }],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(mvs).toHaveLength(1);
+    expect(mvs[0]?.name).toBe('"racy_mv"');
+    expect(mvs[0]?.definition).toBe("SELECT 42");
+  });
+});