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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterMaterializedViewChangeOwner, AlterMaterializedViewSetStorageParams, } from "./changes/materialized-view.alter.js";
 import { CreateCommentOnMaterializedView, CreateCommentOnMaterializedViewColumn, DropCommentOnMaterializedView, DropCommentOnMaterializedViewColumn, } from "./changes/materialized-view.comment.js";
@@ -54,87 +54,18 @@ export function diffMaterializedViews(ctx, main, branch) {
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "materialized_view", mv.schema ?? "");
+        const creatorFilteredDefaults = mv.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         const desiredPrivileges = mv.privileges;
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the materialized view owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, mv.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantMaterializedViewPrivileges({
-                            materializedView: mv,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    // For revoke grant option, we need to find the columns from the effective defaults
-                    const originalPriv = effectiveDefaults.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, mv.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, mv, mv, "materializedView", {
+            Grant: GrantMaterializedViewPrivileges,
+            Revoke: RevokeMaterializedViewPrivileges,
+            RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+        }, effectiveDefaults, ctx.version));
     }
     for (const materializedViewId of dropped) {
         changes.push(new DropMaterializedView({ materializedView: main[materializedViewId] }));
@@ -250,85 +181,12 @@ export function diffMaterializedViews(ctx, main, branch) {
             // PRIVILEGES (unified object and column privileges)
             // Filter out owner privileges - owner always has ALL privileges implicitly
             // and shouldn't be compared. Use branch owner as the reference.
-            const privilegeResults = diffPrivileges(mainMaterializedView.privileges, branchMaterializedView.privileges, branchMaterializedView.owner, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByColumns(result.grants);
-                    for (const [, group] of grantGroups) {
-                        for (const [grantable, privSet] of group.byGrant) {
-                            const privileges = Array.from(privSet).map((priv) => ({
-                                privilege: priv,
-                                grantable,
-                            }));
-                            changes.push(new GrantMaterializedViewPrivileges({
-                                materializedView: branchMaterializedView,
-                                grantee,
-                                privileges,
-                                columns: group.columns,
-                                version: ctx.version,
-                            }));
-                        }
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                    for (const [, group] of revokeGroups) {
-                        // Collapse all grantable groups into a single revoke (grantable: false)
-                        const allPrivileges = new Set();
-                        for (const [, privSet] of group.byGrant) {
-                            for (const priv of privSet) {
-                                allPrivileges.add(priv);
-                            }
-                        }
-                        const privileges = Array.from(allPrivileges).map((priv) => ({
-                            privilege: priv,
-                            grantable: false,
-                        }));
-                        changes.push(new RevokeMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    const revokeGrantGroups = new Map();
-                    for (const r of result.revokeGrantOption) {
-                        // For revoke grant option, we need to find the columns from the original privilege
-                        const originalPriv = mainMaterializedView.privileges.find((p) => p.grantee === grantee && p.privilege === r);
-                        const key = originalPriv?.columns
-                            ? originalPriv.columns.sort().join(",")
-                            : "";
-                        if (!revokeGrantGroups.has(key)) {
-                            revokeGrantGroups.set(key, {
-                                columns: originalPriv?.columns
-                                    ? [...originalPriv.columns]
-                                    : undefined,
-                                privileges: new Set(),
-                            });
-                        }
-                        const group = revokeGrantGroups.get(key);
-                        if (!group)
-                            continue;
-                        group.privileges.add(r);
-                    }
-                    for (const [, group] of revokeGrantGroups) {
-                        const privilegeNames = Array.from(group.privileges);
-                        changes.push(new RevokeGrantOptionMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privilegeNames,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
+            const privilegeResults = diffPrivileges(mainMaterializedView.privileges, branchMaterializedView.privileges, branchMaterializedView.owner);
+            changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchMaterializedView, mainMaterializedView, "materializedView", {
+                Grant: GrantMaterializedViewPrivileges,
+                Revoke: RevokeMaterializedViewPrivileges,
+                RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+            }, mainMaterializedView.privileges, ctx.version));
         }
     }
     return changes;

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

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -148,5 +148,5 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         };
     };
 }
-export declare function extractMaterializedViews(sql: Sql): Promise<MaterializedView[]>;
+export declare function extractMaterializedViews(pool: Pool): Promise<MaterializedView[]>;
 export {};

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterProcedureChangeOwner, AlterProcedureSetConfig, AlterProcedureSetLeakproof, AlterProcedureSetParallel, AlterProcedureSetSecurity, AlterProcedureSetStrictness, AlterProcedureSetVolatility, } from "./changes/procedure.alter.js";
 import { CreateCommentOnProcedure, DropCommentOnProcedure, } from "./changes/procedure.comment.js";
@@ -37,6 +37,9 @@ export function diffProcedures(ctx, main, branch) {
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "procedure", proc.schema ?? "");
+        const creatorFilteredDefaults = proc.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // Filter out PUBLIC's built-in default EXECUTE privilege (PostgreSQL grants it automatically)
         // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
         // This prevents generating unnecessary "GRANT EXECUTE TO PUBLIC" statements
@@ -44,44 +47,12 @@ export function diffProcedures(ctx, main, branch) {
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Note: we use the final owner (proc.owner), not the
         // current user, because ownership change happens before privilege diffing.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, proc.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [grantable, list] of grantGroups) {
-                    void grantable;
-                    changes.push(new GrantProcedurePrivileges({
-                        procedure: proc,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [grantable, list] of revokeGroups) {
-                    void grantable;
-                    changes.push(new RevokeProcedurePrivileges({
-                        procedure: proc,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionProcedurePrivileges({
-                    procedure: proc,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("procedure", creatorFilteredDefaults), desiredPrivileges, proc.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, proc, proc, "procedure", {
+            Grant: GrantProcedurePrivileges,
+            Revoke: RevokeProcedurePrivileges,
+            RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+        }, ctx.version));
     }
     for (const procedureId of dropped) {
         changes.push(new DropProcedure({ procedure: main[procedureId] }));
@@ -238,44 +209,12 @@ export function diffProcedures(ctx, main, branch) {
             const branchPrivilegesFiltered = filterPublicBuiltInDefaults("procedure", branchProcedure.privileges);
             // Filter out owner privileges - owner always has ALL privileges implicitly
             // and shouldn't be compared. Use branch owner as the reference.
-            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchProcedure.owner, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByGrantable(result.grants);
-                    for (const [grantable, list] of grantGroups) {
-                        void grantable;
-                        changes.push(new GrantProcedurePrivileges({
-                            procedure: branchProcedure,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                    for (const [grantable, list] of revokeGroups) {
-                        void grantable;
-                        changes.push(new RevokeProcedurePrivileges({
-                            procedure: mainProcedure,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionProcedurePrivileges({
-                        procedure: mainProcedure,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchProcedure.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchProcedure, mainProcedure, "procedure", {
+                Grant: GrantProcedurePrivileges,
+                Revoke: RevokeProcedurePrivileges,
+                RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

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

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -128,5 +128,5 @@ export declare class Procedure extends BasePgModel {
         }[];
     };
 }
-export declare function extractProcedures(sql: Sql): Promise<Procedure[]>;
+export declare function extractProcedures(pool: Pool): Promise<Procedure[]>;
 export {};

package/dist/core/objects/procedure/procedure.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";
@@ -162,10 +163,8 @@ export class Procedure extends BasePgModel {
         };
     }
 }
-export async function extractProcedures(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const procedureRows = await sql `
+export async function extractProcedures(pool) {
+    const { rows: procedureRows } = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -223,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
@@ -235,10 +234,9 @@ from
   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));
-    });
+  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/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[];