@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

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

@@ -0,0 +1,282 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } 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";
+import { CreateProcedure } from "./changes/procedure.create.js";
+import { DropProcedure } from "./changes/procedure.drop.js";
+import { GrantProcedurePrivileges, RevokeGrantOptionProcedurePrivileges, RevokeProcedurePrivileges, } from "./changes/procedure.privilege.js";
+/**
+ * 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, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    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 ?? "");
+        // 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(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,
+                }));
+            }
+        }
+    }
+    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 = [
+            "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) => {
+                const map = new Map();
+                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, 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,
+                    }));
+                }
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,132 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const procedurePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        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<{
+        i: "i";
+        s: "s";
+        v: "v";
+    }>;
+    parallel_safety: z.ZodEnum<{
+        u: "u";
+        s: "s";
+        r: "r";
+    }>;
+    execution_cost: z.ZodNumber;
+    result_rows: z.ZodNumber;
+    is_strict: z.ZodBoolean;
+    leakproof: z.ZodBoolean;
+    returns_set: z.ZodBoolean;
+    argument_count: z.ZodNumber;
+    argument_default_count: z.ZodNumber;
+    argument_names: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    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<{
+        i: "i";
+        o: "o";
+        b: "b";
+        v: "v";
+        t: "t";
+    }>>>;
+    argument_defaults: z.ZodNullable<z.ZodString>;
+    source_code: z.ZodNullable<z.ZodString>;
+    binary_path: z.ZodNullable<z.ZodString>;
+    sql_body: z.ZodNullable<z.ZodString>;
+    definition: z.ZodString;
+    config: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    privileges: z.ZodArray<z.ZodObject<{
+        grantee: z.ZodString;
+        privilege: z.ZodString;
+        grantable: z.ZodBoolean;
+        columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+type ProcedurePrivilegeProps = PrivilegeProps;
+export type ProcedureProps = z.infer<typeof procedurePropsSchema>;
+export declare class Procedure extends BasePgModel {
+    readonly schema: ProcedureProps["schema"];
+    readonly name: ProcedureProps["name"];
+    readonly kind: ProcedureProps["kind"];
+    readonly return_type: ProcedureProps["return_type"];
+    readonly return_type_schema: ProcedureProps["return_type_schema"];
+    readonly language: ProcedureProps["language"];
+    readonly security_definer: ProcedureProps["security_definer"];
+    readonly volatility: ProcedureProps["volatility"];
+    readonly parallel_safety: ProcedureProps["parallel_safety"];
+    readonly execution_cost: ProcedureProps["execution_cost"];
+    readonly result_rows: ProcedureProps["result_rows"];
+    readonly is_strict: ProcedureProps["is_strict"];
+    readonly leakproof: ProcedureProps["leakproof"];
+    readonly returns_set: ProcedureProps["returns_set"];
+    readonly argument_count: ProcedureProps["argument_count"];
+    readonly argument_default_count: ProcedureProps["argument_default_count"];
+    readonly argument_names: ProcedureProps["argument_names"];
+    readonly argument_types: ProcedureProps["argument_types"];
+    readonly all_argument_types: ProcedureProps["all_argument_types"];
+    readonly argument_modes: ProcedureProps["argument_modes"];
+    readonly argument_defaults: ProcedureProps["argument_defaults"];
+    readonly source_code: ProcedureProps["source_code"];
+    readonly binary_path: ProcedureProps["binary_path"];
+    readonly sql_body: ProcedureProps["sql_body"];
+    readonly definition: ProcedureProps["definition"];
+    readonly config: ProcedureProps["config"];
+    readonly owner: ProcedureProps["owner"];
+    readonly comment: ProcedureProps["comment"];
+    readonly privileges: ProcedurePrivilegeProps[];
+    constructor(props: ProcedureProps);
+    get stableId(): `procedure:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        kind: "a" | "w" | "p" | "f";
+        return_type: string;
+        return_type_schema: string;
+        language: string;
+        security_definer: boolean;
+        volatility: "i" | "s" | "v";
+        parallel_safety: "u" | "s" | "r";
+        is_strict: boolean;
+        leakproof: boolean;
+        returns_set: boolean;
+        argument_count: number;
+        argument_default_count: number;
+        argument_names: string[] | null;
+        argument_types: string[] | null;
+        all_argument_types: string[] | null;
+        argument_modes: ("i" | "o" | "b" | "v" | "t")[] | null;
+        argument_defaults: string | null;
+        source_code: string | null;
+        binary_path: string | null;
+        sql_body: string | null;
+        definition: string;
+        config: string[] | null;
+        owner: string;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+export declare function extractProcedures(sql: Sql): Promise<Procedure[]>;
+export {};

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

@@ -0,0 +1,244 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+const FunctionKindSchema = z.enum([
+    "f", // function
+    "p", // procedure
+    "a", // aggregate function
+    "w", // window function
+]);
+const FunctionVolatilitySchema = z.enum([
+    "i", // IMMUTABLE
+    "s", // STABLE
+    "v", // VOLATILE
+]);
+const FunctionParallelSafetySchema = z.enum([
+    "u", // UNSAFE (cannot run in parallel)
+    "s", // SAFE (can run in parallel)
+    "r", // RESTRICTED (can run in parallel with restrictions)
+]);
+const FunctionArgumentModeSchema = z.enum([
+    "i", // IN parameter
+    "o", // OUT parameter
+    "b", // INOUT parameter
+    "v", // VARIADIC parameter
+    "t", // TABLE parameter
+]);
+const procedurePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    kind: FunctionKindSchema,
+    return_type: z.string(),
+    return_type_schema: z.string(),
+    language: z.string(),
+    security_definer: z.boolean(),
+    volatility: FunctionVolatilitySchema,
+    parallel_safety: FunctionParallelSafetySchema,
+    execution_cost: z.number(),
+    result_rows: z.number(),
+    is_strict: z.boolean(),
+    leakproof: z.boolean(),
+    returns_set: z.boolean(),
+    argument_count: z.number(),
+    argument_default_count: z.number(),
+    argument_names: z.array(z.string()).nullable(),
+    argument_types: z.array(z.string()).nullable(),
+    all_argument_types: z.array(z.string()).nullable(),
+    argument_modes: z.array(FunctionArgumentModeSchema).nullable(),
+    argument_defaults: z.string().nullable(),
+    source_code: z.string().nullable(),
+    binary_path: z.string().nullable(),
+    sql_body: z.string().nullable(),
+    definition: z.string(),
+    config: z.array(z.string()).nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Procedure extends BasePgModel {
+    schema;
+    name;
+    kind;
+    return_type;
+    return_type_schema;
+    language;
+    security_definer;
+    volatility;
+    parallel_safety;
+    execution_cost;
+    result_rows;
+    is_strict;
+    leakproof;
+    returns_set;
+    argument_count;
+    argument_default_count;
+    argument_names;
+    argument_types;
+    all_argument_types;
+    argument_modes;
+    argument_defaults;
+    source_code;
+    binary_path;
+    sql_body;
+    definition;
+    config;
+    owner;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.kind = props.kind;
+        this.return_type = props.return_type;
+        this.return_type_schema = props.return_type_schema;
+        this.language = props.language;
+        this.security_definer = props.security_definer;
+        this.volatility = props.volatility;
+        this.parallel_safety = props.parallel_safety;
+        this.execution_cost = props.execution_cost;
+        this.result_rows = props.result_rows;
+        this.is_strict = props.is_strict;
+        this.leakproof = props.leakproof;
+        this.returns_set = props.returns_set;
+        this.argument_count = props.argument_count;
+        this.argument_default_count = props.argument_default_count;
+        this.argument_names = props.argument_names;
+        this.argument_types = props.argument_types;
+        this.all_argument_types = props.all_argument_types;
+        this.argument_modes = props.argument_modes;
+        this.argument_defaults = props.argument_defaults;
+        this.source_code = props.source_code;
+        this.binary_path = props.binary_path;
+        this.sql_body = props.sql_body;
+        this.definition = props.definition;
+        this.config = props.config;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        const args = this.argument_types?.join(",") ?? "";
+        return `procedure:${this.schema}.${this.name}(${args})`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            kind: this.kind,
+            return_type: this.return_type,
+            return_type_schema: this.return_type_schema,
+            language: this.language,
+            security_definer: this.security_definer,
+            volatility: this.volatility,
+            parallel_safety: this.parallel_safety,
+            // execution_cost and result_rows are planner hints. We intentionally
+            // exclude them from dataFields to avoid generating diffs solely due to
+            // changes in estimates. They are still used for CREATE serialization.
+            is_strict: this.is_strict,
+            leakproof: this.leakproof,
+            returns_set: this.returns_set,
+            argument_count: this.argument_count,
+            argument_default_count: this.argument_default_count,
+            argument_names: this.argument_names,
+            argument_types: this.argument_types,
+            all_argument_types: this.all_argument_types,
+            argument_modes: this.argument_modes,
+            argument_defaults: this.argument_defaults,
+            source_code: this.source_code,
+            binary_path: this.binary_path,
+            sql_body: this.sql_body,
+            definition: this.definition,
+            config: this.config,
+            owner: this.owner,
+            comment: this.comment,
+            privileges: this.privileges,
+        };
+    }
+}
+export async function extractProcedures(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const procedureRows = await sql `
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_proc'::regclass
+)
+select
+  p.pronamespace::regnamespace::text as schema,
+  quote_ident(p.proname) as name,
+  p.prokind as kind,
+  format_type(p.prorettype, null) as return_type,
+  rt.typnamespace::regnamespace::text as return_type_schema,
+  l.lanname as language,
+  p.prosecdef as security_definer,
+  p.provolatile as volatility,
+  p.proparallel as parallel_safety,
+  p.procost as execution_cost,
+  p.prorows as result_rows,
+  p.proisstrict as is_strict,
+  p.proleakproof as leakproof,
+  p.proretset as returns_set,
+  p.pronargs as argument_count,
+  p.pronargdefaults as argument_default_count,
+  -- quote argument names server-side for safe serialization
+  case when p.proargnames is null then null
+       else array(select quote_ident(n) from unnest(p.proargnames) as n)
+  end as argument_names,
+  array(
+    select format_type(oid, null)
+    from unnest(p.proargtypes) as oid
+  ) as argument_types,
+  array(
+    select format_type(oid, null)
+    from unnest(p.proallargtypes) as oid
+  ) as all_argument_types,
+  p.proargmodes as argument_modes,
+  pg_get_expr(p.proargdefaults, 0) as argument_defaults,
+  p.prosrc as source_code,
+  p.probin as binary_path,
+  pg_get_function_sqlbody(p.oid) as sql_body,
+  pg_get_functiondef(p.oid) as definition,
+  p.proconfig as config,
+  p.proowner::regrole::text as owner,
+  obj_description(p.oid, 'pg_proc') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+          'privilege', x.privilege_type,
+          'grantable', x.is_grantable
+        )
+        order by x.grantee, x.privilege_type
+      )
+      from lateral aclexplode(p.proacl) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges
+from
+  pg_catalog.pg_proc p
+  inner join pg_catalog.pg_language l on l.oid = p.prolang
+  left join pg_catalog.pg_type rt on rt.oid = p.prorettype
+  left outer join extension_oids e on p.oid = e.objid
+  where not p.pronamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e.objid is null
+  and l.lanname not in ('c', 'internal')
+order by
+  1, 2;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = procedureRows.map((row) => procedurePropsSchema.parse(row));
+        return validatedRows.map((row) => new Procedure(row));
+    });
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Format function arguments for CREATE/DROP FUNCTION statements.
+ *
+ * @param argNames - Array of argument names (can be null)
+ * @param argTypes - Array of argument types (required)
+ * @param argModes - Array of argument modes (can be null)
+ * @returns Formatted argument string
+ */
+export declare function formatFunctionArguments(argNames: string[] | null, argTypes: string[] | null, argModes: string[] | null): string;
+/**
+ * Format a GUC value for SET ... TO ... in function/procedure definitions.
+ * Applies quoting rules consistent with PostgreSQL docs and psql style.
+ */
+export declare function formatConfigValue(key: string, rawValue: string): string;