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

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import {
   ForeignDataWrapper,
   type ForeignDataWrapperProps,
@@ -10,7 +11,7 @@ import {
 
 describe.concurrent("foreign-data-wrapper", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: ForeignDataWrapperProps = {
         name: "test_fdw",
         owner: "old_owner",
@@ -26,12 +27,14 @@ describe.concurrent("foreign-data-wrapper", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN DATA WRAPPER test_fdw OWNER TO new_owner",
       );
     });
 
-    test("set options ADD", () => {
+    test("set options ADD", async () => {
       const props: ForeignDataWrapperProps = {
         name: "test_fdw",
         owner: "test",
@@ -50,12 +53,14 @@ describe.concurrent("foreign-data-wrapper", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (ADD host 'localhost', ADD port '5432')",
       );
     });
 
-    test("set options SET", () => {
+    test("set options SET", async () => {
       const props: ForeignDataWrapperProps = {
         name: "test_fdw",
         owner: "test",
@@ -71,12 +76,14 @@ describe.concurrent("foreign-data-wrapper", () => {
         options: [{ action: "SET", option: "host", value: "newhost" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (SET host 'newhost')",
       );
     });
 
-    test("set options DROP", () => {
+    test("set options DROP", async () => {
       const props: ForeignDataWrapperProps = {
         name: "test_fdw",
         owner: "test",
@@ -92,12 +99,14 @@ describe.concurrent("foreign-data-wrapper", () => {
         options: [{ action: "DROP", option: "host" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (DROP host)",
       );
     });
 
-    test("set options mixed ADD/SET/DROP", () => {
+    test("set options mixed ADD/SET/DROP", async () => {
       const props: ForeignDataWrapperProps = {
         name: "test_fdw",
         owner: "test",
@@ -117,6 +126,8 @@ describe.concurrent("foreign-data-wrapper", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
 import { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
 
 describe("foreign-data-wrapper", () => {
-  test("create basic", () => {
+  test("create basic", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
@@ -18,16 +19,18 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR",
     );
   });
 
-  test("create with handler", () => {
+  test("create with handler", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
-      handler: "public.handler_func()",
+      handler: "public.handler_func",
       validator: null,
       options: null,
       comment: null,
@@ -38,17 +41,19 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
-      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() NO VALIDATOR",
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func NO VALIDATOR",
     );
   });
 
-  test("create with validator", () => {
+  test("create with validator", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
       handler: null,
-      validator: "public.validator_func()",
+      validator: "public.validator_func",
       options: null,
       comment: null,
       privileges: [],
@@ -58,17 +63,19 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
-      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER VALIDATOR public.validator_func()",
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER VALIDATOR public.validator_func",
     );
   });
 
-  test("create with handler and validator", () => {
+  test("create with handler and validator", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
-      handler: "public.handler_func()",
-      validator: "public.validator_func()",
+      handler: "public.handler_func",
+      validator: "public.validator_func",
       options: null,
       comment: null,
       privileges: [],
@@ -78,12 +85,14 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
-      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() VALIDATOR public.validator_func()",
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func VALIDATOR public.validator_func",
     );
   });
 
-  test("create with options", () => {
+  test("create with options", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
@@ -98,17 +107,19 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR OPTIONS (host 'localhost', port '5432')",
     );
   });
 
-  test("create with all properties", () => {
+  test("create with all properties", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
-      handler: "public.handler_func()",
-      validator: "public.validator_func()",
+      handler: "public.handler_func",
+      validator: "public.validator_func",
       options: ["host", "localhost", "port", "5432"],
       comment: null,
       privileges: [],
@@ -118,8 +129,32 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func VALIDATOR public.validator_func OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+
+  test("create with schema-qualified handler (no function args in output)", async () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: "extensions.iceberg_fdw_handler",
+      validator: "extensions.iceberg_fdw_validator",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
-      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() VALIDATOR public.validator_func() OPTIONS (host 'localhost', port '5432')",
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER extensions.iceberg_fdw_handler VALIDATOR extensions.iceberg_fdw_validator",
     );
   });
 });

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
 import { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
 
 describe("foreign-data-wrapper", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const fdw = new ForeignDataWrapper({
       name: "test_fdw",
       owner: "test",
@@ -18,6 +19,8 @@ describe("foreign-data-wrapper", () => {
       foreignDataWrapper: fdw,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP FOREIGN DATA WRAPPER test_fdw");
   });
 });

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

@@ -4,8 +4,17 @@ 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,
@@ -117,7 +126,7 @@ describe.concurrent("foreign-data-wrapper.diff", () => {
     const main = new ForeignDataWrapper({
       name: "fdw1",
       owner: "o1",
-      handler: "public.old_handler()",
+      handler: "public.old_handler",
       validator: null,
       options: null,
       comment: null,
@@ -126,7 +135,7 @@ describe.concurrent("foreign-data-wrapper.diff", () => {
     const branch = new ForeignDataWrapper({
       name: "fdw1",
       owner: "o1",
-      handler: "public.new_handler()",
+      handler: "public.new_handler",
       validator: null,
       options: null,
       comment: null,
@@ -150,7 +159,7 @@ describe.concurrent("foreign-data-wrapper.diff", () => {
       name: "fdw1",
       owner: "o1",
       handler: null,
-      validator: "public.old_validator()",
+      validator: "public.old_validator",
       options: null,
       comment: null,
       privileges: [],
@@ -159,7 +168,7 @@ describe.concurrent("foreign-data-wrapper.diff", () => {
       name: "fdw1",
       owner: "o1",
       handler: null,
-      validator: "public.new_validator()",
+      validator: "public.new_validator",
       options: null,
       comment: null,
       privileges: [],
@@ -176,4 +185,102 @@ describe.concurrent("foreign-data-wrapper.diff", () => {
       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

@@ -1,11 +1,10 @@
-import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
 import { diffObjects } from "../../base.diff.ts";
 import {
   diffPrivileges,
+  emitObjectPrivilegeChanges,
   filterPublicBuiltInDefaults,
-  groupPrivilegesByGrantable,
 } from "../../base.privilege-diff.ts";
-import type { Role } from "../../role/role.model.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
 import {
   AlterForeignDataWrapperChangeOwner,
   AlterForeignDataWrapperSetOptions,
@@ -33,12 +32,7 @@ import type { ForeignDataWrapper } from "./foreign-data-wrapper.model.ts";
  * @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>;
-  },
+  ctx: Pick<ObjectDiffContext, "version" | "currentUser">,
   main: Record<string, ForeignDataWrapper>,
   branch: Record<string, ForeignDataWrapper>,
 ): ForeignDataWrapperChange[] {
@@ -87,54 +81,22 @@ export function diffForeignDataWrappers(
       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,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdFdw,
+        createdFdw,
+        "foreignDataWrapper",
+        {
+          Grant: GrantForeignDataWrapperPrivileges,
+          Revoke: RevokeForeignDataWrapperPrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignDataWrapperPrivileges,
+        },
+        ctx.version,
+      ) as ForeignDataWrapperChange[]),
+    );
   }
 
   for (const fdwId of dropped) {
@@ -228,54 +190,22 @@ export function diffForeignDataWrappers(
       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,
-          }),
-        );
-      }
-    }
+    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,

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

@@ -93,11 +93,11 @@ export async function extractForeignDataWrappers(
         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,