@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -0,0 +1,269 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import {
+  AlterCompositeTypeAddAttribute,
+  AlterCompositeTypeAlterAttributeType,
+  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,
+  type CompositeTypeProps,
+} from "./composite-type.model.ts";
+
+const base: CompositeTypeProps = {
+  schema: "public",
+  name: "ct",
+  row_security: false,
+  force_row_security: false,
+  has_indexes: false,
+  has_rules: false,
+  has_triggers: false,
+  has_subclasses: false,
+  is_populated: true,
+  replica_identity: "d",
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  owner: "o1",
+  comment: null,
+  columns: [],
+  privileges: [],
+};
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("composite-type.diff", () => {
+  test("create and drop", () => {
+    const ct = new CompositeType(base);
+    const created = diffCompositeTypes(testContext, {}, { [ct.stableId]: ct });
+    expect(created[0]).toBeInstanceOf(CreateCompositeType);
+    const dropped = diffCompositeTypes(testContext, { [ct.stableId]: ct }, {});
+    expect(dropped[0]).toBeInstanceOf(DropCompositeType);
+  });
+
+  test("alter owner", () => {
+    const main = new CompositeType(base);
+    const branch = new CompositeType({ ...base, owner: "o2" });
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterCompositeTypeChangeOwner);
+  });
+
+  test("add attribute", () => {
+    const main = new CompositeType(base);
+    const branch = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterCompositeTypeAddAttribute),
+    ).toBe(true);
+  });
+
+  test("drop attribute", () => {
+    const main = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+    });
+    const branch = new CompositeType(base);
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterCompositeTypeDropAttribute),
+    ).toBe(true);
+  });
+
+  test("alter attribute type/collation", () => {
+    const main = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+    });
+    const branch = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: "en_US",
+          default: null,
+          comment: null,
+        },
+      ],
+    });
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      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

@@ -0,0 +1,310 @@
+import { diffObjects } from "../../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
+import { deepEqual, hasNonAlterableChanges } from "../../utils.ts";
+import {
+  AlterCompositeTypeAddAttribute,
+  AlterCompositeTypeAlterAttributeType,
+  AlterCompositeTypeChangeOwner,
+  AlterCompositeTypeDropAttribute,
+} from "./changes/composite-type.alter.ts";
+import {
+  CreateCommentOnCompositeType,
+  CreateCommentOnCompositeTypeAttribute,
+  DropCommentOnCompositeType,
+  DropCommentOnCompositeTypeAttribute,
+} 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 type { CompositeTypeChange } from "./changes/composite-type.types.ts";
+import type { CompositeType } from "./composite-type.model.ts";
+
+/**
+ * Diff two sets of composite types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The composite types in the main catalog.
+ * @param branch - The composite types in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffCompositeTypes(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, CompositeType>,
+  branch: Record<string, CompositeType>,
+): CompositeTypeChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: CompositeTypeChange[] = [];
+
+  for (const compositeTypeId of created) {
+    const ct = branch[compositeTypeId];
+    changes.push(new CreateCompositeType({ compositeType: ct }));
+
+    // OWNER: If the composite type should be owned by someone other than the current user,
+    // emit ALTER TYPE ... OWNER TO after creation
+    if (ct.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterCompositeTypeChangeOwner({
+          compositeType: ct,
+          owner: ct.owner,
+        }),
+      );
+    }
+
+    // Type comment on creation
+    if (ct.comment !== null) {
+      changes.push(new CreateCommentOnCompositeType({ compositeType: ct }));
+    }
+    // Attribute comments on creation
+    for (const attr of ct.columns) {
+      if (attr.comment !== null) {
+        changes.push(
+          new CreateCommentOnCompositeTypeAttribute({
+            compositeType: ct,
+            attribute: attr,
+          }),
+        );
+      }
+    }
+
+    // PRIVILEGES: For created objects, compare against default privileges state
+    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+    // so objects are created with the default privileges state in effect.
+    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+    // needed to reach the final desired state.
+    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+      ctx.currentUser,
+      "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
+    const desiredPrivileges = filterPublicBuiltInDefaults(
+      "composite_type",
+      ct.privileges,
+    );
+    // 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(
+      filterPublicBuiltInDefaults("composite_type", creatorFilteredDefaults),
+      desiredPrivileges,
+      ct.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        ct,
+        ct,
+        "compositeType",
+        {
+          Grant: GrantCompositeTypePrivileges,
+          Revoke: RevokeCompositeTypePrivileges,
+          RevokeGrantOption: RevokeGrantOptionCompositeTypePrivileges,
+        },
+        ctx.version,
+      ) as CompositeTypeChange[]),
+    );
+  }
+
+  for (const compositeTypeId of dropped) {
+    changes.push(
+      new DropCompositeType({ compositeType: main[compositeTypeId] }),
+    );
+  }
+
+  for (const compositeTypeId of altered) {
+    const mainCompositeType = main[compositeTypeId];
+    const branchCompositeType = branch[compositeTypeId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the composite type
+    const NON_ALTERABLE_FIELDS: Array<keyof CompositeType> = [
+      "row_security",
+      "force_row_security",
+      "has_indexes",
+      "has_rules",
+      "has_triggers",
+      "has_subclasses",
+      "is_populated",
+      "replica_identity",
+      "is_partition",
+      "options",
+      "partition_bound",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainCompositeType,
+      branchCompositeType,
+      NON_ALTERABLE_FIELDS,
+      { options: deepEqual },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replacement is not performed automatically for composite types
+      // to avoid destructive operations; keep changes minimal.
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainCompositeType.owner !== branchCompositeType.owner) {
+        changes.push(
+          new AlterCompositeTypeChangeOwner({
+            compositeType: mainCompositeType,
+            owner: branchCompositeType.owner,
+          }),
+        );
+      }
+
+      // TYPE COMMENT (create/drop when comment changes)
+      if (mainCompositeType.comment !== branchCompositeType.comment) {
+        if (branchCompositeType.comment === null) {
+          changes.push(
+            new DropCommentOnCompositeType({
+              compositeType: mainCompositeType,
+            }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnCompositeType({
+              compositeType: branchCompositeType,
+            }),
+          );
+        }
+      }
+
+      // ATTRIBUTE diffs
+      const mainAttrs = new Map(
+        mainCompositeType.columns.map((c) => [c.name, c]),
+      );
+      const branchAttrs = new Map(
+        branchCompositeType.columns.map((c) => [c.name, c]),
+      );
+
+      // Added attributes
+      for (const [name, attr] of branchAttrs) {
+        if (!mainAttrs.has(name)) {
+          changes.push(
+            new AlterCompositeTypeAddAttribute({
+              compositeType: branchCompositeType,
+              attribute: attr,
+            }),
+          );
+          if (attr.comment !== null) {
+            changes.push(
+              new CreateCommentOnCompositeTypeAttribute({
+                compositeType: branchCompositeType,
+                attribute: attr,
+              }),
+            );
+          }
+        }
+      }
+
+      // Dropped attributes
+      for (const [name, attr] of mainAttrs) {
+        if (!branchAttrs.has(name)) {
+          changes.push(
+            new AlterCompositeTypeDropAttribute({
+              compositeType: mainCompositeType,
+              attribute: attr,
+            }),
+          );
+        }
+      }
+
+      // Altered attribute type/collation
+      for (const [name, mainAttr] of mainAttrs) {
+        const branchAttr = branchAttrs.get(name);
+        if (!branchAttr) continue;
+        if (
+          mainAttr.data_type_str !== branchAttr.data_type_str ||
+          mainAttr.collation !== branchAttr.collation
+        ) {
+          changes.push(
+            new AlterCompositeTypeAlterAttributeType({
+              compositeType: branchCompositeType,
+              attribute: branchAttr,
+            }),
+          );
+        }
+
+        // COMMENT change on attribute
+        if (mainAttr.comment !== branchAttr.comment) {
+          if (branchAttr.comment === null) {
+            changes.push(
+              new DropCommentOnCompositeTypeAttribute({
+                compositeType: mainCompositeType,
+                attribute: mainAttr,
+              }),
+            );
+          } else {
+            changes.push(
+              new CreateCommentOnCompositeTypeAttribute({
+                compositeType: branchCompositeType,
+                attribute: branchAttr,
+              }),
+            );
+          }
+        }
+      }
+
+      // PRIVILEGES
+      // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+      // (PostgreSQL grants it automatically, so we shouldn't compare it)
+      const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "composite_type",
+        mainCompositeType.privileges,
+      );
+      // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+      const branchPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "composite_type",
+        branchCompositeType.privileges,
+      );
+      // Filter out owner privileges - owner always has ALL privileges implicitly
+      // and shouldn't be compared. Use branch owner as the reference.
+      const privilegeResults = diffPrivileges(
+        mainPrivilegesFiltered,
+        branchPrivilegesFiltered,
+        branchCompositeType.owner,
+      );
+
+      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,
+      // a name change would be handled as drop + create by diffObjects()
+    }
+  }
+
+  return changes;
+}