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

package/src/core/plan/sql-format/format-comment-literals.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { formatSqlStatements } from "../sql-format.ts";
+import { scanTokens } from "./tokenizer.ts";
+
+function extractCommentLiteral(statement: string): string {
+  const tokens = scanTokens(statement);
+  const isToken = tokens.find(
+    (token) => token.depth === 0 && token.upper === "IS",
+  );
+  if (!isToken) {
+    throw new Error(`No IS token found in statement:\n${statement}`);
+  }
+
+  let literalStart = isToken.end;
+  while (
+    literalStart < statement.length &&
+    /\s/.test(statement[literalStart])
+  ) {
+    literalStart += 1;
+  }
+
+  const first = statement[literalStart];
+  let quoteStart = -1;
+  if (first === "'") {
+    quoteStart = literalStart;
+  } else if (
+    (first === "E" || first === "e") &&
+    statement[literalStart + 1] === "'"
+  ) {
+    quoteStart = literalStart + 1;
+  } else if (
+    (first === "U" || first === "u") &&
+    statement[literalStart + 1] === "&" &&
+    statement[literalStart + 2] === "'"
+  ) {
+    quoteStart = literalStart + 2;
+  } else {
+    throw new Error(`No comment literal found in statement:\n${statement}`);
+  }
+
+  let cursor = quoteStart + 1;
+  while (cursor < statement.length) {
+    if (statement[cursor] === "'") {
+      if (statement[cursor + 1] === "'") {
+        cursor += 2;
+        continue;
+      }
+      return statement.slice(literalStart, cursor + 1);
+    }
+    cursor += 1;
+  }
+
+  throw new Error(`Unterminated comment literal in statement:\n${statement}`);
+}
+
+describe("comment literal formatting", () => {
+  test("preserves multiline COMMENT payloads exactly while wrapping SQL around them", () => {
+    const sqlStatements = [
+      `COMMENT ON FUNCTION auth.can_project(bigint,bigint,text,auth.action,json,uuid) IS '
+Enhanced wrapper method for the primary auth.can() function. Utilize this wrapper to specifically check for project-related permissions.
+';`,
+      `COMMENT ON FUNCTION auth.can_project(bigint,text,auth.action,json,uuid) IS '
+Enhanced wrapper method for the primary auth.can() function. Utilize this wrapper to specifically check for project-related permissions.
+This method does not require _organization_id parameter.
+';`,
+      `COMMENT ON FUNCTION auth.can(bigint,text,auth.action,json,uuid) IS '
+Enhanced wrapper method for the primary auth.can() function. With the introduction of the _project_id parameter into auth.can(),
+this wrapper guarantees the seamless operation of all existing auth.can() checks.
+';`,
+    ];
+
+    const [first, second, third] = formatSqlStatements(sqlStatements, {
+      maxWidth: 80,
+    });
+
+    expect(extractCommentLiteral(first)).toMatchInlineSnapshot(`
+      "'
+      Enhanced wrapper method for the primary auth.can() function. Utilize this wrapper to specifically check for project-related permissions.
+      '"
+    `);
+
+    expect(extractCommentLiteral(second)).toMatchInlineSnapshot(`
+      "'
+      Enhanced wrapper method for the primary auth.can() function. Utilize this wrapper to specifically check for project-related permissions.
+      This method does not require _organization_id parameter.
+      '"
+    `);
+
+    expect(extractCommentLiteral(third)).toMatchInlineSnapshot(`
+      "'
+      Enhanced wrapper method for the primary auth.can() function. With the introduction of the _project_id parameter into auth.can(),
+      this wrapper guarantees the seamless operation of all existing auth.can() checks.
+      '"
+    `);
+  });
+});

package/src/core/plan/sql-format/format-functions.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "bun:test";
+import { formatSqlStatements } from "../sql-format.ts";
+
+describe("function formatting", () => {
+  test("single unnamed param, RETURNS void", () => {
+    const sql = `CREATE FUNCTION public.drop_table(regclass) RETURNS void LANGUAGE sql AS $function$SELECT 1$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.drop_table (
+        regclass
+      )
+        RETURNS void
+        LANGUAGE sql
+        AS $function$SELECT 1$function$"
+    `);
+  });
+
+  test("named param, RETURNS text[], STABLE + SECURITY DEFINER", () => {
+    const sql = `CREATE FUNCTION public.get_tags(p_id uuid) RETURNS text[] LANGUAGE sql STABLE SECURITY DEFINER AS $function$SELECT ARRAY['a','b']$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.get_tags (
+        p_id uuid
+      )
+        RETURNS text[]
+        LANGUAGE sql
+        STABLE
+        SECURITY DEFINER
+        AS $function$SELECT ARRAY['a','b']$function$"
+    `);
+  });
+
+  test("multiple named params with alignment, RETURNS uuid", () => {
+    const sql = `CREATE FUNCTION audit.to_record_id(entity_oid oid, pkey_cols text[], rec jsonb) RETURNS uuid LANGUAGE sql STABLE AS $function$SELECT gen_random_uuid()$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION audit.to_record_id (
+        entity_oid oid,
+        pkey_cols  text[],
+        rec        jsonb
+      )
+        RETURNS uuid
+        LANGUAGE sql
+        STABLE
+        AS $function$SELECT gen_random_uuid()$function$"
+    `);
+  });
+
+  test("no params, RETURNS trigger", () => {
+    const sql = `CREATE FUNCTION public.audit_trigger() RETURNS trigger LANGUAGE plpgsql AS $function$BEGIN RETURN NEW; END;$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.audit_trigger()
+        RETURNS trigger
+        LANGUAGE plpgsql
+        AS $function$BEGIN RETURN NEW; END;$function$"
+    `);
+  });
+
+  test("no params, RETURNS trigger (second)", () => {
+    const sql = `CREATE FUNCTION public.notify_change() RETURNS trigger LANGUAGE plpgsql AS $function$BEGIN PERFORM pg_notify('change', ''); RETURN NEW; END;$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.notify_change()
+        RETURNS trigger
+        LANGUAGE plpgsql
+        AS $function$BEGIN PERFORM pg_notify('change', ''); RETURN NEW; END;$function$"
+    `);
+  });
+
+  test("many named params with custom types and DEFAULTs", () => {
+    const sql = `CREATE FUNCTION auth.can(_organization_id bigint, _project_id bigint, _resource text, _action auth.action, _data json DEFAULT NULL::json, _subject_id uuid DEFAULT auth.gotrue_id()) RETURNS boolean LANGUAGE sql STABLE AS $function$SELECT true$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION auth.can (
+        _organization_id bigint,
+        _project_id      bigint,
+        _resource        text,
+        _action          auth.action,
+        _data            json        DEFAULT NULL::json,
+        _subject_id      uuid        DEFAULT auth.gotrue_id()
+      )
+        RETURNS boolean
+        LANGUAGE sql
+        STABLE
+        AS $function$SELECT true$function$"
+    `);
+  });
+
+  test("NOT LEAKPROOF kept together as compound clause", () => {
+    const sql = `CREATE FUNCTION public.safe_fn() RETURNS void LANGUAGE sql NOT LEAKPROOF AS $function$SELECT 1$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.safe_fn()
+        RETURNS void
+        LANGUAGE sql
+        NOT LEAKPROOF
+        AS $function$SELECT 1$function$"
+    `);
+  });
+
+  test("LEAKPROOF without NOT still works", () => {
+    const sql = `CREATE FUNCTION public.leak_fn() RETURNS void LANGUAGE sql LEAKPROOF AS $function$SELECT 1$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.leak_fn()
+        RETURNS void
+        LANGUAGE sql
+        LEAKPROOF
+        AS $function$SELECT 1$function$"
+    `);
+  });
+
+  test("CALLED ON NULL INPUT stays together", () => {
+    const sql = `CREATE FUNCTION public.null_fn(x integer) RETURNS integer LANGUAGE sql CALLED ON NULL INPUT AS $function$SELECT x$function$;`;
+    const [result] = formatSqlStatements([sql]);
+    expect(result).toMatchInlineSnapshot(`
+      "CREATE FUNCTION public.null_fn (
+        x integer
+      )
+        RETURNS integer
+        LANGUAGE sql
+        CALLED ON NULL INPUT
+        AS $function$SELECT x$function$"
+    `);
+  });
+});

package/src/core/plan/sql-format/format-lowercase-coverage.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "bun:test";
+import { formatSqlStatements } from "../sql-format.ts";
+
+describe("lowercase coverage formatting", () => {
+  test("normalizes contextual keywords while preserving protected payloads", () => {
+    const statements = [
+      "CREATE EVENT TRIGGER prevent_drop ON sql_drop WHEN TAG IN ('DROP TABLE', 'DROP SCHEMA') EXECUTE FUNCTION public.prevent_drop_fn();",
+      "CREATE FUNCTION auth.uid() RETURNS uuid LANGUAGE sql STABLE AS $function$SELECT coalesce(nullif(current_setting('request.jwt.claim.sub', true), ''), (nullif(current_setting('request.jwt.claims', true), '')::jsonb ->> 'sub'))::uuid$function$;",
+      "COMMENT ON FUNCTION public.fn() IS E'line 1 \\' still quoted\\nline 2';",
+      "CREATE COLLATION public.test (LOCALE = 'en_US', DETERMINISTIC = false, provider = icu);",
+    ];
+
+    const formatted = formatSqlStatements(statements, {
+      keywordCase: "lower",
+      maxWidth: 140,
+    });
+
+    const normalized = [formatted[0], formatted[1], formatted[3]].map((value) =>
+      value.replace(/\s+/g, " ").trim(),
+    );
+    expect(normalized).toMatchInlineSnapshot(`
+      [
+        "create event trigger prevent_drop on sql_drop when tag in ('DROP TABLE', 'DROP SCHEMA') execute function public.prevent_drop_fn()",
+        "create function auth.uid() returns uuid language sql stable AS $function$SELECT coalesce(nullif(current_setting('request.jwt.claim.sub', true), ''), (nullif(current_setting('request.jwt.claims', true), '')::jsonb ->> 'sub'))::uuid$function$",
+        "create collation public.test ( locale = 'en_US', deterministic = false, provider = icu )",
+      ]
+    `);
+
+    expect(formatted[2]).toMatchInlineSnapshot(
+      `"comment on function public.fn() is E'line 1 \\' still quoted\\nline 2'"`,
+    );
+  });
+
+  test("fails safe: malformed protected literals skip casing but still wrap", () => {
+    const statements = [
+      "COMMENT ON FUNCTION public.fn() IS E'unterminated \\'",
+      "ALTER TABLE auth.audit_log_entries ENABLE ROW LEVEL SECURITY;",
+    ];
+
+    const formatted = formatSqlStatements(statements, {
+      keywordCase: "lower",
+      maxWidth: 40,
+    });
+
+    // Malformed statement: casing skipped (stays uppercase) but wrapping still applies
+    expect(formatted[0].replace(/\s+/g, " ").trim()).toMatchInlineSnapshot(
+      `"COMMENT ON FUNCTION public.fn() IS E'unterminated \\'"`,
+    );
+
+    expect(formatted[1].replace(/\s+/g, " ").trim()).toMatchInlineSnapshot(
+      `"alter table auth.audit_log_entries enable row level security"`,
+    );
+  });
+
+  test("lowercases all ALTER DEFAULT PRIVILEGES object-type keywords", () => {
+    const statements = [
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user IN SCHEMA public GRANT ALL ON TABLES TO app_reader;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user GRANT ALL ON SEQUENCES TO app_reader;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user GRANT ALL ON ROUTINES TO PUBLIC;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user GRANT ALL ON TYPES TO PUBLIC;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user IN SCHEMA api GRANT ALL ON SCHEMAS TO app_admin;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user REVOKE ALL ON SEQUENCES FROM app_reader;",
+      "ALTER DEFAULT PRIVILEGES FOR ROLE app_user REVOKE ALL ON TYPES FROM PUBLIC;",
+    ];
+
+    const formatted = formatSqlStatements(statements, {
+      keywordCase: "lower",
+    });
+
+    const normalized = formatted.map((v) => v.replace(/\s+/g, " ").trim());
+    expect(normalized).toMatchInlineSnapshot(`
+      [
+        "alter default privileges for role app_user in schema public grant all on tables to app_reader",
+        "alter default privileges for role app_user grant all on sequences to app_reader",
+        "alter default privileges for role app_user grant all on routines to public",
+        "alter default privileges for role app_user grant all on types to public",
+        "alter default privileges for role app_user in schema api grant all on schemas to app_admin",
+        "alter default privileges for role app_user revoke all on sequences from app_reader",
+        "alter default privileges for role app_user revoke all on types from public",
+      ]
+    `);
+  });
+
+  test("lowercases PUBLIC in standalone GRANT/REVOKE statements", () => {
+    const statements = [
+      "GRANT ALL ON SCHEMA public TO PUBLIC;",
+      "GRANT EXECUTE ON FUNCTION public.my_fn() TO PUBLIC;",
+      "REVOKE ALL ON SCHEMA public FROM PUBLIC;",
+      "GRANT USAGE ON TYPE public.my_type TO PUBLIC;",
+    ];
+
+    const formatted = formatSqlStatements(statements, {
+      keywordCase: "lower",
+    });
+
+    const normalized = formatted.map((v) => v.replace(/\s+/g, " ").trim());
+    expect(normalized).toMatchInlineSnapshot(`
+      [
+        "grant all on schema public to public",
+        "grant execute on function public.my_fn() to public",
+        "revoke all on schema public from public",
+        "grant usage on type public.my_type to public",
+      ]
+    `);
+  });
+
+  test("preserves full CHECK clause text while casing surrounding structure", () => {
+    const [formatted] = formatSqlStatements(
+      [
+        "ALTER TABLE public.t ADD CONSTRAINT c CHECK (State IN ('ON','OFF')) NO INHERIT;",
+      ],
+      { keywordCase: "lower" },
+    );
+
+    expect(formatted.replace(/\s+/g, " ").trim()).toMatchInlineSnapshot(
+      `"alter table public.t add constraint c check (State IN ('ON','OFF')) no inherit"`,
+    );
+  });
+});