@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -0,0 +1,35 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import type { Enum } from "../enum.model.ts";
+import { DropEnumChange } from "./enum.base.ts";
+
+/**
+ * Drop an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptype.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropEnum extends DropEnumChange {
+  public readonly enum: Enum;
+  public readonly scope = "object" as const;
+
+  constructor(props: { enum: Enum }) {
+    super();
+    this.enum = props.enum;
+  }
+
+  get drops() {
+    return [this.enum.stableId];
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return ["DROP TYPE", `${this.enum.schema}.${this.enum.name}`].join(" ");
+  }
+}

package/src/core/objects/type/enum/changes/enum.privilege.ts

@@ -0,0 +1,176 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../../base.privilege.ts";
+import { stableId } from "../../../utils.ts";
+import type { Enum } from "../enum.model.ts";
+import { AlterEnumChange } from "./enum.base.ts";
+
+export type EnumPrivilege =
+  | GrantEnumPrivileges
+  | RevokeEnumPrivileges
+  | RevokeGrantOptionEnumPrivileges;
+
+/**
+ * Grant privileges on an enum type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantEnumPrivileges extends AlterEnumChange {
+  public readonly enum: Enum;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    enum: Enum;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.enum = props.enum;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.enum.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.enum.stableId, stableId.role(this.grantee)];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const hasGrantable = this.privileges.some((p) => p.grantable);
+    const hasBase = this.privileges.some((p) => !p.grantable);
+    if (hasGrantable && hasBase) {
+      throw new Error(
+        "GrantEnumPrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+    const typeName = `${this.enum.schema}.${this.enum.name}`;
+    return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on an enum type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeEnumPrivileges extends AlterEnumChange {
+  public readonly enum: Enum;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    enum: Enum;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.enum = props.enum;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get drops() {
+    // Return ACL ID for dependency tracking, even though this is an ALTER operation
+    // Phase assignment now uses operation type, so this won't affect phase placement
+    return [stableId.acl(this.enum.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.enum.stableId, this.grantee),
+      this.enum.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+    const typeName = `${this.enum.schema}.${this.enum.name}`;
+    return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on an enum type.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionEnumPrivileges extends AlterEnumChange {
+  public readonly enum: Enum;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    enum: Enum;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.enum = props.enum;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.enum.stableId, this.grantee),
+      this.enum.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const privSql = formatObjectPrivilegeList(
+      "TYPE",
+      this.privilegeNames,
+      this.version,
+    );
+    const typeName = `${this.enum.schema}.${this.enum.name}`;
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}

package/src/core/objects/type/enum/changes/enum.security-label.ts

@@ -0,0 +1,77 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import type { SecurityLabelProps } from "../../../security-label.types.ts";
+import { stableId } from "../../../utils.ts";
+import type { Enum } from "../enum.model.ts";
+import { CreateEnumChange, DropEnumChange } from "./enum.base.ts";
+
+export type SecurityLabelEnum =
+  | CreateSecurityLabelOnEnum
+  | DropSecurityLabelOnEnum;
+
+export class CreateSecurityLabelOnEnum extends CreateEnumChange {
+  public readonly enum: Enum;
+  public readonly securityLabel: SecurityLabelProps;
+  public readonly scope = "security_label" as const;
+
+  constructor(props: { enum: Enum; securityLabel: SecurityLabelProps }) {
+    super();
+    this.enum = props.enum;
+    this.securityLabel = props.securityLabel;
+  }
+
+  get creates() {
+    return [
+      stableId.securityLabel(this.enum.stableId, this.securityLabel.provider),
+    ];
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "SECURITY LABEL FOR",
+      this.securityLabel.provider,
+      "ON TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "IS",
+      quoteLiteral(this.securityLabel.label),
+    ].join(" ");
+  }
+}
+
+export class DropSecurityLabelOnEnum extends DropEnumChange {
+  public readonly enum: Enum;
+  public readonly securityLabel: SecurityLabelProps;
+  public readonly scope = "security_label" as const;
+
+  constructor(props: { enum: Enum; securityLabel: SecurityLabelProps }) {
+    super();
+    this.enum = props.enum;
+    this.securityLabel = props.securityLabel;
+  }
+
+  get drops() {
+    return [
+      stableId.securityLabel(this.enum.stableId, this.securityLabel.provider),
+    ];
+  }
+
+  get requires() {
+    return [
+      stableId.securityLabel(this.enum.stableId, this.securityLabel.provider),
+      this.enum.stableId,
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "SECURITY LABEL FOR",
+      this.securityLabel.provider,
+      "ON TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

package/src/core/objects/type/enum/changes/enum.types.ts

@@ -0,0 +1,15 @@
+import type { AlterEnum } from "./enum.alter.ts";
+import type { CommentEnum } from "./enum.comment.ts";
+import type { CreateEnum } from "./enum.create.ts";
+import type { DropEnum } from "./enum.drop.ts";
+import type { EnumPrivilege } from "./enum.privilege.ts";
+import type { SecurityLabelEnum } from "./enum.security-label.ts";
+
+/** Union of all enum-related change variants (`objectType: "enum"`). @category Change Types */
+export type EnumChange =
+  | AlterEnum
+  | CommentEnum
+  | CreateEnum
+  | DropEnum
+  | EnumPrivilege
+  | SecurityLabelEnum;

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

@@ -0,0 +1,372 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+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";
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("enum.diff", () => {
+  test("create and drop", () => {
+    const props: EnumProps = {
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "b", sort_order: 2 },
+      ],
+      comment: null,
+      privileges: [],
+    };
+    const e = new Enum(props);
+
+    const created = diffEnums(testContext, {}, { [e.stableId]: e });
+    expect(created[0]).toBeInstanceOf(CreateEnum);
+
+    const dropped = diffEnums(testContext, { [e.stableId]: e }, {});
+    expect(dropped[0]).toBeInstanceOf(DropEnum);
+  });
+
+  test("alter: owner change and add value positioning", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "c", sort_order: 3 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+    const branch = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o2",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "b", sort_order: 2 },
+        { label: "c", sort_order: 3 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof AlterEnumChangeOwner)).toBe(true);
+    const add = changes.find((c) => c instanceof AlterEnumAddValue) as
+      | AlterEnumAddValue
+      | undefined;
+    expect(add).toBeDefined();
+  });
+
+  test("add value at beginning (BEFORE first)", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { 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: "b", sort_order: 2 },
+        { label: "c", sort_order: 3 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const add = changes.find((c) => c instanceof AlterEnumAddValue) as
+      | AlterEnumAddValue
+      | undefined;
+    expect(add).toBeDefined();
+    expect(add?.position?.before).toBe("b");
+    expect(add?.position?.after).toBeUndefined();
+  });
+
+  test("add value in middle (AFTER previous)", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { 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: "b", sort_order: 2 },
+        { label: "c", sort_order: 3 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const add = changes.find((c) => c instanceof AlterEnumAddValue) as
+      | AlterEnumAddValue
+      | undefined;
+    expect(add).toBeDefined();
+    expect(add?.position?.after).toBe("a");
+    expect(add?.position?.before).toBeUndefined();
+  });
+
+  test("add value at end (AFTER last)", () => {
+    const main = new Enum({
+      schema: "public",
+      name: "e1",
+      owner: "o1",
+      labels: [
+        { label: "a", sort_order: 1 },
+        { label: "b", sort_order: 2 },
+      ],
+      comment: null,
+      privileges: [],
+    });
+    const branch = 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 changes = diffEnums(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const add = changes.find((c) => c instanceof AlterEnumAddValue) as
+      | AlterEnumAddValue
+      | undefined;
+    expect(add).toBeDefined();
+    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);
+  });
+});