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

package/src/core/objects/aggregate/changes/aggregate.create.ts

@@ -0,0 +1,329 @@
+import { quoteLiteral } from "../../base.change.ts";
+import {
+  parseProcedureReference,
+  parseTypeString,
+  stableId,
+} from "../../utils.ts";
+import type { Aggregate } from "../aggregate.model.ts";
+import { CreateAggregateChange } from "./aggregate.base.ts";
+
+/**
+ * Create an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createaggregate.html
+ */
+export class CreateAggregate extends CreateAggregateChange {
+  public readonly aggregate: Aggregate;
+  public readonly orReplace: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { aggregate: Aggregate; orReplace?: boolean }) {
+    super();
+    this.aggregate = props.aggregate;
+    this.orReplace = props.orReplace ?? false;
+  }
+
+  get creates() {
+    return [this.aggregate.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.aggregate.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.aggregate.owner));
+
+    // Transition function dependency
+    const transProc = parseProcedureReference(
+      this.aggregate.transition_function,
+    );
+    if (transProc) {
+      dependencies.add(stableId.procedure(transProc.schema, transProc.name));
+    }
+
+    // State data type dependency (if user-defined)
+    const stateType = parseTypeString(this.aggregate.state_data_type);
+    if (stateType) {
+      dependencies.add(stableId.type(stateType.schema, stateType.name));
+    }
+
+    // Final function dependency
+    if (this.aggregate.final_function) {
+      const finalProc = parseProcedureReference(this.aggregate.final_function);
+      if (finalProc) {
+        dependencies.add(stableId.procedure(finalProc.schema, finalProc.name));
+      }
+    }
+
+    // Combine function dependency
+    if (this.aggregate.combine_function) {
+      const combineProc = parseProcedureReference(
+        this.aggregate.combine_function,
+      );
+      if (combineProc) {
+        dependencies.add(
+          stableId.procedure(combineProc.schema, combineProc.name),
+        );
+      }
+    }
+
+    // Serial function dependency
+    if (this.aggregate.serial_function) {
+      const serialProc = parseProcedureReference(
+        this.aggregate.serial_function,
+      );
+      if (serialProc) {
+        dependencies.add(
+          stableId.procedure(serialProc.schema, serialProc.name),
+        );
+      }
+    }
+
+    // Deserial function dependency
+    if (this.aggregate.deserial_function) {
+      const deserialProc = parseProcedureReference(
+        this.aggregate.deserial_function,
+      );
+      if (deserialProc) {
+        dependencies.add(
+          stableId.procedure(deserialProc.schema, deserialProc.name),
+        );
+      }
+    }
+
+    // Moving transition function dependency
+    if (this.aggregate.moving_transition_function) {
+      const movingTransProc = parseProcedureReference(
+        this.aggregate.moving_transition_function,
+      );
+      if (movingTransProc) {
+        dependencies.add(
+          stableId.procedure(movingTransProc.schema, movingTransProc.name),
+        );
+      }
+    }
+
+    // Moving inverse function dependency
+    if (this.aggregate.moving_inverse_function) {
+      const movingInvProc = parseProcedureReference(
+        this.aggregate.moving_inverse_function,
+      );
+      if (movingInvProc) {
+        dependencies.add(
+          stableId.procedure(movingInvProc.schema, movingInvProc.name),
+        );
+      }
+    }
+
+    // Moving state data type dependency (if user-defined)
+    if (this.aggregate.moving_state_data_type) {
+      const movingStateType = parseTypeString(
+        this.aggregate.moving_state_data_type,
+      );
+      if (movingStateType) {
+        dependencies.add(
+          stableId.type(movingStateType.schema, movingStateType.name),
+        );
+      }
+    }
+
+    // Moving final function dependency
+    if (this.aggregate.moving_final_function) {
+      const movingFinalProc = parseProcedureReference(
+        this.aggregate.moving_final_function,
+      );
+      if (movingFinalProc) {
+        dependencies.add(
+          stableId.procedure(movingFinalProc.schema, movingFinalProc.name),
+        );
+      }
+    }
+
+    // Return type dependency (if user-defined)
+    if (this.aggregate.return_type_schema) {
+      const returnType = parseTypeString(this.aggregate.return_type);
+      if (returnType) {
+        dependencies.add(stableId.type(returnType.schema, returnType.name));
+      }
+    }
+
+    // Argument type dependencies (if user-defined)
+    if (this.aggregate.argument_types) {
+      for (const argType of this.aggregate.argument_types) {
+        const parsedType = parseTypeString(argType);
+        if (parsedType) {
+          dependencies.add(stableId.type(parsedType.schema, parsedType.name));
+        }
+      }
+    }
+
+    // Note: Sort operator dependencies are complex (they reference operators which
+    // may reference types/functions). For now, we rely on pg_depend for these.
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const signature = this.aggregate.identityArguments;
+    const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+    const head = [
+      "CREATE",
+      this.orReplace ? "OR REPLACE" : null,
+      "AGGREGATE",
+      `${qualifiedName}${signature ? `(${signature})` : "()"}`,
+    ]
+      .filter(Boolean)
+      .join(" ");
+
+    const clauses: string[] = [];
+
+    clauses.push(`SFUNC = ${formatProc(this.aggregate.transition_function)}`);
+    clauses.push(`STYPE = ${this.aggregate.state_data_type}`);
+
+    if (this.aggregate.state_data_space > 0) {
+      clauses.push(`SSPACE = ${this.aggregate.state_data_space}`);
+    }
+
+    if (this.aggregate.final_function) {
+      clauses.push(`FINALFUNC = ${formatProc(this.aggregate.final_function)}`);
+    }
+    if (this.aggregate.final_function_extra_args) {
+      clauses.push("FINALFUNC_EXTRA");
+    }
+    // Only include FINALFUNC_MODIFY if it's explicitly set to a non-default value
+    // PostgreSQL defaults to 'r' (READ_ONLY) when not specified
+    if (
+      this.aggregate.final_function_modify &&
+      this.aggregate.final_function_modify !== "r"
+    ) {
+      clauses.push(
+        `FINALFUNC_MODIFY = ${formatModify(this.aggregate.final_function_modify)}`,
+      );
+    }
+
+    if (this.aggregate.combine_function) {
+      clauses.push(
+        `COMBINEFUNC = ${formatProc(this.aggregate.combine_function)}`,
+      );
+    }
+    if (this.aggregate.serial_function) {
+      clauses.push(
+        `SERIALFUNC = ${formatProc(this.aggregate.serial_function)}`,
+      );
+    }
+    if (this.aggregate.deserial_function) {
+      clauses.push(
+        `DESERIALFUNC = ${formatProc(this.aggregate.deserial_function)}`,
+      );
+    }
+
+    if (this.aggregate.initial_condition !== null) {
+      clauses.push(
+        `INITCOND = ${quoteLiteral(this.aggregate.initial_condition)}`,
+      );
+    }
+
+    if (this.aggregate.moving_transition_function) {
+      clauses.push(
+        `MSFUNC = ${formatProc(this.aggregate.moving_transition_function)}`,
+      );
+    }
+    if (this.aggregate.moving_inverse_function) {
+      clauses.push(
+        `MINVFUNC = ${formatProc(this.aggregate.moving_inverse_function)}`,
+      );
+    }
+    if (this.aggregate.moving_state_data_type) {
+      clauses.push(`MSTYPE = ${this.aggregate.moving_state_data_type}`);
+    }
+    if (
+      this.aggregate.moving_state_data_space &&
+      this.aggregate.moving_state_data_space > 0
+    ) {
+      clauses.push(`MSSPACE = ${this.aggregate.moving_state_data_space}`);
+    }
+    if (this.aggregate.moving_final_function) {
+      clauses.push(
+        `MFINALFUNC = ${formatProc(this.aggregate.moving_final_function)}`,
+      );
+    }
+    if (this.aggregate.moving_final_function_extra_args) {
+      clauses.push("MFINALFUNC_EXTRA");
+    }
+    // Only include MFINALFUNC_MODIFY if it's explicitly set to a non-default value
+    // PostgreSQL defaults to 'r' (READ_ONLY) when not specified
+    if (
+      this.aggregate.moving_final_function_modify &&
+      this.aggregate.moving_final_function_modify !== "r"
+    ) {
+      clauses.push(
+        `MFINALFUNC_MODIFY = ${formatModify(this.aggregate.moving_final_function_modify)}`,
+      );
+    }
+    if (this.aggregate.moving_initial_condition !== null) {
+      clauses.push(
+        `MINITCOND = ${quoteLiteral(this.aggregate.moving_initial_condition)}`,
+      );
+    }
+
+    if (this.aggregate.sort_operator) {
+      clauses.push(`SORTOP = ${formatOperator(this.aggregate.sort_operator)}`);
+    }
+
+    if (this.aggregate.parallel_safety !== "u") {
+      clauses.push(
+        `PARALLEL ${formatParallel(this.aggregate.parallel_safety)}`,
+      );
+    }
+
+    if (this.aggregate.is_strict) {
+      clauses.push("STRICT");
+    }
+
+    if (this.aggregate.aggkind === "h") {
+      clauses.push("HYPOTHETICAL");
+    }
+
+    const body = clauses.length ? `(${clauses.join(", ")})` : "()";
+
+    return `${head} ${body}`;
+  }
+}
+
+function formatProc(proc: string): string {
+  const idx = proc.indexOf("(");
+  return idx === -1 ? proc : proc.slice(0, idx);
+}
+
+function formatOperator(op: string): string {
+  const idx = op.indexOf("(");
+  const qualified = idx === -1 ? op : op.slice(0, idx);
+  return `OPERATOR(${qualified})`;
+}
+
+function formatModify(code: string): string {
+  switch (code) {
+    case "r":
+      return "READ_ONLY";
+    case "s":
+      return "SHAREABLE";
+    case "w":
+      return "READ_WRITE";
+    default:
+      return code;
+  }
+}
+
+function formatParallel(code: string): string {
+  switch (code) {
+    case "s":
+      return "SAFE";
+    case "r":
+      return "RESTRICTED";
+    default:
+      return "UNSAFE";
+  }
+}

package/src/core/objects/aggregate/changes/aggregate.drop.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import { Aggregate } from "../aggregate.model.ts";
+import { DropAggregate } from "./aggregate.drop.ts";
+
+type AggregateProps = ConstructorParameters<typeof Aggregate>[0];
+
+const base: AggregateProps = {
+  schema: "public",
+  name: "agg_sum",
+  identity_arguments: "integer",
+  kind: "a",
+  aggkind: "n",
+  num_direct_args: 0,
+  return_type: "integer",
+  return_type_schema: "pg_catalog",
+  parallel_safety: "u",
+  is_strict: false,
+  transition_function: "pg_catalog.int4pl(integer,integer)",
+  state_data_type: "integer",
+  state_data_type_schema: "pg_catalog",
+  state_data_space: 0,
+  final_function: null,
+  final_function_extra_args: false,
+  final_function_modify: null,
+  combine_function: null,
+  serial_function: null,
+  deserial_function: null,
+  initial_condition: null,
+  moving_transition_function: null,
+  moving_inverse_function: null,
+  moving_state_data_type: null,
+  moving_state_data_type_schema: null,
+  moving_state_data_space: null,
+  moving_final_function: null,
+  moving_final_function_extra_args: false,
+  moving_final_function_modify: null,
+  moving_initial_condition: null,
+  sort_operator: null,
+  argument_count: 1,
+  argument_default_count: 0,
+  argument_names: null,
+  argument_types: ["integer"],
+  all_argument_types: null,
+  argument_modes: null,
+  argument_defaults: null,
+  owner: "owner1",
+  comment: null,
+  privileges: [],
+};
+
+const makeAggregate = (override: Partial<AggregateProps> = {}) =>
+  new Aggregate({
+    ...base,
+    ...override,
+  });
+
+describe("aggregate.drop", () => {
+  test("serialize drop for aggregate with arguments", () => {
+    const aggregate = makeAggregate();
+    const change = new DropAggregate({ aggregate });
+
+    expect(change.drops).toEqual([aggregate.stableId]);
+    expect(change.requires).toEqual([aggregate.stableId]);
+    expect(change.serialize()).toBe("DROP AGGREGATE public.agg_sum(integer)");
+  });
+
+  test("serialize drop for aggregate without arguments", () => {
+    const aggregate = makeAggregate({
+      name: "agg_no_args",
+      identity_arguments: "",
+      argument_count: 0,
+      argument_types: [],
+    });
+    const change = new DropAggregate({ aggregate });
+
+    expect(change.serialize()).toBe("DROP AGGREGATE public.agg_no_args()");
+  });
+});

package/src/core/objects/aggregate/changes/aggregate.drop.ts

@@ -0,0 +1,32 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { DropAggregateChange } from "./aggregate.base.ts";
+
+/**
+ * Drop an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropaggregate.html
+ */
+export class DropAggregate extends DropAggregateChange {
+  public readonly aggregate: Aggregate;
+  public readonly scope = "object" as const;
+
+  constructor(props: { aggregate: Aggregate }) {
+    super();
+    this.aggregate = props.aggregate;
+  }
+
+  get drops() {
+    return [this.aggregate.stableId];
+  }
+
+  get requires() {
+    return [this.aggregate.stableId];
+  }
+
+  serialize(): string {
+    const signature = this.aggregate.identityArguments;
+    const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+    const withArgs = signature.length > 0 ? `(${signature})` : "()";
+    return `DROP AGGREGATE ${qualifiedName}${withArgs}`;
+  }
+}

package/src/core/objects/aggregate/changes/aggregate.privilege.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import { stableId } from "../../utils.ts";
+import { Aggregate } from "../aggregate.model.ts";
+import {
+  GrantAggregatePrivileges,
+  RevokeAggregatePrivileges,
+  RevokeGrantOptionAggregatePrivileges,
+} from "./aggregate.privilege.ts";
+
+type AggregateProps = ConstructorParameters<typeof Aggregate>[0];
+
+const base: AggregateProps = {
+  schema: "public",
+  name: "agg_sum",
+  identity_arguments: "integer",
+  kind: "a",
+  aggkind: "n",
+  num_direct_args: 0,
+  return_type: "integer",
+  return_type_schema: "pg_catalog",
+  parallel_safety: "u",
+  is_strict: false,
+  transition_function: "pg_catalog.int4pl(integer,integer)",
+  state_data_type: "integer",
+  state_data_type_schema: "pg_catalog",
+  state_data_space: 0,
+  final_function: null,
+  final_function_extra_args: false,
+  final_function_modify: null,
+  combine_function: null,
+  serial_function: null,
+  deserial_function: null,
+  initial_condition: null,
+  moving_transition_function: null,
+  moving_inverse_function: null,
+  moving_state_data_type: null,
+  moving_state_data_type_schema: null,
+  moving_state_data_space: null,
+  moving_final_function: null,
+  moving_final_function_extra_args: false,
+  moving_final_function_modify: null,
+  moving_initial_condition: null,
+  sort_operator: null,
+  argument_count: 1,
+  argument_default_count: 0,
+  argument_names: null,
+  argument_types: ["integer"],
+  all_argument_types: null,
+  argument_modes: null,
+  argument_defaults: null,
+  owner: "owner1",
+  comment: null,
+  privileges: [],
+};
+
+describe("aggregate.privilege", () => {
+  test("grant privileges without grant option", () => {
+    const aggregate = new Aggregate(base);
+    const change = new GrantAggregatePrivileges({
+      aggregate,
+      grantee: "role_exec",
+      privileges: [{ privilege: "EXECUTE", grantable: false }],
+      version: 170000,
+    });
+
+    expect(change.creates).toEqual([
+      stableId.acl(aggregate.stableId, "role_exec"),
+    ]);
+    expect(change.requires).toEqual([
+      aggregate.stableId,
+      stableId.role("role_exec"),
+    ]);
+    expect(change.serialize()).toBe(
+      "GRANT ALL ON FUNCTION public.agg_sum(integer) TO role_exec",
+    );
+  });
+
+  test("grant privileges with grant option", () => {
+    const aggregate = new Aggregate(base);
+    const change = new GrantAggregatePrivileges({
+      aggregate,
+      grantee: "role_exec",
+      privileges: [{ privilege: "EXECUTE", grantable: true }],
+    });
+
+    expect(change.serialize()).toBe(
+      "GRANT ALL ON FUNCTION public.agg_sum(integer) TO role_exec WITH GRANT OPTION",
+    );
+  });
+
+  test("revoke privileges and grant option", () => {
+    const aggregate = new Aggregate(base);
+    const revoke = new RevokeAggregatePrivileges({
+      aggregate,
+      grantee: "role_old",
+      privileges: [{ privilege: "EXECUTE", grantable: false }],
+      version: 170000,
+    });
+
+    expect(revoke.drops).toEqual([
+      stableId.acl(aggregate.stableId, "role_old"),
+    ]);
+    expect(revoke.requires).toEqual([
+      stableId.acl(aggregate.stableId, "role_old"),
+      aggregate.stableId,
+      stableId.role("role_old"),
+    ]);
+    expect(revoke.serialize()).toBe(
+      "REVOKE ALL ON FUNCTION public.agg_sum(integer) FROM role_old",
+    );
+
+    const revokeGrantOption = new RevokeGrantOptionAggregatePrivileges({
+      aggregate,
+      grantee: "role_with_option",
+      // testing deduplication of privilege names
+      privilegeNames: ["EXECUTE", "EXECUTE"],
+      version: 170000,
+    });
+
+    expect(revokeGrantOption.privilegeNames).toEqual(["EXECUTE"]);
+    expect(revokeGrantOption.requires).toEqual([
+      stableId.acl(aggregate.stableId, "role_with_option"),
+      aggregate.stableId,
+      stableId.role("role_with_option"),
+    ]);
+    expect(revokeGrantOption.serialize()).toBe(
+      "REVOKE GRANT OPTION FOR ALL ON FUNCTION public.agg_sum(integer) FROM role_with_option",
+    );
+  });
+});