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

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Procedure, type ProcedureProps } from "../procedure.model.ts";
 import {
   AlterProcedureChangeOwner,
@@ -12,7 +13,7 @@ import {
 
 describe.concurrent("procedure", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<ProcedureProps, "owner"> = {
         schema: "public",
         name: "test_procedure",
@@ -54,12 +55,14 @@ describe.concurrent("procedure", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure OWNER TO new_owner",
+        "ALTER PROCEDURE public.test_procedure() OWNER TO new_owner",
       );
     });
 
-    test("change owner (function)", () => {
+    test("change owner (function)", async () => {
       const props: Omit<ProcedureProps, "owner"> = {
         schema: "public",
         name: "test_function",
@@ -101,12 +104,56 @@ describe.concurrent("procedure", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function() OWNER TO new_owner",
+      );
+    });
+
+    test("change owner with argument types (overloaded function)", async () => {
+      const procedure = new Procedure({
+        schema: "public",
+        name: "my_func",
+        kind: "f",
+        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: 2,
+        argument_default_count: 0,
+        argument_names: ["a", "b"],
+        argument_types: ["integer", "text"],
+        all_argument_types: ["integer", "text"],
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: null,
+        definition: "CREATE FUNCTION public.my_func(integer, text) ...",
+        config: null,
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+        owner: "old_owner",
+      });
+      const change = new AlterProcedureChangeOwner({
+        procedure,
+        owner: "postgres",
+      });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function OWNER TO new_owner",
+        "ALTER FUNCTION public.my_func(integer, text) OWNER TO postgres",
       );
     });
 
-    test("set security definer", () => {
+    test("set security definer", async () => {
       const props: Omit<ProcedureProps, "security_definer"> = {
         schema: "public",
         name: "test_function",
@@ -143,12 +190,13 @@ describe.concurrent("procedure", () => {
         procedure,
         securityDefiner: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function SECURITY DEFINER",
+        "ALTER FUNCTION public.test_function() SECURITY DEFINER",
       );
     });
 
-    test("unset security definer (invoker)", () => {
+    test("unset security definer (invoker)", async () => {
       const props: Omit<ProcedureProps, "security_definer"> = {
         schema: "public",
         name: "test_function",
@@ -185,12 +233,13 @@ describe.concurrent("procedure", () => {
         procedure,
         securityDefiner: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function SECURITY INVOKER",
+        "ALTER FUNCTION public.test_function() SECURITY INVOKER",
       );
     });
 
-    test("set and reset config", () => {
+    test("set and reset config", async () => {
       const base: Omit<ProcedureProps, "config"> = {
         schema: "public",
         name: "test_function",
@@ -243,18 +292,21 @@ describe.concurrent("procedure", () => {
         key: "work_mem",
         value: "64MB",
       });
+      await assertValidSql(change1.serialize());
       expect(change1.serialize()).toBe(
-        "ALTER FUNCTION public.test_function RESET search_path",
+        "ALTER FUNCTION public.test_function() RESET search_path",
       );
+      await assertValidSql(change2.serialize());
       expect(change2.serialize()).toBe(
-        "ALTER FUNCTION public.test_function SET search_path TO pg_temp",
+        "ALTER FUNCTION public.test_function() SET search_path TO pg_temp",
       );
+      await assertValidSql(change3.serialize());
       expect(change3.serialize()).toBe(
-        "ALTER FUNCTION public.test_function SET work_mem TO '64MB'",
+        "ALTER FUNCTION public.test_function() SET work_mem TO '64MB'",
       );
     });
 
-    test("set config from null (function)", () => {
+    test("set config from null (function)", async () => {
       const base: Omit<ProcedureProps, "config"> = {
         schema: "public",
         name: "test_function",
@@ -293,12 +345,13 @@ describe.concurrent("procedure", () => {
         key: "search_path",
         value: "public",
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function SET search_path TO public",
+        "ALTER FUNCTION public.test_function() SET search_path TO public",
       );
     });
 
-    test("set volatility", () => {
+    test("set volatility", async () => {
       const base: Omit<ProcedureProps, "volatility"> = {
         schema: "public",
         name: "test_function",
@@ -335,12 +388,13 @@ describe.concurrent("procedure", () => {
         procedure,
         volatility: "i",
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function IMMUTABLE",
+        "ALTER FUNCTION public.test_function() IMMUTABLE",
       );
     });
 
-    test("set strictness", () => {
+    test("set strictness", async () => {
       const base: Omit<ProcedureProps, "is_strict"> = {
         schema: "public",
         name: "test_function",
@@ -377,12 +431,13 @@ describe.concurrent("procedure", () => {
         procedure,
         isStrict: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function STRICT",
+        "ALTER FUNCTION public.test_function() STRICT",
       );
     });
 
-    test("unset strictness (called on null input)", () => {
+    test("unset strictness (called on null input)", async () => {
       const base: Omit<ProcedureProps, "is_strict"> = {
         schema: "public",
         name: "test_function",
@@ -419,12 +474,13 @@ describe.concurrent("procedure", () => {
         procedure,
         isStrict: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function CALLED ON NULL INPUT",
+        "ALTER FUNCTION public.test_function() CALLED ON NULL INPUT",
       );
     });
 
-    test("set leakproof", () => {
+    test("set leakproof", async () => {
       const base: Omit<ProcedureProps, "leakproof"> = {
         schema: "public",
         name: "test_function",
@@ -461,12 +517,13 @@ describe.concurrent("procedure", () => {
         procedure,
         leakproof: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function LEAKPROOF",
+        "ALTER FUNCTION public.test_function() LEAKPROOF",
       );
     });
 
-    test("unset leakproof", () => {
+    test("unset leakproof", async () => {
       const base: Omit<ProcedureProps, "leakproof"> = {
         schema: "public",
         name: "test_function",
@@ -503,12 +560,13 @@ describe.concurrent("procedure", () => {
         procedure,
         leakproof: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function NOT LEAKPROOF",
+        "ALTER FUNCTION public.test_function() NOT LEAKPROOF",
       );
     });
 
-    test("set parallel safety", () => {
+    test("set parallel safety", async () => {
       const base: Omit<ProcedureProps, "parallel_safety"> = {
         schema: "public",
         name: "test_function",
@@ -545,13 +603,14 @@ describe.concurrent("procedure", () => {
         procedure,
         parallelSafety: "r",
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER FUNCTION public.test_function PARALLEL RESTRICTED",
+        "ALTER FUNCTION public.test_function() PARALLEL RESTRICTED",
       );
     });
 
     // PROCEDURE variants
-    test("procedure: set security definer", () => {
+    test("procedure: set security definer", async () => {
       const base: Omit<ProcedureProps, "security_definer"> = {
         schema: "public",
         name: "test_procedure",
@@ -588,12 +647,13 @@ describe.concurrent("procedure", () => {
         procedure,
         securityDefiner: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure SECURITY DEFINER",
+        "ALTER PROCEDURE public.test_procedure() SECURITY DEFINER",
       );
     });
 
-    test("procedure: unset security definer (invoker)", () => {
+    test("procedure: unset security definer (invoker)", async () => {
       const base: Omit<ProcedureProps, "security_definer"> = {
         schema: "public",
         name: "test_procedure",
@@ -630,12 +690,13 @@ describe.concurrent("procedure", () => {
         procedure,
         securityDefiner: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure SECURITY INVOKER",
+        "ALTER PROCEDURE public.test_procedure() SECURITY INVOKER",
       );
     });
 
-    test("procedure: set and reset config", () => {
+    test("procedure: set and reset config", async () => {
       const base: Omit<ProcedureProps, "config"> = {
         schema: "public",
         name: "test_procedure",
@@ -685,18 +746,21 @@ describe.concurrent("procedure", () => {
         key: "work_mem",
         value: "64MB",
       });
+      await assertValidSql(change1.serialize());
       expect(change1.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure RESET search_path",
+        "ALTER PROCEDURE public.test_procedure() RESET search_path",
       );
+      await assertValidSql(change2.serialize());
       expect(change2.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure SET search_path TO pg_temp",
+        "ALTER PROCEDURE public.test_procedure() SET search_path TO pg_temp",
       );
+      await assertValidSql(change3.serialize());
       expect(change3.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure SET work_mem TO '64MB'",
+        "ALTER PROCEDURE public.test_procedure() SET work_mem TO '64MB'",
       );
     });
 
-    test("procedure: reset all config (to null)", () => {
+    test("procedure: reset all config (to null)", async () => {
       const base: Omit<ProcedureProps, "config"> = {
         schema: "public",
         name: "test_procedure",
@@ -742,15 +806,17 @@ describe.concurrent("procedure", () => {
         action: "reset",
         key: "work_mem",
       });
+      await assertValidSql(change1.serialize());
       expect(change1.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure RESET search_path",
+        "ALTER PROCEDURE public.test_procedure() RESET search_path",
       );
+      await assertValidSql(change2.serialize());
       expect(change2.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure RESET work_mem",
+        "ALTER PROCEDURE public.test_procedure() RESET work_mem",
       );
     });
 
-    test("procedure: set volatility", () => {
+    test("procedure: set volatility", async () => {
       const base: Omit<ProcedureProps, "volatility"> = {
         schema: "public",
         name: "test_procedure",
@@ -787,12 +853,13 @@ describe.concurrent("procedure", () => {
         procedure,
         volatility: "s",
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure STABLE",
+        "ALTER PROCEDURE public.test_procedure() STABLE",
       );
     });
 
-    test("procedure: set strictness", () => {
+    test("procedure: set strictness", async () => {
       const base: Omit<ProcedureProps, "is_strict"> = {
         schema: "public",
         name: "test_procedure",
@@ -829,12 +896,13 @@ describe.concurrent("procedure", () => {
         procedure,
         isStrict: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure STRICT",
+        "ALTER PROCEDURE public.test_procedure() STRICT",
       );
     });
 
-    test("procedure: unset strictness (called on null input)", () => {
+    test("procedure: unset strictness (called on null input)", async () => {
       const base: Omit<ProcedureProps, "is_strict"> = {
         schema: "public",
         name: "test_procedure",
@@ -871,12 +939,13 @@ describe.concurrent("procedure", () => {
         procedure,
         isStrict: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure CALLED ON NULL INPUT",
+        "ALTER PROCEDURE public.test_procedure() CALLED ON NULL INPUT",
       );
     });
 
-    test("procedure: set leakproof", () => {
+    test("procedure: set leakproof", async () => {
       const base: Omit<ProcedureProps, "leakproof"> = {
         schema: "public",
         name: "test_procedure",
@@ -913,12 +982,13 @@ describe.concurrent("procedure", () => {
         procedure,
         leakproof: true,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure LEAKPROOF",
+        "ALTER PROCEDURE public.test_procedure() LEAKPROOF",
       );
     });
 
-    test("procedure: unset leakproof", () => {
+    test("procedure: unset leakproof", async () => {
       const base: Omit<ProcedureProps, "leakproof"> = {
         schema: "public",
         name: "test_procedure",
@@ -955,12 +1025,13 @@ describe.concurrent("procedure", () => {
         procedure,
         leakproof: false,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure NOT LEAKPROOF",
+        "ALTER PROCEDURE public.test_procedure() NOT LEAKPROOF",
       );
     });
 
-    test("procedure: set parallel safety", () => {
+    test("procedure: set parallel safety", async () => {
       const base: Omit<ProcedureProps, "parallel_safety"> = {
         schema: "public",
         name: "test_procedure",
@@ -997,8 +1068,9 @@ describe.concurrent("procedure", () => {
         procedure,
         parallelSafety: "s",
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER PROCEDURE public.test_procedure PARALLEL SAFE",
+        "ALTER PROCEDURE public.test_procedure() PARALLEL SAFE",
       );
     });
   });

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

@@ -2,6 +2,12 @@ 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.
  *
@@ -60,7 +66,7 @@ export class AlterProcedureChangeOwner extends AlterProcedureChange {
     return [
       "ALTER",
       objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
       "OWNER TO",
       this.owner,
     ].join(" ");
@@ -94,7 +100,7 @@ export class AlterProcedureSetSecurity extends AlterProcedureChange {
     return [
       "ALTER",
       objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
       security,
     ].join(" ");
   }
@@ -140,7 +146,7 @@ export class AlterProcedureSetConfig extends AlterProcedureChange {
     const head = [
       "ALTER",
       this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
     ].join(" ");
     if (this.action === "reset_all") return `${head} RESET ALL`;
     if (this.action === "reset") return `${head} RESET ${this.key}`;
@@ -180,7 +186,7 @@ export class AlterProcedureSetVolatility extends AlterProcedureChange {
     return [
       "ALTER",
       objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
       volMap[this.volatility],
     ].join(" ");
   }
@@ -210,7 +216,7 @@ export class AlterProcedureSetStrictness extends AlterProcedureChange {
     return [
       "ALTER",
       objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
       strictness,
     ].join(" ");
   }
@@ -237,12 +243,9 @@ export class AlterProcedureSetLeakproof extends AlterProcedureChange {
   serialize(): string {
     const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
     const leak = this.leakproof ? "LEAKPROOF" : "NOT LEAKPROOF";
-    return [
-      "ALTER",
-      objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
-      leak,
-    ].join(" ");
+    return ["ALTER", objectType, procedureSignature(this.procedure), leak].join(
+      " ",
+    );
   }
 }
 
@@ -274,7 +277,7 @@ export class AlterProcedureSetParallel extends AlterProcedureChange {
     return [
       "ALTER",
       objectType,
-      `${this.procedure.schema}.${this.procedure.name}`,
+      procedureSignature(this.procedure),
       parallelMap[this.parallelSafety],
     ].join(" ");
   }

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

@@ -1,9 +1,10 @@
 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", () => {
+  test("create", async () => {
     const procedure = new Procedure({
       schema: "public",
       name: "test_procedure",
@@ -41,6 +42,8 @@ describe("procedure", () => {
       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.drop.test.ts

@@ -1,9 +1,10 @@
 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", () => {
+  test("drop", async () => {
     const procedure = new Procedure({
       schema: "public",
       name: "test_procedure",
@@ -41,10 +42,12 @@ describe("procedure", () => {
       procedure,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP PROCEDURE public.test_procedure()");
   });
 
-  test("drop function", () => {
+  test("drop function", async () => {
     const fn = new Procedure({
       schema: "public",
       name: "test_function",
@@ -80,6 +83,8 @@ describe("procedure", () => {
 
     const change = new DropProcedure({ procedure: fn });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP FUNCTION public.test_function()");
   });
 });