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

package/src/core/objects/type/composite-type/changes/composite-type.alter.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import {
   CompositeType,
   type CompositeTypeProps,
@@ -12,7 +13,7 @@ import {
 
 describe.concurrent("composite-type", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<CompositeTypeProps, "owner"> = {
         schema: "public",
         name: "test_type",
@@ -40,13 +41,15 @@ describe.concurrent("composite-type", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TYPE public.test_type OWNER TO new_owner",
       );
     });
   });
 
-  test("add attribute", () => {
+  test("add attribute", async () => {
     const base = {
       schema: "public",
       name: "ct",
@@ -93,12 +96,13 @@ describe.concurrent("composite-type", () => {
       compositeType: branch,
       attribute: branch.columns[0],
     });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "ALTER TYPE public.ct ADD ATTRIBUTE a text",
     );
   });
 
-  test("drop attribute", () => {
+  test("drop attribute", async () => {
     const base = {
       schema: "public",
       name: "ct",
@@ -145,10 +149,11 @@ describe.concurrent("composite-type", () => {
       compositeType: main,
       attribute: main.columns[0],
     });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("ALTER TYPE public.ct DROP ATTRIBUTE a");
   });
 
-  test("alter attribute type and collation", () => {
+  test("alter attribute type and collation", async () => {
     const base = {
       schema: "public",
       name: "ct",
@@ -195,6 +200,7 @@ describe.concurrent("composite-type", () => {
       compositeType: branch,
       attribute: branch.columns[0],
     });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       'ALTER TYPE public.ct ALTER ATTRIBUTE a TYPE text COLLATE "en_US"',
     );

package/src/core/objects/type/composite-type/changes/composite-type.create.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { CompositeType } from "../composite-type.model.ts";
 import { CreateCompositeType } from "./composite-type.create.ts";
 
 describe("composite-type", () => {
-  test("create", () => {
+  test("create", async () => {
     const compositeType = new CompositeType({
       schema: "public",
       name: "test_type",
@@ -47,12 +48,14 @@ describe("composite-type", () => {
       compositeType,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE TYPE public.test_type AS (id integer)",
     );
   });
 
-  test("create with collate", () => {
+  test("create with collate", async () => {
     const compositeType = new CompositeType({
       schema: "public",
       name: "test_type",
@@ -94,6 +97,8 @@ describe("composite-type", () => {
 
     const change = new CreateCompositeType({ compositeType });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       'CREATE TYPE public.test_type AS (name text COLLATE "en_US")',
     );

package/src/core/objects/type/composite-type/changes/composite-type.drop.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { CompositeType } from "../composite-type.model.ts";
 import { DropCompositeType } from "./composite-type.drop.ts";
 
 describe("composite-type", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const compositeType = new CompositeType({
       schema: "public",
       name: "test_type",
@@ -28,6 +29,8 @@ describe("composite-type", () => {
       compositeType,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP TYPE public.test_type");
   });
 });

package/src/core/objects/type/composite-type/composite-type.diff.test.ts

@@ -6,8 +6,17 @@ import {
   AlterCompositeTypeChangeOwner,
   AlterCompositeTypeDropAttribute,
 } from "./changes/composite-type.alter.ts";
+import {
+  CreateCommentOnCompositeType,
+  DropCommentOnCompositeType,
+} from "./changes/composite-type.comment.ts";
 import { CreateCompositeType } from "./changes/composite-type.create.ts";
 import { DropCompositeType } from "./changes/composite-type.drop.ts";
+import {
+  GrantCompositeTypePrivileges,
+  RevokeCompositeTypePrivileges,
+  RevokeGrantOptionCompositeTypePrivileges,
+} from "./changes/composite-type.privilege.ts";
 import { diffCompositeTypes } from "./composite-type.diff.ts";
 import {
   CompositeType,
@@ -188,4 +197,73 @@ describe.concurrent("composite-type.diff", () => {
       changes.some((c) => c instanceof AlterCompositeTypeAlterAttributeType),
     ).toBe(true);
   });
+
+  test("created with privileges emits grant/revoke/revoke grant option", () => {
+    const ct = new CompositeType({
+      ...base,
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+        { grantee: "role_grant", privilege: "USAGE", grantable: true },
+      ],
+    });
+    const changes = diffCompositeTypes(testContext, {}, { [ct.stableId]: ct });
+    expect(changes[0]).toBeInstanceOf(CreateCompositeType);
+    expect(changes.some((c) => c instanceof GrantCompositeTypePrivileges)).toBe(
+      true,
+    );
+  });
+
+  test("altered comment emits create/drop comment", () => {
+    const main = new CompositeType(base);
+    const withComment = new CompositeType({ ...base, comment: "my type" });
+
+    const addComment = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnCompositeType);
+
+    const dropComment = diffCompositeTypes(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnCompositeType);
+  });
+
+  test("altered privileges emit grant, revoke, and revoke grant option", () => {
+    const main = new CompositeType({
+      ...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 CompositeType({
+      ...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 = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof GrantCompositeTypePrivileges)).toBe(
+      true,
+    );
+    expect(
+      changes.some((c) => c instanceof RevokeCompositeTypePrivileges),
+    ).toBe(true);
+    expect(
+      changes.some(
+        (c) => c instanceof RevokeGrantOptionCompositeTypePrivileges,
+      ),
+    ).toBe(true);
+  });
 });

package/src/core/objects/type/composite-type/composite-type.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 { deepEqual, hasNonAlterableChanges } from "../../utils.ts";
 import {
   AlterCompositeTypeAddAttribute,
@@ -38,12 +37,10 @@ import type { CompositeType } from "./composite-type.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffCompositeTypes(
-  ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-  },
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
   main: Record<string, CompositeType>,
   branch: Record<string, CompositeType>,
 ): CompositeTypeChange[] {
@@ -92,6 +89,10 @@ export function diffCompositeTypes(
       "composite_type",
       ct.schema ?? "",
     );
+    const creatorFilteredDefaults =
+      ct.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
     // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
     // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
     // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
@@ -102,56 +103,25 @@ export function diffCompositeTypes(
     // Filter out owner privileges - owner always has ALL privileges implicitly
     // and shouldn't be compared. Use the composite type owner as the reference.
     const privilegeResults = diffPrivileges(
-      effectiveDefaults,
+      filterPublicBuiltInDefaults("composite_type", creatorFilteredDefaults),
       desiredPrivileges,
       ct.owner,
     );
 
-    // 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 GrantCompositeTypePrivileges({
-              compositeType: ct,
-              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 RevokeCompositeTypePrivileges({
-              compositeType: ct,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionCompositeTypePrivileges({
-            compositeType: ct,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        ct,
+        ct,
+        "compositeType",
+        {
+          Grant: GrantCompositeTypePrivileges,
+          Revoke: RevokeCompositeTypePrivileges,
+          RevokeGrantOption: RevokeGrantOptionCompositeTypePrivileges,
+        },
+        ctx.version,
+      ) as CompositeTypeChange[]),
+    );
   }
 
   for (const compositeTypeId of dropped) {
@@ -313,54 +283,22 @@ export function diffCompositeTypes(
         mainPrivilegesFiltered,
         branchPrivilegesFiltered,
         branchCompositeType.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 GrantCompositeTypePrivileges({
-                compositeType: branchCompositeType,
-                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 RevokeCompositeTypePrivileges({
-                compositeType: mainCompositeType,
-                grantee,
-                privileges: list,
-                version: ctx.version,
-              }),
-            );
-          }
-        }
-
-        // Generate revoke grant option changes
-        if (result.revokeGrantOption.length > 0) {
-          changes.push(
-            new RevokeGrantOptionCompositeTypePrivileges({
-              compositeType: mainCompositeType,
-              grantee,
-              privilegeNames: result.revokeGrantOption,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchCompositeType,
+          mainCompositeType,
+          "compositeType",
+          {
+            Grant: GrantCompositeTypePrivileges,
+            Revoke: RevokeCompositeTypePrivileges,
+            RevokeGrantOption: RevokeGrantOptionCompositeTypePrivileges,
+          },
+          ctx.version,
+        ) as CompositeTypeChange[]),
+      );
 
       // Note: Composite type renaming would also use ALTER TYPE ... RENAME TO ...
       // But since our CompositeType model uses 'name' as the identity field,

package/src/core/objects/type/composite-type/composite-type.model.ts

@@ -164,6 +164,7 @@ export async function extractCompositeTypes(
           c.relowner::regrole::text           AS owner,
           obj_description(c.reltype, 'pg_type') AS comment,
           c.relacl                            AS relacl,    -- used by privileges LATERAL
+          c.relowner                          AS relowner,
           c.oid                                AS oid
         FROM pg_catalog.pg_class c
         LEFT JOIN extension_oids e ON c.reltype = e.objid
@@ -201,7 +202,7 @@ export async function extractCompositeTypes(
                 )
                 ORDER BY x.grantee, x.privilege_type
               ) AS privileges
-        FROM LATERAL aclexplode(ct.relacl) AS x(grantor, grantee, privilege_type, is_grantable)
+        FROM LATERAL aclexplode(COALESCE(ct.relacl, acldefault('T', ct.relowner))) AS x(grantor, grantee, privilege_type, is_grantable)
       ) priv ON TRUE
 
       -- columns as a per-row LATERAL subquery (so no GROUP BY needed)

package/src/core/objects/type/enum/changes/enum.alter.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Enum, type EnumProps } from "../enum.model.ts";
 import { AlterEnumAddValue, AlterEnumChangeOwner } from "./enum.alter.ts";
 
 describe.concurrent("enum", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<EnumProps, "owner"> = {
         schema: "public",
         name: "test_enum",
@@ -24,12 +25,14 @@ describe.concurrent("enum", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TYPE public.test_enum OWNER TO new_owner",
       );
     });
 
-    test("add value", () => {
+    test("add value", async () => {
       const props: EnumProps = {
         schema: "public",
         name: "test_enum",
@@ -44,12 +47,14 @@ describe.concurrent("enum", () => {
       const main = new Enum(props);
       const change = new AlterEnumAddValue({ enum: main, newValue: "value3" });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TYPE public.test_enum ADD VALUE 'value3'",
       );
     });
 
-    test("add value before", () => {
+    test("add value before", async () => {
       const props: EnumProps = {
         schema: "public",
         name: "test_enum",
@@ -68,12 +73,14 @@ describe.concurrent("enum", () => {
         position: { before: "value2" },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TYPE public.test_enum ADD VALUE 'value1_5' BEFORE 'value2'",
       );
     });
 
-    test("add value after", () => {
+    test("add value after", async () => {
       const props: EnumProps = {
         schema: "public",
         name: "test_enum",
@@ -92,12 +99,14 @@ describe.concurrent("enum", () => {
         position: { after: "value1" },
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TYPE public.test_enum ADD VALUE 'value1_5' AFTER 'value1'",
       );
     });
 
-    test("complex enum changes are not auto-replaced", () => {
+    test("complex enum changes are not auto-replaced", async () => {
       expect(1).toBe(1);
     });
   });

package/src/core/objects/type/enum/changes/enum.create.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Enum } from "../enum.model.ts";
 import { CreateEnum } from "./enum.create.ts";
 
 describe("enum", () => {
-  test("create", () => {
+  test("create", async () => {
     const enumType = new Enum({
       schema: "public",
       name: "test_enum",
@@ -21,6 +22,8 @@ describe("enum", () => {
       enum: enumType,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE TYPE public.test_enum AS ENUM ('value1', 'value2', 'value3')",
     );

package/src/core/objects/type/enum/changes/enum.drop.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Enum } from "../enum.model.ts";
 import { DropEnum } from "./enum.drop.ts";
 
 describe("enum", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const enumType = new Enum({
       schema: "public",
       name: "test_enum",
@@ -20,6 +21,8 @@ describe("enum", () => {
       enum: enumType,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP TYPE public.test_enum");
   });
 });