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

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

package/dist/core/objects/foreign-data-wrapper/foreign-table/foreign-table.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 { AlterForeignTableAddColumn, AlterForeignTableAlterColumnDropDefault, AlterForeignTableAlterColumnDropNotNull, AlterForeignTableAlterColumnSetDefault, AlterForeignTableAlterColumnSetNotNull, AlterForeignTableAlterColumnType, AlterForeignTableChangeOwner, AlterForeignTableDropColumn, AlterForeignTableSetOptions, } from "./changes/foreign-table.alter.js";
 import { CreateCommentOnForeignTable, DropCommentOnForeignTable, } from "./changes/foreign-table.comment.js";
 import { CreateForeignTable } from "./changes/foreign-table.create.js";
@@ -32,45 +32,16 @@ export function diffForeignTables(ctx, main, branch) {
         }
         // PRIVILEGES: For created objects, compare against default privileges state
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "foreign_table", createdTable.schema ?? "");
+        const creatorFilteredDefaults = createdTable.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         const desiredPrivileges = filterPublicBuiltInDefaults("foreign_table", createdTable.privileges);
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdTable.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 GrantForeignTablePrivileges({
-                        foreignTable: createdTable,
-                        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 RevokeForeignTablePrivileges({
-                        foreignTable: createdTable,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionForeignTablePrivileges({
-                    foreignTable: createdTable,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("foreign_table", creatorFilteredDefaults), desiredPrivileges, createdTable.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdTable, createdTable, "foreignTable", {
+            Grant: GrantForeignTablePrivileges,
+            Revoke: RevokeForeignTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        }, ctx.version));
     }
     for (const tableId of dropped) {
         changes.push(new DropForeignTable({ foreignTable: main[tableId] }));
@@ -180,44 +151,12 @@ export function diffForeignTables(ctx, main, branch) {
         // PRIVILEGES
         const mainPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_table", mainTable.privileges);
         const branchPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_table", branchTable.privileges);
-        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchTable.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 GrantForeignTablePrivileges({
-                        foreignTable: branchTable,
-                        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 RevokeForeignTablePrivileges({
-                        foreignTable: mainTable,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionForeignTablePrivileges({
-                    foreignTable: mainTable,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchTable.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchTable, mainTable, "foreignTable", {
+            Grant: GrantForeignTablePrivileges,
+            Revoke: RevokeForeignTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        }, ctx.version));
         // Note: Foreign table renaming would also use ALTER FOREIGN TABLE ... RENAME TO ...
         // But since our ForeignTable model uses 'name' as the identity field,
         // a name change would be handled as drop + create by diffObjects()

package/dist/core/objects/foreign-data-wrapper/foreign-table/foreign-table.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";
@@ -113,5 +113,5 @@ export declare class ForeignTable extends BasePgModel implements TableLikeObject
         };
     };
 }
-export declare function extractForeignTables(sql: Sql): Promise<ForeignTable[]>;
+export declare function extractForeignTables(pool: Pool): Promise<ForeignTable[]>;
 export {};

package/dist/core/objects/foreign-data-wrapper/foreign-table/foreign-table.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";
@@ -82,10 +83,8 @@ export class ForeignTable extends BasePgModel {
         };
     }
 }
-export async function extractForeignTables(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const tableRows = await sql `
+export async function extractForeignTables(pool) {
+    const { rows: tableRows } = await pool.query(sql `
       with extension_oids as (
         select objid
         from pg_depend d
@@ -169,7 +168,7 @@ export async function extractForeignTables(sql) {
             from (
               -- one row for object ACL + one row per column ACL
               select null::name as attname, ft.oid as relacl_oid, (
-                select c_rel.relacl from pg_class c_rel where c_rel.oid = ft.oid
+                select COALESCE(c_rel.relacl, acldefault('r', c_rel.relowner)) from pg_class c_rel where c_rel.oid = ft.oid
               ) as acl
               union all
               select a2.attname, ft.oid as relacl_oid, a2.attacl
@@ -191,25 +190,24 @@ export async function extractForeignTables(sql) {
       group by
         ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
       order by
-        ft.schema, ft.name;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = tableRows.map((row) => {
-            const parsed = foreignTablePropsSchema.parse(row);
-            // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
-            if (parsed.options && parsed.options.length > 0) {
-                const parsedOptions = [];
-                for (const opt of parsed.options) {
-                    const eqIndex = opt.indexOf("=");
-                    if (eqIndex > 0) {
-                        parsedOptions.push(opt.substring(0, eqIndex));
-                        parsedOptions.push(opt.substring(eqIndex + 1));
-                    }
+        ft.schema, ft.name
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = tableRows.map((row) => {
+        const parsed = foreignTablePropsSchema.parse(row);
+        // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+        if (parsed.options && parsed.options.length > 0) {
+            const parsedOptions = [];
+            for (const opt of parsed.options) {
+                const eqIndex = opt.indexOf("=");
+                if (eqIndex > 0) {
+                    parsedOptions.push(opt.substring(0, eqIndex));
+                    parsedOptions.push(opt.substring(eqIndex + 1));
                 }
-                parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
             }
-            return parsed;
-        });
-        return validatedRows.map((row) => new ForeignTable(row));
+            parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+        }
+        return parsed;
     });
+    return validatedRows.map((row) => new ForeignTable(row));
 }

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

package/dist/core/objects/foreign-data-wrapper/server/server.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 { AlterServerChangeOwner, AlterServerSetOptions, AlterServerSetVersion, } from "./changes/server.alter.js";
 import { CreateCommentOnServer, DropCommentOnServer, } from "./changes/server.comment.js";
 import { CreateServer } from "./changes/server.create.js";
@@ -33,44 +33,12 @@ export function diffServers(ctx, main, branch) {
         // PRIVILEGES: Servers don't have default privileges
         const effectiveDefaults = [];
         const desiredPrivileges = filterPublicBuiltInDefaults("server", createdServer.privileges);
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdServer.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 GrantServerPrivileges({
-                        server: createdServer,
-                        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 RevokeServerPrivileges({
-                        server: createdServer,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionServerPrivileges({
-                    server: createdServer,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdServer.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdServer, createdServer, "server", {
+            Grant: GrantServerPrivileges,
+            Revoke: RevokeServerPrivileges,
+            RevokeGrantOption: RevokeGrantOptionServerPrivileges,
+        }, ctx.version));
     }
     for (const serverId of dropped) {
         changes.push(new DropServer({ server: main[serverId] }));
@@ -121,44 +89,12 @@ export function diffServers(ctx, main, branch) {
         // PRIVILEGES
         const mainPrivilegesFiltered = filterPublicBuiltInDefaults("server", mainServer.privileges);
         const branchPrivilegesFiltered = filterPublicBuiltInDefaults("server", branchServer.privileges);
-        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchServer.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 GrantServerPrivileges({
-                        server: branchServer,
-                        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 RevokeServerPrivileges({
-                        server: mainServer,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionServerPrivileges({
-                    server: mainServer,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchServer.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchServer, mainServer, "server", {
+            Grant: GrantServerPrivileges,
+            Revoke: RevokeServerPrivileges,
+            RevokeGrantOption: RevokeGrantOptionServerPrivileges,
+        }, ctx.version));
         // Note: Server renaming would also use ALTER SERVER ... RENAME TO ...
         // But since our Server model uses 'name' as the identity field,
         // a name change would be handled as drop + create by diffObjects()

package/dist/core/objects/foreign-data-wrapper/server/server.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";
@@ -58,5 +58,5 @@ export declare class Server extends BasePgModel {
         }[];
     };
 }
-export declare function extractServers(sql: Sql): Promise<Server[]>;
+export declare function extractServers(pool: Pool): Promise<Server[]>;
 export {};

package/dist/core/objects/foreign-data-wrapper/server/server.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";
@@ -63,10 +64,8 @@ export class Server extends BasePgModel {
         };
     }
 }
-export async function extractServers(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const serverRows = await sql `
+export async function extractServers(pool) {
+    const { rows: serverRows } = await pool.query(sql `
       select
         quote_ident(srv.srvname) as name,
         srv.srvowner::regrole::text as owner,
@@ -94,25 +93,24 @@ export async function extractServers(sql) {
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by
-        srv.srvname;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = serverRows.map((row) => {
-            const parsed = serverPropsSchema.parse(row);
-            // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
-            if (parsed.options && parsed.options.length > 0) {
-                const parsedOptions = [];
-                for (const opt of parsed.options) {
-                    const eqIndex = opt.indexOf("=");
-                    if (eqIndex > 0) {
-                        parsedOptions.push(opt.substring(0, eqIndex));
-                        parsedOptions.push(opt.substring(eqIndex + 1));
-                    }
+        srv.srvname
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = serverRows.map((row) => {
+        const parsed = serverPropsSchema.parse(row);
+        // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+        if (parsed.options && parsed.options.length > 0) {
+            const parsedOptions = [];
+            for (const opt of parsed.options) {
+                const eqIndex = opt.indexOf("=");
+                if (eqIndex > 0) {
+                    parsedOptions.push(opt.substring(0, eqIndex));
+                    parsedOptions.push(opt.substring(eqIndex + 1));
                 }
-                parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
             }
-            return parsed;
-        });
-        return validatedRows.map((row) => new Server(row));
+            parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+        }
+        return parsed;
     });
+    return validatedRows.map((row) => new Server(row));
 }

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.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";
 /**
@@ -32,5 +32,5 @@ export declare class UserMapping extends BasePgModel {
         options: string[] | null;
     };
 }
-export declare function extractUserMappings(sql: Sql): Promise<UserMapping[]>;
+export declare function extractUserMappings(pool: Pool): Promise<UserMapping[]>;
 export {};

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.js

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../../base.model.js";
 /**
@@ -43,10 +44,8 @@ export class UserMapping extends BasePgModel {
         };
     }
 }
-export async function extractUserMappings(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const mappingRows = await sql `
+export async function extractUserMappings(pool) {
+    const { rows: mappingRows } = await pool.query(sql `
       select
         case
           when um.umuser = 0 then 'PUBLIC'
@@ -61,25 +60,24 @@ export async function extractUserMappings(sql) {
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by
-        srv.srvname, um.umuser;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = mappingRows.map((row) => {
-            const parsed = userMappingPropsSchema.parse(row);
-            // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
-            if (parsed.options && parsed.options.length > 0) {
-                const parsedOptions = [];
-                for (const opt of parsed.options) {
-                    const eqIndex = opt.indexOf("=");
-                    if (eqIndex > 0) {
-                        parsedOptions.push(opt.substring(0, eqIndex));
-                        parsedOptions.push(opt.substring(eqIndex + 1));
-                    }
+        srv.srvname, um.umuser
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = mappingRows.map((row) => {
+        const parsed = userMappingPropsSchema.parse(row);
+        // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+        if (parsed.options && parsed.options.length > 0) {
+            const parsedOptions = [];
+            for (const opt of parsed.options) {
+                const eqIndex = opt.indexOf("=");
+                if (eqIndex > 0) {
+                    parsedOptions.push(opt.substring(0, eqIndex));
+                    parsedOptions.push(opt.substring(eqIndex + 1));
                 }
-                parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
             }
-            return parsed;
-        });
-        return validatedRows.map((row) => new UserMapping(row));
+            parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+        }
+        return parsed;
     });
+    return validatedRows.map((row) => new UserMapping(row));
 }

package/dist/core/objects/index/index.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";
 declare const indexPropsSchema: z.ZodObject<{
@@ -17,7 +17,7 @@ declare const indexPropsSchema: z.ZodObject<{
     is_clustered: z.ZodBoolean;
     is_replica_identity: z.ZodBoolean;
     key_columns: z.ZodArray<z.ZodNumber>;
-    column_collations: z.ZodArray<z.ZodString>;
+    column_collations: z.ZodArray<z.ZodNullable<z.ZodString>>;
     operator_classes: z.ZodArray<z.ZodString>;
     column_options: z.ZodArray<z.ZodNumber>;
     index_expressions: z.ZodNullable<z.ZodString>;
@@ -98,7 +98,7 @@ export declare class Index extends BasePgModel {
         immediate: boolean;
         is_clustered: boolean;
         is_replica_identity: boolean;
-        column_collations: string[];
+        column_collations: (string | null)[];
         operator_classes: string[];
         column_options: number[];
         index_expressions: string | null;
@@ -146,5 +146,5 @@ export declare class Index extends BasePgModel {
         };
     };
 }
-export declare function extractIndexes(sql: Sql): Promise<Index[]>;
+export declare function extractIndexes(pool: Pool): Promise<Index[]>;
 export {};

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } from "../base.privilege-diff.js";
 import { hasNonAlterableChanges } from "../utils.js";
 import { AlterLanguageChangeOwner } from "./changes/language.alter.js";
 import { CreateCommentOnLanguage, DropCommentOnLanguage, } from "./changes/language.comment.js";
@@ -73,44 +73,12 @@ export function diffLanguages(ctx, main, branch) {
             const branchPrivilegesFiltered = filterPublicBuiltInDefaults("language", branchLanguage.privileges);
             // Filter out owner privileges - owner always has ALL privileges implicitly
             // and shouldn't be compared. Use branch owner as the reference.
-            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchLanguage.owner, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByGrantable(result.grants);
-                    for (const [grantable, list] of grantGroups) {
-                        void grantable;
-                        changes.push(new GrantLanguagePrivileges({
-                            language: branchLanguage,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                    for (const [grantable, list] of revokeGroups) {
-                        void grantable;
-                        changes.push(new RevokeLanguagePrivileges({
-                            language: mainLanguage,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionLanguagePrivileges({
-                        language: mainLanguage,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchLanguage.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchLanguage, mainLanguage, "language", {
+                Grant: GrantLanguagePrivileges,
+                Revoke: RevokeLanguagePrivileges,
+                RevokeGrantOption: RevokeGrantOptionLanguagePrivileges,
+            }, ctx.version));
         }
     }
     return changes;