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

package/src/core/objects/type/enum/enum.diff.test.ts

@@ -4,8 +4,17 @@ import {
   AlterEnumAddValue,
   AlterEnumChangeOwner,
 } from "./changes/enum.alter.ts";
+import {
+  CreateCommentOnEnum,
+  DropCommentOnEnum,
+} from "./changes/enum.comment.ts";
 import { CreateEnum } from "./changes/enum.create.ts";
 import { DropEnum } from "./changes/enum.drop.ts";
+import {
+  GrantEnumPrivileges,
+  RevokeEnumPrivileges,
+  RevokeGrantOptionEnumPrivileges,
+} from "./changes/enum.privilege.ts";
 import { diffEnums } from "./enum.diff.ts";
 import { Enum, type EnumProps } from "./enum.model.ts";
 
@@ -188,4 +197,176 @@ describe.concurrent("enum.diff", () => {
     expect(add?.position?.after).toBe("b");
     expect(add?.position?.before).toBeUndefined();
   });
+
+  test("create with comment emits CreateCommentOnEnum", () => {
+    const e = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: "my enum",
+      privileges: [],
+    });
+    const changes = diffEnums(testContext, {}, { [e.stableId]: e });
+    expect(changes[0]).toBeInstanceOf(CreateEnum);
+    expect(changes.some((c) => c instanceof CreateCommentOnEnum)).toBe(true);
+  });
+
+  test("create with privileges that trigger revoke grant option", () => {
+    const dpState = new DefaultPrivilegeState({});
+    dpState.applyGrant("postgres", "T", null, "role_downgrade", [
+      { privilege: "USAGE", grantable: true },
+    ]);
+    const ctx = { ...testContext, defaultPrivilegeState: dpState };
+    const e = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: null,
+      privileges: [
+        { grantee: "role_downgrade", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const changes = diffEnums(ctx, {}, { [e.stableId]: e });
+    expect(changes[0]).toBeInstanceOf(CreateEnum);
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionEnumPrivileges),
+    ).toBe(true);
+  });
+
+  test("alter with removed labels triggers drop and recreate", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "b", sort_order: 2 },
+        { label: "c", sort_order: 3 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+    const branch = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "c", sort_order: 2 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropEnum);
+    expect(changes[1]).toBeInstanceOf(CreateEnum);
+  });
+
+  test("alter with removed labels preserves comment and privileges", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "b", sort_order: 2 },
+      ],
+      comment: "my enum",
+      privileges: [{ grantee: "role_a", privilege: "USAGE", grantable: false }],
+    });
+    const branch = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: "my enum",
+      privileges: [{ grantee: "role_a", privilege: "USAGE", grantable: false }],
+    });
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropEnum);
+    expect(changes[1]).toBeInstanceOf(CreateEnum);
+    expect(changes.some((c) => c instanceof CreateCommentOnEnum)).toBe(true);
+    expect(changes.some((c) => c instanceof GrantEnumPrivileges)).toBe(true);
+  });
+
+  test("alter comment emits create and drop comment", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: null,
+      privileges: [],
+    });
+    const withComment = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: "my enum",
+      privileges: [],
+    });
+
+    const addComment = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment.some((c) => c instanceof CreateCommentOnEnum)).toBe(true);
+
+    const dropComment = diffEnums(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment.some((c) => c instanceof DropCommentOnEnum)).toBe(true);
+  });
+
+  test("alter privileges emits grant, revoke, and revoke grant option", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: null,
+      privileges: [
+        { grantee: "role_a", privilege: "USAGE", grantable: false },
+        { grantee: "role_b", privilege: "USAGE", grantable: true },
+        { grantee: "role_removed", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const branch = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [{ label: "a", sort_order: 1 }],
+      comment: null,
+      privileges: [
+        { grantee: "role_a", privilege: "USAGE", grantable: true },
+        { grantee: "role_b", privilege: "USAGE", grantable: false },
+        { grantee: "role_new", privilege: "USAGE", grantable: false },
+      ],
+    });
+
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof GrantEnumPrivileges)).toBe(true);
+    expect(changes.some((c) => c instanceof RevokeEnumPrivileges)).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionEnumPrivileges),
+    ).toBe(true);
+  });
 });

package/src/core/objects/type/enum/enum.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 {
   AlterEnumAddValue,
   AlterEnumChangeOwner,
@@ -33,12 +32,10 @@ import type { Enum } from "./enum.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffEnums(
-  ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-  },
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
   main: Record<string, Enum>,
   branch: Record<string, Enum>,
 ): EnumChange[] {
@@ -75,6 +72,10 @@ export function diffEnums(
       "enum",
       createdEnum.schema ?? "",
     );
+    const creatorFilteredDefaults =
+      createdEnum.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
@@ -85,57 +86,25 @@ export function diffEnums(
     // Filter out owner privileges - owner always has ALL privileges implicitly
     // and shouldn't be compared. Use the enum owner as the reference.
     const privilegeResults = diffPrivileges(
-      effectiveDefaults,
+      filterPublicBuiltInDefaults("enum", creatorFilteredDefaults),
       desiredPrivileges,
       createdEnum.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 GrantEnumPrivileges({
-              enum: createdEnum,
-              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 RevokeEnumPrivileges({
-              enum: createdEnum,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionEnumPrivileges({
-            enum: createdEnum,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdEnum,
+        createdEnum,
+        "enum",
+        {
+          Grant: GrantEnumPrivileges,
+          Revoke: RevokeEnumPrivileges,
+          RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        },
+        ctx.version,
+      ) as EnumChange[]),
+    );
   }
 
   for (const enumId of dropped) {
@@ -173,59 +142,34 @@ export function diffEnums(
         "enum",
         branchEnum.schema ?? "",
       );
+      const creatorFilteredDefaults =
+        branchEnum.owner !== ctx.currentUser
+          ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+          : effectiveDefaults;
       const desiredPrivileges = filterPublicBuiltInDefaults(
         "enum",
         branchEnum.privileges,
       );
       const privilegeResults = diffPrivileges(
-        effectiveDefaults,
+        filterPublicBuiltInDefaults("enum", creatorFilteredDefaults),
         desiredPrivileges,
         branchEnum.owner,
-        ctx.mainRoles,
       );
 
-      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 GrantEnumPrivileges({
-                enum: branchEnum,
-                grantee,
-                privileges: list,
-                version: ctx.version,
-              }),
-            );
-          }
-        }
-
-        if (result.revokes.length > 0) {
-          const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-          for (const [grantable, list] of revokeGroups) {
-            void grantable;
-            changes.push(
-              new RevokeEnumPrivileges({
-                enum: branchEnum,
-                grantee,
-                privileges: list,
-                version: ctx.version,
-              }),
-            );
-          }
-        }
-
-        if (result.revokeGrantOption.length > 0) {
-          changes.push(
-            new RevokeGrantOptionEnumPrivileges({
-              enum: branchEnum,
-              grantee,
-              privilegeNames: result.revokeGrantOption,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchEnum,
+          branchEnum,
+          "enum",
+          {
+            Grant: GrantEnumPrivileges,
+            Revoke: RevokeEnumPrivileges,
+            RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+          },
+          ctx.version,
+        ) as EnumChange[]),
+      );
 
       continue;
     }
@@ -270,54 +214,22 @@ export function diffEnums(
       mainPrivilegesFiltered,
       branchPrivilegesFiltered,
       branchEnum.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 GrantEnumPrivileges({
-              enum: branchEnum,
-              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 RevokeEnumPrivileges({
-              enum: mainEnum,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionEnumPrivileges({
-            enum: mainEnum,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchEnum,
+        mainEnum,
+        "enum",
+        {
+          Grant: GrantEnumPrivileges,
+          Revoke: RevokeEnumPrivileges,
+          RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        },
+        ctx.version,
+      ) as EnumChange[]),
+    );
 
     // Note: Enum renaming would also use ALTER TYPE ... RENAME TO ...
     // But since our Enum model uses 'name' as the identity field,

package/src/core/objects/type/enum/enum.model.ts

@@ -145,7 +145,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Range, type RangeProps } from "../range.model.ts";
 import { AlterRangeChangeOwner } from "./range.alter.ts";
 
 describe.concurrent("range", () => {
-  test("change owner", () => {
+  test("change owner", async () => {
     const base: RangeProps = {
       schema: "public",
       name: "ts_custom",
@@ -22,6 +23,7 @@ describe.concurrent("range", () => {
     };
     const main = new Range(base);
     const change = new AlterRangeChangeOwner({ range: main, owner: "o2" });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("ALTER TYPE public.ts_custom OWNER TO o2");
   });
 });

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Range } from "../range.model.ts";
 import { CreateRange } from "./range.create.ts";
 
 describe("range", () => {
-  test("create minimal", () => {
+  test("create minimal", async () => {
     const r = new Range({
       schema: "public",
       name: "tsrange_custom",
@@ -21,12 +22,13 @@ describe("range", () => {
       privileges: [],
     });
     const change = new CreateRange({ range: r });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "CREATE TYPE public.tsrange_custom AS RANGE (SUBTYPE = int4)",
     );
   });
 
-  test("create with options", () => {
+  test("create with options", async () => {
     const r = new Range({
       schema: "public",
       name: "daterange_custom",
@@ -44,6 +46,7 @@ describe("range", () => {
       privileges: [],
     });
     const change = new CreateRange({ range: r });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       'CREATE TYPE public.daterange_custom AS RANGE (SUBTYPE = date, SUBTYPE_OPCLASS = public.date_ops, COLLATION = "en_US", CANONICAL = public.canon_fn, SUBTYPE_DIFF = public.diff_fn)',
     );

package/src/core/objects/type/range/changes/range.create.ts

@@ -1,6 +1,7 @@
 import {
   isUserDefinedTypeSchema,
   parseProcedureReference,
+  parseTypeString,
   stableId,
 } from "../../../utils.ts";
 import type { Range } from "../range.model.ts";
@@ -103,9 +104,12 @@ export class CreateRange extends CreateRangeChange {
 
     const opts: string[] = [];
 
-    // Required subtype
+    // Required subtype (format_type may already return schema-qualified name)
+    const alreadyQualified = parseTypeString(this.range.subtype_str);
     const subtypeQualified =
-      this.range.subtype_schema && this.range.subtype_schema !== "pg_catalog"
+      !alreadyQualified &&
+      this.range.subtype_schema &&
+      this.range.subtype_schema !== "pg_catalog"
         ? `${this.range.subtype_schema}.${this.range.subtype_str}`
         : this.range.subtype_str;
     opts.push(`SUBTYPE = ${subtypeQualified}`);

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
 import { Range } from "../range.model.ts";
 import { DropRange } from "./range.drop.ts";
 
 describe("range", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const r = new Range({
       schema: "public",
       name: "tsrange_custom",
@@ -21,6 +22,7 @@ describe("range", () => {
       privileges: [],
     });
     const change = new DropRange({ range: r });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("DROP TYPE public.tsrange_custom");
   });
 });

package/src/core/objects/type/range/range.diff.test.ts

@@ -1,8 +1,17 @@
 import { describe, expect, test } from "bun:test";
 import { DefaultPrivilegeState } from "../../base.default-privileges.ts";
 import { AlterRangeChangeOwner } from "./changes/range.alter.ts";
+import {
+  CreateCommentOnRange,
+  DropCommentOnRange,
+} from "./changes/range.comment.ts";
 import { CreateRange } from "./changes/range.create.ts";
 import { DropRange } from "./changes/range.drop.ts";
+import {
+  GrantRangePrivileges,
+  RevokeGrantOptionRangePrivileges,
+  RevokeRangePrivileges,
+} from "./changes/range.privilege.ts";
 import { diffRanges } from "./range.diff.ts";
 import { Range, type RangeProps } from "./range.model.ts";
 
@@ -67,4 +76,72 @@ describe.concurrent("range.diff", () => {
     expect(changes[0]).toBeInstanceOf(DropRange);
     expect(changes[1]).toBeInstanceOf(CreateRange);
   });
+
+  test("create with comment emits CreateCommentOnRange", () => {
+    const r = new Range({ ...base, comment: "my range" });
+    const changes = diffRanges(testContext, {}, { [r.stableId]: r });
+    expect(changes[0]).toBeInstanceOf(CreateRange);
+    expect(changes.some((c) => c instanceof CreateCommentOnRange)).toBe(true);
+  });
+
+  test("create with privileges emits grant changes", () => {
+    const r = new Range({
+      ...base,
+      privileges: [{ grantee: "role_a", privilege: "USAGE", grantable: false }],
+    });
+    const changes = diffRanges(testContext, {}, { [r.stableId]: r });
+    expect(changes[0]).toBeInstanceOf(CreateRange);
+    expect(changes.some((c) => c instanceof GrantRangePrivileges)).toBe(true);
+  });
+
+  test("alter comment emits create and drop comment", () => {
+    const main = new Range(base);
+    const withComment = new Range({ ...base, comment: "my range" });
+
+    const addComment = diffRanges(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment.some((c) => c instanceof CreateCommentOnRange)).toBe(
+      true,
+    );
+
+    const dropComment = diffRanges(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment.some((c) => c instanceof DropCommentOnRange)).toBe(true);
+  });
+
+  test("alter privileges emits grant, revoke, and revoke grant option", () => {
+    const main = new Range({
+      ...base,
+      privileges: [
+        { grantee: "role_a", privilege: "USAGE", grantable: false },
+        { grantee: "role_b", privilege: "USAGE", grantable: true },
+        { grantee: "role_removed", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const branch = new Range({
+      ...base,
+      privileges: [
+        { grantee: "role_a", privilege: "USAGE", grantable: true },
+        { grantee: "role_b", privilege: "USAGE", grantable: false },
+        { grantee: "role_new", privilege: "USAGE", grantable: false },
+      ],
+    });
+
+    const changes = diffRanges(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof GrantRangePrivileges)).toBe(true);
+    expect(changes.some((c) => c instanceof RevokeRangePrivileges)).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionRangePrivileges),
+    ).toBe(true);
+  });
 });