feat: implement getTypesFromFunction to parse function signatures and return types

nicosammito · nicosammito · commit a9b92c0ecf55 · 2026-03-26T18:01:03.000+01:00
diff --git a/src/extraction/getTypeVariant.ts b/src/extraction/getTypeVariant.ts
@@ -26,6 +26,8 @@ export const getTypeVariant = (
         const val: TargetType = {} as any;
     `;
 
+    console.log(sourceCode)
+
     const fileName = `index.ts`;
     const host = createCompilerHost(fileName, sourceCode);
     const sourceFile = host.getSourceFile(fileName)!;
diff --git a/src/extraction/getTypesFromFunction.ts b/src/extraction/getTypesFromFunction.ts
@@ -0,0 +1,137 @@
+import {FunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+
+export interface FunctionTypes {
+    parameters: string[];
+    returnType: string;
+}
+
+/**
+ * Resolves the types of the parameters and the return type of a NodeFunction.
+ */
+export const getTypesFromFunction = (
+    functionDefinition: FunctionDefinition
+): FunctionTypes => {
+    const signature = functionDefinition.signature;
+
+    if (!signature) {
+        return {parameters: [], returnType: "any"};
+    }
+
+    let searchStart = 0;
+    // Skip generics
+    if (signature.trim().startsWith('<')) {
+        let depth = 0;
+        for (let i = 0; i < signature.length; i++) {
+            const char = signature[i];
+            if (char === '<') depth++;
+            else if (char === '>') {
+                depth--;
+                if (depth === 0) {
+                    searchStart = i + 1;
+                    break;
+                }
+            }
+        }
+    }
+
+    const paramStart = signature.indexOf('(', searchStart);
+    if (paramStart === -1) {
+        return {parameters: [], returnType: "any"};
+    }
+
+    // Find matching closing paren
+    let paramEnd = -1;
+    let depth = 0;
+    for (let i = paramStart; i < signature.length; i++) {
+        const char = signature[i];
+        if (char === '(') depth++;
+        else if (char === ')') {
+            depth--;
+            if (depth === 0) {
+                paramEnd = i;
+                break;
+            }
+        }
+    }
+
+    if (paramEnd === -1) {
+        return {parameters: [], returnType: "any"};
+    }
+
+    const paramsString = signature.substring(paramStart + 1, paramEnd);
+    let returnTypeString = signature.substring(paramEnd + 1).trim();
+
+    // Parse return type
+    if (returnTypeString.startsWith(':')) {
+        returnTypeString = returnTypeString.substring(1).trim();
+    }
+    const returnType = returnTypeString || "void";
+
+    // Parse parameters
+    const parameters: string[] = [];
+    if (paramsString.trim()) {
+        let currentParam = "";
+        let pDepthParen = 0;
+        let pDepthAngle = 0;
+        let pDepthBrace = 0;
+        let pDepthBracket = 0;
+
+        const pushParam = (p: string) => {
+            // Extract type from "name: Type"
+            // Scan for first colon at top level
+            let colonIndex = -1;
+
+            let cDepthBrace = 0;
+            let cDepthBracket = 0;
+            let cDepthParen = 0;
+            let cDepthAngle = 0;
+
+            for (let i = 0; i < p.length; i++) {
+                const c = p[i];
+                if (c === '{') cDepthBrace++;
+                else if (c === '}') cDepthBrace--;
+                else if (c === '[') cDepthBracket++;
+                else if (c === ']') cDepthBracket--;
+                else if (c === '(') cDepthParen++;
+                else if (c === ')') cDepthParen--;
+                else if (c === '<') cDepthAngle++;
+                else if (c === '>') cDepthAngle--;
+                else if (c === ':' && cDepthBrace === 0 && cDepthBracket === 0 && cDepthParen === 0 && cDepthAngle === 0) {
+                    colonIndex = i;
+                    break;
+                }
+            }
+
+            if (colonIndex !== -1) {
+                parameters.push(p.substring(colonIndex + 1).trim());
+            } else {
+                parameters.push("any");
+            }
+        };
+
+        for (const char of paramsString) {
+            if (char === '(') pDepthParen++;
+            else if (char === ')') pDepthParen--;
+            else if (char === '<') pDepthAngle++;
+            else if (char === '>') pDepthAngle--;
+            else if (char === '{') pDepthBrace++;
+            else if (char === '}') pDepthBrace--;
+            else if (char === '[') pDepthBracket++;
+            else if (char === ']') pDepthBracket--;
+            else if (char === ',' && pDepthParen === 0 && pDepthAngle === 0 && pDepthBrace === 0 && pDepthBracket === 0) {
+                pushParam(currentParam.trim());
+                currentParam = "";
+                continue;
+            }
+            currentParam += char;
+        }
+        if (currentParam.trim()) {
+            pushParam(currentParam.trim());
+        }
+    }
+
+    return {
+        parameters,
+        returnType
+    };
+};
diff --git a/src/extraction/getValueFromType.ts b/src/extraction/getValueFromType.ts
@@ -75,7 +75,7 @@ export const getValueFromType = (
             const typeRef = t as ts.TypeReference;
             const elementType = typeRef.typeArguments?.[0] || checker.getAnyType();
             const sample = generateSample(elementType, node, visited);
-            return sample === "null" ? [generateSample(elementType, node, visited)] : [];
+            return sample !== null ? [sample] : [];
         }
 
         // 4. Handle Objects / Interfaces
diff --git a/src/utils.ts b/src/utils.ts
@@ -80,7 +80,7 @@ export const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions = {
  */
 export function getSharedTypeDeclarations(dataTypes?: DataType[]): string {
     const genericDeclarations = Array.from(new Set(dataTypes?.flatMap(dt => dt.genericKeys || [])))
-        .map(g => `type ${g} = any;`)
+        .map(g => `type ${g} = unknown;`)
         .join("\n");
 
     const typeAliasDeclarations = dataTypes?.map(dt =>
diff --git a/test/getTypeVariant.test.ts b/test/getTypeVariant.test.ts
@@ -18,6 +18,7 @@ describe('getTypeVariant', () => {
     it('sollte OBJECT für Interfaces oder Objekte mit Properties zurückgeben', () => {
         expect(getTypeVariant("{ name: string }", DATA_TYPES)).toBe(DataTypeVariant.OBJECT);
         expect(getTypeVariant("{}", DATA_TYPES)).toBe(DataTypeVariant.OBJECT);
+        expect(getTypeVariant("OBJECT<T>", DATA_TYPES)).toBe(DataTypeVariant.OBJECT);
     });
 
     it('sollte TYPE für einfache Type-Aliase oder void zurückgeben', () => {
@@ -29,6 +30,7 @@ describe('getTypeVariant', () => {
         // In data.ts ist LIST als T[] definiert
         expect(getTypeVariant("LIST<NUMBER>", DATA_TYPES)).toBe(DataTypeVariant.ARRAY);
         expect(getTypeVariant("LIST<unknown>", DATA_TYPES)).toBe(DataTypeVariant.ARRAY);
+        expect(getTypeVariant("LIST<T>", DATA_TYPES)).toBe(DataTypeVariant.ARRAY);
     });
 
     it('sollte NODE für Funktionstypen wie CONSUMER zurückgeben', () => {
diff --git a/test/getTypesFromFunction.test.ts b/test/getTypesFromFunction.test.ts
@@ -0,0 +1,66 @@
+import {describe, expect, it} from "vitest";
+import {getTypesFromFunction} from "../src/extraction/getTypesFromFunction";
+import {FUNCTION_SIGNATURES} from "./data";
+
+describe("getTypesFromFunction", () => {
+
+    it("should correctly parse std::list::filter", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::filter");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>", "PREDICATE<T>"]);
+            expect(result.returnType).toBe("LIST<T>");
+        }
+    });
+
+    it("should correctly parse std::list::first", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::first");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>"]);
+            expect(result.returnType).toBe("T");
+        }
+    });
+
+    it("should correctly parse std::list::for_each", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::for_each");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>", "CONSUMER<T>"]);
+            expect(result.returnType).toBe("void");
+        }
+    });
+
+    it("should correctly parse std::list::map", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::map");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>", "TRANSFORM<T, R>"]);
+            expect(result.returnType).toBe("LIST<R>");
+        }
+    });
+
+    it("should correctly parse std::list::at", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::at");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>", "NUMBER"]);
+            expect(result.returnType).toBe("T");
+        }
+    });
+
+    it("should correctly parse std::list::sort_reverse", () => {
+        const func = FUNCTION_SIGNATURES.find(f => f.identifier === "std::list::sort_reverse");
+        expect(func).toBeDefined();
+        if (func) {
+            const result = getTypesFromFunction(func);
+            expect(result.parameters).toEqual(["LIST<T>", "COMPARATOR<T>"]);
+            expect(result.returnType).toBe("LIST<T>");
+        }
+    });
+});
diff --git a/test/valueFromType.test.ts b/test/valueFromType.test.ts
@@ -73,6 +73,8 @@ describe('getValueFromType', () => {
             const type = 'LIST<{ uid: TEXT, tags: LIST<NUMBER> }>';
             const result = getValueFromType(type, DATA_TYPES);
 
+            console.log(result)
+
             expect(result.value).toEqual([
                 {
                     uid: '',

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ export const getValueFromType = (`
`75`	`75`	`const typeRef = t as ts.TypeReference;`
`76`	`76`	`const elementType = typeRef.typeArguments?.[0] \|\| checker.getAnyType();`
`77`	`77`	`const sample = generateSample(elementType, node, visited);`
`78`		`- return sample === "null" ? [generateSample(elementType, node, visited)] : [];`
	`78`	`+ return sample !== null ? [sample] : [];`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`// 4. Handle Objects / Interfaces`
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,8 @@ describe('getValueFromType', () => {`
`73`	`73`	`const type = 'LIST<{ uid: TEXT, tags: LIST<NUMBER> }>';`
`74`	`74`	`const result = getValueFromType(type, DATA_TYPES);`
`75`	`75`
	`76`	`+ console.log(result)`
	`77`	`+`
`76`	`78`	`expect(result.value).toEqual([`
`77`	`79`	`{`
`78`	`80`	`uid: '',`