import { foldService, syntaxTree } from "@codemirror/language"; import type { EditorState } from "@codemirror/state"; import { elasticsearchRestRequestRanges } from "@/lib/sql/sqlStatementRanges"; import type { DatabaseType } from "@/types/database"; // `@lezer/common` is only a transitive dependency here (see sqlSyntaxTreeWindow.ts's comment on // the same pattern), so derive the node types structurally instead of importing them. type SyntaxNode = ReturnType["resolve"]>; type Tree = ReturnType; interface FoldRange { from: number; to: number; } // `@codemirror/lang-sql`'s grammar is deliberately shallow (see its `foldNodeProp`, which only // covers the flat `Statement` and `BlockComment` nodes). This service adds structure-aware folds // for procedural blocks and parenthesized query expressions without replacing CodeMirror's native // folds. // // Scoped to `BEGIN...END` and `CASE...END` (issue #6574) -- `BEGIN TRY`/`END TRY` and // `BEGIN CATCH`/`END CATCH` fall out of this for free, since `BEGIN` is matched regardless of a // trailing word. `IF`/`WHILE`/`LOOP` are deliberately excluded as openers: MySQL's // `IF(cond, a, b)` is a builtin scalar function, so treating bare `IF` as a block opener would // misparse every such call as an unterminated block and desync all fold ranges after it. T-SQL // (the dialect in #6574) doesn't need `IF` support anyway -- its `IF`/`ELSE` bodies are // themselves wrapped in `BEGIN...END`, which this already folds. const BLOCK_OPENERS = new Set(["BEGIN", "CASE"]); // Continuation words whose `END ` pairing closes something this service DID push an opener // for, so the `END` must pop the stack: `END CASE` closes a procedural `CASE` (the CASE-expression // form closes with plain `END` instead); `END TRY`/`END CATCH` close T-SQL's `BEGIN TRY`/ // `BEGIN CATCH` -- the leading `BEGIN` there already pushed a generic entry (see BLOCK_OPENERS; // the following `TRY`/`CATCH` word itself isn't inspected on push), so its closer must be // recognized too or that entry is never popped and desyncs every fold range after it. const TRACKED_END_CONTINUATIONS = new Set(["CASE", "TRY", "CATCH"]); // `END IF`/`END WHILE`/`END LOOP` close constructs with no `BEGIN`/`CASE` prefix at all -- bare // `IF`/`WHILE`/`LOOP` are never pushed (see BLOCK_OPENERS comment), so these `END`s must NOT pop // the stack; nothing on it belongs to them. const UNTRACKED_END_CONTINUATIONS = new Set(["IF", "WHILE", "LOOP"]); // A comment is legal SQL wherever whitespace is, so "END /* note */ CASE" must still read as a // continuation; this matches a run of pure whitespace and/or `--`/`/* */` comments so real code // between the two words (e.g. a `;` starting an unrelated statement) still fails the check. const GAP_IS_WHITESPACE_OR_COMMENT = /^(?:\s|--[^\n]*|\/\*[\s\S]*?\*\/)*$/; // T-SQL transaction openers do not have a matching `END`, so they must not consume the closer // of an enclosing procedural `BEGIN...END` block. Match complete keyword tokens only: `TRAN` is // SQL Server's documented abbreviation, while similar identifiers such as `TRANS` remain blocks. const SQLSERVER_TRANSACTION_BEGIN_WORDS = new Set(["TRAN", "TRANSACTION"]); function isSqlServerTransactionBegin(state: EditorState, tokens: SyntaxNode[], index: number): boolean { const next = tokens[index + 1]; if (!next || !GAP_IS_WHITESPACE_OR_COMMENT.test(state.sliceDoc(tokens[index].to, next.from))) return false; const nextText = state.sliceDoc(next.from, next.to).toUpperCase(); if (SQLSERVER_TRANSACTION_BEGIN_WORDS.has(nextText)) return true; if (nextText !== "DISTRIBUTED") return false; const transaction = tokens[index + 2]; return Boolean(transaction && GAP_IS_WHITESPACE_OR_COMMENT.test(state.sliceDoc(next.to, transaction.from)) && state.sliceDoc(transaction.from, transaction.to).toUpperCase() === "TRANSACTION"); } // Keyed by the `Tree` instance (not `Text`): the syntax tree is also invalidated when the SQL // dialect is reconfigured with the document unchanged (QueryEditor.vue's databaseType/dialect // watcher), and when Lezer's incremental parser finishes covering more of a large document in the // background -- both produce a new `Tree` without a new `Text`, so keying on `Text` alone would // keep serving ranges computed from a stale or partial parse. const rangeCache = new WeakMap>>(); function addMultilineFoldRange(state: EditorState, ranges: Map, openerPosition: number, endPosition: number, overwrite = false) { const openerLine = state.doc.lineAt(openerPosition); const endLine = state.doc.lineAt(endPosition); if (openerLine.number === endLine.number || endPosition <= openerLine.to || (!overwrite && ranges.has(openerLine.number))) return; ranges.set(openerLine.number, { from: openerLine.to, to: endPosition }); } function queryParent(node: SyntaxNode): SyntaxNode | null { for (let parent = node.parent; parent; parent = parent.parent) { if (parent.name === "Parens" || parent.name === "Statement") return parent; } return null; } function queryScopeKey(node: SyntaxNode): string { return `${node.name}:${node.from}:${node.to}`; } function queryScopeEnd(state: EditorState, scope: SyntaxNode): number { const lastChild = scope.lastChild; if (scope.name === "Parens" && lastChild?.name === ")") return lastChild.from; let end = scope.to; while (end > scope.from && /\s/.test(state.sliceDoc(end - 1, end))) end--; if (end > scope.from && state.sliceDoc(end - 1, end) === ";") end--; return end; } interface QueryScopeTokens { scope: SyntaxNode; tokens: Array<{ from: number; keyword: "SELECT" | "UNION" }>; hasUnion: boolean; } export function collectUnionBranchFoldRanges(tokens: ReadonlyArray<{ from: number; keyword: "SELECT" | "UNION" }>, scopeEnd: number): FoldRange[] { const ranges: FoldRange[] = []; let branchEnd = scopeEnd; for (let index = tokens.length - 1; index >= 0; index--) { const token = tokens[index]; if (token.keyword === "UNION") { branchEnd = token.from; } else { ranges.push({ from: token.from, to: branchEnd }); } } ranges.reverse(); return ranges; } function addQueryStructureFoldRanges(state: EditorState, tree: Tree, ranges: Map) { const scopes = new Map(); tree.iterate({ enter(node) { // Fold any multiline parenthesized expression, including large `IN (...)` // value lists. The opening line remains visible so the surrounding SQL // structure is still readable while the contents can be collapsed. if (node.name === "Parens") { addMultilineFoldRange(state, ranges, node.from, queryScopeEnd(state, node.node)); } if (node.name !== "Keyword") return; const keyword = state.sliceDoc(node.from, node.to).toUpperCase(); if (keyword !== "SELECT" && keyword !== "UNION") return; const scope = queryParent(node.node); if (!scope) return; const key = queryScopeKey(scope); const group = scopes.get(key) ?? { scope, tokens: [], hasUnion: false }; group.tokens.push({ from: node.from, keyword }); if (keyword === "UNION") group.hasUnion = true; scopes.set(key, group); }, }); for (const { scope, tokens, hasUnion } of scopes.values()) { if (!hasUnion) continue; const branchRanges = collectUnionBranchFoldRanges(tokens, queryScopeEnd(state, scope)); for (const range of branchRanges) { addMultilineFoldRange(state, ranges, range.from, range.to); } } } function addRestRequestFoldRanges(state: EditorState, ranges: Map, databaseType?: DatabaseType): boolean { const requests = elasticsearchRestRequestRanges(state.doc.toString(), databaseType ?? "elasticsearch"); if (requests.length === 0) return false; for (const request of requests) { addMultilineFoldRange(state, ranges, request.from, request.to); } return true; } function computeBlockFoldRanges(state: EditorState, databaseType?: DatabaseType): Map { const tree = syntaxTree(state); const cacheByDatabaseType = rangeCache.get(tree); const cacheKey = databaseType ?? "auto-detect"; const cached = cacheByDatabaseType?.get(cacheKey); if (cached) return cached; const byOpenerLine = new Map(); const isRestDocument = addRestRequestFoldRanges(state, byOpenerLine, databaseType); if (isRestDocument) { const nextCacheByDatabaseType = cacheByDatabaseType ?? new Map>(); nextCacheByDatabaseType.set(cacheKey, byOpenerLine); rangeCache.set(tree, nextCacheByDatabaseType); return byOpenerLine; } const tokens: SyntaxNode[] = []; tree.iterate({ enter(node) { if (node.name === "Keyword") tokens.push(node.node); }, }); const stack: SyntaxNode[] = []; for (let i = 0; i < tokens.length; i++) { const token = tokens[i]; const text = state.sliceDoc(token.from, token.to).toUpperCase(); if (text === "END") { const next = tokens[i + 1]; const continuation = next && GAP_IS_WHITESPACE_OR_COMMENT.test(state.sliceDoc(token.to, next.from)) ? state.sliceDoc(next.from, next.to).toUpperCase() : null; if (continuation && UNTRACKED_END_CONTINUATIONS.has(continuation)) { i++; // "END IF"/"END WHILE"/... -- closes something we don't track; skip past it untouched continue; } if (continuation && TRACKED_END_CONTINUATIONS.has(continuation)) i++; // "END CASE" -- consume the word, not a new opener const opener = stack.pop(); if (opener) { const openerLine = state.doc.lineAt(opener.to); const endLine = state.doc.lineAt(token.from); // Same source line as its opener (e.g. "BEGIN END"): nothing to collapse, and the // from/to formula below would otherwise invert (from > to) since `from` is the end of // that shared line while `to` is a position earlier on it. if (openerLine.number !== endLine.number) { addMultilineFoldRange(state, byOpenerLine, opener.from, token.from, true); } } } else if (BLOCK_OPENERS.has(text) && (text !== "BEGIN" || !isSqlServerTransactionBegin(state, tokens, i))) { stack.push(token); } } addQueryStructureFoldRanges(state, tree, byOpenerLine); const nextCacheByDatabaseType = cacheByDatabaseType ?? new Map>(); nextCacheByDatabaseType.set(cacheKey, byOpenerLine); rangeCache.set(tree, nextCacheByDatabaseType); return byOpenerLine; } /** Creates folding for REST requests, procedural blocks, query parentheses, and UNION branches. */ export function createSqlBlockFoldService(databaseType?: DatabaseType) { return foldService.of((state, lineStart) => { const range = computeBlockFoldRanges(state, databaseType).get(state.doc.lineAt(lineStart).number); return range ?? null; }); } /** Public compatibility extension with REST request auto-detection for text editors. */ export const sqlBlockFoldService = createSqlBlockFoldService();