@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/core/plan/sql-format/index.ts

@@ -0,0 +1,149 @@
+import { DEFAULT_OPTIONS } from "./constants.ts";
+import { splitLeadingComments, splitSqlStatements } from "./format-utils.ts";
+import {
+  formatAlterGeneric,
+  formatAlterTable,
+  formatCreateAggregate,
+  formatCreateCollation,
+  formatCreateCompositeType,
+  formatCreateDomain,
+  formatCreateEnum,
+  formatCreateFDW,
+  formatCreateFunction,
+  formatCreateIndex,
+  formatCreateLanguage,
+  formatCreateMaterializedView,
+  formatCreatePolicy,
+  formatCreateRange,
+  formatCreateServer,
+  formatCreateSubscription,
+  formatCreateTable,
+  formatCreateTrigger,
+  formatGeneric,
+} from "./formatters.ts";
+import { applyKeywordCase } from "./keyword-case.ts";
+import { protectSegments, restorePlaceholders } from "./protect.ts";
+import { scanTokens } from "./tokenizer.ts";
+import type { NormalizedOptions, SqlFormatOptions } from "./types.ts";
+import { wrapStatement } from "./wrap.ts";
+
+export function formatSqlStatements(
+  statements: string[],
+  options: SqlFormatOptions = {},
+): string[] {
+  const resolved = normalizeOptions(options);
+  const flattened = flattenStatements(statements);
+  return flattened
+    .map((statement) => formatStatement(statement, resolved))
+    .filter((statement) => statement.length > 0);
+}
+
+function normalizeOptions(options: SqlFormatOptions): NormalizedOptions {
+  const indent =
+    typeof options.indent === "number" && Number.isFinite(options.indent)
+      ? Math.max(0, Math.floor(options.indent))
+      : DEFAULT_OPTIONS.indent;
+  const maxWidth =
+    typeof options.maxWidth === "number" && Number.isFinite(options.maxWidth)
+      ? Math.max(20, Math.floor(options.maxWidth))
+      : DEFAULT_OPTIONS.maxWidth;
+  const keywordCase =
+    options.keywordCase === "upper" ||
+    options.keywordCase === "lower" ||
+    options.keywordCase === "preserve"
+      ? options.keywordCase
+      : DEFAULT_OPTIONS.keywordCase;
+  const commaStyle =
+    options.commaStyle === "leading" || options.commaStyle === "trailing"
+      ? options.commaStyle
+      : DEFAULT_OPTIONS.commaStyle;
+
+  return {
+    keywordCase,
+    indent,
+    maxWidth,
+    commaStyle,
+    alignColumns:
+      typeof options.alignColumns === "boolean"
+        ? options.alignColumns
+        : DEFAULT_OPTIONS.alignColumns,
+    alignKeyValues:
+      typeof options.alignKeyValues === "boolean"
+        ? options.alignKeyValues
+        : DEFAULT_OPTIONS.alignKeyValues,
+    preserveRoutineBodies:
+      typeof options.preserveRoutineBodies === "boolean"
+        ? options.preserveRoutineBodies
+        : DEFAULT_OPTIONS.preserveRoutineBodies,
+    preserveViewBodies:
+      typeof options.preserveViewBodies === "boolean"
+        ? options.preserveViewBodies
+        : DEFAULT_OPTIONS.preserveViewBodies,
+    preserveRuleBodies:
+      typeof options.preserveRuleBodies === "boolean"
+        ? options.preserveRuleBodies
+        : DEFAULT_OPTIONS.preserveRuleBodies,
+  };
+}
+
+function flattenStatements(statements: string[]): string[] {
+  const output: string[] = [];
+  for (const statement of statements) {
+    for (const split of splitSqlStatements(statement)) {
+      if (split.trim().length > 0) {
+        output.push(split);
+      }
+    }
+  }
+  return output;
+}
+
+function formatStatement(
+  statement: string,
+  options: NormalizedOptions,
+): string {
+  const { commentLines, body } = splitLeadingComments(statement);
+  if (body.trim().length === 0) {
+    return commentLines.join("\n");
+  }
+
+  const protectedSegments = protectSegments(body, options);
+  const tokens = scanTokens(protectedSegments.text);
+  let formatted =
+    formatCreateDomain(protectedSegments.text, tokens, options) ??
+    formatCreateEnum(protectedSegments.text, tokens, options) ??
+    formatCreateCompositeType(protectedSegments.text, tokens, options) ??
+    formatCreateTable(protectedSegments.text, tokens, options) ??
+    formatCreateRange(protectedSegments.text, tokens, options) ??
+    formatCreateCollation(protectedSegments.text, tokens, options) ??
+    formatCreateFunction(protectedSegments.text, tokens, options) ??
+    formatCreatePolicy(protectedSegments.text, tokens, options) ??
+    formatCreateTrigger(protectedSegments.text, tokens, options) ??
+    formatCreateIndex(protectedSegments.text, tokens, options) ??
+    formatCreateAggregate(protectedSegments.text, tokens, options) ??
+    formatCreateLanguage(protectedSegments.text, tokens, options) ??
+    formatCreateMaterializedView(protectedSegments.text, tokens, options) ??
+    formatCreateSubscription(protectedSegments.text, tokens, options) ??
+    formatCreateFDW(protectedSegments.text, tokens, options) ??
+    formatCreateServer(protectedSegments.text, tokens, options) ??
+    formatAlterTable(protectedSegments.text, tokens, options) ??
+    formatAlterGeneric(protectedSegments.text, tokens, options) ??
+    formatGeneric(protectedSegments.text, tokens, options);
+
+  if (!protectedSegments.skipCasing && options.keywordCase !== "preserve") {
+    formatted = applyKeywordCase(formatted, options);
+  }
+
+  formatted = wrapStatement(
+    formatted,
+    options,
+    protectedSegments.noWrapPlaceholders,
+  );
+  formatted = restorePlaceholders(formatted, protectedSegments.placeholders);
+
+  if (commentLines.length > 0) {
+    return [...commentLines, formatted].join("\n");
+  }
+
+  return formatted;
+}

package/src/core/plan/sql-format/keyword-case.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "bun:test";
+import { DEFAULT_OPTIONS } from "./constants.ts";
+import { applyKeywordCase } from "./keyword-case.ts";
+import type { NormalizedOptions } from "./types.ts";
+
+const upperOpts: NormalizedOptions = {
+  ...DEFAULT_OPTIONS,
+  keywordCase: "upper",
+};
+const lowerOpts: NormalizedOptions = {
+  ...DEFAULT_OPTIONS,
+  keywordCase: "lower",
+};
+
+describe("applyKeywordCase", () => {
+  it("normalizes structural create/function clauses contextually", () => {
+    const sql =
+      "CREATE FUNCTION auth.uid() RETURNS uuid LANGUAGE sql STABLE SECURITY DEFINER PARALLEL SAFE AS __PGDELTA_PLACEHOLDER_0__";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"create function auth.uid() returns uuid language sql stable security definer parallel safe as __PGDELTA_PLACEHOLDER_0__"`,
+    );
+  });
+
+  it("normalizes grant/revoke privilege clauses without touching grantee identifiers", () => {
+    const sql =
+      "REVOKE GRANT OPTION FOR USAGE ON SCHEMA app_schema FROM app_user";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"revoke grant option for usage on schema app_schema from app_user"`,
+    );
+  });
+
+  it("does not force-case keyword-looking identifiers in COMMENT object targets", () => {
+    const sql = "COMMENT ON SCHEMA USAGE IS 'schema comment'";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"comment on schema USAGE is 'schema comment'"`,
+    );
+  });
+
+  it("does not force-case qualified identifier tokens", () => {
+    const sql = "ALTER TABLE public.USAGE ADD COLUMN event_time TIMESTAMPTZ";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"alter table public.USAGE add column event_time TIMESTAMPTZ"`,
+    );
+  });
+
+  it("normalizes restrictive/safe tokens only in valid contexts", () => {
+    const sql =
+      "CREATE POLICY p ON t AS RESTRICTIVE FOR DELETE TO authenticated";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"create policy p on t as restrictive for delete to authenticated"`,
+    );
+  });
+
+  it("normalizes role options in role option context", () => {
+    const sql = "ALTER ROLE app_user WITH NOSUPERUSER CREATEDB LOGIN";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"alter role app_user with nosuperuser createdb login"`,
+    );
+  });
+
+  it("preserves full CHECK clause text", () => {
+    const sql =
+      "ALTER TABLE public.t ADD CONSTRAINT c CHECK (State IN ('ON','OFF')) NO INHERIT";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"alter table public.t add constraint c check (State IN ('ON','OFF')) no inherit"`,
+    );
+  });
+
+  it("preserves key=value text in option-list contexts", () => {
+    const sql =
+      "CREATE COLLATION public.test (LOCALE = 'en_US', DETERMINISTIC = false, provider = icu)";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"create collation public.test (locale = 'en_US', deterministic = false, provider = icu)"`,
+    );
+  });
+
+  it("preserves definition name/type casing in create lists", () => {
+    const sql = "CREATE TABLE public.t (RoleID UUID NOT NULL)";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"create table public.t (RoleID UUID not null)"`,
+    );
+  });
+
+  it("keeps create-if-not-exists clause keywords caseable", () => {
+    const sql = "CREATE TABLE IF NOT EXISTS public.t (id bigint)";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"create table if not exists public.t (id bigint)"`,
+    );
+  });
+
+  it("fails safe when protected-range parsing is uncertain", () => {
+    const sql = "ALTER TABLE t ADD CONSTRAINT c CHECK (foo > 0";
+    const result = applyKeywordCase(sql, lowerOpts);
+    expect(result).toMatchInlineSnapshot(
+      `"ALTER TABLE t ADD CONSTRAINT c CHECK (foo > 0"`,
+    );
+  });
+
+  it("preserves content inside quoted identifiers, strings, and comments", () => {
+    const result = applyKeywordCase(
+      `CREATE TABLE "Select" ("from" text DEFAULT 'CREATE TABLE') -- UPDATE`,
+      upperOpts,
+    );
+    expect(result).toMatchInlineSnapshot(
+      `"CREATE TABLE "Select" ("from" text DEFAULT 'CREATE TABLE') -- UPDATE"`,
+    );
+  });
+});