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

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

@@ -0,0 +1,54 @@
+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", async () => {
+    const r = new Range({
+      schema: "public",
+      name: "tsrange_custom",
+      owner: "owner1",
+      subtype_schema: "pg_catalog",
+      subtype_str: "int4",
+      collation: null,
+      canonical_function_schema: null,
+      canonical_function_name: null,
+      subtype_diff_schema: null,
+      subtype_diff_name: null,
+      subtype_opclass_schema: null,
+      subtype_opclass_name: null,
+      comment: null,
+      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", async () => {
+    const r = new Range({
+      schema: "public",
+      name: "daterange_custom",
+      owner: "owner1",
+      subtype_schema: "pg_catalog",
+      subtype_str: "date",
+      collation: '"en_US"',
+      canonical_function_schema: "public",
+      canonical_function_name: "canon_fn",
+      subtype_diff_schema: "public",
+      subtype_diff_name: "diff_fn",
+      subtype_opclass_schema: "public",
+      subtype_opclass_name: "date_ops",
+      comment: null,
+      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

@@ -0,0 +1,156 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import {
+  isUserDefinedTypeSchema,
+  parseProcedureReference,
+  parseTypeString,
+  stableId,
+} from "../../../utils.ts";
+import type { Range } from "../range.model.ts";
+import { CreateRangeChange } from "./range.base.ts";
+
+/**
+ * Create a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS RANGE (
+ *   SUBTYPE = subtype
+ *   [ , SUBTYPE_OPCLASS = subtype_operator_class ]
+ *   [ , COLLATION = collation ]
+ *   [ , CANONICAL = canonical_function ]
+ *   [ , SUBTYPE_DIFF = subtype_diff_function ]
+ * )
+ * ```
+ *
+ * Notes
+ * - Only non-default options are emitted in the generated SQL.
+ */
+export class CreateRange extends CreateRangeChange {
+  public readonly range: Range;
+  public readonly scope = "object" as const;
+
+  constructor(props: { range: Range }) {
+    super();
+    this.range = props.range;
+  }
+
+  get creates() {
+    return [this.range.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.range.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.range.owner));
+
+    // Subtype dependency (if user-defined)
+    if (
+      this.range.subtype_schema &&
+      isUserDefinedTypeSchema(this.range.subtype_schema)
+    ) {
+      // subtype_str is the type name without schema (e.g., "integer", "text")
+      // subtype_schema is the schema name
+      dependencies.add(
+        stableId.type(this.range.subtype_schema, this.range.subtype_str),
+      );
+    }
+
+    // Canonical function dependency
+    if (
+      this.range.canonical_function_schema &&
+      this.range.canonical_function_name
+    ) {
+      const procRef = parseProcedureReference(
+        `${this.range.canonical_function_schema}.${this.range.canonical_function_name}()`,
+      );
+      if (procRef) {
+        dependencies.add(stableId.procedure(procRef.schema, procRef.name));
+      }
+    }
+
+    // Subtype diff function dependency
+    if (this.range.subtype_diff_schema && this.range.subtype_diff_name) {
+      const procRef = parseProcedureReference(
+        `${this.range.subtype_diff_schema}.${this.range.subtype_diff_name}()`,
+      );
+      if (procRef) {
+        dependencies.add(stableId.procedure(procRef.schema, procRef.name));
+      }
+    }
+
+    // Collation dependency (if non-default and user-defined)
+    if (this.range.collation) {
+      const unquotedCollation = this.range.collation.replace(/^"|"$/g, "");
+      const collationParts = unquotedCollation.split(".");
+      if (collationParts.length === 2) {
+        const [collationSchema, collationName] = collationParts;
+        if (isUserDefinedTypeSchema(collationSchema)) {
+          dependencies.add(stableId.collation(collationSchema, collationName));
+        }
+      }
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const name = `${this.range.schema}.${this.range.name}`;
+    const prefix: string = ["CREATE TYPE", name, "AS RANGE"].join(" ");
+
+    const opts: string[] = [];
+
+    // Required subtype (format_type may already return schema-qualified name)
+    const alreadyQualified = parseTypeString(this.range.subtype_str);
+    const subtypeQualified =
+      !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}`);
+
+    // Optional opclass
+    if (this.range.subtype_opclass_name) {
+      const opclassQualified =
+        this.range.subtype_opclass_schema &&
+        this.range.subtype_opclass_schema !== "pg_catalog"
+          ? `${this.range.subtype_opclass_schema}.${this.range.subtype_opclass_name}`
+          : this.range.subtype_opclass_name;
+      opts.push(`SUBTYPE_OPCLASS = ${opclassQualified}`);
+    }
+
+    // Optional collation
+    if (this.range.collation) {
+      opts.push(`COLLATION = ${this.range.collation}`);
+    }
+
+    // Optional canonical function
+    if (this.range.canonical_function_name) {
+      const canonQualified =
+        this.range.canonical_function_schema &&
+        this.range.canonical_function_schema !== "pg_catalog"
+          ? `${this.range.canonical_function_schema}.${this.range.canonical_function_name}`
+          : this.range.canonical_function_name;
+      opts.push(`CANONICAL = ${canonQualified}`);
+    }
+
+    // Optional subtype diff function
+    if (this.range.subtype_diff_name) {
+      const diffQualified =
+        this.range.subtype_diff_schema &&
+        this.range.subtype_diff_schema !== "pg_catalog"
+          ? `${this.range.subtype_diff_schema}.${this.range.subtype_diff_name}`
+          : this.range.subtype_diff_name;
+      opts.push(`SUBTYPE_DIFF = ${diffQualified}`);
+    }
+
+    const body = `(${opts.join(", ")})`;
+    return `${prefix} ${body}`;
+  }
+}

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

@@ -0,0 +1,28 @@
+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", async () => {
+    const r = new Range({
+      schema: "public",
+      name: "tsrange_custom",
+      owner: "owner1",
+      subtype_schema: "pg_catalog",
+      subtype_str: "int4",
+      collation: null,
+      canonical_function_schema: null,
+      canonical_function_name: null,
+      subtype_diff_schema: null,
+      subtype_diff_name: null,
+      subtype_opclass_schema: null,
+      subtype_opclass_name: null,
+      comment: null,
+      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/changes/range.drop.ts

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

package/src/core/objects/type/range/changes/range.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 { Range } from "../range.model.ts";
+import { AlterRangeChange } from "./range.base.ts";
+
+export type RangePrivilege =
+  | GrantRangePrivileges
+  | RevokeRangePrivileges
+  | RevokeGrantOptionRangePrivileges;
+
+/**
+ * Grant privileges on a range 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 GrantRangePrivileges extends AlterRangeChange {
+  public readonly range: Range;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    range: Range;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.range = props.range;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.range.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.range.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(
+        "GrantRangePrivileges 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.range.schema}.${this.range.name}`;
+    return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a range 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 RevokeRangePrivileges extends AlterRangeChange {
+  public readonly range: Range;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    range: Range;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.range = props.range;
+    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.range.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.range.stableId, this.grantee),
+      this.range.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.range.schema}.${this.range.name}`;
+    return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a range 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 RevokeGrantOptionRangePrivileges extends AlterRangeChange {
+  public readonly range: Range;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    range: Range;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.range = props.range;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.range.stableId, this.grantee),
+      this.range.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const privSql = formatObjectPrivilegeList(
+      "TYPE",
+      this.privilegeNames,
+      this.version,
+    );
+    const typeName = `${this.range.schema}.${this.range.name}`;
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { AlterRange } from "./range.alter.ts";
+import type { CommentRange } from "./range.comment.ts";
+import type { CreateRange } from "./range.create.ts";
+import type { DropRange } from "./range.drop.ts";
+import type { RangePrivilege } from "./range.privilege.ts";
+
+/** Union of all range-related change variants (`objectType: "range"`). @category Change Types */
+export type RangeChange =
+  | AlterRange
+  | CommentRange
+  | CreateRange
+  | DropRange
+  | RangePrivilege;

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

@@ -0,0 +1,147 @@
+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";
+
+const base: RangeProps = {
+  schema: "public",
+  name: "ts_custom",
+  owner: "o1",
+  subtype_schema: "pg_catalog",
+  subtype_str: "int4",
+  collation: null,
+  canonical_function_schema: null,
+  canonical_function_name: null,
+  subtype_diff_schema: null,
+  subtype_diff_name: null,
+  subtype_opclass_schema: null,
+  subtype_opclass_name: null,
+  comment: null,
+  privileges: [],
+};
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("range.diff", () => {
+  test("create and drop", () => {
+    const r = new Range(base);
+    const created = diffRanges(testContext, {}, { [r.stableId]: r });
+    expect(created[0]).toBeInstanceOf(CreateRange);
+    const dropped = diffRanges(testContext, { [r.stableId]: r }, {});
+    expect(dropped[0]).toBeInstanceOf(DropRange);
+  });
+
+  test("alter owner", () => {
+    const main = new Range(base);
+    const branch = new Range({ ...base, owner: "o2" });
+    const changes = diffRanges(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterRangeChangeOwner);
+  });
+
+  test("drop and create when non-alterable property changes", () => {
+    const main = new Range(base);
+    const branch = new Range({
+      ...base,
+      subtype_schema: "pg_catalog",
+      subtype_str: "text",
+      collation: "en_US",
+    });
+    const changes = diffRanges(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(2);
+    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);
+  });
+});