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

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

@@ -0,0 +1,286 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../../base.default-privileges.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 { diffForeignDataWrappers } from "./foreign-data-wrapper.diff.ts";
+import {
+  ForeignDataWrapper,
+  type ForeignDataWrapperProps,
+} from "./foreign-data-wrapper.model.ts";
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("foreign-data-wrapper.diff", () => {
+  test("create and drop", () => {
+    const props: ForeignDataWrapperProps = {
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const fdw = new ForeignDataWrapper(props);
+
+    const created = diffForeignDataWrappers(
+      testContext,
+      {},
+      {
+        [fdw.stableId]: fdw,
+      },
+    );
+    expect(created[0]).toBeInstanceOf(CreateForeignDataWrapper);
+
+    const dropped = diffForeignDataWrappers(
+      testContext,
+      {
+        [fdw.stableId]: fdw,
+      },
+      {},
+    );
+    expect(dropped[0]).toBeInstanceOf(DropForeignDataWrapper);
+  });
+
+  test("alter: owner change", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o2",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterForeignDataWrapperChangeOwner),
+    ).toBe(true);
+  });
+
+  test("alter: options changes", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: ["host", "localhost"],
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: ["host", "newhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const optionsChange = changes.find(
+      (c) => c instanceof AlterForeignDataWrapperSetOptions,
+    ) as AlterForeignDataWrapperSetOptions | undefined;
+    expect(optionsChange).toBeDefined();
+    expect(optionsChange?.options.length).toBeGreaterThan(0);
+  });
+
+  test("handler change triggers drop and create", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: "public.old_handler",
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: "public.new_handler",
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    // Handler change should trigger drop + create
+    expect(changes.some((c) => c instanceof DropForeignDataWrapper)).toBe(true);
+    expect(changes.some((c) => c instanceof CreateForeignDataWrapper)).toBe(
+      true,
+    );
+  });
+
+  test("validator change triggers drop and create", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: "public.old_validator",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: "public.new_validator",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    // Validator change should trigger drop + create
+    expect(changes.some((c) => c instanceof DropForeignDataWrapper)).toBe(true);
+    expect(changes.some((c) => c instanceof CreateForeignDataWrapper)).toBe(
+      true,
+    );
+  });
+
+  test("created with privileges emits grant", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const changes = diffForeignDataWrappers(
+      testContext,
+      {},
+      { [fdw.stableId]: fdw },
+    );
+    expect(changes[0]).toBeInstanceOf(CreateForeignDataWrapper);
+    expect(
+      changes.some((c) => c instanceof GrantForeignDataWrapperPrivileges),
+    ).toBe(true);
+  });
+
+  test("altered comment emits create/drop comment", () => {
+    const base: ForeignDataWrapperProps = {
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const main = new ForeignDataWrapper(base);
+    const withComment = new ForeignDataWrapper({
+      ...base,
+      comment: "my fdw",
+    });
+
+    const addComment = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnForeignDataWrapper);
+
+    const dropComment = diffForeignDataWrappers(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnForeignDataWrapper);
+  });
+
+  test("altered privileges emit grant, revoke, and revoke grant option", () => {
+    const base: ForeignDataWrapperProps = {
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const main = new ForeignDataWrapper({
+      ...base,
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: true },
+        { grantee: "role_removed", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const branch = new ForeignDataWrapper({
+      ...base,
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: true },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: false },
+        { grantee: "role_new", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof GrantForeignDataWrapperPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeForeignDataWrapperPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some(
+        (c) => c instanceof RevokeGrantOptionForeignDataWrapperPrivileges,
+      ),
+    ).toBe(true);
+  });
+});

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

@@ -0,0 +1,271 @@
+import { diffObjects } from "../../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../../diff-context.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: Pick<ObjectDiffContext, "version" | "currentUser">,
+  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,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdFdw,
+        createdFdw,
+        "foreignDataWrapper",
+        {
+          Grant: GrantForeignDataWrapperPrivileges,
+          Revoke: RevokeForeignDataWrapperPrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignDataWrapperPrivileges,
+        },
+        ctx.version,
+      ) as ForeignDataWrapperChange[]),
+    );
+  }
+
+  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,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchFdw,
+        mainFdw,
+        "foreignDataWrapper",
+        {
+          Grant: GrantForeignDataWrapperPrivileges,
+          Revoke: RevokeForeignDataWrapperPrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignDataWrapperPrivileges,
+        },
+        ctx.version,
+      ) as ForeignDataWrapperChange[]),
+    );
+
+    // 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)
+        end as handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          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,
+        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),
+  );
+}