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

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.comment.js

@@ -0,0 +1,50 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateForeignDataWrapperChange, DropForeignDataWrapperChange, } from "./foreign-data-wrapper.base.js";
+export class CreateCommentOnForeignDataWrapper extends CreateForeignDataWrapperChange {
+    foreignDataWrapper;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+    }
+    get creates() {
+        return [stableId.comment(this.foreignDataWrapper.stableId)];
+    }
+    get requires() {
+        return [this.foreignDataWrapper.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON FOREIGN DATA WRAPPER",
+            this.foreignDataWrapper.name,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+            quoteLiteral(this.foreignDataWrapper.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnForeignDataWrapper extends DropForeignDataWrapperChange {
+    foreignDataWrapper;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+    }
+    get drops() {
+        return [stableId.comment(this.foreignDataWrapper.stableId)];
+    }
+    get requires() {
+        return [
+            stableId.comment(this.foreignDataWrapper.stableId),
+            this.foreignDataWrapper.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "COMMENT ON FOREIGN DATA WRAPPER",
+            this.foreignDataWrapper.name,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { CreateForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+/**
+ * Create a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN DATA WRAPPER name
+ *     [ HANDLER handler_function | NO HANDLER ]
+ *     [ VALIDATOR validator_function | NO VALIDATOR ]
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export declare class CreateForeignDataWrapper extends CreateForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly scope: "object";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+    });
+    get creates(): `foreignDataWrapper:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.create.js

@@ -0,0 +1,78 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateForeignDataWrapperChange } from "./foreign-data-wrapper.base.js";
+/**
+ * Create a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN DATA WRAPPER name
+ *     [ HANDLER handler_function | NO HANDLER ]
+ *     [ VALIDATOR validator_function | NO VALIDATOR ]
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateForeignDataWrapper extends CreateForeignDataWrapperChange {
+    foreignDataWrapper;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+    }
+    get creates() {
+        return [this.foreignDataWrapper.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Owner dependency
+        dependencies.add(stableId.role(this.foreignDataWrapper.owner));
+        // Handler function dependency (if specified)
+        if (this.foreignDataWrapper.handler) {
+            // Handler is stored as "schema.function_name(args)"
+            // We need to parse it to get the procedure stableId
+            // For now, we'll skip this dependency as it's complex to parse
+            // TODO: Parse handler function reference to add procedure dependency
+        }
+        // Validator function dependency (if specified)
+        if (this.foreignDataWrapper.validator) {
+            // Similar to handler
+            // TODO: Parse validator function reference to add procedure dependency
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE FOREIGN DATA WRAPPER"];
+        // Add FDW name
+        parts.push(this.foreignDataWrapper.name);
+        // Add HANDLER clause
+        if (this.foreignDataWrapper.handler) {
+            parts.push("HANDLER", this.foreignDataWrapper.handler);
+        }
+        else {
+            parts.push("NO HANDLER");
+        }
+        // Add VALIDATOR clause
+        if (this.foreignDataWrapper.validator) {
+            parts.push("VALIDATOR", this.foreignDataWrapper.validator);
+        }
+        else {
+            parts.push("NO VALIDATOR");
+        }
+        // Add OPTIONS clause
+        if (this.foreignDataWrapper.options &&
+            this.foreignDataWrapper.options.length > 0) {
+            const optionPairs = [];
+            for (let i = 0; i < this.foreignDataWrapper.options.length; i += 2) {
+                if (i + 1 < this.foreignDataWrapper.options.length) {
+                    optionPairs.push(`${this.foreignDataWrapper.options[i]} ${quoteLiteral(this.foreignDataWrapper.options[i + 1])}`);
+                }
+            }
+            if (optionPairs.length > 0) {
+                parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+            }
+        }
+        return parts.join(" ");
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { DropForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+/**
+ * Drop a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropForeignDataWrapper extends DropForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly scope: "object";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+    });
+    get drops(): `foreignDataWrapper:${string}`[];
+    get requires(): `foreignDataWrapper:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.drop.js

@@ -0,0 +1,28 @@
+import { DropForeignDataWrapperChange } from "./foreign-data-wrapper.base.js";
+/**
+ * Drop a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropForeignDataWrapper extends DropForeignDataWrapperChange {
+    foreignDataWrapper;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+    }
+    get drops() {
+        return [this.foreignDataWrapper.stableId];
+    }
+    get requires() {
+        return [this.foreignDataWrapper.stableId];
+    }
+    serialize() {
+        return ["DROP FOREIGN DATA WRAPPER", this.foreignDataWrapper.name].join(" ");
+    }
+}

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

@@ -0,0 +1,97 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { AlterForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+export type ForeignDataWrapperPrivilege = GrantForeignDataWrapperPrivileges | RevokeForeignDataWrapperPrivileges | RevokeGrantOptionForeignDataWrapperPrivileges;
+/**
+ * Grant privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON FOREIGN DATA WRAPPER name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `foreignDataWrapper:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN DATA WRAPPER name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `foreignDataWrapper:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a foreign data wrapper.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export declare class RevokeGrantOptionForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `foreignDataWrapper:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.privilege.js

@@ -0,0 +1,123 @@
+import { formatObjectPrivilegeList } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterForeignDataWrapperChange } from "./foreign-data-wrapper.base.js";
+/**
+ * Grant privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON FOREIGN DATA WRAPPER name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    foreignDataWrapper;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.foreignDataWrapper.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.foreignDataWrapper.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantForeignDataWrapperPrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FOREIGN DATA WRAPPER", list, this.version);
+        return `GRANT ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN DATA WRAPPER name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    foreignDataWrapper;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        return [stableId.acl(this.foreignDataWrapper.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.foreignDataWrapper.stableId, this.grantee),
+            this.foreignDataWrapper.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FOREIGN DATA WRAPPER", list, this.version);
+        return `REVOKE ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a foreign data wrapper.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+    foreignDataWrapper;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.foreignDataWrapper.stableId, this.grantee),
+            this.foreignDataWrapper.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const privSql = formatObjectPrivilegeList("FOREIGN DATA WRAPPER", this.privilegeNames, this.version);
+        return `REVOKE GRANT OPTION FOR ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} FROM ${this.grantee}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { AlterForeignDataWrapper } from "./foreign-data-wrapper.alter.ts";
+import type { CommentForeignDataWrapper } from "./foreign-data-wrapper.comment.ts";
+import type { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
+import type { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
+import type { ForeignDataWrapperPrivilege } from "./foreign-data-wrapper.privilege.ts";
+export type ForeignDataWrapperChange = AlterForeignDataWrapper | CommentForeignDataWrapper | CreateForeignDataWrapper | DropForeignDataWrapper | ForeignDataWrapperPrivilege;

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import type { Role } from "../../role/role.model.ts";
+import type { ForeignDataWrapperChange } from "./changes/foreign-data-wrapper.types.ts";
+import type { ForeignDataWrapper } from "./foreign-data-wrapper.model.ts";
+/**
+ * Diff two sets of foreign data wrappers from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The foreign data wrappers in the main catalog.
+ * @param branch - The foreign data wrappers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffForeignDataWrappers(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, ForeignDataWrapper>, branch: Record<string, ForeignDataWrapper>): ForeignDataWrapperChange[];

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.diff.js

@@ -0,0 +1,221 @@
+import { diffObjects } from "../../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { AlterForeignDataWrapperChangeOwner, AlterForeignDataWrapperSetOptions, } from "./changes/foreign-data-wrapper.alter.js";
+import { CreateCommentOnForeignDataWrapper, DropCommentOnForeignDataWrapper, } from "./changes/foreign-data-wrapper.comment.js";
+import { CreateForeignDataWrapper } from "./changes/foreign-data-wrapper.create.js";
+import { DropForeignDataWrapper } from "./changes/foreign-data-wrapper.drop.js";
+import { GrantForeignDataWrapperPrivileges, RevokeForeignDataWrapperPrivileges, RevokeGrantOptionForeignDataWrapperPrivileges, } from "./changes/foreign-data-wrapper.privilege.js";
+/**
+ * Diff two sets of foreign data wrappers from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The foreign data wrappers in the main catalog.
+ * @param branch - The foreign data wrappers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffForeignDataWrappers(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const fdwId of created) {
+        const createdFdw = branch[fdwId];
+        changes.push(new CreateForeignDataWrapper({ foreignDataWrapper: createdFdw }));
+        // OWNER: If the FDW should be owned by someone other than the current user,
+        // emit ALTER FOREIGN DATA WRAPPER ... OWNER TO after creation
+        if (createdFdw.owner !== ctx.currentUser) {
+            changes.push(new AlterForeignDataWrapperChangeOwner({
+                foreignDataWrapper: createdFdw,
+                owner: createdFdw.owner,
+            }));
+        }
+        if (createdFdw.comment !== null) {
+            changes.push(new CreateCommentOnForeignDataWrapper({
+                foreignDataWrapper: createdFdw,
+            }));
+        }
+        // PRIVILEGES: For created objects, compare against default privileges state
+        // Foreign Data Wrappers don't have default privileges, so we compare against empty array
+        const effectiveDefaults = [];
+        const desiredPrivileges = filterPublicBuiltInDefaults("foreign_data_wrapper", createdFdw.privileges);
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdFdw.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 GrantForeignDataWrapperPrivileges({
+                        foreignDataWrapper: createdFdw,
+                        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 RevokeForeignDataWrapperPrivileges({
+                        foreignDataWrapper: createdFdw,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionForeignDataWrapperPrivileges({
+                    foreignDataWrapper: createdFdw,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const fdwId of dropped) {
+        changes.push(new DropForeignDataWrapper({ foreignDataWrapper: main[fdwId] }));
+    }
+    for (const fdwId of altered) {
+        const mainFdw = main[fdwId];
+        const branchFdw = branch[fdwId];
+        // OWNER
+        if (mainFdw.owner !== branchFdw.owner) {
+            changes.push(new AlterForeignDataWrapperChangeOwner({
+                foreignDataWrapper: mainFdw,
+                owner: branchFdw.owner,
+            }));
+        }
+        // HANDLER - if changed, need to recreate (not directly alterable)
+        if (mainFdw.handler !== branchFdw.handler) {
+            changes.push(new DropForeignDataWrapper({ foreignDataWrapper: mainFdw }));
+            changes.push(new CreateForeignDataWrapper({ foreignDataWrapper: branchFdw }));
+            if (branchFdw.comment !== null) {
+                changes.push(new CreateCommentOnForeignDataWrapper({
+                    foreignDataWrapper: branchFdw,
+                }));
+            }
+            continue;
+        }
+        // VALIDATOR - if changed, need to recreate (not directly alterable)
+        if (mainFdw.validator !== branchFdw.validator) {
+            changes.push(new DropForeignDataWrapper({ foreignDataWrapper: mainFdw }));
+            changes.push(new CreateForeignDataWrapper({ foreignDataWrapper: branchFdw }));
+            if (branchFdw.comment !== null) {
+                changes.push(new CreateCommentOnForeignDataWrapper({
+                    foreignDataWrapper: branchFdw,
+                }));
+            }
+            continue;
+        }
+        // OPTIONS
+        const optionsChanged = diffOptions(mainFdw.options, branchFdw.options);
+        if (optionsChanged.length > 0) {
+            changes.push(new AlterForeignDataWrapperSetOptions({
+                foreignDataWrapper: mainFdw,
+                options: optionsChanged,
+            }));
+        }
+        // COMMENT
+        if (mainFdw.comment !== branchFdw.comment) {
+            if (branchFdw.comment === null) {
+                changes.push(new DropCommentOnForeignDataWrapper({ foreignDataWrapper: mainFdw }));
+            }
+            else {
+                changes.push(new CreateCommentOnForeignDataWrapper({
+                    foreignDataWrapper: branchFdw,
+                }));
+            }
+        }
+        // PRIVILEGES
+        const mainPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_data_wrapper", mainFdw.privileges);
+        const branchPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_data_wrapper", branchFdw.privileges);
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchFdw.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 GrantForeignDataWrapperPrivileges({
+                        foreignDataWrapper: branchFdw,
+                        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 RevokeForeignDataWrapperPrivileges({
+                        foreignDataWrapper: mainFdw,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionForeignDataWrapperPrivileges({
+                    foreignDataWrapper: mainFdw,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+        // Note: FDW renaming would also use ALTER FOREIGN DATA WRAPPER ... RENAME TO ...
+        // But since our ForeignDataWrapper model uses 'name' as the identity field,
+        // a name change would be handled as drop + create by diffObjects()
+    }
+    return changes;
+}
+/**
+ * Diff options arrays to determine ADD/SET/DROP operations.
+ * Options are stored as [key1, value1, key2, value2, ...]
+ */
+function diffOptions(mainOptions, branchOptions) {
+    const mainMap = new Map();
+    const branchMap = new Map();
+    // Parse main options
+    if (mainOptions) {
+        for (let i = 0; i < mainOptions.length; i += 2) {
+            if (i + 1 < mainOptions.length) {
+                mainMap.set(mainOptions[i], mainOptions[i + 1]);
+            }
+        }
+    }
+    // Parse branch options
+    if (branchOptions) {
+        for (let i = 0; i < branchOptions.length; i += 2) {
+            if (i + 1 < branchOptions.length) {
+                branchMap.set(branchOptions[i], branchOptions[i + 1]);
+            }
+        }
+    }
+    const changes = [];
+    // Find options to ADD or SET
+    for (const [key, value] of branchMap) {
+        const mainValue = mainMap.get(key);
+        if (mainValue === undefined) {
+            changes.push({ action: "ADD", option: key, value });
+        }
+        else if (mainValue !== value) {
+            changes.push({ action: "SET", option: key, value });
+        }
+    }
+    // Find options to DROP
+    for (const [key] of mainMap) {
+        if (!branchMap.has(key)) {
+            changes.push({ action: "DROP", option: key });
+        }
+    }
+    return changes;
+}