feat: implement getTypesFromNode function and corresponding tests for type resolution

Author: nicosammito

src/extraction/getTypesFromFunction.ts

@@ -0,0 +1,96 @@
+import ts from "typescript";
+import {Flow, NodeFunction, NodeParameter} from "@code0-tech/sagittarius-graphql-types";
+import {
+    createCompilerHost,
+    DEFAULT_COMPILER_OPTIONS,
+    ExtendedDataType,
+    ExtendedFunction,
+    getParameterCode,
+    getSharedTypeDeclarations,
+} from "../utils";
+import {getNodeValidation} from "../validation/getNodeValidation"; // Wieder hinzugefügt
+
+export interface NodeTypes {
+    parameters: string[];
+    returnType: string;
+}
+
+/**
+ * Resolves the types of the parameters and the return type of a NodeFunction.
+ */
+export const getTypesFromNode = (
+    node: NodeFunction,
+    functions: ExtendedFunction[],
+    dataTypes: ExtendedDataType[]
+): NodeTypes => {
+    const funcMap = new Map(functions.map(f => [f.identifier, f]));
+    const funcDef = funcMap.get(node.functionDefinition?.identifier);
+
+    if (!funcDef) {
+        return {
+            parameters: [],
+            returnType: "any",
+        };
+    }
+
+    const mockFlow: Flow = {
+        id: "gid://sagittarius/Flow/0" as any,
+        nodes: { __typename: "NodeFunctionConnection", nodes: [node] }
+    } as Flow;
+
+    const params = (node.parameters?.nodes as NodeParameter[]) || [];
+    const paramCodes = params.map(param => getParameterCode(param, mockFlow, (f, n) => getNodeValidation(f, n, functions, dataTypes)));
+
+    const funcCallArgs = paramCodes.map(code => code === 'undefined' ? '({} as any)' : code).join(", ");
+
+    const signature = funcDef.signature;
+    const sourceCode = `
+        ${getSharedTypeDeclarations(dataTypes)}
+        declare function testFunc${signature};
+        const result = testFunc(${funcCallArgs});
+    `;
+
+    const fileName = "node_types_virtual.ts";
+    const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest);
+    const host = createCompilerHost(fileName, sourceCode, sourceFile);
+
+    const program = ts.createProgram([fileName], DEFAULT_COMPILER_OPTIONS, host);
+    const checker = program.getTypeChecker();
+
+    let inferredReturnType = "any";
+    let inferredParameterTypes: string[] = [];
+
+    const visitor = (n: ts.Node) => {
+        if (ts.isVariableDeclaration(n) && n.name.getText() === "result") {
+            const resultType = checker.getTypeAtLocation(n);
+            inferredReturnType = checker.typeToString(
+                resultType,
+                n,
+                ts.TypeFormatFlags.NoTruncation
+            );
+
+            if (ts.isCallExpression(n.initializer!)) {
+                const callExpr = n.initializer;
+                const signature = checker.getResolvedSignature(callExpr);
+                if (signature) {
+                    inferredParameterTypes = signature.getParameters().map(p => {
+                        const type = checker.getTypeOfSymbolAtLocation(p, callExpr);
+                        return checker.typeToString(
+                            type,
+                            callExpr,
+                            ts.TypeFormatFlags.NoTruncation
+                        );
+                    });
+                }
+            }
+        }
+        ts.forEachChild(n, visitor);
+    };
+
+    visitor(sourceFile);
+
+    return {
+        parameters: inferredParameterTypes,
+        returnType: inferredReturnType,
+    };
+};

src/extraction/getTypesFromNode.ts

@@ -7,4 +7,4 @@ export * from './extraction/getTypeVariant';
 export * from './extraction/getValueFromType';
 export * from './suggestion/getValueSuggestions';
 export * from './validation/getValueValidation';
-
+export * from './extraction/getTypesFromNode';

src/index.ts

@@ -0,0 +1,96 @@
+import {describe, expect, it} from 'vitest';
+import {getTypesFromNode} from '../src/extraction/getTypesFromNode';
+import {FUNCTION_SIGNATURES, DATA_TYPES} from "./data";
+
+describe('getTypesFromNode', () => {
+    it('should resolve types for std::list::at with string array', () => {
+        const node = {
+            functionDefinition: {
+                identifier: "std::list::at" as any
+            },
+            parameters: {
+                nodes: [{
+                    value: {
+                        __typename: "LiteralValue",
+                        value: ["a", "b", "c"]
+                    }
+                }, {
+                    value: {
+                        __typename: "LiteralValue",
+                        value: 1
+                    }
+                }]
+            }
+        };
+        const result = getTypesFromNode(node as any, FUNCTION_SIGNATURES, DATA_TYPES);
+
+        console.log(result)
+
+        expect(result.returnType).toBe("string");
+        expect(result.parameters).toContain("LIST<string>");
+        expect(result.parameters).toContain("number");
+    });
+
+    it('should resolve types for std::list::at with string array', () => {
+        const node = {
+            functionDefinition: {
+                identifier: "std::list::at" as any
+            },
+            parameters: {
+                nodes: [{
+                    value: null
+                }, {
+                    value: {
+                        __typename: "LiteralValue",
+                        value: 1
+                    }
+                }]
+            }
+        };
+        const result = getTypesFromNode(node as any, FUNCTION_SIGNATURES, DATA_TYPES);
+
+        console.log(result)
+
+        expect(result.returnType).toBe("unknown");
+        expect(result.parameters).toContain("LIST<unknown>");
+        expect(result.parameters).toContain("number");
+    });
+
+    it('should resolve types for std::math::add', () => {
+        const node = {
+            functionDefinition: {
+                identifier: "std::math::add" as any
+            },
+            parameters: {
+                nodes: [{
+                    value: {
+                        __typename: "LiteralValue",
+                        value: 5
+                    }
+                }, {
+                    value: {
+                        __typename: "LiteralValue",
+                        value: 10
+                    }
+                }]
+            }
+        };
+        const result = getTypesFromNode(node as any, FUNCTION_SIGNATURES, DATA_TYPES);
+
+        expect(result.returnType).toBe("number");
+        expect(result.parameters).toEqual(["number", "number"]);
+    });
+
+    it('should return any for unknown function', () => {
+        const node = {
+            functionDefinition: {
+                identifier: "unknown::func" as any
+            }
+        };
+        const result = getTypesFromNode(node as any, FUNCTION_SIGNATURES, DATA_TYPES);
+
+        expect(result.returnType).toBe("any");
+        expect(result.parameters).toEqual([]);
+    });
+});
+