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

package/dist/core/objects/language/language.model.js

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
@@ -71,10 +72,8 @@ export class Language extends BasePgModel {
         };
     }
 }
-async function _extractLanguages(sql) {
-    const languageRows = await sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        return sql `
+async function _extractLanguages(pool) {
+    const { rows: languageRows } = await pool.query(sql `
     with extension_oids as (
       select
         objid
@@ -112,9 +111,8 @@ async function _extractLanguages(sql) {
       -- <EXCLUDE_INTERNAL and default>
       where lan.lanname not in ('internal', 'c')
     order by
-      lan.lanname;
-  `;
-    });
+      lan.lanname
+  `);
     // Process rows to handle "-" as null values
     const processedRows = languageRows.map((row) => ({
         ...row,

package/dist/core/objects/materialized-view/materialized-view.diff.d.ts

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { MaterializedViewChange } from "./changes/materialized-view.types.ts";
 import type { MaterializedView } from "./materialized-view.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { MaterializedView } from "./materialized-view.model.ts";
  * @param branch - The materialized views in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffMaterializedViews(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, MaterializedView>, branch: Record<string, MaterializedView>): MaterializedViewChange[];
+export declare function diffMaterializedViews(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, MaterializedView>, branch: Record<string, MaterializedView>): MaterializedViewChange[];

package/dist/core/objects/materialized-view/materialized-view.diff.js

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterMaterializedViewChangeOwner, AlterMaterializedViewSetStorageParams, } from "./changes/materialized-view.alter.js";
 import { CreateCommentOnMaterializedView, CreateCommentOnMaterializedViewColumn, DropCommentOnMaterializedView, DropCommentOnMaterializedViewColumn, } from "./changes/materialized-view.comment.js";
@@ -54,87 +54,18 @@ export function diffMaterializedViews(ctx, main, branch) {
         // 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(effectiveDefaults, desiredPrivileges, mv.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 GrantMaterializedViewPrivileges({
-                            materializedView: mv,
-                            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();
-                    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 RevokeMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                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 RevokeGrantOptionMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, mv.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, mv, mv, "materializedView", {
+            Grant: GrantMaterializedViewPrivileges,
+            Revoke: RevokeMaterializedViewPrivileges,
+            RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+        }, effectiveDefaults, ctx.version));
     }
     for (const materializedViewId of dropped) {
         changes.push(new DropMaterializedView({ materializedView: main[materializedViewId] }));
@@ -250,85 +181,12 @@ export function diffMaterializedViews(ctx, main, branch) {
             // 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, 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 GrantMaterializedViewPrivileges({
-                                materializedView: branchMaterializedView,
-                                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();
-                        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 RevokeMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    const revokeGrantGroups = new Map();
-                    for (const r of result.revokeGrantOption) {
-                        // For revoke grant option, we need to find the columns from the original privilege
-                        const originalPriv = mainMaterializedView.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 RevokeGrantOptionMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privilegeNames,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
+            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));
         }
     }
     return changes;

package/dist/core/objects/materialized-view/materialized-view.model.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -14,10 +14,10 @@ declare const materializedViewPropsSchema: z.ZodObject<{
     has_subclasses: z.ZodBoolean;
     is_populated: z.ZodBoolean;
     replica_identity: z.ZodEnum<{
-        f: "f";
         n: "n";
         i: "i";
         d: "d";
+        f: "f";
     }>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
@@ -85,7 +85,7 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         has_triggers: boolean;
         has_subclasses: boolean;
         is_populated: boolean;
-        replica_identity: "f" | "n" | "i" | "d";
+        replica_identity: "n" | "i" | "d" | "f";
         is_partition: boolean;
         options: string[] | null;
         partition_bound: string | null;
@@ -133,7 +133,7 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
             has_triggers: boolean;
             has_subclasses: boolean;
             is_populated: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
             is_partition: boolean;
             options: string[] | null;
             partition_bound: string | null;
@@ -148,5 +148,5 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         };
     };
 }
-export declare function extractMaterializedViews(sql: Sql): Promise<MaterializedView[]>;
+export declare function extractMaterializedViews(pool: Pool): Promise<MaterializedView[]>;
 export {};

package/dist/core/objects/materialized-view/materialized-view.model.js

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel, columnPropsSchema, } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
@@ -113,10 +114,8 @@ export class MaterializedView extends BasePgModel {
         };
     }
 }
-export async function extractMaterializedViews(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const mvRows = await sql `
+export async function extractMaterializedViews(pool) {
+    const { rows: mvRows } = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -194,7 +193,7 @@ select
           filter (where src.attname is not null) as cols
       from (
         -- one row for object ACL + one row per column ACL
-        select null::name as attname, c.relacl as acl
+        select null::name as attname, COALESCE(c.relacl, acldefault('r', c.relowner)) as acl
         union all
         select a2.attname, a2.attacl
         from pg_attribute a2
@@ -219,10 +218,9 @@ where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'informati
 group by
   c.oid, c.relnamespace, c.relname, pg_get_viewdef(c.oid), c.relrowsecurity, c.relforcerowsecurity, c.relhasindex, c.relhasrules, c.relhastriggers, c.relhassubclass, c.relispopulated, c.relreplident, c.relispartition, c.reloptions, pg_get_expr(c.relpartbound, c.oid), c.relowner
 order by
-  c.relnamespace::regnamespace, c.relname;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = mvRows.map((row) => materializedViewPropsSchema.parse(row));
-        return validatedRows.map((row) => new MaterializedView(row));
-    });
+  c.relnamespace::regnamespace, c.relname
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = mvRows.map((row) => materializedViewPropsSchema.parse(row));
+    return validatedRows.map((row) => new MaterializedView(row));
 }

package/dist/core/objects/procedure/changes/procedure.alter.js

@@ -1,5 +1,10 @@
 import { formatConfigValue } from "../utils.js";
 import { AlterProcedureChange } from "./procedure.base.js";
+/** Build schema.name(args) for ALTER statements so overloaded functions are unambiguous. */
+function procedureSignature(procedure) {
+    const args = procedure.argument_types?.join(", ") ?? "";
+    return `${procedure.schema}.${procedure.name}(${args})`;
+}
 /**
  * ALTER FUNCTION/PROCEDURE ... OWNER TO ...
  */
@@ -20,7 +25,7 @@ export class AlterProcedureChangeOwner extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             "OWNER TO",
             this.owner,
         ].join(" ");
@@ -49,7 +54,7 @@ export class AlterProcedureSetSecurity extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             security,
         ].join(" ");
     }
@@ -78,7 +83,7 @@ export class AlterProcedureSetConfig extends AlterProcedureChange {
         const head = [
             "ALTER",
             this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
         ].join(" ");
         if (this.action === "reset_all")
             return `${head} RESET ALL`;
@@ -113,7 +118,7 @@ export class AlterProcedureSetVolatility extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             volMap[this.volatility],
         ].join(" ");
     }
@@ -139,7 +144,7 @@ export class AlterProcedureSetStrictness extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             strictness,
         ].join(" ");
     }
@@ -162,12 +167,7 @@ export class AlterProcedureSetLeakproof extends AlterProcedureChange {
     serialize() {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const leak = this.leakproof ? "LEAKPROOF" : "NOT LEAKPROOF";
-        return [
-            "ALTER",
-            objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
-            leak,
-        ].join(" ");
+        return ["ALTER", objectType, procedureSignature(this.procedure), leak].join(" ");
     }
 }
 /**
@@ -195,7 +195,7 @@ export class AlterProcedureSetParallel extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             parallelMap[this.parallelSafety],
         ].join(" ");
     }

package/dist/core/objects/procedure/procedure.diff.d.ts

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { ProcedureChange } from "./changes/procedure.types.ts";
 import type { Procedure } from "./procedure.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Procedure } from "./procedure.model.ts";
  * @param branch - The procedures in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffProcedures(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Procedure>, branch: Record<string, Procedure>): ProcedureChange[];
+export declare function diffProcedures(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Procedure>, branch: Record<string, Procedure>): ProcedureChange[];

package/dist/core/objects/procedure/procedure.diff.js

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterProcedureChangeOwner, AlterProcedureSetConfig, AlterProcedureSetLeakproof, AlterProcedureSetParallel, AlterProcedureSetSecurity, AlterProcedureSetStrictness, AlterProcedureSetVolatility, } from "./changes/procedure.alter.js";
 import { CreateCommentOnProcedure, DropCommentOnProcedure, } from "./changes/procedure.comment.js";
@@ -37,6 +37,9 @@ export function diffProcedures(ctx, main, branch) {
         // 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
@@ -44,44 +47,12 @@ export function diffProcedures(ctx, main, branch) {
         // 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(effectiveDefaults, desiredPrivileges, proc.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [grantable, list] of grantGroups) {
-                    void grantable;
-                    changes.push(new GrantProcedurePrivileges({
-                        procedure: proc,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [grantable, list] of revokeGroups) {
-                    void grantable;
-                    changes.push(new RevokeProcedurePrivileges({
-                        procedure: proc,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionProcedurePrivileges({
-                    procedure: proc,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("procedure", creatorFilteredDefaults), desiredPrivileges, proc.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, proc, proc, "procedure", {
+            Grant: GrantProcedurePrivileges,
+            Revoke: RevokeProcedurePrivileges,
+            RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+        }, ctx.version));
     }
     for (const procedureId of dropped) {
         changes.push(new DropProcedure({ procedure: main[procedureId] }));
@@ -238,44 +209,12 @@ export function diffProcedures(ctx, main, branch) {
             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, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByGrantable(result.grants);
-                    for (const [grantable, list] of grantGroups) {
-                        void grantable;
-                        changes.push(new GrantProcedurePrivileges({
-                            procedure: branchProcedure,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                    for (const [grantable, list] of revokeGroups) {
-                        void grantable;
-                        changes.push(new RevokeProcedurePrivileges({
-                            procedure: mainProcedure,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionProcedurePrivileges({
-                        procedure: mainProcedure,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchProcedure.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchProcedure, mainProcedure, "procedure", {
+                Grant: GrantProcedurePrivileges,
+                Revoke: RevokeProcedurePrivileges,
+                RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

package/dist/core/objects/procedure/procedure.model.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -6,24 +6,24 @@ declare const procedurePropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
     kind: z.ZodEnum<{
-        f: "f";
-        w: "w";
         a: "a";
+        w: "w";
         p: "p";
+        f: "f";
     }>;
     return_type: z.ZodString;
     return_type_schema: z.ZodString;
     language: z.ZodString;
     security_definer: z.ZodBoolean;
     volatility: z.ZodEnum<{
-        s: "s";
         i: "i";
+        s: "s";
         v: "v";
     }>;
     parallel_safety: z.ZodEnum<{
-        r: "r";
         u: "u";
         s: "s";
+        r: "r";
     }>;
     execution_cost: z.ZodNumber;
     result_rows: z.ZodNumber;
@@ -36,8 +36,8 @@ declare const procedurePropsSchema: z.ZodObject<{
     argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     all_argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     argument_modes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        o: "o";
         i: "i";
+        o: "o";
         b: "b";
         v: "v";
         t: "t";
@@ -96,13 +96,13 @@ export declare class Procedure extends BasePgModel {
         name: string;
     };
     get dataFields(): {
-        kind: "f" | "w" | "a" | "p";
+        kind: "a" | "w" | "p" | "f";
         return_type: string;
         return_type_schema: string;
         language: string;
         security_definer: boolean;
-        volatility: "s" | "i" | "v";
-        parallel_safety: "r" | "u" | "s";
+        volatility: "i" | "s" | "v";
+        parallel_safety: "u" | "s" | "r";
         is_strict: boolean;
         leakproof: boolean;
         returns_set: boolean;
@@ -111,7 +111,7 @@ export declare class Procedure extends BasePgModel {
         argument_names: string[] | null;
         argument_types: string[] | null;
         all_argument_types: string[] | null;
-        argument_modes: ("o" | "i" | "b" | "v" | "t")[] | null;
+        argument_modes: ("i" | "o" | "b" | "v" | "t")[] | null;
         argument_defaults: string | null;
         source_code: string | null;
         binary_path: string | null;
@@ -128,5 +128,5 @@ export declare class Procedure extends BasePgModel {
         }[];
     };
 }
-export declare function extractProcedures(sql: Sql): Promise<Procedure[]>;
+export declare function extractProcedures(pool: Pool): Promise<Procedure[]>;
 export {};