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

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.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";
@@ -59,10 +60,8 @@ export class ForeignDataWrapper extends BasePgModel {
         };
     }
 }
-export async function extractForeignDataWrappers(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const fdwRows = await sql `
+export async function extractForeignDataWrappers(pool) {
+    const { rows: fdwRows } = await pool.query(sql `
       with extension_oids as (
         select objid
         from pg_depend d
@@ -74,11 +73,11 @@ export async function extractForeignDataWrappers(sql) {
         fdw.fdwowner::regrole::text as owner,
         case
           when fdw.fdwhandler = 0 then null
-          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname) || '(' || pg_get_function_identity_arguments(fdw.fdwhandler) || ')'
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
         end as handler,
         case
           when fdw.fdwvalidator = 0 then null
-          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname) || '(' || pg_get_function_identity_arguments(fdw.fdwvalidator) || ')'
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
         end as validator,
         coalesce(fdw.fdwoptions, array[]::text[]) as options,
         obj_description(fdw.oid, 'pg_foreign_data_wrapper') as comment,
@@ -104,25 +103,24 @@ export async function extractForeignDataWrappers(sql) {
         not fdw.fdwname like any(array['pg\\_%'])
         and e.objid is null
       order by
-        fdw.fdwname;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = fdwRows.map((row) => {
-            const parsed = foreignDataWrapperPropsSchema.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));
-                    }
+        fdw.fdwname
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = fdwRows.map((row) => {
+        const parsed = foreignDataWrapperPropsSchema.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 ForeignDataWrapper(row));
+            parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+        }
+        return parsed;
     });
+    return validatedRows.map((row) => new ForeignDataWrapper(row));
 }

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.d.ts

@@ -2,4 +2,5 @@ import type { ForeignDataWrapperChange as FDWChange } from "./foreign-data-wrapp
 import type { ForeignTableChange } from "./foreign-table/changes/foreign-table.types.ts";
 import type { ServerChange } from "./server/changes/server.types.ts";
 import type { UserMappingChange } from "./user-mapping/changes/user-mapping.types.ts";
+/** Union of all foreign-data-wrapper-related change variants (`objectType: "foreign_data_wrapper" | "server" | "foreign_table" | "user_mapping"`). @category Change Types */
 export type ForeignDataWrapperChange = FDWChange | ServerChange | UserMappingChange | ForeignTableChange;

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentForeignTable } from "./foreign-table.comment.ts";
 import type { CreateForeignTable } from "./foreign-table.create.ts";
 import type { DropForeignTable } from "./foreign-table.drop.ts";
 import type { ForeignTablePrivilege } from "./foreign-table.privilege.ts";
+/** Union of all foreign-table-related change variants (`objectType: "foreign_table"`). @category Change Types */
 export type ForeignTableChange = AlterForeignTable | CommentForeignTable | CreateForeignTable | DropForeignTable | ForeignTablePrivilege;

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

@@ -3,4 +3,5 @@ import type { CommentServer } from "./server.comment.ts";
 import type { CreateServer } from "./server.create.ts";
 import type { DropServer } from "./server.drop.ts";
 import type { ServerPrivilege } from "./server.privilege.ts";
+/** Union of all server-related change variants (`objectType: "server"`). @category Change Types */
 export type ServerChange = AlterServer | CommentServer | CreateServer | DropServer | ServerPrivilege;

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

@@ -1,4 +1,5 @@
 import type { AlterUserMapping } from "./user-mapping.alter.ts";
 import type { CreateUserMapping } from "./user-mapping.create.ts";
 import type { DropUserMapping } from "./user-mapping.drop.ts";
+/** Union of all user-mapping-related change variants (`objectType: "user_mapping"`). @category Change Types */
 export type UserMappingChange = AlterUserMapping | CreateUserMapping | DropUserMapping;

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

@@ -2,4 +2,5 @@ import type { AlterIndex } from "./index.alter.ts";
 import type { CommentIndex } from "./index.comment.ts";
 import type { CreateIndex } from "./index.create.ts";
 import type { DropIndex } from "./index.drop.ts";
+/** Union of all index-related change variants (`objectType: "index"`). @category Change Types */
 export type IndexChange = AlterIndex | CommentIndex | CreateIndex | DropIndex;

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 {};