feat: enhance getTypeFromValue to support data type extraction and improve type inference

Author: nicosammito

src/extraction/getTypeFromValue.ts

@@ -1,18 +1,24 @@
 import ts from "typescript";
-import {createCompilerHost} from "../utils";
-import {LiteralValue} from "@code0-tech/sagittarius-graphql-types";
+import {createCompilerHost, getSharedTypeDeclarations} from "../utils";
+import {DataType, LiteralValue} from "@code0-tech/sagittarius-graphql-types";
 
 /**
  * Uses the TypeScript compiler to generate a precise type string from any runtime value.
  */
 export const getTypeFromValue = (
-    value?: LiteralValue | null
+    value?: LiteralValue | null,
+    dataTypes?: DataType[]
 ): string => {
     // 1. Serialize value to a JSON string for embedding in source code.
     const literal = JSON.stringify(value?.value);
 
+    if (!literal) return "any"
+
     // 2. Wrap value in virtual source code.
-    const sourceCode = `const tempValue = ${literal ?? "any"};`;
+    const sourceCode = `
+        ${getSharedTypeDeclarations(dataTypes, "unknown")}
+        const tempValue = ${literal ?? "any"};
+    `;
     const fileName = "index.ts";
     const host = createCompilerHost(fileName, sourceCode);
     const sourceFile = host.getSourceFile(fileName)!;
@@ -25,16 +31,64 @@ export const getTypeFromValue = (
     const visit = (node: ts.Node) => {
         if (ts.isVariableDeclaration(node) && node.name.getText() === "tempValue") {
             const type = checker.getTypeAtLocation(node);
-            inferredType = checker.typeToString(
-                type,
-                node,
-                ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType
-            );
+            const allAliases = checker.getSymbolsInScope(node, ts.SymbolFlags.TypeAlias);
+
+            const resolve = (t: ts.Type): string => {
+                if (t.isUnion()) {
+                    const parts = t.types.map(resolve);
+                    return Array.from(new Set(parts)).sort().join(" | ");
+                }
+
+                // 2. Array-Handling
+                if (checker.isArrayType(t)) {
+                    const typeArgs = (t as any).typeArguments || [];
+                    const inner = typeArgs.length > 0 ? resolve(typeArgs[0]) : "any";
+                    return typeArgs[0]?.isUnion() ? `(${inner})[]` : `${inner}[]`;
+                }
+
+                if ((t.getFlags() & ts.TypeFlags.Object) || t.isClassOrInterface()) {
+                    const props = checker.getPropertiesOfType(t);
+                    if (props.length > 0) {
+                        const fields = props.map(p => {
+                            const pType = checker.getTypeOfSymbolAtLocation(p, node);
+                            return `${p.getName()}: ${resolve(pType)}`;
+                        });
+                        return `{ ${fields.join(", ")} }`;
+                    }
+                }
+
+                // 4. Alias-Suche für Blätter (Zahlen, Strings, etc.)
+                const matches = allAliases.filter(s =>
+                    checker.isTypeAssignableTo(t, checker.getDeclaredTypeOfSymbol(s))
+                );
+
+                if (matches.length > 0) {
+                    const bestMatch = matches.sort((a, b) => {
+                        const typeA = checker.getDeclaredTypeOfSymbol(a);
+                        const typeB = checker.getDeclaredTypeOfSymbol(b);
+
+                        const aSubB = checker.isTypeAssignableTo(typeA, typeB);
+                        const bSubA = checker.isTypeAssignableTo(typeB, typeA);
+
+                        if (aSubB && !bSubA) return -1;
+                        if (bSubA && !aSubB) return 1;
+
+                        return a.getName().length - b.getName().length || a.getName().localeCompare(b.getName());
+                    })[0];
+
+                    return bestMatch.getName();
+                }
+
+                return checker.typeToString(t, node);
+            };
+
+            inferredType = resolve(type);
         }
         ts.forEachChild(node, visit);
     };
 
     visit(sourceFile);
 
     return inferredType;
-};
+};
+

src/utils.ts

@@ -45,8 +45,6 @@ export const MINIMAL_LIB = `
     interface NewableFunction extends Function {}
     interface IArguments { }
     interface RegExp { }
-    type Record<K extends keyof any, T> = { [P in K]: T; };
-    type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
 `;
 
 /**
@@ -78,7 +76,7 @@ export const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions = {
 /**
  * Extracts and returns common type and generic declarations from DATA_TYPES.
  */
-export function getSharedTypeDeclarations(dataTypes?: DataType[], genericType: string = "any"): string {
+export function getSharedTypeDeclarations(dataTypes?: DataType[], genericType: string = "any", useGenericDeclarations: boolean = true): string {
     const genericDeclarations = Array.from(new Set(dataTypes?.flatMap(dt => dt.genericKeys || [])))
         .map(g => `type ${g} = ${genericType};`)
         .join("\n");
@@ -87,7 +85,7 @@ export function getSharedTypeDeclarations(dataTypes?: DataType[], genericType: s
         `type ${dt.identifier}${(dt.genericKeys?.length ?? 0) > 0 ? `<${dt.genericKeys?.join(",")}>` : ""} = ${dt.type};`
     ).join("\n");
 
-    return `${genericDeclarations}\n${typeAliasDeclarations}`;
+    return `${useGenericDeclarations ? genericDeclarations : ""}\n${typeAliasDeclarations}`;
 }
 
 /**

test/typeFromValue.test.ts

@@ -1,16 +1,17 @@
 import { describe, it, expect } from 'vitest';
 import { getTypeFromValue } from '../src/extraction/getTypeFromValue';
+import { DATA_TYPES } from './data';
 
 describe('getTypeFromValue', () => {
 
     it('should infer exact string literals', () => {
-        expect(getTypeFromValue({value: "POST"})).toBe('"POST"');
-        expect(getTypeFromValue({value: "active"})).toBe('"active"');
+        expect(getTypeFromValue({value: "POST"}, DATA_TYPES)).toBe('HTTP_METHOD');
+        expect(getTypeFromValue({value: "active"}, DATA_TYPES)).toBe('TEXT');
     });
 
     it('should infer exact number and boolean literals', () => {
-        expect(getTypeFromValue({value: 200})).toBe('200');
-        expect(getTypeFromValue({value: false})).toBe('false');
+        expect(getTypeFromValue({value: 200}, DATA_TYPES)).toBe('NUMBER');
+        expect(getTypeFromValue({value: false}, DATA_TYPES)).toBe('BOOLEAN');
     });
 
     it('should infer complex object structures', () => {
@@ -20,24 +21,24 @@ describe('getTypeFromValue', () => {
         };
 
 
-        const result = getTypeFromValue({value: user});
+        const result = getTypeFromValue({value: user}, DATA_TYPES);
 
-        expect(result).toMatch(/id:\s*number/);
-        expect(result).toMatch(/name:\s*string/);
-        expect(result).toMatch(/age:\s*number/);
+        expect(result).toMatch(/id:\s*NUMBER/);
+        expect(result).toMatch(/name:\s*TEXT/);
+        expect(result).toMatch(/age:\s*NUMBER/);
     });
 
     it('should infer arrays as unions of literals', () => {
         const list = ["A", "B"];
-        const result = getTypeFromValue({value: list});
+        const result = getTypeFromValue({value: list}, DATA_TYPES);
 
-        expect(result).toBe("string[]");
+        expect(result).toBe("TEXT[]");
     });
 
     it('should handle nested arrays', () => {
         const nested = [1, [2, 3]];
-        const result = getTypeFromValue({value: nested});
-        expect(result).toBe('(number | number[])[]');
+        const result = getTypeFromValue({value: nested}, DATA_TYPES);
+        expect(result).toBe('(NUMBER | NUMBER[])[]');
     });
 
     it('should handle null and empty structures', () => {

test/valueFromType.test.ts

@@ -47,6 +47,11 @@ describe('getValueFromType', () => {
             expect(result.value).toBe('GET');
         });
 
+        it('sollte das erste Element einer String-Union nehmen 2', () => {
+            const result = getValueFromType('HTTP_METHOD', DATA_TYPES);
+            expect(result.value).toBe('GET');
+        });
+
         it('sollte bei einer Union aus verschiedenen Typen den ersten Typ wählen', () => {
             const result = getValueFromType('number | string', DATA_TYPES);