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

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

@@ -0,0 +1,188 @@
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../base.privilege.ts";
+import { stableId } from "../../utils.ts";
+import type { Procedure } from "../procedure.model.ts";
+import { AlterProcedureChange } from "./procedure.base.ts";
+
+export type ProcedurePrivilege =
+  | GrantProcedurePrivileges
+  | RevokeProcedurePrivileges
+  | RevokeGrantOptionProcedurePrivileges;
+
+/**
+ * Grant privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { EXECUTE | ALL [ PRIVILEGES ] }
+ *    ON { { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+ *         | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantProcedurePrivileges extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    procedure: Procedure;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.procedure = props.procedure;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.procedure.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.procedure.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(
+        "GrantProcedurePrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const kindPrefix = getObjectKindPrefix(objectKind);
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(objectKind, list, this.version);
+    const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+    const args = this.procedure.argument_types?.join(", ") ?? "";
+    // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+    const signature = `${procedureName}(${args})`;
+    return `GRANT ${privSql} ${kindPrefix} ${signature} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { EXECUTE | ALL [ PRIVILEGES ] } }
+ *     ON { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeProcedurePrivileges extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    procedure: Procedure;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.procedure = props.procedure;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    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.procedure.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.procedure.stableId, this.grantee),
+      this.procedure.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const kindPrefix = getObjectKindPrefix(objectKind);
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(objectKind, list, this.version);
+    const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+    const args = this.procedure.argument_types?.join(", ") ?? "";
+    // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+    const signature = `${procedureName}(${args})`;
+    return `REVOKE ${privSql} ${kindPrefix} ${signature} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a procedure.
+ *
+ * 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 RevokeGrantOptionProcedurePrivileges extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    procedure: Procedure;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.procedure = props.procedure;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.procedure.stableId, this.grantee),
+      this.procedure.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const kindPrefix = getObjectKindPrefix(objectKind);
+    const privSql = formatObjectPrivilegeList(
+      objectKind,
+      this.privilegeNames,
+      this.version,
+    );
+    const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+    const args = this.procedure.argument_types?.join(", ") ?? "";
+    // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+    const signature = `${procedureName}(${args})`;
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${signature} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { AlterProcedure } from "./procedure.alter.ts";
+import type { CommentProcedure } from "./procedure.comment.ts";
+import type { CreateProcedure } from "./procedure.create.ts";
+import type { DropProcedure } from "./procedure.drop.ts";
+import type { ProcedurePrivilege } from "./procedure.privilege.ts";
+
+/** Union of all procedure-related change variants (`objectType: "procedure"`). @category Change Types */
+export type ProcedureChange =
+  | AlterProcedure
+  | CommentProcedure
+  | CreateProcedure
+  | DropProcedure
+  | ProcedurePrivilege;

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

@@ -0,0 +1,161 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import {
+  AlterProcedureChangeOwner,
+  AlterProcedureSetConfig,
+  AlterProcedureSetLeakproof,
+  AlterProcedureSetParallel,
+  AlterProcedureSetSecurity,
+  AlterProcedureSetStrictness,
+  AlterProcedureSetVolatility,
+} from "./changes/procedure.alter.ts";
+import { CreateProcedure } from "./changes/procedure.create.ts";
+import { DropProcedure } from "./changes/procedure.drop.ts";
+import { diffProcedures } from "./procedure.diff.ts";
+import { Procedure, type ProcedureProps } from "./procedure.model.ts";
+
+const base: ProcedureProps = {
+  schema: "public",
+  name: "fn1",
+  kind: "f",
+  return_type: "int4",
+  return_type_schema: "pg_catalog",
+  language: "sql",
+  security_definer: false,
+  volatility: "v",
+  parallel_safety: "s",
+  is_strict: false,
+  leakproof: false,
+  returns_set: false,
+  argument_count: 0,
+  argument_default_count: 0,
+  argument_names: null,
+  argument_types: null,
+  all_argument_types: null,
+  argument_modes: null,
+  argument_defaults: null,
+  source_code: null,
+  binary_path: null,
+  sql_body: null,
+  definition:
+    "CREATE FUNCTION public.fn1() RETURNS int4 LANGUAGE sql AS $$SELECT NULL::int4$$",
+  config: null,
+  owner: "o1",
+  execution_cost: 0,
+  result_rows: 0,
+  comment: null,
+  privileges: [],
+};
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("procedure.diff", () => {
+  test("create and drop", () => {
+    const p = new Procedure(base);
+    const created = diffProcedures(testContext, {}, { [p.stableId]: p });
+    expect(created[0]).toBeInstanceOf(CreateProcedure);
+    const dropped = diffProcedures(testContext, { [p.stableId]: p }, {});
+    expect(dropped[0]).toBeInstanceOf(DropProcedure);
+  });
+
+  test("alter owner", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, owner: "o2" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureChangeOwner);
+  });
+
+  test("diff emits alter security when security_definer changes", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, security_definer: true });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetSecurity);
+  });
+
+  test("diff emits config set/reset when config changes", () => {
+    const main = new Procedure({ ...base, config: ["search_path=public"] });
+    const branch = new Procedure({
+      ...base,
+      config: ["search_path=pg_temp", "work_mem=64MB"],
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetConfig);
+  });
+
+  test("diff emits volatility change", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, volatility: "i" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetVolatility);
+  });
+
+  test("diff emits strictness change", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, is_strict: true });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetStrictness);
+  });
+
+  test("diff emits leakproof change", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, leakproof: true });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetLeakproof);
+  });
+
+  test("diff emits parallel safety change", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, parallel_safety: "r" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterProcedureSetParallel);
+  });
+
+  test("create or replace when non-alterable property changes", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({
+      ...base,
+      return_type: "text",
+      language: "plpgsql",
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(CreateProcedure);
+  });
+});

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

@@ -0,0 +1,341 @@
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterProcedureChangeOwner,
+  AlterProcedureSetConfig,
+  AlterProcedureSetLeakproof,
+  AlterProcedureSetParallel,
+  AlterProcedureSetSecurity,
+  AlterProcedureSetStrictness,
+  AlterProcedureSetVolatility,
+} from "./changes/procedure.alter.ts";
+import {
+  CreateCommentOnProcedure,
+  DropCommentOnProcedure,
+} from "./changes/procedure.comment.ts";
+import { CreateProcedure } from "./changes/procedure.create.ts";
+import { DropProcedure } from "./changes/procedure.drop.ts";
+import {
+  GrantProcedurePrivileges,
+  RevokeGrantOptionProcedurePrivileges,
+  RevokeProcedurePrivileges,
+} from "./changes/procedure.privilege.ts";
+import type { ProcedureChange } from "./changes/procedure.types.ts";
+import type { Procedure } from "./procedure.model.ts";
+
+/**
+ * Diff two sets of procedures from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The procedures in the main catalog.
+ * @param branch - The procedures in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffProcedures(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, Procedure>,
+  branch: Record<string, Procedure>,
+): ProcedureChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: ProcedureChange[] = [];
+
+  for (const procedureId of created) {
+    const proc = branch[procedureId];
+    changes.push(new CreateProcedure({ procedure: proc }));
+
+    // OWNER: If the procedure should be owned by someone other than the current user,
+    // emit ALTER FUNCTION/PROCEDURE ... OWNER TO after creation
+    if (proc.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterProcedureChangeOwner({
+          procedure: proc,
+          owner: proc.owner,
+        }),
+      );
+    }
+
+    if (proc.comment !== null) {
+      changes.push(new CreateCommentOnProcedure({ procedure: proc }));
+    }
+
+    // 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,
+      "procedure",
+      proc.schema ?? "",
+    );
+    const creatorFilteredDefaults =
+      proc.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    // Filter out PUBLIC's built-in default EXECUTE privilege (PostgreSQL grants it automatically)
+    // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
+    // This prevents generating unnecessary "GRANT EXECUTE TO PUBLIC" statements
+    const desiredPrivileges = filterPublicBuiltInDefaults(
+      "procedure",
+      proc.privileges,
+    );
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Note: we use the final owner (proc.owner), not the
+    // current user, because ownership change happens before privilege diffing.
+    const privilegeResults = diffPrivileges(
+      filterPublicBuiltInDefaults("procedure", creatorFilteredDefaults),
+      desiredPrivileges,
+      proc.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        proc,
+        proc,
+        "procedure",
+        {
+          Grant: GrantProcedurePrivileges,
+          Revoke: RevokeProcedurePrivileges,
+          RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+        },
+        ctx.version,
+      ) as ProcedureChange[]),
+    );
+  }
+
+  for (const procedureId of dropped) {
+    changes.push(new DropProcedure({ procedure: main[procedureId] }));
+  }
+
+  for (const procedureId of altered) {
+    const mainProcedure = main[procedureId];
+    const branchProcedure = branch[procedureId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the procedure
+    const NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+      "kind",
+      "return_type",
+      "return_type_schema",
+      "language",
+      // The following properties are alterable in SQL, but our generator may choose
+      // to replace on changes not covered by explicit ALTER actions. Keep them out here
+      // to allow ALTER for those we implement below.
+      // security_definer,
+      // volatility,
+      // parallel_safety,
+      // is_strict,
+      // leakproof,
+      // Returns-set is part of the signature and not alterable
+      "returns_set",
+      "argument_count",
+      "argument_default_count",
+      "argument_names",
+      "argument_types",
+      "all_argument_types",
+      "argument_modes",
+      "argument_defaults",
+      "source_code",
+      "binary_path",
+      "sql_body",
+      // config is alterable via SET/RESET
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainProcedure,
+      branchProcedure,
+      NON_ALTERABLE_FIELDS,
+      {
+        argument_names: deepEqual,
+        argument_types: deepEqual,
+        all_argument_types: deepEqual,
+        argument_modes: deepEqual,
+        config: deepEqual,
+      },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire procedure
+      changes.push(
+        new CreateProcedure({ procedure: branchProcedure, orReplace: true }),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainProcedure.owner !== branchProcedure.owner) {
+        changes.push(
+          new AlterProcedureChangeOwner({
+            procedure: mainProcedure,
+            owner: branchProcedure.owner,
+          }),
+        );
+      }
+
+      // COMMENT
+      if (mainProcedure.comment !== branchProcedure.comment) {
+        if (branchProcedure.comment === null) {
+          changes.push(
+            new DropCommentOnProcedure({ procedure: mainProcedure }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnProcedure({ procedure: branchProcedure }),
+          );
+        }
+      }
+
+      // SECURITY DEFINER/INVOKER
+      if (mainProcedure.security_definer !== branchProcedure.security_definer) {
+        changes.push(
+          new AlterProcedureSetSecurity({
+            procedure: mainProcedure,
+            securityDefiner: branchProcedure.security_definer,
+          }),
+        );
+      }
+
+      // CONFIG SET/RESET
+      const toMap = (opts?: string[] | null) => {
+        const map = new Map<string, string>();
+        for (const opt of opts ?? []) {
+          const eq = opt.indexOf("=");
+          const key = opt.slice(0, eq).trim();
+          const value = opt.slice(eq + 1).trim();
+          map.set(key, value);
+        }
+        return map;
+      };
+      const mainCfg = toMap(mainProcedure.config);
+      const branchCfg = toMap(branchProcedure.config);
+      if (branchCfg.size === 0 && mainCfg.size > 0) {
+        // Branch has no config at all -> prefer a single RESET ALL
+        changes.push(
+          new AlterProcedureSetConfig({
+            procedure: mainProcedure,
+            action: "reset_all",
+          }),
+        );
+      } else {
+        for (const [key, oldValue] of mainCfg.entries()) {
+          const hasInBranch = branchCfg.has(key);
+          const newValue = branchCfg.get(key);
+          const changed = hasInBranch ? oldValue !== newValue : true;
+          if (changed) {
+            changes.push(
+              new AlterProcedureSetConfig({
+                procedure: mainProcedure,
+                action: "reset",
+                key,
+              }),
+            );
+          }
+        }
+        for (const [key, newValue] of branchCfg.entries()) {
+          const oldValue = mainCfg.get(key);
+          if (oldValue !== newValue) {
+            changes.push(
+              new AlterProcedureSetConfig({
+                procedure: mainProcedure,
+                action: "set",
+                key,
+                value: newValue,
+              }),
+            );
+          }
+        }
+      }
+
+      // VOLATILITY
+      if (mainProcedure.volatility !== branchProcedure.volatility) {
+        changes.push(
+          new AlterProcedureSetVolatility({
+            procedure: mainProcedure,
+            volatility: branchProcedure.volatility,
+          }),
+        );
+      }
+
+      // STRICTNESS
+      if (mainProcedure.is_strict !== branchProcedure.is_strict) {
+        changes.push(
+          new AlterProcedureSetStrictness({
+            procedure: mainProcedure,
+            isStrict: branchProcedure.is_strict,
+          }),
+        );
+      }
+
+      // LEAKPROOF
+      if (mainProcedure.leakproof !== branchProcedure.leakproof) {
+        changes.push(
+          new AlterProcedureSetLeakproof({
+            procedure: mainProcedure,
+            leakproof: branchProcedure.leakproof,
+          }),
+        );
+      }
+
+      // PARALLEL
+      if (mainProcedure.parallel_safety !== branchProcedure.parallel_safety) {
+        changes.push(
+          new AlterProcedureSetParallel({
+            procedure: mainProcedure,
+            parallelSafety: branchProcedure.parallel_safety,
+          }),
+        );
+      }
+
+      // Note: Procedure renaming would also use ALTER FUNCTION/PROCEDURE ... RENAME TO ...
+      // But since our Procedure model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+
+      // PRIVILEGES
+      // Filter out PUBLIC's built-in default EXECUTE privilege from main catalog
+      // (PostgreSQL grants it automatically, so we shouldn't compare it)
+      const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "procedure",
+        mainProcedure.privileges,
+      );
+      // Filter out PUBLIC's built-in default EXECUTE privilege from branch catalog
+      const branchPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "procedure",
+        branchProcedure.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(
+        mainPrivilegesFiltered,
+        branchPrivilegesFiltered,
+        branchProcedure.owner,
+      );
+
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchProcedure,
+          mainProcedure,
+          "procedure",
+          {
+            Grant: GrantProcedurePrivileges,
+            Revoke: RevokeProcedurePrivileges,
+            RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+          },
+          ctx.version,
+        ) as ProcedureChange[]),
+      );
+    }
+  }
+
+  return changes;
+}