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

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.diff.ts

@@ -0,0 +1,341 @@
+import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import { diffObjects } from "../../base.diff.ts";
+import {
+  diffPrivileges,
+  filterPublicBuiltInDefaults,
+  groupPrivilegesByGrantable,
+} from "../../base.privilege-diff.ts";
+import type { Role } from "../../role/role.model.ts";
+import {
+  AlterForeignDataWrapperChangeOwner,
+  AlterForeignDataWrapperSetOptions,
+} from "./changes/foreign-data-wrapper.alter.ts";
+import {
+  CreateCommentOnForeignDataWrapper,
+  DropCommentOnForeignDataWrapper,
+} from "./changes/foreign-data-wrapper.comment.ts";
+import { CreateForeignDataWrapper } from "./changes/foreign-data-wrapper.create.ts";
+import { DropForeignDataWrapper } from "./changes/foreign-data-wrapper.drop.ts";
+import {
+  GrantForeignDataWrapperPrivileges,
+  RevokeForeignDataWrapperPrivileges,
+  RevokeGrantOptionForeignDataWrapperPrivileges,
+} from "./changes/foreign-data-wrapper.privilege.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 function diffForeignDataWrappers(
+  ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+  },
+  main: Record<string, ForeignDataWrapper>,
+  branch: Record<string, ForeignDataWrapper>,
+): ForeignDataWrapperChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: ForeignDataWrapperChange[] = [];
+
+  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: Array<{
+      grantee: string;
+      privilege: string;
+      grantable: boolean;
+    }> = [];
+    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: string[] | null,
+  branchOptions: string[] | null,
+): Array<{ action: "ADD" | "SET" | "DROP"; option: string; value?: string }> {
+  const mainMap = new Map<string, string>();
+  const branchMap = new Map<string, string>();
+
+  // 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: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }> = [];
+
+  // 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;
+}

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.ts

@@ -0,0 +1,149 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../../base.privilege-diff.ts";
+
+/**
+ * All properties exposed by CREATE FOREIGN DATA WRAPPER statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * ALTER FOREIGN DATA WRAPPER statement can be generated for changes to the following properties:
+ *  - owner, handler, validator, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigndatawrapper.html
+ *
+ * Foreign Data Wrappers are not schema-qualified (no schema property).
+ */
+const foreignDataWrapperPropsSchema = z.object({
+  name: z.string(),
+  owner: z.string(),
+  handler: z.string().nullable(),
+  validator: z.string().nullable(),
+  options: z.array(z.string()).nullable(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type ForeignDataWrapperPrivilegeProps = PrivilegeProps;
+export type ForeignDataWrapperProps = z.infer<
+  typeof foreignDataWrapperPropsSchema
+>;
+
+export class ForeignDataWrapper extends BasePgModel {
+  public readonly name: ForeignDataWrapperProps["name"];
+  public readonly owner: ForeignDataWrapperProps["owner"];
+  public readonly handler: ForeignDataWrapperProps["handler"];
+  public readonly validator: ForeignDataWrapperProps["validator"];
+  public readonly options: ForeignDataWrapperProps["options"];
+  public readonly comment: ForeignDataWrapperProps["comment"];
+  public readonly privileges: ForeignDataWrapperPrivilegeProps[];
+
+  constructor(props: ForeignDataWrapperProps) {
+    super();
+
+    // Identity fields
+    this.name = props.name;
+
+    // Data fields
+    this.owner = props.owner;
+    this.handler = props.handler;
+    this.validator = props.validator;
+    this.options = props.options;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `foreignDataWrapper:${string}` {
+    return `foreignDataWrapper:${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      owner: this.owner,
+      handler: this.handler,
+      validator: this.validator,
+      options: this.options,
+      comment: this.comment,
+      privileges: this.privileges,
+    };
+  }
+}
+
+export async function extractForeignDataWrappers(
+  pool: Pool,
+): Promise<ForeignDataWrapper[]> {
+  const { rows: fdwRows } = await pool.query<ForeignDataWrapperProps>(sql`
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_foreign_data_wrapper'::regclass
+      )
+      select
+        quote_ident(fdw.fdwname) as name,
+        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) || ')'
+        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) || ')'
+        end as validator,
+        coalesce(fdw.fdwoptions, array[]::text[]) as options,
+        obj_description(fdw.oid, 'pg_foreign_data_wrapper') as comment,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object(
+                'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+                'privilege', x.privilege_type,
+                'grantable', x.is_grantable
+              )
+              order by x.grantee, x.privilege_type
+            )
+            from lateral aclexplode(fdw.fdwacl) as x(grantor, grantee, privilege_type, is_grantable)
+          ), '[]'
+        ) as privileges
+      from
+        pg_catalog.pg_foreign_data_wrapper fdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
+        left join extension_oids e on fdw.oid = e.objid
+      where
+        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: unknown) => {
+    const parsed = foreignDataWrapperPropsSchema.parse(row);
+    // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+    if (parsed.options && parsed.options.length > 0) {
+      const parsedOptions: string[] = [];
+      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: ForeignDataWrapperProps) => new ForeignDataWrapper(row),
+  );
+}

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.ts

@@ -0,0 +1,10 @@
+import type { ForeignDataWrapperChange as FDWChange } from "./foreign-data-wrapper/changes/foreign-data-wrapper.types.ts";
+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";
+
+export type ForeignDataWrapperChange =
+  | FDWChange
+  | ServerChange
+  | UserMappingChange
+  | ForeignTableChange;