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

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

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 const TableRelkindSchema = z.enum([
@@ -21,7 +22,7 @@ const indexPropsSchema = z.object({
     is_clustered: z.boolean(),
     is_replica_identity: z.boolean(),
     key_columns: z.array(z.number()),
-    column_collations: z.array(z.string()),
+    column_collations: z.array(z.string().nullable()),
     operator_classes: z.array(z.string()),
     column_options: z.array(z.number()),
     index_expressions: z.string().nullable(),
@@ -174,10 +175,8 @@ export class Index extends BasePgModel {
         };
     }
 }
-export async function extractIndexes(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const indexRows = await sql `
+export async function extractIndexes(pool) {
+    const { rows: indexRows } = await pool.query(sql `
       with extension_oids as (
         select objid
         from pg_depend d
@@ -331,10 +330,9 @@ export async function extractIndexes(sql) {
         and e.objid is null
         and e_table.objid is null
 
-      order by 1, 2;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = indexRows.map((row) => indexPropsSchema.parse(row));
-        return validatedRows.map((row) => new Index(row));
-    });
+      order by 1, 2
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = indexRows.map((row) => indexPropsSchema.parse(row));
+    return validatedRows.map((row) => new Index(row));
 }

package/dist/core/objects/language/changes/language.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentLanguage } from "./language.comment.ts";
 import type { CreateLanguage } from "./language.create.ts";
 import type { DropLanguage } from "./language.drop.ts";
 import type { LanguagePrivilege } from "./language.privilege.ts";
+/** Union of all language-related change variants (`objectType: "language"`). @category Change Types */
 export type LanguageChange = AlterLanguage | CommentLanguage | CreateLanguage | DropLanguage | LanguagePrivilege;

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

@@ -1,5 +1,5 @@
 import type { Change } from "../../change.types.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { Language } from "./language.model.ts";
 /**
  * Diff two sets of languages from main and branch catalogs.
@@ -9,7 +9,4 @@ import type { Language } from "./language.model.ts";
  * @param branch - The languages in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffLanguages(ctx: {
-    version: number;
-    mainRoles?: Record<string, Role>;
-}, main: Record<string, Language>, branch: Record<string, Language>): Change[];
+export declare function diffLanguages(ctx: Pick<ObjectDiffContext, "version">, main: Record<string, Language>, branch: Record<string, Language>): Change[];

package/dist/core/objects/language/language.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 { hasNonAlterableChanges } from "../utils.js";
 import { AlterLanguageChangeOwner } from "./changes/language.alter.js";
 import { CreateCommentOnLanguage, DropCommentOnLanguage, } from "./changes/language.comment.js";
@@ -73,44 +73,12 @@ export function diffLanguages(ctx, main, branch) {
             const branchPrivilegesFiltered = filterPublicBuiltInDefaults("language", branchLanguage.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, branchLanguage.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 GrantLanguagePrivileges({
-                            language: branchLanguage,
-                            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 RevokeLanguagePrivileges({
-                            language: mainLanguage,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionLanguagePrivileges({
-                        language: mainLanguage,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchLanguage.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchLanguage, mainLanguage, "language", {
+                Grant: GrantLanguagePrivileges,
+                Revoke: RevokeLanguagePrivileges,
+                RevokeGrantOption: RevokeGrantOptionLanguagePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

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/changes/materialized-view.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentMaterializedView } from "./materialized-view.comment.ts";
 import type { CreateMaterializedView } from "./materialized-view.create.ts";
 import type { DropMaterializedView } from "./materialized-view.drop.ts";
 import type { MaterializedViewPrivilege } from "./materialized-view.privilege.ts";
+/** Union of all materialized-view-related change variants (`objectType: "materialized_view"`). @category Change Types */
 export type MaterializedViewChange = AlterMaterializedView | CommentMaterializedView | CreateMaterializedView | DropMaterializedView | MaterializedViewPrivilege;

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/changes/procedure.types.d.ts

@@ -3,4 +3,5 @@ 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/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[];