getFlowValidation.ts

import {flattenDiagnosticMessageText} from "typescript";
import {DataType, Flow, FunctionDefinition, NodeFunction} from "@code0-tech/sagittarius-graphql-types";
import {createCompilerHost, generateFlowSourceCode, ValidationResult} from "../utils";

/**
 * Validates a flow by generating virtual TypeScript code and running it through the TS compiler.
 */
export const getFlowValidation = (
    flow?: Flow,
    functions?: FunctionDefinition[],
    dataTypes?: DataType[]
): ValidationResult => {

    if (!flow?.startingNodeId) {
        return {
            isValid: false,
            returnType: "void",
            diagnostics: [{
                nodeId: null,
                parameterIndex: null,
                code: 0,
                message: "You need to provide a starting node to be able to execute this flow.",
                severity: "error",
            }]
        }
    }

    if (!flow.nodes?.nodes?.find(n => n?.id == flow.startingNodeId)) {
        return {
            isValid: false,
            returnType: "void",
            diagnostics: [{
                nodeId: null,
                parameterIndex: null,
                code: 0,
                message: "The starting node is not linked within the flow. Please make sure the starting node is connected to the rest of the flow.",
                severity: "error",
            }]
        }
    }

    const functionIdentifiers = new Set(functions?.map(f => f.identifier));
    const unreachableFunctionDiagnostics = (flow.nodes?.nodes ?? [])
        .filter(n => n?.functionDefinition && !functionIdentifiers.has(n.functionDefinition.identifier))
        .map(n => ({
            nodeId: n!.id,
            parameterIndex: null,
            code: 0,
            message: `The function definition "${n!.functionDefinition!.identifier}" is not reachable.`,
            severity: "error" as const,
        }));

    if (unreachableFunctionDiagnostics.length > 0) {
        return {
            isValid: false,
            returnType: "void",
            diagnostics: unreachableFunctionDiagnostics,
        }
    }

    const sourceCode = generateFlowSourceCode(flow, functions, dataTypes);

    // 3. Virtual TypeScript Compilation
    const fileName = "index.ts";
    const host = createCompilerHost(fileName, sourceCode);
    const sourceFile = host.getSourceFile(fileName)!;

    const program = host.languageService.getProgram()!;
    const diagnostics = program.getSemanticDiagnostics(sourceFile);

    const errors = diagnostics.map(d => {
        const message = flattenDiagnosticMessageText(d.messageText, "\n");
        // "Argument of type 'undefined' is not assignable to parameter of type 'number'."
        // We ignore this in flow validation too because we might generate code for incomplete flows.

        let nodeId: NodeFunction['id'] | undefined;
        let parameterIndex: number | null = null;

        if (d.start !== undefined) {
            const fullText = sourceFile.getFullText();

            // Search for position marker comment near the error location
            // The error position is typically the start of the problematic token (e.g., "undefined")
            const searchStart = Math.max(0, d.start - 300);
            const searchEnd = Math.min(fullText.length, d.start);
            const searchText = fullText.substring(searchStart, searchEnd);

            // Find all @pos comments in the search range
            const posRegex = /\/\* @pos ([^ ]+) (\d+|null) \*\//g;
            let match;
            let closestMatch: RegExpExecArray | null = null;
            let closestCommentEnd = -1;

            // Collect all matches and find the one whose end is closest to d.start
            // We want the comment that is immediately before the error
            while ((match = posRegex.exec(searchText)) !== null) {
                const commentStart = searchStart + match.index;
                const commentEnd = commentStart + match[0].length;

                // Only consider comments that end before or very close to the error start
                // This ensures we get the @pos comment that directly precedes the problematic argument
                if (commentEnd <= d.start!) {
                    if (commentEnd > closestCommentEnd) {
                        closestCommentEnd = commentEnd;
                        closestMatch = match;
                    }
                }
            }

            if (closestMatch) {
                nodeId = closestMatch[1] === "null" ? null : closestMatch[1] as NodeFunction['id'];
                parameterIndex = parseInt(closestMatch[2], 10);
            }
        }

        return {
            message,
            code: d.code,
            severity: "error" as const,
            nodeId,
            parameterIndex: typeof parameterIndex == "number" && Number.isSafeInteger(parameterIndex) ? parameterIndex : null,
        };
    }).filter((e) => e !== null);

    return {
        isValid: !errors.some(e => e?.severity === "error"),
        returnType: "void",
        diagnostics: errors,
    };
};