@supabase/pg-delta 1.0.0-alpha.4 → 1.0.0-alpha.6

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

@@ -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;

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

@@ -193,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

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

@@ -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;

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

@@ -222,7 +222,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(p.proacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from

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

@@ -13,15 +13,6 @@ export declare class AlterPublicationSetOptions extends AlterPublicationChange {
     get requires(): `publication:${string}`[];
     serialize(): string;
 }
-export declare class AlterPublicationSetForAllTables extends AlterPublicationChange {
-    readonly publication: Publication;
-    readonly scope: "object";
-    constructor(props: {
-        publication: Publication;
-    });
-    get requires(): `publication:${string}`[];
-    serialize(): string;
-}
 export declare class AlterPublicationSetList extends AlterPublicationChange {
     readonly publication: Publication;
     readonly scope: "object";

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

@@ -27,20 +27,6 @@ export class AlterPublicationSetOptions extends AlterPublicationChange {
         return `ALTER PUBLICATION ${this.publication.name} SET (${assignments.join(", ")})`;
     }
 }
-export class AlterPublicationSetForAllTables extends AlterPublicationChange {
-    publication;
-    scope = "object";
-    constructor(props) {
-        super();
-        this.publication = props.publication;
-    }
-    get requires() {
-        return [this.publication.stableId];
-    }
-    serialize() {
-        return `ALTER PUBLICATION ${this.publication.name} SET FOR ALL TABLES`;
-    }
-}
 export class AlterPublicationSetList extends AlterPublicationChange {
     publication;
     scope = "object";

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

@@ -1,5 +1,5 @@
-import type { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublicationDropSchemas, AlterPublicationDropTables, AlterPublicationSetForAllTables, AlterPublicationSetList, AlterPublicationSetOptions, AlterPublicationSetOwner } from "./publication.alter.ts";
+import type { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublicationDropSchemas, AlterPublicationDropTables, AlterPublicationSetList, AlterPublicationSetOptions, AlterPublicationSetOwner } from "./publication.alter.ts";
 import type { CommentPublication } from "./publication.comment.ts";
 import type { CreatePublication } from "./publication.create.ts";
 import type { DropPublication } from "./publication.drop.ts";
-export type PublicationChange = AlterPublicationAddSchemas | AlterPublicationAddTables | AlterPublicationDropSchemas | AlterPublicationDropTables | AlterPublicationSetForAllTables | AlterPublicationSetList | AlterPublicationSetOptions | AlterPublicationSetOwner | CommentPublication | CreatePublication | DropPublication;
+export type PublicationChange = AlterPublicationAddSchemas | AlterPublicationAddTables | AlterPublicationDropSchemas | AlterPublicationDropTables | AlterPublicationSetList | AlterPublicationSetOptions | AlterPublicationSetOwner | CommentPublication | CreatePublication | DropPublication;

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

@@ -1,5 +1,4 @@
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { PublicationChange } from "./changes/publication.types.ts";
 import type { Publication } from "./publication.model.ts";
-export declare function diffPublications(ctx: {
-    currentUser: string;
-}, main: Record<string, Publication>, branch: Record<string, Publication>): PublicationChange[];
+export declare function diffPublications(ctx: Pick<ObjectDiffContext, "currentUser">, main: Record<string, Publication>, branch: Record<string, Publication>): PublicationChange[];

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

@@ -1,6 +1,6 @@
 import { diffObjects } from "../base.diff.js";
 import { deepEqual } from "../utils.js";
-import { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublicationDropSchemas, AlterPublicationDropTables, AlterPublicationSetForAllTables, AlterPublicationSetOptions, AlterPublicationSetOwner, } from "./changes/publication.alter.js";
+import { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublicationDropSchemas, AlterPublicationDropTables, AlterPublicationSetOptions, AlterPublicationSetOwner, } from "./changes/publication.alter.js";
 import { CreateCommentOnPublication, DropCommentOnPublication, } from "./changes/publication.comment.js";
 import { CreatePublication } from "./changes/publication.create.js";
 import { DropPublication } from "./changes/publication.drop.js";
@@ -52,21 +52,16 @@ export function diffPublications(ctx, main, branch) {
         let handledObjectLists = false;
         if (mainPublication.all_tables !== branchPublication.all_tables) {
             handledObjectLists = true;
-            if (branchPublication.all_tables) {
-                changes.push(new AlterPublicationSetForAllTables({
+            // Changing the all_tables mode requires DROP + CREATE because
+            // ALTER PUBLICATION does not support SET ALL TABLES.
+            changes.push(new DropPublication({ publication: mainPublication }));
+            changes.push(new CreatePublication({ publication: branchPublication }));
+            if (branchPublication.comment !== null) {
+                changes.push(new CreateCommentOnPublication({
                     publication: branchPublication,
                 }));
             }
-            else {
-                changes.push(new DropPublication({ publication: mainPublication }));
-                changes.push(new CreatePublication({ publication: branchPublication }));
-                if (branchPublication.comment !== null) {
-                    changes.push(new CreateCommentOnPublication({
-                        publication: branchPublication,
-                    }));
-                }
-                continue;
-            }
+            continue;
         }
         if (!handledObjectLists && !branchPublication.all_tables) {
             const tableDiff = diffPublicationTables(mainPublication.tables, branchPublication.tables);