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

package/src/core/objects/view/changes/view.privilege.ts

@@ -0,0 +1,200 @@
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../base.privilege.ts";
+import { stableId } from "../../utils.ts";
+import type { View } from "../view.model.ts";
+import { AlterViewChange } from "./view.base.ts";
+
+export type ViewPrivilege =
+  | GrantViewPrivileges
+  | RevokeViewPrivileges
+  | RevokeGrantOptionViewPrivileges;
+
+/**
+ * Grant privileges on a view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { [ TABLE ] view_name [, ...]
+ *          | ALL TABLES IN SCHEMA schema_name [, ...] }
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantViewPrivileges extends AlterViewChange {
+  public readonly view: View;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly columns?: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    view: View;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    columns?: string[];
+    version?: number;
+  }) {
+    super();
+    this.view = props.view;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.columns = props.columns;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.view.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.view.stableId, stableId.role(this.grantee)];
+  }
+
+  serialize(): string {
+    const hasGrantable = this.privileges.some((p) => p.grantable);
+    const hasBase = this.privileges.some((p) => !p.grantable);
+    if (hasGrantable && hasBase) {
+      throw new Error(
+        "GrantViewPrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const kindPrefix = getObjectKindPrefix("VIEW");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("VIEW", list, this.version);
+    const viewName = `${this.view.schema}.${this.view.name}`;
+    const columnSpec =
+      this.columns && this.columns.length > 0
+        ? ` (${this.columns.join(", ")})`
+        : "";
+    return `GRANT ${privSql}${columnSpec} ${kindPrefix} ${viewName} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { [ TABLE ] view_name [, ...]
+ *          | ALL TABLES IN SCHEMA schema_name [, ...] }
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeViewPrivileges extends AlterViewChange {
+  public readonly view: View;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly columns?: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    view: View;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    columns?: string[];
+    version?: number;
+  }) {
+    super();
+    this.view = props.view;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.columns = props.columns;
+    this.version = props.version;
+  }
+
+  get drops() {
+    // Return ACL ID for dependency tracking, even though this is an ALTER operation
+    // Phase assignment now uses operation type, so this won't affect phase placement
+    return [stableId.acl(this.view.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.view.stableId, this.grantee),
+      this.view.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("VIEW");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("VIEW", list, this.version);
+    const viewName = `${this.view.schema}.${this.view.name}`;
+    const columnSpec =
+      this.columns && this.columns.length > 0
+        ? ` (${this.columns.join(", ")})`
+        : "";
+    return `REVOKE ${privSql}${columnSpec} ${kindPrefix} ${viewName} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a view.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionViewPrivileges extends AlterViewChange {
+  public readonly view: View;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly columns?: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    view: View;
+    grantee: string;
+    privilegeNames: string[];
+    columns?: string[];
+    version?: number;
+  }) {
+    super();
+    this.view = props.view;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.columns = props.columns;
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.view.stableId, this.grantee),
+      this.view.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("VIEW");
+    const privSql = formatObjectPrivilegeList(
+      "VIEW",
+      this.privilegeNames,
+      this.version,
+    );
+    const viewName = `${this.view.schema}.${this.view.name}`;
+    const columnSpec =
+      this.columns && this.columns.length > 0
+        ? ` (${this.columns.join(", ")})`
+        : "";
+    return `REVOKE GRANT OPTION FOR ${privSql}${columnSpec} ${kindPrefix} ${viewName} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { AlterView } from "./view.alter.ts";
+import type { CommentView } from "./view.comment.ts";
+import type { CreateView } from "./view.create.ts";
+import type { DropView } from "./view.drop.ts";
+import type { ViewPrivilege } from "./view.privilege.ts";
+
+export type ViewChange =
+  | AlterView
+  | CommentView
+  | CreateView
+  | DropView
+  | ViewPrivilege;

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

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import {
+  AlterViewChangeOwner,
+  AlterViewResetOptions,
+  AlterViewSetOptions,
+} from "./changes/view.alter.ts";
+import { CreateView } from "./changes/view.create.ts";
+import { DropView } from "./changes/view.drop.ts";
+import { diffViews } from "./view.diff.ts";
+import { View, type ViewProps } from "./view.model.ts";
+
+const base: ViewProps = {
+  schema: "public",
+  name: "v",
+  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 testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("view.diff", () => {
+  test("create and drop", () => {
+    const v = new View(base);
+    const created = diffViews(testContext, {}, { [v.stableId]: v });
+    expect(created[0]).toBeInstanceOf(CreateView);
+    const dropped = diffViews(testContext, { [v.stableId]: v }, {});
+    expect(dropped[0]).toBeInstanceOf(DropView);
+  });
+
+  test("alter owner", () => {
+    const main = new View(base);
+    const branch = new View({ ...base, owner: "o2" });
+    const changes = diffViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterViewChangeOwner);
+  });
+
+  test("alter: set and reset options", () => {
+    const main = new View({
+      ...base,
+      options: ["security_barrier=true", "check_option=local"],
+    });
+    const branch = new View({ ...base, options: ["security_barrier=false"] });
+    const changes = diffViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof AlterViewSetOptions)).toBe(true);
+    expect(changes.some((c) => c instanceof AlterViewResetOptions)).toBe(true);
+  });
+
+  test("create or replace when non-alterable property changes", () => {
+    const main = new View(base);
+    const branch = new View({
+      ...base,
+      definition: "select 2",
+      row_security: true,
+    });
+    const changes = diffViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(CreateView);
+  });
+});

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

@@ -0,0 +1,365 @@
+import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  groupPrivilegesByColumns,
+} from "../base.privilege-diff.ts";
+import type { Role } from "../role/role.model.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterViewChangeOwner,
+  AlterViewResetOptions,
+  AlterViewSetOptions,
+} from "./changes/view.alter.ts";
+import {
+  CreateCommentOnView,
+  DropCommentOnView,
+} from "./changes/view.comment.ts";
+import { CreateView } from "./changes/view.create.ts";
+import { DropView } from "./changes/view.drop.ts";
+import {
+  GrantViewPrivileges,
+  RevokeGrantOptionViewPrivileges,
+  RevokeViewPrivileges,
+} from "./changes/view.privilege.ts";
+import type { ViewChange } from "./changes/view.types.ts";
+import type { View } from "./view.model.ts";
+
+/**
+ * Diff two sets of views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The views in the main catalog.
+ * @param branch - The views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffViews(
+  ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+  },
+  main: Record<string, View>,
+  branch: Record<string, View>,
+): ViewChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: ViewChange[] = [];
+
+  for (const viewId of created) {
+    const v = branch[viewId];
+    changes.push(new CreateView({ view: v }));
+
+    // OWNER: If the view should be owned by someone other than the current user,
+    // emit ALTER VIEW ... OWNER TO after creation
+    if (v.owner !== ctx.currentUser) {
+      changes.push(new AlterViewChangeOwner({ view: v, owner: v.owner }));
+    }
+
+    if (v.comment !== null) {
+      changes.push(new CreateCommentOnView({ view: v }));
+    }
+
+    // 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,
+      "view",
+      v.schema ?? "",
+    );
+    const desiredPrivileges = v.privileges;
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Use the view owner as the reference.
+    const privilegeResults = diffPrivileges(
+      effectiveDefaults,
+      desiredPrivileges,
+      v.owner,
+      ctx.mainRoles,
+    );
+
+    // Generate grant changes
+    for (const [grantee, result] of privilegeResults) {
+      if (result.grants.length > 0) {
+        const grantGroups = groupPrivilegesByColumns(result.grants);
+        for (const [, group] of grantGroups) {
+          for (const [grantable, privSet] of group.byGrant) {
+            const privileges = Array.from(privSet).map((priv) => ({
+              privilege: priv,
+              grantable,
+            }));
+            changes.push(
+              new GrantViewPrivileges({
+                view: v,
+                grantee,
+                privileges,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+      }
+
+      // Generate revoke changes
+      if (result.revokes.length > 0) {
+        const revokeGroups = groupPrivilegesByColumns(result.revokes);
+        for (const [, group] of revokeGroups) {
+          const allPrivileges = new Set<string>();
+          for (const [, privSet] of group.byGrant) {
+            for (const priv of privSet) {
+              allPrivileges.add(priv);
+            }
+          }
+          const privileges = Array.from(allPrivileges).map((priv) => ({
+            privilege: priv,
+            grantable: false,
+          }));
+          changes.push(
+            new RevokeViewPrivileges({
+              view: v,
+              grantee,
+              privileges,
+              columns: group.columns,
+              version: ctx.version,
+            }),
+          );
+        }
+      }
+
+      // Generate revoke grant option changes
+      if (result.revokeGrantOption.length > 0) {
+        const revokeGrantGroups = new Map<
+          string,
+          { columns?: string[]; privileges: Set<string> }
+        >();
+        for (const r of result.revokeGrantOption) {
+          // For revoke grant option, we need to find the columns from the effective defaults
+          const originalPriv = effectiveDefaults.find(
+            (p) => p.grantee === grantee && p.privilege === r,
+          );
+          const key = originalPriv?.columns
+            ? originalPriv.columns.sort().join(",")
+            : "";
+          if (!revokeGrantGroups.has(key)) {
+            revokeGrantGroups.set(key, {
+              columns: originalPriv?.columns
+                ? [...originalPriv.columns]
+                : undefined,
+              privileges: new Set(),
+            });
+          }
+          const group = revokeGrantGroups.get(key);
+          if (!group) continue;
+          group.privileges.add(r);
+        }
+        for (const [, group] of revokeGrantGroups) {
+          const privilegeNames = Array.from(group.privileges);
+          changes.push(
+            new RevokeGrantOptionViewPrivileges({
+              view: v,
+              grantee,
+              privilegeNames,
+              columns: group.columns,
+              version: ctx.version,
+            }),
+          );
+        }
+      }
+    }
+  }
+
+  for (const viewId of dropped) {
+    changes.push(new DropView({ view: main[viewId] }));
+  }
+
+  for (const viewId of altered) {
+    const mainView = main[viewId];
+    const branchView = branch[viewId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the view
+    const NON_ALTERABLE_FIELDS: Array<keyof View> = [
+      "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(
+      mainView,
+      branchView,
+      NON_ALTERABLE_FIELDS,
+      { options: deepEqual },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire view using CREATE OR REPLACE to avoid drop when possible
+      changes.push(new CreateView({ view: branchView, orReplace: true }));
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainView.owner !== branchView.owner) {
+        changes.push(
+          new AlterViewChangeOwner({ view: mainView, owner: branchView.owner }),
+        );
+      }
+
+      // VIEW OPTIONS (WITH (...))
+      if (!deepEqual(mainView.options, branchView.options)) {
+        const mainOpts = mainView.options ?? [];
+        const branchOpts = branchView.options ?? [];
+
+        // Always set branch options when provided
+        if (branchOpts.length > 0) {
+          changes.push(
+            new AlterViewSetOptions({ view: mainView, options: branchOpts }),
+          );
+        }
+
+        // Reset any params that are present in main but absent in branch
+        if (mainOpts.length > 0) {
+          const mainNames = new Set(mainOpts.map((opt) => opt.split("=")[0]));
+          const branchNames = new Set(
+            branchOpts.map((opt) => opt.split("=")[0]),
+          );
+          const removed: string[] = [];
+          for (const name of mainNames) {
+            if (!branchNames.has(name)) removed.push(name);
+          }
+          if (removed.length > 0) {
+            changes.push(
+              new AlterViewResetOptions({ view: mainView, params: removed }),
+            );
+          }
+        }
+      }
+
+      // COMMENT
+      if (mainView.comment !== branchView.comment) {
+        if (branchView.comment === null) {
+          changes.push(new DropCommentOnView({ view: mainView }));
+        } else {
+          changes.push(new CreateCommentOnView({ view: branchView }));
+        }
+      }
+
+      // Note: View renaming would also use ALTER VIEW ... RENAME TO ...
+      // But since our View model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+
+      // 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(
+        mainView.privileges,
+        branchView.privileges,
+        branchView.owner,
+        ctx.mainRoles,
+      );
+
+      for (const [grantee, result] of privilegeResults) {
+        // Generate grant changes
+        if (result.grants.length > 0) {
+          const grantGroups = groupPrivilegesByColumns(result.grants);
+          for (const [, group] of grantGroups) {
+            for (const [grantable, privSet] of group.byGrant) {
+              const privileges = Array.from(privSet).map((priv) => ({
+                privilege: priv,
+                grantable,
+              }));
+              changes.push(
+                new GrantViewPrivileges({
+                  view: branchView,
+                  grantee,
+                  privileges,
+                  columns: group.columns,
+                  version: ctx.version,
+                }),
+              );
+            }
+          }
+        }
+
+        // Generate revoke changes
+        if (result.revokes.length > 0) {
+          const revokeGroups = groupPrivilegesByColumns(result.revokes);
+          for (const [, group] of revokeGroups) {
+            // Collapse all grantable groups into a single revoke (grantable: false)
+            const allPrivileges = new Set<string>();
+            for (const [, privSet] of group.byGrant) {
+              for (const priv of privSet) {
+                allPrivileges.add(priv);
+              }
+            }
+            const privileges = Array.from(allPrivileges).map((priv) => ({
+              privilege: priv,
+              grantable: false,
+            }));
+            changes.push(
+              new RevokeViewPrivileges({
+                view: mainView,
+                grantee,
+                privileges,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+
+        // Generate revoke grant option changes
+        if (result.revokeGrantOption.length > 0) {
+          const revokeGrantGroups = new Map<
+            string,
+            { columns?: string[]; privileges: Set<string> }
+          >();
+          for (const r of result.revokeGrantOption) {
+            // For revoke grant option, we need to find the columns from the original privilege
+            const originalPriv = mainView.privileges.find(
+              (p) => p.grantee === grantee && p.privilege === r,
+            );
+            const key = originalPriv?.columns
+              ? originalPriv.columns.sort().join(",")
+              : "";
+            if (!revokeGrantGroups.has(key)) {
+              revokeGrantGroups.set(key, {
+                columns: originalPriv?.columns
+                  ? [...originalPriv.columns]
+                  : undefined,
+                privileges: new Set(),
+              });
+            }
+            const group = revokeGrantGroups.get(key);
+            if (!group) continue;
+            group.privileges.add(r);
+          }
+          for (const [, group] of revokeGrantGroups) {
+            const privilegeNames = Array.from(group.privileges);
+            changes.push(
+              new RevokeGrantOptionViewPrivileges({
+                view: mainView,
+                grantee,
+                privilegeNames,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return changes;
+}