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

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Server } from "../server.model.ts";
 import { CreateServer } from "./server.create.ts";
 
 describe("server", () => {
-  test("create basic", () => {
+  test("create basic", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -19,12 +20,14 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server FOREIGN DATA WRAPPER test_fdw",
     );
   });
 
-  test("create with type", () => {
+  test("create with type", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -40,12 +43,14 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server TYPE 'postgres_fdw' FOREIGN DATA WRAPPER test_fdw",
     );
   });
 
-  test("create with version", () => {
+  test("create with version", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -61,12 +66,14 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server VERSION '1.0' FOREIGN DATA WRAPPER test_fdw",
     );
   });
 
-  test("create with type and version", () => {
+  test("create with type and version", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -82,12 +89,14 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server TYPE 'postgres_fdw' VERSION '1.0' FOREIGN DATA WRAPPER test_fdw",
     );
   });
 
-  test("create with options", () => {
+  test("create with options", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -103,12 +112,14 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server FOREIGN DATA WRAPPER test_fdw OPTIONS (host 'localhost', port '5432')",
     );
   });
 
-  test("create with all properties", () => {
+  test("create with all properties", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -124,6 +135,8 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE SERVER test_server TYPE 'postgres_fdw' VERSION '1.0' FOREIGN DATA WRAPPER test_fdw OPTIONS (host 'localhost', port '5432')",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Server } from "../server.model.ts";
 import { DropServer } from "./server.drop.ts";
 
 describe("server", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const server = new Server({
       name: "test_server",
       owner: "test",
@@ -19,6 +20,8 @@ describe("server", () => {
       server,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP SERVER test_server");
   });
 });

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

@@ -5,8 +5,17 @@ import {
   AlterServerSetOptions,
   AlterServerSetVersion,
 } from "./changes/server.alter.ts";
+import {
+  CreateCommentOnServer,
+  DropCommentOnServer,
+} from "./changes/server.comment.ts";
 import { CreateServer } from "./changes/server.create.ts";
 import { DropServer } from "./changes/server.drop.ts";
+import {
+  GrantServerPrivileges,
+  RevokeGrantOptionServerPrivileges,
+  RevokeServerPrivileges,
+} from "./changes/server.privilege.ts";
 import { diffServers } from "./server.diff.ts";
 import { Server, type ServerProps } from "./server.model.ts";
 
@@ -164,4 +173,90 @@ describe.concurrent("server.diff", () => {
     expect(changes.some((c) => c instanceof DropServer)).toBe(true);
     expect(changes.some((c) => c instanceof CreateServer)).toBe(true);
   });
+
+  test("created with privileges emits grant", () => {
+    const server = new Server({
+      name: "srv1",
+      owner: "o1",
+      foreign_data_wrapper: "fdw1",
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const changes = diffServers(testContext, {}, { [server.stableId]: server });
+    expect(changes[0]).toBeInstanceOf(CreateServer);
+    expect(changes.some((c) => c instanceof GrantServerPrivileges)).toBe(true);
+  });
+
+  test("altered comment emits create/drop comment", () => {
+    const base: ServerProps = {
+      name: "srv1",
+      owner: "o1",
+      foreign_data_wrapper: "fdw1",
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const main = new Server(base);
+    const withComment = new Server({ ...base, comment: "my server" });
+
+    const addComment = diffServers(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnServer);
+
+    const dropComment = diffServers(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnServer);
+  });
+
+  test("altered privileges emit grant, revoke, and revoke grant option", () => {
+    const base: ServerProps = {
+      name: "srv1",
+      owner: "o1",
+      foreign_data_wrapper: "fdw1",
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const main = new Server({
+      ...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 Server({
+      ...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 = diffServers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof GrantServerPrivileges)).toBe(true);
+    expect(changes.some((c) => c instanceof RevokeServerPrivileges)).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionServerPrivileges),
+    ).toBe(true);
+  });
 });

package/src/core/objects/foreign-data-wrapper/server/server.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 {
   AlterServerChangeOwner,
   AlterServerSetOptions,
@@ -34,12 +33,7 @@ import type { Server } from "./server.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffServers(
-  ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-  },
+  ctx: Pick<ObjectDiffContext, "version" | "currentUser">,
   main: Record<string, Server>,
   branch: Record<string, Server>,
 ): ServerChange[] {
@@ -80,54 +74,22 @@ export function diffServers(
       effectiveDefaults,
       desiredPrivileges,
       createdServer.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 GrantServerPrivileges({
-              server: createdServer,
-              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 RevokeServerPrivileges({
-              server: createdServer,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionServerPrivileges({
-            server: createdServer,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdServer,
+        createdServer,
+        "server",
+        {
+          Grant: GrantServerPrivileges,
+          Revoke: RevokeServerPrivileges,
+          RevokeGrantOption: RevokeGrantOptionServerPrivileges,
+        },
+        ctx.version,
+      ) as ServerChange[]),
+    );
   }
 
   for (const serverId of dropped) {
@@ -204,54 +166,22 @@ export function diffServers(
       mainPrivilegesFiltered,
       branchPrivilegesFiltered,
       branchServer.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 GrantServerPrivileges({
-              server: branchServer,
-              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 RevokeServerPrivileges({
-              server: mainServer,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionServerPrivileges({
-            server: mainServer,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchServer,
+        mainServer,
+        "server",
+        {
+          Grant: GrantServerPrivileges,
+          Revoke: RevokeServerPrivileges,
+          RevokeGrantOption: RevokeGrantOptionServerPrivileges,
+        },
+        ctx.version,
+      ) as ServerChange[]),
+    );
 
     // Note: Server renaming would also use ALTER SERVER ... RENAME TO ...
     // But since our Server model uses 'name' as the identity field,

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

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { UserMapping, type UserMappingProps } from "../user-mapping.model.ts";
 import { AlterUserMappingSetOptions } from "./user-mapping.alter.ts";
 
 describe.concurrent("user-mapping", () => {
   describe("alter", () => {
-    test("set options ADD", () => {
+    test("set options ADD", async () => {
       const props: UserMappingProps = {
         user: "test_user",
         server: "test_server",
@@ -19,12 +20,14 @@ describe.concurrent("user-mapping", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (ADD user 'remote_user', ADD password 'secret')",
       );
     });
 
-    test("set options SET", () => {
+    test("set options SET", async () => {
       const props: UserMappingProps = {
         user: "test_user",
         server: "test_server",
@@ -36,12 +39,14 @@ describe.concurrent("user-mapping", () => {
         options: [{ action: "SET", option: "password", value: "new_secret" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (SET password 'new_secret')",
       );
     });
 
-    test("set options DROP", () => {
+    test("set options DROP", async () => {
       const props: UserMappingProps = {
         user: "test_user",
         server: "test_server",
@@ -53,12 +58,14 @@ describe.concurrent("user-mapping", () => {
         options: [{ action: "DROP", option: "password" }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (DROP password)",
       );
     });
 
-    test("set options mixed ADD/SET/DROP", () => {
+    test("set options mixed ADD/SET/DROP", async () => {
       const props: UserMappingProps = {
         user: "PUBLIC",
         server: "test_server",
@@ -74,6 +81,8 @@ describe.concurrent("user-mapping", () => {
         ],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER USER MAPPING FOR PUBLIC SERVER test_server OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { UserMapping } from "../user-mapping.model.ts";
 import { CreateUserMapping } from "./user-mapping.create.ts";
 
 describe("user-mapping", () => {
-  test("create basic", () => {
+  test("create basic", async () => {
     const userMapping = new UserMapping({
       user: "test_user",
       server: "test_server",
@@ -14,12 +15,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE USER MAPPING FOR test_user SERVER test_server",
     );
   });
 
-  test("create with PUBLIC user", () => {
+  test("create with PUBLIC user", async () => {
     const userMapping = new UserMapping({
       user: "PUBLIC",
       server: "test_server",
@@ -30,12 +33,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE USER MAPPING FOR PUBLIC SERVER test_server",
     );
   });
 
-  test("create with CURRENT_USER", () => {
+  test("create with CURRENT_USER", async () => {
     const userMapping = new UserMapping({
       user: "CURRENT_USER",
       server: "test_server",
@@ -46,12 +51,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE USER MAPPING FOR CURRENT_USER SERVER test_server",
     );
   });
 
-  test("create with options", () => {
+  test("create with options", async () => {
     const userMapping = new UserMapping({
       user: "test_user",
       server: "test_server",
@@ -62,12 +69,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE USER MAPPING FOR test_user SERVER test_server OPTIONS (user 'remote_user', password 'secret')",
     );
   });
 
-  test("create with all properties", () => {
+  test("create with all properties", async () => {
     const userMapping = new UserMapping({
       user: "PUBLIC",
       server: "test_server",
@@ -78,6 +87,8 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE USER MAPPING FOR PUBLIC SERVER test_server OPTIONS (user 'remote_user', password 'secret')",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { UserMapping } from "../user-mapping.model.ts";
 import { DropUserMapping } from "./user-mapping.drop.ts";
 
 describe("user-mapping", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const userMapping = new UserMapping({
       user: "test_user",
       server: "test_server",
@@ -14,12 +15,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "DROP USER MAPPING FOR test_user SERVER test_server",
     );
   });
 
-  test("drop PUBLIC user mapping", () => {
+  test("drop PUBLIC user mapping", async () => {
     const userMapping = new UserMapping({
       user: "PUBLIC",
       server: "test_server",
@@ -30,12 +33,14 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "DROP USER MAPPING FOR PUBLIC SERVER test_server",
     );
   });
 
-  test("drop CURRENT_USER mapping", () => {
+  test("drop CURRENT_USER mapping", async () => {
     const userMapping = new UserMapping({
       user: "CURRENT_USER",
       server: "test_server",
@@ -46,6 +51,8 @@ describe("user-mapping", () => {
       userMapping,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "DROP USER MAPPING FOR CURRENT_USER SERVER test_server",
     );

package/src/core/objects/index/changes/index.alter.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Index, type IndexProps } from "../index.model.ts";
 import {
   AlterIndexSetStatistics,
@@ -8,7 +9,7 @@ import {
 
 describe.concurrent("index", () => {
   describe("alter", () => {
-    test("set storage params", () => {
+    test("set storage params", async () => {
       const props: Omit<IndexProps, "storage_params"> = {
         schema: "public",
         table_name: "test_table",
@@ -50,12 +51,14 @@ describe.concurrent("index", () => {
         keysToReset: [],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER INDEX public.test_index SET (fillfactor=90)",
       );
     });
 
-    test("reset and set storage params", () => {
+    test("reset and set storage params", async () => {
       const props: Omit<IndexProps, "storage_params"> = {
         schema: "public",
         table_name: "test_table",
@@ -97,6 +100,8 @@ describe.concurrent("index", () => {
         keysToReset: ["fastupdate"],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         [
           "ALTER INDEX public.test_index RESET (fastupdate)",
@@ -105,7 +110,7 @@ describe.concurrent("index", () => {
       );
     });
 
-    test("set statistics", () => {
+    test("set statistics", async () => {
       const props: Omit<IndexProps, "statistics_target"> = {
         schema: "public",
         table_name: "test_table",
@@ -146,12 +151,14 @@ describe.concurrent("index", () => {
         columnTargets: [{ columnNumber: 1, statistics: 100 }],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER INDEX public.test_index ALTER COLUMN 1 SET STATISTICS 100",
       );
     });
 
-    test("set tablespace", () => {
+    test("set tablespace", async () => {
       const props: Omit<IndexProps, "tablespace"> = {
         schema: "public",
         table_name: "test_table",
@@ -192,6 +199,8 @@ describe.concurrent("index", () => {
         tablespace: "fast_space",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER INDEX public.test_index SET TABLESPACE fast_space",
       );