@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -31,8 +31,15 @@ export function diffRoles(ctx, main, branch) {
         if (role.comment !== null) {
             changes.push(new CreateCommentOnRole({ role }));
         }
-        // MEMBERSHIPS: Grant memberships immediately after role creation
+        // MEMBERSHIPS: Grant memberships immediately after role creation.
+        // Members are already deduplicated by the Role model constructor.
         for (const membership of role.members) {
+            // Skip memberships where the member is the grantor (auto-created by
+            // CREATE ROLE — re-granting them, especially WITH ADMIN OPTION, fails
+            // with "ADMIN option cannot be granted back to your own grantor").
+            if (membership.grantor === membership.member) {
+                continue;
+            }
             changes.push(new GrantRoleMembership({
                 role,
                 member: membership.member,
@@ -45,6 +52,8 @@ export function diffRoles(ctx, main, branch) {
         }
         // DEFAULT PRIVILEGES: Grant default privileges immediately after role creation
         for (const defaultPriv of role.default_privileges) {
+            if (defaultPriv.is_implicit)
+                continue;
             if (defaultPriv.privileges.length === 0)
                 continue;
             const grantGroups = new Map();
@@ -163,11 +172,18 @@ export function diffRoles(ctx, main, branch) {
             }
         }
         // MEMBERSHIPS
+        // Members are already deduplicated by the Role model constructor.
         const mainMembers = new Map(mainRole.members.map((m) => [m.member, m]));
         const branchMembers = new Map(branchRole.members.map((m) => [m.member, m]));
         // Find new members to grant
         for (const [member, membership] of branchMembers) {
             if (!mainMembers.has(member)) {
+                // Skip memberships where the member is the grantor (auto-created by
+                // CREATE ROLE — re-granting them fails with "ADMIN option cannot be
+                // granted back to your own grantor").
+                if (membership.grantor === membership.member) {
+                    continue;
+                }
                 changes.push(new GrantRoleMembership({
                     role: branchRole,
                     member: membership.member,
@@ -224,6 +240,11 @@ export function diffRoles(ctx, main, branch) {
                     }));
                 }
                 if (toGrant.admin || toGrant.inherit || toGrant.set) {
+                    // Skip granting options back to the grantor (same restriction as
+                    // for newly created roles).
+                    if (branchMembership.grantor === branchMembership.member) {
+                        continue;
+                    }
                     changes.push(new GrantRoleMembership({
                         role: branchRole,
                         member: branchMembership.member,

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

@@ -23,17 +23,18 @@ declare const rolePropsSchema: z.ZodObject<{
     default_privileges: z.ZodArray<z.ZodObject<{
         in_schema: z.ZodNullable<z.ZodString>;
         objtype: z.ZodEnum<{
+            n: "n";
             r: "r";
-            S: "S";
             f: "f";
+            S: "S";
             T: "T";
-            n: "n";
         }>;
         grantee: z.ZodString;
         privileges: z.ZodArray<z.ZodObject<{
             privilege: z.ZodString;
             grantable: z.ZodBoolean;
         }, z.z.core.$strip>>;
+        is_implicit: z.ZodBoolean;
     }, z.z.core.$strip>>;
 }, z.z.core.$strip>;
 export type RoleProps = z.infer<typeof rolePropsSchema>;
@@ -80,7 +81,7 @@ export declare class Role extends BasePgModel {
                 grantable: boolean;
             }[];
             in_schema: string | null;
-            objtype: "r" | "S" | "f" | "T" | "n";
+            objtype: "n" | "r" | "f" | "S" | "T";
             grantee: string;
         }[];
     };

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

@@ -13,6 +13,7 @@ const defaultPrivilegeSchema = z.object({
     objtype: z.enum(["r", "S", "f", "T", "n"]),
     grantee: z.string(),
     privileges: z.array(z.object({ privilege: z.string(), grantable: z.boolean() })),
+    is_implicit: z.boolean(),
 });
 const rolePropsSchema = z.object({
     name: z.string(),
@@ -58,7 +59,7 @@ export class Role extends BasePgModel {
         this.can_bypass_rls = props.can_bypass_rls;
         this.config = props.config;
         this.comment = props.comment;
-        this.members = props.members;
+        this.members = deduplicateMembers(props.members);
         this.default_privileges = props.default_privileges;
     }
     get stableId() {
@@ -77,13 +78,16 @@ export class Role extends BasePgModel {
                 Number(a.inherit_option ?? false) - Number(b.inherit_option ?? false) ||
                 Number(a.set_option ?? false) - Number(b.set_option ?? false));
         });
-        const sortedDefaultPrivs = [...this.default_privileges].map((dp) => ({
-            ...dp,
-            privileges: [...dp.privileges].sort((a, b) => {
-                return (a.privilege.localeCompare(b.privilege) ||
-                    Number(a.grantable) - Number(b.grantable));
-            }),
-        }));
+        const sortedDefaultPrivs = [...this.default_privileges].map((dp) => {
+            const { is_implicit: _, ...rest } = dp;
+            return {
+                ...rest,
+                privileges: [...dp.privileges].sort((a, b) => {
+                    return (a.privilege.localeCompare(b.privilege) ||
+                        Number(a.grantable) - Number(b.grantable));
+                }),
+            };
+        });
         sortedDefaultPrivs.sort((a, b) => {
             return ((a.in_schema ?? "").localeCompare(b.in_schema ?? "") ||
                 a.objtype.localeCompare(b.objtype) ||
@@ -105,6 +109,46 @@ export class Role extends BasePgModel {
         };
     }
 }
+/**
+ * Deduplicate members by member name.
+ *
+ * In PostgreSQL 16+, `pg_auth_members` can have multiple rows for the same
+ * (roleid, member) pair with different grantors. Merge them into a single
+ * entry per member, combining options with OR so the most permissive wins.
+ *
+ * When merging, prefer a non-self grantor (grantor !== member) so that
+ * downstream code can detect true self-grants (auto-created by CREATE ROLE)
+ * by checking `grantor === member`.
+ */
+function deduplicateMembers(members) {
+    const map = new Map();
+    for (const m of members) {
+        const existing = map.get(m.member);
+        if (existing) {
+            // admin_option is always boolean (non-nullable in schema)
+            existing.admin_option = existing.admin_option || m.admin_option;
+            // inherit_option and set_option are nullish (only available in PG 16+)
+            if (m.inherit_option != null) {
+                existing.inherit_option =
+                    (existing.inherit_option ?? false) || m.inherit_option;
+            }
+            if (m.set_option != null) {
+                existing.set_option = (existing.set_option ?? false) || m.set_option;
+            }
+            // Prefer a non-self grantor so diff can detect true self-grants.
+            // Once a non-self grantor is chosen the value is kept (the specific
+            // non-self grantor doesn't matter — only the self vs non-self
+            // distinction is used downstream).
+            if (existing.grantor === existing.member && m.grantor !== m.member) {
+                existing.grantor = m.grantor;
+            }
+        }
+        else {
+            map.set(m.member, { ...m });
+        }
+    }
+    return [...map.values()];
+}
 export async function extractRoles(pool) {
     // Check PostgreSQL version capabilities for membership options
     const { rows: capabilitiesRows } = await pool.query(sql `
@@ -172,13 +216,15 @@ export async function extractRoles(pool) {
                                     THEN 'PUBLIC'
                                     ELSE s.grantee::regrole::text
                             END,
-                          'privileges', s.privileges
+                          'privileges', s.privileges,
+                          'is_implicit', s.is_implicit
                         )
                         ORDER BY s.defaclnamespace NULLS FIRST,
                                   s.defaclobjtype,
                                   s.grantee
                       )
                 FROM (
+                  -- Explicit entries from pg_default_acl
                   SELECT
                     d.defaclnamespace,
                     d.defaclobjtype,
@@ -189,12 +235,41 @@ export async function extractRoles(pool) {
                         'grantable',  x.is_grantable
                       )
                       ORDER BY x.privilege_type, x.is_grantable
-                    ) AS privileges
+                    ) AS privileges,
+                    false AS is_implicit
                   FROM pg_default_acl d
                   CROSS JOIN LATERAL aclexplode(COALESCE(d.defaclacl, ARRAY[]::aclitem[]))
                     AS x(grantor, grantee, privilege_type, is_grantable)
                   WHERE d.defaclrole = r.oid
                   GROUP BY d.defaclnamespace, d.defaclobjtype, x.grantee
+                  UNION ALL
+                  -- Implicit defaults from acldefault() for objtypes without a
+                  -- global pg_default_acl entry.  PostgreSQL applies these implicit
+                  -- defaults (e.g. PUBLIC gets EXECUTE on functions) when no
+                  -- explicit ALTER DEFAULT PRIVILEGES has been issued.  Including
+                  -- them lets the diff detect REVOKEs of implicit grants.
+                  SELECT
+                    0 AS defaclnamespace,
+                    v.t::"char" AS defaclobjtype,
+                    x.grantee,
+                    json_agg(
+                      json_build_object(
+                        'privilege',  x.privilege_type,
+                        'grantable',  x.is_grantable
+                      )
+                      ORDER BY x.privilege_type, x.is_grantable
+                    ) AS privileges,
+                    true AS is_implicit
+                  FROM (VALUES ('r'), ('S'), ('f'), ('T'), ('n')) AS v(t)
+                  CROSS JOIN LATERAL aclexplode(acldefault(v.t::"char", r.oid))
+                    AS x(grantor, grantee, privilege_type, is_grantable)
+                  WHERE NOT EXISTS (
+                    SELECT 1 FROM pg_default_acl d2
+                    WHERE d2.defaclrole     = r.oid
+                      AND d2.defaclobjtype  = v.t::"char"
+                      AND d2.defaclnamespace = 0
+                  )
+                  GROUP BY v.t, x.grantee
                 ) AS s
               ),
               '[]'
@@ -263,13 +338,15 @@ export async function extractRoles(pool) {
                                     THEN 'PUBLIC'
                                     ELSE s.grantee::regrole::text
                             END,
-                          'privileges', s.privileges
+                          'privileges', s.privileges,
+                          'is_implicit', s.is_implicit
                         )
                         ORDER BY s.defaclnamespace NULLS FIRST,
                                   s.defaclobjtype,
                                   s.grantee
                       )
                 FROM (
+                  -- Explicit entries from pg_default_acl
                   SELECT
                     d.defaclnamespace,
                     d.defaclobjtype,
@@ -280,12 +357,41 @@ export async function extractRoles(pool) {
                         'grantable',  x.is_grantable
                       )
                       ORDER BY x.privilege_type, x.is_grantable
-                    ) AS privileges
+                    ) AS privileges,
+                    false AS is_implicit
                   FROM pg_default_acl d
                   CROSS JOIN LATERAL aclexplode(COALESCE(d.defaclacl, ARRAY[]::aclitem[]))
                     AS x(grantor, grantee, privilege_type, is_grantable)
                   WHERE d.defaclrole = r.oid
                   GROUP BY d.defaclnamespace, d.defaclobjtype, x.grantee
+                  UNION ALL
+                  -- Implicit defaults from acldefault() for objtypes without a
+                  -- global pg_default_acl entry.  PostgreSQL applies these implicit
+                  -- defaults (e.g. PUBLIC gets EXECUTE on functions) when no
+                  -- explicit ALTER DEFAULT PRIVILEGES has been issued.  Including
+                  -- them lets the diff detect REVOKEs of implicit grants.
+                  SELECT
+                    0 AS defaclnamespace,
+                    v.t::"char" AS defaclobjtype,
+                    x.grantee,
+                    json_agg(
+                      json_build_object(
+                        'privilege',  x.privilege_type,
+                        'grantable',  x.is_grantable
+                      )
+                      ORDER BY x.privilege_type, x.is_grantable
+                    ) AS privileges,
+                    true AS is_implicit
+                  FROM (VALUES ('r'), ('S'), ('f'), ('T'), ('n')) AS v(t)
+                  CROSS JOIN LATERAL aclexplode(acldefault(v.t::"char", r.oid))
+                    AS x(grantor, grantee, privilege_type, is_grantable)
+                  WHERE NOT EXISTS (
+                    SELECT 1 FROM pg_default_acl d2
+                    WHERE d2.defaclrole     = r.oid
+                      AND d2.defaclobjtype  = v.t::"char"
+                      AND d2.defaclnamespace = 0
+                  )
+                  GROUP BY v.t, x.grantee
                 ) AS s
               ),
               '[]'

package/dist/core/objects/rule/changes/rule.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule, RuleEnabledState } from "../rule.model.ts";
 import { AlterRuleChange } from "./rule.base.ts";
 export declare class ReplaceRule extends AlterRuleChange {
@@ -7,7 +8,7 @@ export declare class ReplaceRule extends AlterRuleChange {
         rule: Rule;
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class SetRuleEnabledState extends AlterRuleChange {
     readonly rule: Rule;
@@ -18,5 +19,5 @@ export declare class SetRuleEnabledState extends AlterRuleChange {
         enabled?: RuleEnabledState;
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -15,7 +15,7 @@ export class ReplaceRule extends AlterRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return new CreateRule({ rule: this.rule, orReplace: true }).serialize();
     }
 }
@@ -35,7 +35,7 @@ export class SetRuleEnabledState extends AlterRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const clause = clauseForState(this.enabled);
         return `ALTER TABLE ${this.rule.schema}.${this.rule.table_name} ${clause} ${this.rule.name}`;
     }

package/dist/core/objects/rule/changes/rule.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { CreateRuleChange, DropRuleChange } from "./rule.base.ts";
 export declare class CreateCommentOnRule extends CreateRuleChange {
@@ -8,7 +9,7 @@ export declare class CreateCommentOnRule extends CreateRuleChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `rule:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnRule extends DropRuleChange {
     readonly rule: Rule;
@@ -18,5 +19,5 @@ export declare class DropCommentOnRule extends DropRuleChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `rule:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/rule/changes/rule.comment.js

@@ -14,7 +14,7 @@ export class CreateCommentOnRule extends CreateRuleChange {
     get requires() {
         return [this.rule.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON RULE",
             this.rule.name,
@@ -39,7 +39,7 @@ export class DropCommentOnRule extends DropRuleChange {
     get requires() {
         return [stableId.comment(this.rule.stableId), this.rule.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON RULE",
             this.rule.name,

package/dist/core/objects/rule/changes/rule.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { CreateRuleChange } from "./rule.base.ts";
 export declare class CreateRule extends CreateRuleChange {
@@ -10,5 +11,5 @@ export declare class CreateRule extends CreateRuleChange {
     });
     get creates(): `rule:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/rule/changes/rule.create.js

@@ -18,7 +18,7 @@ export class CreateRule extends CreateRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         let definition = this.rule.definition.trim();
         definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
         // Remove trailing semicolons (pg_get_ruledef includes them, but we add our own)

package/dist/core/objects/rule/changes/rule.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { DropRuleChange } from "./rule.base.ts";
 export declare class DropRule extends DropRuleChange {
@@ -8,5 +9,5 @@ export declare class DropRule extends DropRuleChange {
     });
     get drops(): `rule:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/rule/changes/rule.drop.js

@@ -12,7 +12,7 @@ export class DropRule extends DropRuleChange {
     get requires() {
         return [this.rule.stableId, this.rule.relationStableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "DROP RULE",
             this.rule.name,

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

@@ -2,4 +2,5 @@ import type { ReplaceRule, SetRuleEnabledState } from "./rule.alter.ts";
 import type { CreateCommentOnRule, DropCommentOnRule } from "./rule.comment.ts";
 import type { CreateRule } from "./rule.create.ts";
 import type { DropRule } from "./rule.drop.ts";
+/** Union of all rule-related change variants (`objectType: "rule"`). @category Change Types */
 export type RuleChange = CreateRule | DropRule | ReplaceRule | SetRuleEnabledState | CreateCommentOnRule | DropCommentOnRule;

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

@@ -13,10 +13,10 @@ declare const rulePropsSchema: z.ZodObject<{
     table_name: z.ZodString;
     relation_kind: z.ZodEnum<{
         r: "r";
-        f: "f";
         v: "v";
         m: "m";
         p: "p";
+        f: "f";
     }>;
     event: z.ZodEnum<{
         DELETE: "DELETE";

package/dist/core/objects/schema/changes/schema.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { AlterSchemaChange } from "./schema.base.ts";
 /**
@@ -24,7 +25,7 @@ export declare class AlterSchemaChangeOwner extends AlterSchemaChange {
         owner: string;
     });
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Replace a schema by dropping and recreating it.

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

@@ -14,7 +14,7 @@ export class AlterSchemaChangeOwner extends AlterSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["ALTER SCHEMA", this.schema.name, "OWNER TO", this.owner].join(" ");
     }
 }

package/dist/core/objects/schema/changes/schema.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { CreateSchemaChange, DropSchemaChange } from "./schema.base.ts";
 export type CommentSchema = CreateCommentOnSchema | DropCommentOnSchema;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnSchema extends CreateSchemaChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnSchema extends DropSchemaChange {
     readonly schema: Schema;
@@ -19,5 +20,5 @@ export declare class DropCommentOnSchema extends DropSchemaChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`schema:${string}` | `comment:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/schema/changes/schema.comment.js

@@ -14,7 +14,7 @@ export class CreateCommentOnSchema extends CreateSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON SCHEMA",
             this.schema.name,
@@ -37,7 +37,7 @@ export class DropCommentOnSchema extends DropSchemaChange {
     get requires() {
         return [stableId.comment(this.schema.stableId), this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["COMMENT ON SCHEMA", this.schema.name, "IS NULL"].join(" ");
     }
 }

package/dist/core/objects/schema/changes/schema.create.d.ts

@@ -1,3 +1,4 @@
+import type { SchemaSerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { CreateSchemaChange } from "./schema.base.ts";
 /**
@@ -17,11 +18,8 @@ export declare class CreateSchema extends CreateSchemaChange {
     readonly scope: "object";
     constructor(props: {
         schema: Schema;
-        skipAuthorization?: boolean;
-    });
+    } & SchemaSerializeOptions);
     get creates(): `schema:${string}`[];
     get requires(): `role:${string}`[];
-    serialize(options?: {
-        skipAuthorization?: boolean;
-    }): string;
+    serialize(options?: SchemaSerializeOptions): string;
 }

package/dist/core/objects/schema/changes/schema.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { DropSchemaChange } from "./schema.base.ts";
 /**
@@ -18,5 +19,5 @@ export declare class DropSchema extends DropSchemaChange {
     });
     get drops(): `schema:${string}`[];
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/schema/changes/schema.drop.js

@@ -22,7 +22,7 @@ export class DropSchema extends DropSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["DROP SCHEMA", this.schema.name].join(" ");
     }
 }

package/dist/core/objects/schema/changes/schema.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { AlterSchemaChange } from "./schema.base.ts";
 export type SchemaPrivilege = GrantSchemaPrivileges | RevokeSchemaPrivileges | RevokeGrantOptionSchemaPrivileges;
@@ -34,7 +35,7 @@ export declare class GrantSchemaPrivileges extends AlterSchemaChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`schema:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a schema.
@@ -71,7 +72,7 @@ export declare class RevokeSchemaPrivileges extends AlterSchemaChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`schema:${string}` | `acl:${string}::grantee:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a schema.
@@ -93,5 +94,5 @@ export declare class RevokeGrantOptionSchemaPrivileges extends AlterSchemaChange
         version?: number;
     });
     get requires(): (`schema:${string}` | `acl:${string}::grantee:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/schema/changes/schema.privilege.js

@@ -33,7 +33,7 @@ export class GrantSchemaPrivileges extends AlterSchemaChange {
     get requires() {
         return [this.schema.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -87,7 +87,7 @@ export class RevokeSchemaPrivileges extends AlterSchemaChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("SCHEMA");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("SCHEMA", list, this.version);
@@ -122,7 +122,7 @@ export class RevokeGrantOptionSchemaPrivileges extends AlterSchemaChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("SCHEMA");
         const privSql = formatObjectPrivilegeList("SCHEMA", this.privilegeNames, this.version);
         const schemaName = this.schema.name;

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

@@ -3,4 +3,5 @@ import type { CommentSchema } from "./schema.comment.ts";
 import type { CreateSchema } from "./schema.create.ts";
 import type { DropSchema } from "./schema.drop.ts";
 import type { SchemaPrivilege } from "./schema.privilege.ts";
+/** Union of all schema-related change variants (`objectType: "schema"`). @category Change Types */
 export type SchemaChange = AlterSchema | CommentSchema | CreateSchema | DropSchema | SchemaPrivilege;

package/dist/core/objects/schema/schema.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 { SchemaChange } from "./changes/schema.types.ts";
 import type { Schema } from "./schema.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Schema } from "./schema.model.ts";
  * @param branch - The schemas in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffSchemas(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Schema>, branch: Record<string, Schema>): SchemaChange[];
+export declare function diffSchemas(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Schema>, branch: Record<string, Schema>): SchemaChange[];