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

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import {
   ForeignTable,
   type ForeignTableProps,
@@ -47,19 +48,21 @@ describe.concurrent("foreign-table", () => {
       privileges: [],
     };
 
-    test("change owner", () => {
+    test("change owner", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableChangeOwner({
         foreignTable,
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table OWNER TO new_owner",
       );
     });
 
-    test("add column", () => {
+    test("add column", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAddColumn({
         foreignTable,
@@ -83,12 +86,14 @@ describe.concurrent("foreign-table", () => {
         },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text",
       );
     });
 
-    test("add column with NOT NULL", () => {
+    test("add column with NOT NULL", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAddColumn({
         foreignTable,
@@ -112,12 +117,14 @@ describe.concurrent("foreign-table", () => {
         },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text NOT NULL",
       );
     });
 
-    test("add column with DEFAULT", () => {
+    test("add column with DEFAULT", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAddColumn({
         foreignTable,
@@ -141,12 +148,14 @@ describe.concurrent("foreign-table", () => {
         },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text DEFAULT 'default_value'",
       );
     });
 
-    test("add column with NOT NULL and DEFAULT", () => {
+    test("add column with NOT NULL and DEFAULT", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAddColumn({
         foreignTable,
@@ -170,24 +179,28 @@ describe.concurrent("foreign-table", () => {
         },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text NOT NULL DEFAULT 'default_value'",
       );
     });
 
-    test("drop column", () => {
+    test("drop column", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableDropColumn({
         foreignTable,
         columnName: "id",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table DROP COLUMN id",
       );
     });
 
-    test("alter column type", () => {
+    test("alter column type", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAlterColumnType({
         foreignTable,
@@ -195,12 +208,14 @@ describe.concurrent("foreign-table", () => {
         dataType: "bigint",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id TYPE bigint",
       );
     });
 
-    test("alter column set default", () => {
+    test("alter column set default", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAlterColumnSetDefault({
         foreignTable,
@@ -208,48 +223,56 @@ describe.concurrent("foreign-table", () => {
         defaultValue: "0",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id SET DEFAULT 0",
       );
     });
 
-    test("alter column drop default", () => {
+    test("alter column drop default", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAlterColumnDropDefault({
         foreignTable,
         columnName: "id",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id DROP DEFAULT",
       );
     });
 
-    test("alter column set not null", () => {
+    test("alter column set not null", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAlterColumnSetNotNull({
         foreignTable,
         columnName: "id",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id SET NOT NULL",
       );
     });
 
-    test("alter column drop not null", () => {
+    test("alter column drop not null", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableAlterColumnDropNotNull({
         foreignTable,
         columnName: "id",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id DROP NOT NULL",
       );
     });
 
-    test("set options ADD", () => {
+    test("set options ADD", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableSetOptions({
         foreignTable,
@@ -259,12 +282,14 @@ describe.concurrent("foreign-table", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table OPTIONS (ADD schema_name 'remote_schema', ADD table_name 'remote_table')",
       );
     });
 
-    test("set options SET", () => {
+    test("set options SET", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableSetOptions({
         foreignTable,
@@ -273,24 +298,28 @@ describe.concurrent("foreign-table", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table OPTIONS (SET schema_name 'new_schema')",
       );
     });
 
-    test("set options DROP", () => {
+    test("set options DROP", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableSetOptions({
         foreignTable,
         options: [{ action: "DROP", option: "schema_name" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table OPTIONS (DROP schema_name)",
       );
     });
 
-    test("set options mixed ADD/SET/DROP", () => {
+    test("set options mixed ADD/SET/DROP", async () => {
       const foreignTable = new ForeignTable(baseTableProps);
       const change = new AlterForeignTableSetOptions({
         foreignTable,
@@ -301,6 +330,8 @@ describe.concurrent("foreign-table", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER FOREIGN TABLE public.test_table OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { ForeignTable } from "../foreign-table.model.ts";
 import { CreateForeignTable } from "./foreign-table.create.ts";
 
 describe("foreign-table", () => {
-  test("create basic", () => {
+  test("create basic", async () => {
     const foreignTable = new ForeignTable({
       schema: "public",
       name: "test_table",
@@ -38,12 +39,14 @@ describe("foreign-table", () => {
       foreignTable,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN TABLE public.test_table (id integer) SERVER test_server",
     );
   });
 
-  test("create with multiple columns", () => {
+  test("create with multiple columns", async () => {
     const foreignTable = new ForeignTable({
       schema: "public",
       name: "test_table",
@@ -96,12 +99,14 @@ describe("foreign-table", () => {
       foreignTable,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN TABLE public.test_table (id integer, name text) SERVER test_server",
     );
   });
 
-  test("create with options", () => {
+  test("create with options", async () => {
     const foreignTable = new ForeignTable({
       schema: "public",
       name: "test_table",
@@ -136,12 +141,14 @@ describe("foreign-table", () => {
       foreignTable,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN TABLE public.test_table (id integer) SERVER test_server OPTIONS (schema_name 'remote_schema', table_name 'remote_table')",
     );
   });
 
-  test("create with all properties", () => {
+  test("create with all properties", async () => {
     const foreignTable = new ForeignTable({
       schema: "public",
       name: "test_table",
@@ -194,6 +201,8 @@ describe("foreign-table", () => {
       foreignTable,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE FOREIGN TABLE public.test_table (id integer, name text) SERVER test_server OPTIONS (schema_name 'remote_schema', table_name 'remote_table')",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { ForeignTable } from "../foreign-table.model.ts";
 import { DropForeignTable } from "./foreign-table.drop.ts";
 
 describe("foreign-table", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const foreignTable = new ForeignTable({
       schema: "public",
       name: "test_table",
@@ -38,6 +39,8 @@ describe("foreign-table", () => {
       foreignTable,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP FOREIGN TABLE public.test_table");
   });
 });

package/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.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 {
   AlterForeignTableAddColumn,
   AlterForeignTableAlterColumnDropDefault,
@@ -40,12 +39,10 @@ import type { ForeignTable } from "./foreign-table.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffForeignTables(
-  ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-  },
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
   main: Record<string, ForeignTable>,
   branch: Record<string, ForeignTable>,
 ): ForeignTableChange[] {
@@ -80,62 +77,34 @@ export function diffForeignTables(
       "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,
+      filterPublicBuiltInDefaults("foreign_table", creatorFilteredDefaults),
       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,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdTable,
+        createdTable,
+        "foreignTable",
+        {
+          Grant: GrantForeignTablePrivileges,
+          Revoke: RevokeForeignTablePrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        },
+        ctx.version,
+      ) as ForeignTableChange[]),
+    );
   }
 
   for (const tableId of dropped) {
@@ -293,54 +262,22 @@ export function diffForeignTables(
       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,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchTable,
+        mainTable,
+        "foreignTable",
+        {
+          Grant: GrantForeignTablePrivileges,
+          Revoke: RevokeForeignTablePrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        },
+        ctx.version,
+      ) as ForeignTableChange[]),
+    );
 
     // Note: Foreign table renaming would also use ALTER FOREIGN TABLE ... RENAME TO ...
     // But since our ForeignTable model uses 'name' as the identity field,

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

@@ -196,7 +196,7 @@ export async function extractForeignTables(
             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

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Server, type ServerProps } from "../server.model.ts";
 import {
   AlterServerChangeOwner,
@@ -8,7 +9,7 @@ import {
 
 describe.concurrent("server", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "old_owner",
@@ -25,12 +26,14 @@ describe.concurrent("server", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER SERVER test_server OWNER TO new_owner",
       );
     });
 
-    test("set version", () => {
+    test("set version", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -47,10 +50,12 @@ describe.concurrent("server", () => {
         version: "2.0",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe("ALTER SERVER test_server VERSION '2.0'");
     });
 
-    test("set version to null", () => {
+    test("set version to null", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -67,10 +72,12 @@ describe.concurrent("server", () => {
         version: null,
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe("ALTER SERVER test_server VERSION ''");
     });
 
-    test("set options ADD", () => {
+    test("set options ADD", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -90,12 +97,14 @@ describe.concurrent("server", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER SERVER test_server OPTIONS (ADD host 'localhost', ADD port '5432')",
       );
     });
 
-    test("set options SET", () => {
+    test("set options SET", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -112,12 +121,14 @@ describe.concurrent("server", () => {
         options: [{ action: "SET", option: "host", value: "newhost" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER SERVER test_server OPTIONS (SET host 'newhost')",
       );
     });
 
-    test("set options DROP", () => {
+    test("set options DROP", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -134,12 +145,14 @@ describe.concurrent("server", () => {
         options: [{ action: "DROP", option: "host" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER SERVER test_server OPTIONS (DROP host)",
       );
     });
 
-    test("set options mixed ADD/SET/DROP", () => {
+    test("set options mixed ADD/SET/DROP", async () => {
       const props: ServerProps = {
         name: "test_server",
         owner: "test",
@@ -160,6 +173,8 @@ describe.concurrent("server", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER SERVER test_server OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
       );