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

package/src/core/objects/procedure/changes/procedure.alter.ts

@@ -0,0 +1,291 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Procedure } from "../procedure.model.ts";
+import { formatConfigValue } from "../utils.ts";
+import { AlterProcedureChange } from "./procedure.base.ts";
+
+/** Build schema.name(args) for ALTER statements so overloaded functions are unambiguous. */
+function procedureSignature(procedure: Procedure): string {
+  const args = procedure.argument_types?.join(", ") ?? "";
+  return `${procedure.schema}.${procedure.name}(${args})`;
+}
+
+/**
+ * Alter a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
+ *     action [, ... ] [ RESTRICT ]
+ * ALTER PROCEDURE name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
+ *     action [, ... ] [ RESTRICT ]
+ * where action is one of:
+ *     [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *     SET configuration_parameter { TO | = } { value | DEFAULT }
+ *     SET configuration_parameter FROM CURRENT
+ *     RESET configuration_parameter
+ *     RESET ALL
+ *     [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *     SET configuration_parameter { TO | = } { value | DEFAULT }
+ *     SET configuration_parameter FROM CURRENT
+ *     RESET configuration_parameter
+ *     RESET ALL
+ * ```
+ */
+
+export type AlterProcedure =
+  | AlterProcedureChangeOwner
+  | AlterProcedureSetConfig
+  | AlterProcedureSetLeakproof
+  | AlterProcedureSetParallel
+  | AlterProcedureSetSecurity
+  | AlterProcedureSetStrictness
+  | AlterProcedureSetVolatility;
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... OWNER TO ...
+ */
+export class AlterProcedureChangeOwner extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; owner: string }) {
+    super();
+    this.procedure = props.procedure;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+
+    return [
+      "ALTER",
+      objectType,
+      procedureSignature(this.procedure),
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... SECURITY { INVOKER | DEFINER }
+ */
+export class AlterProcedureSetSecurity extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly securityDefiner: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; securityDefiner: boolean }) {
+    super();
+    this.procedure = props.procedure;
+    this.securityDefiner = props.securityDefiner;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const security = this.securityDefiner
+      ? "SECURITY DEFINER"
+      : "SECURITY INVOKER"; // INVOKER is default; only emitted when changed via diff
+
+    return [
+      "ALTER",
+      objectType,
+      procedureSignature(this.procedure),
+      security,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... SET/RESET configuration_parameter
+ * Emits individual RESET for removed keys and SET for added/changed keys.
+ */
+export class AlterProcedureSetConfig extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly action: "set" | "reset" | "reset_all";
+  public readonly key?: string;
+  public readonly value?: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    procedure: Procedure;
+    action: "set";
+    key: string;
+    value: string;
+  });
+  constructor(props: { procedure: Procedure; action: "reset"; key: string });
+  constructor(props: { procedure: Procedure; action: "reset_all" });
+  constructor(props: {
+    procedure: Procedure;
+    action: "set" | "reset" | "reset_all";
+    key?: string;
+    value?: string;
+  }) {
+    super();
+    this.procedure = props.procedure;
+    this.action = props.action;
+    this.key = props.key;
+    this.value = props.value;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const head = [
+      "ALTER",
+      this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+      procedureSignature(this.procedure),
+    ].join(" ");
+    if (this.action === "reset_all") return `${head} RESET ALL`;
+    if (this.action === "reset") return `${head} RESET ${this.key}`;
+    const formatted = formatConfigValue(
+      this.key as string,
+      this.value as string,
+    );
+    return `${head} SET ${this.key} TO ${formatted}`;
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... { IMMUTABLE | STABLE | VOLATILE }
+ */
+export class AlterProcedureSetVolatility extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly volatility: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; volatility: string }) {
+    super();
+    this.procedure = props.procedure;
+    this.volatility = props.volatility;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const volMap: Record<string, string> = {
+      i: "IMMUTABLE",
+      s: "STABLE",
+      v: "VOLATILE",
+    };
+    return [
+      "ALTER",
+      objectType,
+      procedureSignature(this.procedure),
+      volMap[this.volatility],
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... { STRICT | CALLED ON NULL INPUT }
+ */
+export class AlterProcedureSetStrictness extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly isStrict: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; isStrict: boolean }) {
+    super();
+    this.procedure = props.procedure;
+    this.isStrict = props.isStrict;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const strictness = this.isStrict ? "STRICT" : "CALLED ON NULL INPUT";
+    return [
+      "ALTER",
+      objectType,
+      procedureSignature(this.procedure),
+      strictness,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... { LEAKPROOF | NOT LEAKPROOF }
+ */
+export class AlterProcedureSetLeakproof extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly leakproof: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; leakproof: boolean }) {
+    super();
+    this.procedure = props.procedure;
+    this.leakproof = props.leakproof;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const leak = this.leakproof ? "LEAKPROOF" : "NOT LEAKPROOF";
+    return ["ALTER", objectType, procedureSignature(this.procedure), leak].join(
+      " ",
+    );
+  }
+}
+
+/**
+ * ALTER FUNCTION/PROCEDURE ... PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ */
+export class AlterProcedureSetParallel extends AlterProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly parallelSafety: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; parallelSafety: string }) {
+    super();
+    this.procedure = props.procedure;
+    this.parallelSafety = props.parallelSafety;
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+    const parallelMap: Record<string, string> = {
+      u: "PARALLEL UNSAFE",
+      s: "PARALLEL SAFE",
+      r: "PARALLEL RESTRICTED",
+    };
+    return [
+      "ALTER",
+      objectType,
+      procedureSignature(this.procedure),
+      parallelMap[this.parallelSafety],
+    ].join(" ");
+  }
+}
+
+/**
+ * Replace a procedure by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER FUNCTION/PROCEDURE change.
+ */
+// NOTE: ReplaceProcedure removed. Non-alterable changes are emitted as Drop + Create in procedure.diff.ts.

package/src/core/objects/procedure/changes/procedure.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Procedure } from "../procedure.model.ts";
+
+abstract class BaseProcedureChange extends BaseChange {
+  abstract readonly procedure: Procedure;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "procedure" = "procedure";
+}
+
+export abstract class CreateProcedureChange extends BaseProcedureChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterProcedureChange extends BaseProcedureChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropProcedureChange extends BaseProcedureChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/procedure/changes/procedure.comment.ts

@@ -0,0 +1,71 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Procedure } from "../procedure.model.ts";
+import {
+  CreateProcedureChange,
+  DropProcedureChange,
+} from "./procedure.base.ts";
+
+export type CommentProcedure =
+  | CreateCommentOnProcedure
+  | DropCommentOnProcedure;
+
+/**
+ * Create/drop comments on procedures/functions.
+ */
+export class CreateCommentOnProcedure extends CreateProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { procedure: Procedure }) {
+    super();
+    this.procedure = props.procedure;
+  }
+
+  get creates() {
+    return [stableId.comment(this.procedure.stableId)];
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON",
+      this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+      `${this.procedure.schema}.${this.procedure.name}(${(this.procedure.argument_types ?? []).join(",")})`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: procedure comment is not nullable in this case
+      quoteLiteral(this.procedure.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnProcedure extends DropProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { procedure: Procedure }) {
+    super();
+    this.procedure = props.procedure;
+  }
+
+  get drops() {
+    return [stableId.comment(this.procedure.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.procedure.stableId), this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON",
+      this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+      `${this.procedure.schema}.${this.procedure.name}(${(this.procedure.argument_types ?? []).join(",")})`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

package/src/core/objects/procedure/changes/procedure.create.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Procedure } from "../procedure.model.ts";
+import { CreateProcedure } from "./procedure.create.ts";
+
+describe("procedure", () => {
+  test("create", async () => {
+    const procedure = new Procedure({
+      schema: "public",
+      name: "test_procedure",
+      kind: "p",
+      return_type: "void",
+      return_type_schema: "pg_catalog",
+      language: "plpgsql",
+      security_definer: false,
+      volatility: "v",
+      parallel_safety: "u",
+      is_strict: false,
+      leakproof: false,
+      returns_set: false,
+      argument_count: 0,
+      argument_default_count: 0,
+      argument_names: null,
+      argument_types: null,
+      all_argument_types: null,
+      argument_modes: null,
+      argument_defaults: null,
+      source_code: "BEGIN RETURN; END;",
+      definition:
+        "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+      binary_path: null,
+      sql_body: null,
+      config: null,
+      owner: "test",
+      execution_cost: 0,
+      result_rows: 0,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateProcedure({
+      procedure,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+    );
+  });
+});

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

@@ -0,0 +1,93 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { parseTypeString, stableId } from "../../utils.ts";
+import type { Procedure } from "../procedure.model.ts";
+import { CreateProcedureChange } from "./procedure.base.ts";
+
+/**
+ * Create a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] FUNCTION
+ *     name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
+ *     [ RETURNS rettype
+ *       | RETURNS TABLE ( column_name column_type [, ...] ) ]
+ *     { LANGUAGE lang_name
+ *       | TRANSFORM { FOR TYPE type_name } [, ... ]
+ *       | WINDOW
+ *       | IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF
+ *       | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
+ *       | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *       | PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ *       | COST execution_cost
+ *       | ROWS result_rows
+ *       | SUPPORT support_function
+ *       | SET configuration_parameter { TO value | = value | FROM CURRENT }
+ *       | AS 'definition'
+ *       | AS 'obj_file', 'link_symbol'
+ *       | sql_body
+ *     } ...
+ * ```
+ */
+export class CreateProcedure extends CreateProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly orReplace: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure; orReplace?: boolean }) {
+    super();
+    this.procedure = props.procedure;
+    this.orReplace = props.orReplace ?? false;
+  }
+
+  get creates() {
+    return [this.procedure.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.procedure.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.procedure.owner));
+
+    // Language dependency (if user-defined)
+    // Note: Most languages are built-in (plpgsql, sql, etc.), but custom languages
+    // can be created. We can't reliably determine if a language is user-defined
+    // from just the name, so we rely on pg_depend for language dependencies.
+
+    // Return type dependency (if user-defined)
+    const returnType = parseTypeString(this.procedure.return_type);
+    if (returnType) {
+      dependencies.add(stableId.type(returnType.schema, returnType.name));
+    }
+
+    // Argument type dependencies (if user-defined)
+    if (this.procedure.argument_types) {
+      for (const argType of this.procedure.argument_types) {
+        const parsedType = parseTypeString(argType);
+        if (parsedType) {
+          dependencies.add(stableId.type(parsedType.schema, parsedType.name));
+        }
+      }
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    // Use the server-generated CREATE statement for functions/procedures
+    // Normalize trailing semicolon and OR REPLACE clause according to flag
+    let definition = this.procedure.definition.trim();
+    definition = definition.replace(/;\s*$/, "");
+    definition = definition.replace(
+      /^CREATE\s+(?:OR\s+REPLACE\s+)?/i,
+      `CREATE ${this.orReplace ? "OR REPLACE " : ""}`,
+    );
+    return definition;
+  }
+}

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

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Procedure } from "../procedure.model.ts";
+import { DropProcedure } from "./procedure.drop.ts";
+
+describe("procedure", () => {
+  test("drop", async () => {
+    const procedure = new Procedure({
+      schema: "public",
+      name: "test_procedure",
+      kind: "p",
+      return_type: "void",
+      return_type_schema: "pg_catalog",
+      language: "plpgsql",
+      security_definer: false,
+      volatility: "v",
+      parallel_safety: "u",
+      is_strict: false,
+      leakproof: false,
+      returns_set: false,
+      argument_count: 0,
+      argument_default_count: 0,
+      argument_names: null,
+      argument_types: null,
+      all_argument_types: null,
+      argument_modes: null,
+      argument_defaults: null,
+      source_code: "BEGIN RETURN; END;",
+      definition:
+        "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+      binary_path: null,
+      sql_body: null,
+      config: null,
+      owner: "test",
+      execution_cost: 0,
+      result_rows: 0,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropProcedure({
+      procedure,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP PROCEDURE public.test_procedure()");
+  });
+
+  test("drop function", async () => {
+    const fn = new Procedure({
+      schema: "public",
+      name: "test_function",
+      kind: "f",
+      return_type: "int4",
+      return_type_schema: "pg_catalog",
+      language: "sql",
+      security_definer: false,
+      volatility: "v",
+      parallel_safety: "u",
+      is_strict: false,
+      leakproof: false,
+      returns_set: false,
+      argument_count: 0,
+      argument_default_count: 0,
+      argument_names: null,
+      argument_types: null,
+      all_argument_types: null,
+      argument_modes: null,
+      argument_defaults: null,
+      source_code: null,
+      binary_path: null,
+      sql_body: "SELECT 1",
+      definition:
+        "CREATE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+      config: null,
+      owner: "test",
+      execution_cost: 0,
+      result_rows: 0,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropProcedure({ procedure: fn });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP FUNCTION public.test_function()");
+  });
+});

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

@@ -0,0 +1,50 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Procedure } from "../procedure.model.ts";
+import { formatFunctionArguments } from "../utils.ts";
+import { DropProcedureChange } from "./procedure.base.ts";
+
+/**
+ * Drop a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FUNCTION [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * DROP PROCEDURE [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropProcedure extends DropProcedureChange {
+  public readonly procedure: Procedure;
+  public readonly scope = "object" as const;
+
+  constructor(props: { procedure: Procedure }) {
+    super();
+    this.procedure = props.procedure;
+  }
+
+  get drops() {
+    return [this.procedure.stableId];
+  }
+
+  get requires() {
+    return [this.procedure.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+
+    // Build argument list
+    const args = formatFunctionArguments(
+      this.procedure.argument_names,
+      this.procedure.argument_types,
+      this.procedure.argument_modes,
+    );
+
+    return [
+      "DROP",
+      objectType,
+      `${this.procedure.schema}.${this.procedure.name}(${args})`,
+    ].join(" ");
+  }
+}