feat: add nodeId and parameterIndex to diagnostics for enhanced error tracking

Author: nicosammito

src/validation/getFlowValidation.ts

@@ -2,7 +2,7 @@ import ts, {flattenDiagnosticMessageText} from "typescript";
 import {
     DataType,
     Flow,
-    FunctionDefinition,
+    FunctionDefinition, NodeFunction,
     NodeFunctionIdWrapper,
     NodeParameter,
     ReferenceValue
@@ -52,8 +52,8 @@ export const getFlowValidation = (
                 if (!ref.nodeFunctionId) return "undefined";
 
                 let refCode = ref.parameterIndex !== undefined
-                    ? `p_${sanitizeId(ref.nodeFunctionId)}_${ref.parameterIndex}`
-                    : `node_${sanitizeId(ref.nodeFunctionId)}`;
+                    ? `/* @pos ${nodeId} ${index} */ p_${sanitizeId(ref.nodeFunctionId)}_${ref.parameterIndex}`
+                    : `/* @pos ${nodeId} ${index} */ node_${sanitizeId(ref.nodeFunctionId)}`;
 
                 ref.referencePath?.forEach(pathObj => {
                     refCode += `?.${pathObj.path}`;
@@ -63,14 +63,14 @@ export const getFlowValidation = (
             }
 
             if (val.__typename === "LiteralValue") {
-                return JSON.stringify(val.value);
+                return `/* @pos ${nodeId} ${index} */ ${JSON.stringify(val.value)}`;
             }
 
             if (val.__typename === "NodeFunctionIdWrapper") {
                 const wrapper = val as NodeFunctionIdWrapper;
                 const lambdaArgName = `p_${sanitizeId(node.id!)}_${index}`;
                 const subTreeCode = generateNodeCode(wrapper.id!, indent + "  ");
-                return `(${lambdaArgName}) => {\n${subTreeCode}${indent}}`;
+                return `/* @pos ${nodeId} ${index} */ (${lambdaArgName}) => {\n${subTreeCode}${indent}}`;
             }
 
             return "undefined";
@@ -121,10 +121,25 @@ export const getFlowValidation = (
 
         if (isMockError) return null;
 
+        let nodeId: NodeFunction['id'] | undefined;
+        let parameterIndex: number | undefined;
+
+        if (d.start !== undefined) {
+            const fullText = sourceFile.getFullText();
+            const textBefore = fullText.substring(0, d.start);
+            const posMatch = textBefore.match(/\/\* @pos ([^ ]+) (\d+) \*\/\s*$/);
+            if (posMatch) {
+                nodeId = posMatch[1] as NodeFunction['id'];
+                parameterIndex = parseInt(posMatch[2], 10);
+            }
+        }
+
         return {
             message,
             code: d.code,
             severity: "error" as const,
+            nodeId,
+            parameterIndex
         };
     }).filter((e) => e !== null);
 

test/flowValidation.test.ts

@@ -113,4 +113,32 @@ describe('getFlowValidation - Integrationstest', () => {
         expect(result.diagnostics).toHaveLength(0);
     });
 
+    it('sollte nodeId und parameterIndex in den Diagnostics zurückgeben', () => {
+        const flow: Flow = {
+            nodes: {
+                nodes: [
+                    {
+                        id: "gid://sagittarius/NodeFunction/1",
+                        functionDefinition: { identifier: "std::math::add" },
+                        parameters: {
+                            nodes: [
+                                { value: { __typename: "LiteralValue", value: "not accessibility a number" } },
+                                { value: { __typename: "LiteralValue", value: 10 } }
+                            ]
+                        }
+                    }
+                ]
+            }
+        };
+
+        const result = getFlowValidation(flow, FUNCTION_SIGNATURES, DATA_TYPES);
+
+        console.log(result);
+
+        expect(result.isValid).toBe(false);
+        const diagnostic = result.diagnostics.find(d => d.nodeId === "gid://sagittarius/NodeFunction/1" && d.parameterIndex === 0);
+        expect(diagnostic).toBeDefined();
+        expect(diagnostic?.message).toContain("number");
+    });
+
 });