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

package/dist/core/plan/sql-format/formatters.js

@@ -0,0 +1,737 @@
+import { formatColumnList, formatKeyValueItems, formatListItems, formatMixedItems, indentString, joinHeaderAndClauses, } from "./format-utils.js";
+import { findClausePositions, findTopLevelParen, scanTokens, skipQualifiedName, sliceClauses, splitByCommas, } from "./tokenizer.js";
+// ── Module-level keyword sets (hoisted to avoid per-call allocations) ────────
+const DOMAIN_CLAUSE_KEYWORDS = new Set(["COLLATE", "DEFAULT", "CHECK"]);
+const FUNCTION_CLAUSE_KEYWORDS = new Set([
+    "RETURNS",
+    "LANGUAGE",
+    "TRANSFORM",
+    "WINDOW",
+    "IMMUTABLE",
+    "STABLE",
+    "VOLATILE",
+    "LEAKPROOF",
+    "CALLED",
+    "STRICT",
+    "SECURITY",
+    "PARALLEL",
+    "COST",
+    "ROWS",
+    "SUPPORT",
+    "SET",
+    "AS",
+]);
+const POLICY_CLAUSE_KEYWORDS = new Set(["FOR", "TO", "USING", "WITH"]);
+const TRIGGER_CLAUSE_KEYWORDS = new Set([
+    "BEFORE",
+    "AFTER",
+    "INSTEAD",
+    "FOR",
+    "WHEN",
+    "EXECUTE",
+]);
+const EVENT_TRIGGER_CLAUSE_KEYWORDS = new Set(["ON", "WHEN", "EXECUTE"]);
+const INDEX_CLAUSE_KEYWORDS = new Set(["WHERE", "WITH", "TABLESPACE"]);
+const LANGUAGE_CLAUSE_KEYWORDS = new Set(["HANDLER", "INLINE", "VALIDATOR"]);
+const MATVIEW_CLAUSE_KEYWORDS = new Set(["WITH", "AS"]);
+const SUBSCRIPTION_CLAUSE_KEYWORDS = new Set([
+    "CONNECTION",
+    "PUBLICATION",
+    "WITH",
+]);
+const FDW_CLAUSE_KEYWORDS = new Set(["HANDLER", "VALIDATOR", "OPTIONS"]);
+const EXPANDABLE_KEYWORDS = new Set(["OPTIONS", "WITH", "SET"]);
+// ── Formatters ───────────────────────────────────────────────────────────────
+export function formatCreateDomain(statement, tokens, options) {
+    if (tokens.length < 2)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "DOMAIN") {
+        return null;
+    }
+    // Domain has a special NOT NULL compound clause that findClausePositions
+    // can't handle generically, so we keep a custom scan here.
+    const clauseStarts = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        if (tokens[i].depth !== 0)
+            continue;
+        const upper = tokens[i].upper;
+        if (DOMAIN_CLAUSE_KEYWORDS.has(upper)) {
+            clauseStarts.push(tokens[i].start);
+            continue;
+        }
+        if (upper === "NOT" &&
+            tokens[i + 1]?.upper === "NULL" &&
+            tokens[i + 1]?.depth === 0) {
+            clauseStarts.push(tokens[i].start);
+            i += 1;
+        }
+    }
+    if (clauseStarts.length === 0)
+        return null;
+    clauseStarts.sort((a, b) => a - b);
+    const prefix = statement.slice(0, clauseStarts[0]).trim();
+    const clauses = sliceClauses(statement, clauseStarts);
+    return joinHeaderAndClauses(prefix, clauses, options);
+}
+export function formatCreateEnum(statement, tokens, options) {
+    if (tokens.length < 4)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "TYPE") {
+        return null;
+    }
+    const enumToken = tokens.find((token, index) => token.upper === "ENUM" && tokens[index - 1]?.upper === "AS");
+    if (!enumToken)
+        return null;
+    const parens = findTopLevelParen(statement, enumToken.end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const items = splitByCommas(content);
+    const indent = indentString(options.indent);
+    const listLines = formatListItems(items, indent, options.commaStyle);
+    const lines = [`${header} (`, ...listLines, `)${suffix ? ` ${suffix}` : ""}`];
+    return lines.join("\n");
+}
+export function formatCreateCompositeType(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "TYPE") {
+        return null;
+    }
+    const asToken = tokens.find((token) => token.upper === "AS");
+    if (!asToken)
+        return null;
+    const asIndex = tokens.indexOf(asToken);
+    const nextToken = tokens[asIndex + 1];
+    if (nextToken?.upper === "ENUM" || nextToken?.upper === "RANGE") {
+        return null;
+    }
+    const parens = findTopLevelParen(statement, asToken.end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const formattedColumns = formatColumnList(content, options);
+    if (!formattedColumns)
+        return null;
+    const lines = [
+        `${header} (`,
+        ...formattedColumns,
+        `)${suffix ? ` ${suffix}` : ""}`,
+    ];
+    return lines.join("\n");
+}
+export function formatCreateTable(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    const tableToken = tokens.find((token, index) => {
+        if (token.upper !== "TABLE")
+            return false;
+        if (index > 0 && tokens[index - 1].upper === "RETURNS")
+            return false;
+        return true;
+    });
+    if (!tableToken)
+        return null;
+    const parens = findTopLevelParen(statement, tableToken.end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const hasPartitionBeforeColumns = tokens.some((token) => token.depth === 0 && token.upper === "PARTITION" && token.start < open);
+    if (hasPartitionBeforeColumns)
+        return null;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const formattedColumns = formatColumnList(content, options);
+    if (!formattedColumns)
+        return null;
+    const lines = [
+        `${header} (`,
+        ...formattedColumns,
+        `)${suffix ? ` ${suffix}` : ""}`,
+    ];
+    return lines.join("\n");
+}
+export function formatCreateRange(statement, tokens, options) {
+    if (tokens.length < 4)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "TYPE") {
+        return null;
+    }
+    const rangeToken = tokens.find((token, index) => token.upper === "RANGE" && tokens[index - 1]?.upper === "AS");
+    if (!rangeToken)
+        return null;
+    const parens = findTopLevelParen(statement, rangeToken.end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const items = splitByCommas(content);
+    if (items.length === 0)
+        return null;
+    const formattedItems = formatKeyValueItems(items, options);
+    const lines = [
+        `${header} (`,
+        ...formattedItems,
+        `)${suffix ? ` ${suffix}` : ""}`,
+    ];
+    return lines.join("\n");
+}
+export function formatCreateCollation(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "COLLATION") {
+        return null;
+    }
+    const parens = findTopLevelParen(statement, tokens[1].end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const items = splitByCommas(content);
+    if (items.length === 0)
+        return null;
+    const formattedItems = formatKeyValueItems(items, options);
+    const lines = [
+        `${header} (`,
+        ...formattedItems,
+        `)${suffix ? ` ${suffix}` : ""}`,
+    ];
+    return lines.join("\n");
+}
+export function formatCreateFunction(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    let cursor = 1;
+    if (tokens[cursor]?.upper === "OR" &&
+        tokens[cursor + 1]?.upper === "REPLACE") {
+        cursor += 2;
+    }
+    const objectToken = tokens[cursor];
+    if (!objectToken ||
+        (objectToken.upper !== "FUNCTION" && objectToken.upper !== "PROCEDURE")) {
+        return null;
+    }
+    const parens = findTopLevelParen(statement, objectToken.end);
+    if (!parens)
+        return null;
+    const { open, close } = parens;
+    const header = statement.slice(0, open).trim();
+    const argContent = statement.slice(open + 1, close).trim();
+    const postArgs = statement.slice(close + 1).trim();
+    const indent = indentString(options.indent);
+    const lines = [];
+    if (argContent.length === 0) {
+        lines.push(`${header}()`);
+    }
+    else {
+        const formattedArgs = formatColumnList(argContent, options);
+        if (formattedArgs) {
+            lines.push(`${header} (`, ...formattedArgs, `)`);
+        }
+        else {
+            lines.push(`${header}(${argContent})`);
+        }
+    }
+    if (postArgs.length === 0) {
+        return lines.join("\n");
+    }
+    // Function/procedure has special compound clauses (NOT LEAKPROOF, placeholders)
+    // that require a custom scan rather than the generic findClausePositions.
+    const postTokens = scanTokens(postArgs);
+    const clauseStarts = [];
+    for (let i = 0; i < postTokens.length; i += 1) {
+        const tok = postTokens[i];
+        if (tok.depth !== 0)
+            continue;
+        if (tok.upper === "NOT" && postTokens[i + 1]?.upper === "LEAKPROOF") {
+            clauseStarts.push(tok.start);
+            i += 1;
+            continue;
+        }
+        if (FUNCTION_CLAUSE_KEYWORDS.has(tok.upper)) {
+            clauseStarts.push(tok.start);
+            continue;
+        }
+        if (tok.value.startsWith("__PGDELTA_PLACEHOLDER_")) {
+            clauseStarts.push(tok.start);
+        }
+    }
+    if (clauseStarts.length === 0) {
+        lines[lines.length - 1] += ` ${postArgs}`;
+        return lines.join("\n");
+    }
+    clauseStarts.sort((a, b) => a - b);
+    const beforeFirstClause = postArgs.slice(0, clauseStarts[0]).trim();
+    if (beforeFirstClause.length > 0) {
+        lines[lines.length - 1] += ` ${beforeFirstClause}`;
+    }
+    const clauses = sliceClauses(postArgs, clauseStarts);
+    for (const clause of clauses) {
+        const clauseTokens = scanTokens(clause);
+        if (clauseTokens.length >= 2 &&
+            clauseTokens[0].upper === "RETURNS" &&
+            clauseTokens[1].upper === "TABLE") {
+            const tableParens = findTopLevelParen(clause, clauseTokens[1].end);
+            if (tableParens) {
+                const innerContent = clause
+                    .slice(tableParens.open + 1, tableParens.close)
+                    .trim();
+                const afterTable = clause.slice(tableParens.close + 1).trim();
+                if (innerContent.length > 0) {
+                    const formattedCols = formatColumnList(innerContent, {
+                        ...options,
+                        indent: options.indent * 2,
+                    });
+                    if (formattedCols) {
+                        lines.push(`${indent}RETURNS TABLE (`, ...formattedCols, `${indent})`);
+                    }
+                    else {
+                        lines.push(`${indent}RETURNS TABLE (${innerContent})`);
+                    }
+                }
+                else {
+                    lines.push(`${indent}RETURNS TABLE ()`);
+                }
+                if (afterTable.length > 0) {
+                    lines[lines.length - 1] += ` ${afterTable}`;
+                }
+                continue;
+            }
+        }
+        lines.push(`${indent}${clause}`);
+    }
+    return lines.join("\n");
+}
+export function formatCreatePolicy(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "POLICY") {
+        return null;
+    }
+    // Policy has special WITH CHECK handling that requires a custom scan.
+    const clauseStarts = [];
+    for (let i = 2; i < tokens.length; i += 1) {
+        if (tokens[i].depth !== 0)
+            continue;
+        const upper = tokens[i].upper;
+        if (upper === "AS" &&
+            (tokens[i + 1]?.upper === "PERMISSIVE" ||
+                tokens[i + 1]?.upper === "RESTRICTIVE")) {
+            clauseStarts.push(tokens[i].start);
+            continue;
+        }
+        if (upper === "WITH" && tokens[i + 1]?.upper === "CHECK") {
+            clauseStarts.push(tokens[i].start);
+            continue;
+        }
+        if (upper === "WITH")
+            continue;
+        if (POLICY_CLAUSE_KEYWORDS.has(upper)) {
+            clauseStarts.push(tokens[i].start);
+        }
+    }
+    if (clauseStarts.length === 0)
+        return null;
+    clauseStarts.sort((a, b) => a - b);
+    const header = statement.slice(0, clauseStarts[0]).trim();
+    const clauses = sliceClauses(statement, clauseStarts);
+    return joinHeaderAndClauses(header, clauses, options);
+}
+export function formatCreateTrigger(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    let triggerIndex = -1;
+    for (let i = 1; i < Math.min(5, tokens.length); i += 1) {
+        if (tokens[i].upper === "TRIGGER") {
+            triggerIndex = i;
+            break;
+        }
+    }
+    if (triggerIndex === -1)
+        return null;
+    const nameToken = tokens[triggerIndex + 1];
+    if (!nameToken)
+        return null;
+    const headerEnd = nameToken.end;
+    const rest = statement.slice(headerEnd).trim();
+    const header = statement.slice(0, headerEnd).trim();
+    if (rest.length === 0)
+        return null;
+    const restTokens = scanTokens(rest);
+    const clauseKeywords = tokens[triggerIndex - 1]?.upper === "EVENT"
+        ? EVENT_TRIGGER_CLAUSE_KEYWORDS
+        : TRIGGER_CLAUSE_KEYWORDS;
+    const positions = findClausePositions(restTokens, clauseKeywords);
+    if (positions.length === 0)
+        return null;
+    const clauses = sliceClauses(rest, positions);
+    return joinHeaderAndClauses(header, clauses, options);
+}
+export function formatCreateIndex(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    let indexIndex = -1;
+    for (let i = 1; i < Math.min(4, tokens.length); i += 1) {
+        if (tokens[i].upper === "INDEX") {
+            indexIndex = i;
+            break;
+        }
+    }
+    if (indexIndex === -1)
+        return null;
+    const parens = findTopLevelParen(statement, tokens[indexIndex].end);
+    if (!parens)
+        return null;
+    let headerEnd = parens.close + 1;
+    const afterParens = statement.slice(headerEnd).trim();
+    const afterTokens = scanTokens(afterParens);
+    if (afterTokens.length > 0 && afterTokens[0].upper === "INCLUDE") {
+        const includeParens = findTopLevelParen(afterParens, afterTokens[0].end);
+        if (includeParens) {
+            headerEnd =
+                headerEnd + afterParens.slice(0, includeParens.close + 1).length;
+        }
+    }
+    const restText = statement.slice(headerEnd).trim();
+    if (restText.length === 0)
+        return null;
+    const restTokens = scanTokens(restText);
+    const positions = findClausePositions(restTokens, INDEX_CLAUSE_KEYWORDS);
+    if (positions.length === 0)
+        return null;
+    const header = statement.slice(0, headerEnd).trim();
+    const clauses = sliceClauses(restText, positions);
+    return joinHeaderAndClauses(header, clauses, options);
+}
+export function formatAlterTable(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "ALTER" || tokens[1].upper !== "TABLE") {
+        return null;
+    }
+    let cursor = 2;
+    if (tokens[cursor]?.upper === "IF" &&
+        tokens[cursor + 1]?.upper === "EXISTS") {
+        cursor += 2;
+    }
+    if (tokens[cursor]?.upper === "ONLY") {
+        cursor += 1;
+    }
+    if (cursor >= tokens.length)
+        return null;
+    cursor = skipQualifiedName(statement, tokens, cursor);
+    if (cursor >= tokens.length)
+        return null;
+    const headerEnd = tokens[cursor].start;
+    const header = statement.slice(0, headerEnd).trim();
+    const action = statement.slice(headerEnd).trim();
+    if (action.length === 0)
+        return null;
+    const indent = indentString(options.indent);
+    return `${header}\n${indent}${action}`;
+}
+export function formatCreateAggregate(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "AGGREGATE") {
+        return null;
+    }
+    // Find the argument list parentheses first (e.g. array_cat_agg(anycompatiblearray))
+    const argParens = findTopLevelParen(statement, tokens[1].end);
+    if (!argParens)
+        return null;
+    // Find the options parentheses after the argument list
+    const optParens = findTopLevelParen(statement, argParens.close + 1);
+    if (!optParens)
+        return null;
+    const { open, close } = optParens;
+    const header = statement.slice(0, open).trim();
+    const content = statement.slice(open + 1, close).trim();
+    const suffix = statement.slice(close + 1).trim();
+    const items = splitByCommas(content);
+    if (items.length === 0)
+        return null;
+    const formattedItems = formatMixedItems(items, options);
+    const lines = [
+        `${header} (`,
+        ...formattedItems,
+        `)${suffix ? ` ${suffix}` : ""}`,
+    ];
+    return lines.join("\n");
+}
+export function formatCreateLanguage(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    // Find LANGUAGE token (may be preceded by TRUSTED)
+    let langIndex = -1;
+    for (let i = 1; i < Math.min(4, tokens.length); i += 1) {
+        if (tokens[i].upper === "LANGUAGE") {
+            langIndex = i;
+            break;
+        }
+    }
+    if (langIndex === -1)
+        return null;
+    // Must have a name token after LANGUAGE
+    const nameToken = tokens[langIndex + 1];
+    if (!nameToken)
+        return null;
+    const headerEnd = nameToken.end;
+    const rest = statement.slice(headerEnd).trim();
+    const header = statement.slice(0, headerEnd).trim();
+    if (rest.length === 0)
+        return null;
+    const restTokens = scanTokens(rest);
+    const positions = findClausePositions(restTokens, LANGUAGE_CLAUSE_KEYWORDS);
+    if (positions.length === 0)
+        return null;
+    const clauses = sliceClauses(rest, positions);
+    return joinHeaderAndClauses(header, clauses, options);
+}
+export function formatCreateMaterializedView(statement, tokens, options) {
+    if (tokens.length < 4)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    // Find MATERIALIZED VIEW sequence
+    let viewIndex = -1;
+    for (let i = 1; i < Math.min(5, tokens.length); i += 1) {
+        if (tokens[i].upper === "MATERIALIZED" && tokens[i + 1]?.upper === "VIEW") {
+            viewIndex = i + 1; // point to VIEW
+            break;
+        }
+    }
+    if (viewIndex === -1)
+        return null;
+    // Find schema-qualified name after VIEW
+    let cursor = viewIndex + 1;
+    if (cursor >= tokens.length)
+        return null;
+    cursor = skipQualifiedName(statement, tokens, cursor);
+    const nameEnd = tokens[cursor - 1].end;
+    const rest = statement.slice(nameEnd).trim();
+    const header = statement.slice(0, nameEnd).trim();
+    if (rest.length === 0)
+        return null;
+    // Materialized view has special placeholder handling for protected view bodies
+    const restTokens = scanTokens(rest);
+    const clauseStarts = [];
+    for (let i = 0; i < restTokens.length; i += 1) {
+        if (restTokens[i].depth !== 0)
+            continue;
+        if (MATVIEW_CLAUSE_KEYWORDS.has(restTokens[i].upper)) {
+            clauseStarts.push(restTokens[i].start);
+        }
+        // Handle placeholder for protected view body
+        if (restTokens[i].value.startsWith("__PGDELTA_PLACEHOLDER_")) {
+            clauseStarts.push(restTokens[i].start);
+        }
+    }
+    if (clauseStarts.length === 0)
+        return null;
+    clauseStarts.sort((a, b) => a - b);
+    const clauses = sliceClauses(rest, clauseStarts);
+    return joinHeaderAndClauses(header, clauses, options);
+}
+export function formatCreateSubscription(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "SUBSCRIPTION") {
+        return null;
+    }
+    // Name is the token after SUBSCRIPTION
+    const nameToken = tokens[2];
+    if (!nameToken)
+        return null;
+    const headerEnd = nameToken.end;
+    const rest = statement.slice(headerEnd).trim();
+    const header = statement.slice(0, headerEnd).trim();
+    if (rest.length === 0)
+        return null;
+    const restTokens = scanTokens(rest);
+    const positions = findClausePositions(restTokens, SUBSCRIPTION_CLAUSE_KEYWORDS);
+    if (positions.length === 0)
+        return null;
+    const clauses = sliceClauses(rest, positions);
+    return joinHeaderAndClauses(header, clauses, options, expandOptionsClause);
+}
+export function formatCreateFDW(statement, tokens, options) {
+    if (tokens.length < 5)
+        return null;
+    if (tokens[0].upper !== "CREATE")
+        return null;
+    // Must be CREATE FOREIGN DATA WRAPPER (not CREATE SERVER ... FOREIGN DATA WRAPPER)
+    if (tokens[1].upper !== "FOREIGN" ||
+        tokens[2]?.upper !== "DATA" ||
+        tokens[3]?.upper !== "WRAPPER") {
+        return null;
+    }
+    // Name is the token after WRAPPER
+    const nameToken = tokens[4];
+    if (!nameToken)
+        return null;
+    const headerEnd = nameToken.end;
+    const rest = statement.slice(headerEnd).trim();
+    const header = statement.slice(0, headerEnd).trim();
+    if (rest.length === 0)
+        return null;
+    const restTokens = scanTokens(rest);
+    const positions = findClausePositions(restTokens, FDW_CLAUSE_KEYWORDS);
+    if (positions.length === 0)
+        return null;
+    const clauses = sliceClauses(rest, positions);
+    return joinHeaderAndClauses(header, clauses, options, expandOptionsClause);
+}
+export function formatCreateServer(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "CREATE" || tokens[1].upper !== "SERVER") {
+        return null;
+    }
+    // Name is the token after SERVER
+    const nameToken = tokens[2];
+    if (!nameToken)
+        return null;
+    const headerEnd = nameToken.end;
+    const rest = statement.slice(headerEnd).trim();
+    const header = statement.slice(0, headerEnd).trim();
+    if (rest.length === 0)
+        return null;
+    // Server has a multi-keyword clause (FOREIGN DATA WRAPPER) requiring custom scan
+    const restTokens = scanTokens(rest);
+    const clauseStarts = [];
+    for (let i = 0; i < restTokens.length; i += 1) {
+        if (restTokens[i].depth !== 0)
+            continue;
+        const upper = restTokens[i].upper;
+        if (upper === "TYPE" || upper === "VERSION" || upper === "OPTIONS") {
+            clauseStarts.push(restTokens[i].start);
+            continue;
+        }
+        // Handle FOREIGN DATA WRAPPER as a clause start
+        if (upper === "FOREIGN" &&
+            restTokens[i + 1]?.upper === "DATA" &&
+            restTokens[i + 2]?.upper === "WRAPPER") {
+            clauseStarts.push(restTokens[i].start);
+        }
+    }
+    if (clauseStarts.length === 0)
+        return null;
+    clauseStarts.sort((a, b) => a - b);
+    const clauses = sliceClauses(rest, clauseStarts);
+    return joinHeaderAndClauses(header, clauses, options, expandOptionsClause);
+}
+export function formatAlterGeneric(statement, tokens, options) {
+    if (tokens.length < 3)
+        return null;
+    if (tokens[0].upper !== "ALTER")
+        return null;
+    // Already handled by formatAlterTable
+    if (tokens[1].upper === "TABLE")
+        return null;
+    // Map of ALTER types to the number of type-keyword tokens
+    // e.g. ALTER DOMAIN = 1, ALTER FOREIGN DATA WRAPPER = 3, ALTER MATERIALIZED VIEW = 2
+    let typeTokenCount = 0;
+    const t1 = tokens[1]?.upper;
+    if (t1 === "DOMAIN" || t1 === "SUBSCRIPTION" || t1 === "SERVER") {
+        typeTokenCount = 1;
+    }
+    else if (t1 === "MATERIALIZED" && tokens[2]?.upper === "VIEW") {
+        typeTokenCount = 2;
+    }
+    else if (t1 === "FOREIGN") {
+        if (tokens[2]?.upper === "TABLE") {
+            typeTokenCount = 2;
+        }
+        else if (tokens[2]?.upper === "DATA" && tokens[3]?.upper === "WRAPPER") {
+            typeTokenCount = 3;
+        }
+        else {
+            return null;
+        }
+    }
+    else if (t1 === "EVENT" && tokens[2]?.upper === "TRIGGER") {
+        typeTokenCount = 2;
+    }
+    else {
+        return null;
+    }
+    // cursor now points to the first token after the type keywords
+    let cursor = 1 + typeTokenCount;
+    // Skip IF EXISTS
+    if (tokens[cursor]?.upper === "IF" &&
+        tokens[cursor + 1]?.upper === "EXISTS") {
+        cursor += 2;
+    }
+    if (cursor >= tokens.length)
+        return null;
+    // Skip the name (may be schema-qualified)
+    cursor = skipQualifiedName(statement, tokens, cursor);
+    if (cursor >= tokens.length)
+        return null;
+    const headerEnd = tokens[cursor].start;
+    const header = statement.slice(0, headerEnd).trim();
+    const action = statement.slice(headerEnd).trim();
+    if (action.length === 0)
+        return null;
+    const indent = indentString(options.indent);
+    const expandedLines = expandOptionsClause(action, indent, options);
+    return [header, ...expandedLines].join("\n");
+}
+/**
+ * If a clause contains a parenthesized options list (e.g. OPTIONS(...), WITH(...), SET(...))
+ * and it has multiple comma-separated items, expand them one per line.
+ * Returns an array of properly indented lines that should be pushed directly into the output.
+ *
+ * Also used as a `clauseTransform` callback for `joinHeaderAndClauses`.
+ */
+function expandOptionsClause(clause, baseIndent, options) {
+    const clauseTokens = scanTokens(clause);
+    if (clauseTokens.length === 0)
+        return [`${baseIndent}${clause}`];
+    const firstUpper = clauseTokens[0].upper;
+    if (!EXPANDABLE_KEYWORDS.has(firstUpper)) {
+        return [`${baseIndent}${clause}`];
+    }
+    const parens = findTopLevelParen(clause, clauseTokens[0].end);
+    if (!parens)
+        return [`${baseIndent}${clause}`];
+    const { open, close } = parens;
+    const content = clause.slice(open + 1, close).trim();
+    const suffix = clause.slice(close + 1).trim();
+    const keyword = clause.slice(0, open).trim();
+    const items = splitByCommas(content);
+    if (items.length <= 1)
+        return [`${baseIndent}${clause}`];
+    const innerIndent = `${baseIndent}${indentString(options.indent)}`;
+    const formattedItems = formatMixedItems(items, options, innerIndent);
+    return [
+        `${baseIndent}${keyword} (`,
+        ...formattedItems,
+        `${baseIndent})${suffix ? ` ${suffix}` : ""}`,
+    ];
+}
+export function formatGeneric(statement, _tokens, _options) {
+    return statement.trim();
+}