feat: reorganize module structure and update imports for validation and suggestion functionalities

Author: nicosammito

src/data.ts

@@ -1,12 +1,13 @@
 import ts from "typescript";
-import {createCompilerHost} from "./utils";
+import {createCompilerHost} from "../utils";
+import {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: any): string => {
+export const getTypeFromValue = (value: LiteralValue): string => {
     // 1. Serialize value to a JSON string for embedding in source code.
-    const literal = JSON.stringify(value);
+    const literal = JSON.stringify(value.value);
 
     // 2. Wrap value in virtual source code.
     const sourceCode = `const tempValue = ${literal};`;

src/getTypeFromValue.ts src/extraction/getTypeFromValue.tssrc/getTypeFromValue.ts renamed to src/extraction/getTypeFromValue.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import {ExtendedDataType, getSharedTypeDeclarations, createCompilerHost, DEFAULT_COMPILER_OPTIONS} from "./utils";
+import {ExtendedDataType, getSharedTypeDeclarations, createCompilerHost, DEFAULT_COMPILER_OPTIONS} from "../utils";
 
-export enum Variant {
+export enum DataTypeVariant {
     PRIMITIVE,
     TYPE,
     ARRAY,
@@ -12,16 +12,16 @@ export enum Variant {
  * Determines the variant of a given TypeScript type string using the TS compiler.
  */
 export const getTypeVariant = (
-    typeString: string,
+    type: string,
     dataTypes: ExtendedDataType[]
-): Variant => {
+): DataTypeVariant => {
     const typeDefs = getSharedTypeDeclarations(dataTypes);
     const fileName = `type_probe_${Math.random().toString(36).substring(7)}.ts`;
 
     // We declare a variable with the type to probe it
     const sourceCode = `
         ${typeDefs}
-        type TargetType = ${typeString};
+        type TargetType = ${type};
         const val: TargetType = {} as any;
     `;
 
@@ -30,29 +30,29 @@ export const getTypeVariant = (
     const program = ts.createProgram([fileName], DEFAULT_COMPILER_OPTIONS, host);
     const checker = program.getTypeChecker();
 
-    let discoveredVariant: Variant = Variant.TYPE;
+    let discoveredVariant: DataTypeVariant = DataTypeVariant.TYPE;
 
     const visit = (node: ts.Node) => {
         if (ts.isVariableDeclaration(node) && node.name.getText() === "val") {
             const type = checker.getTypeAtLocation(node);
 
             if (checker.isArrayType(type)) {
-                discoveredVariant = Variant.ARRAY;
+                discoveredVariant = DataTypeVariant.ARRAY;
             } else if (
                 type.isStringLiteral() ||
                 type.isNumberLiteral() ||
                 (type.getFlags() & (ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.Boolean | ts.TypeFlags.EnumLiteral | ts.TypeFlags.BigInt | ts.TypeFlags.ESSymbol)) !== 0
             ) {
-                discoveredVariant = Variant.PRIMITIVE;
+                discoveredVariant = DataTypeVariant.PRIMITIVE;
             } else if (type.isClassOrInterface() || (type.getFlags() & ts.TypeFlags.Object) !== 0) {
                 // Check if it's literally just a type alias to something else or a complex object
                 if (type.getProperties().length > 0) {
-                    discoveredVariant = Variant.OBJECT;
+                    discoveredVariant = DataTypeVariant.OBJECT;
                 } else {
-                    discoveredVariant = Variant.TYPE;
+                    discoveredVariant = DataTypeVariant.TYPE;
                 }
             } else {
-                discoveredVariant = Variant.TYPE;
+                discoveredVariant = DataTypeVariant.TYPE;
             }
         }
         ts.forEachChild(node, visit);

src/getTypeVariant.ts src/extraction/getTypeVariant.tssrc/getTypeVariant.ts renamed to src/extraction/getTypeVariant.ts

@@ -1,18 +1,18 @@
 import ts from "typescript";
 import {LiteralValue} from "@code0-tech/sagittarius-graphql-types";
-import {createCompilerHost, DEFAULT_COMPILER_OPTIONS, getSharedTypeDeclarations, ExtendedDataType} from "./utils";
+import {createCompilerHost, DEFAULT_COMPILER_OPTIONS, ExtendedDataType, getSharedTypeDeclarations} from "../utils";
 
 /**
  * Generates a sample LiteralValue from a TypeScript type string.
  */
 export const getValueFromType = (
-    targetType: string,
+    type: string,
     dataTypes: ExtendedDataType[]
 ): LiteralValue => {
     // 1. Prepare declarations.
     const sourceCode = `
         ${getSharedTypeDeclarations(dataTypes)}
-        type Target = ${targetType};
+        type Target = ${type};
     `;
 
     const fileName = "temp_type_to_value.ts";
@@ -34,7 +34,7 @@ export const getValueFromType = (
         return {__typename: 'LiteralValue', value: null};
     }
 
-    const type = checker.getTypeAtLocation(targetNode.type);
+    const typeFound = checker.getTypeAtLocation(targetNode.type);
 
     /**
      * Recursively generates a sample JavaScript value for a given TypeScript Type.
@@ -98,7 +98,7 @@ export const getValueFromType = (
         return null;
     };
 
-    const sample = generateSample(type, targetNode);
+    const sample = generateSample(typeFound, targetNode);
 
     // Test Expectation: result.value should be null for unknown types.
     // However, if we return null from the function, result.value access fails.

src/extraction/getTypesFromFunction.ts

@@ -1,12 +1,10 @@
-export * from './data';
-export * from './getFlowValidation';
-export * from './getNodeSuggestions';
-export * from './getNodeValidation';
-export * from './getReferenceSuggestions';
-export * from './getTypeFromValue';
-export * from './getTypeVariant';
-export * from './getValueFromType';
-export * from './getValueSuggestions';
-export * from './getValueValidation';
-export * from './utils';
+export * from './validation/getFlowValidation';
+export * from './suggestion/getNodeSuggestions';
+export * from './validation/getNodeValidation';
+export * from './suggestion/getReferenceSuggestions';
+export * from './extraction/getTypeFromValue';
+export * from './extraction/getTypeVariant';
+export * from './extraction/getValueFromType';
+export * from './suggestion/getValueSuggestions';
+export * from './validation/getValueValidation';
 

src/extraction/getTypesFromNode.ts

@@ -1,40 +1,49 @@
 import {NodeFunction} from "@code0-tech/sagittarius-graphql-types";
 import ts from "typescript";
-import {ExtendedFunction, createCompilerHost, DEFAULT_COMPILER_OPTIONS, getSharedTypeDeclarations} from "./utils";
-import {DATA_TYPES} from "./data";
+import {createCompilerHost, DEFAULT_COMPILER_OPTIONS, ExtendedFunction, getSharedTypeDeclarations} from "../utils";
+import {DATA_TYPES} from "../../test/data";
 
 /**
  * Suggests NodeFunctions based on a given type and a list of available FunctionDefinitions.
  * Returns functions whose return type is compatible with the target type.
  */
-export function getNodeSuggestions(targetType: string, functions: ExtendedFunction[]): NodeFunction[] {
-    if (!targetType || !functions || functions.length === 0) {
+export function getNodeSuggestions(type: string, functions: ExtendedFunction[]): NodeFunction[] {
+    if (!type || !functions || functions.length === 0) {
         return [];
     }
 
     const fileName = "suggestions.ts";
 
     const sharedTypes = getSharedTypeDeclarations(DATA_TYPES);
 
+    function getGenericsCount(input: string): number {
+        const match = input.match(/<([^>]+)>/);
+        if (!match) return 0;
+        return match[1].split(',').map(s => s.trim()).filter(Boolean).length;
+    }
+
     const sourceCode = `
         ${sharedTypes}
-        type TargetType = ${targetType};
+        type TargetType = ${type};
         ${functions.map((f, i) => {
-            const generics = f.genericKeys && f.genericKeys.length > 0
-                ? `<${f.genericKeys.map(k => `${k} = any`).join(",")}>`
-                : "";
-            return `type F${i}${generics} = ${f.returnType};`;
-        }).join("\n")}
+            
+        return `
+        declare function Fu${i}${f.signature};
+        type F${i} = ReturnType<typeof Fu${i}${getGenericsCount(f.signature) > 0 ? `<${Array(getGenericsCount(f.signature)).fill("any").join(", ")}>` : ""}>;
+        `;
+    }).join("\n")}
         ${functions.map((_, i) => `const check${i}: TargetType = {} as F${i};`).join("\n")}
     `;
 
+    console.log(sourceCode)
+
     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 diagnostics = ts.getPreEmitDiagnostics(program);
+    const diagnostics = program.getSemanticDiagnostics();
     const errorLines = new Set<number>();
     diagnostics.forEach(diag => {
         if (diag.file === sourceFile && diag.start !== undefined) {
@@ -49,6 +58,8 @@ export function getNodeSuggestions(targetType: string, functions: ExtendedFuncti
             const lines = sourceCode.split("\n");
             const actualLine = lines.findIndex(l => l.includes(lineToMatch));
 
+
+
             if (actualLine !== -1 && errorLines.has(actualLine)) {
                 return null;
             }
@@ -63,12 +74,12 @@ export function getNodeSuggestions(targetType: string, functions: ExtendedFuncti
                 },
                 parameters: {
                     __typename: "NodeParameterConnection",
-                    nodes: (f.parameters?.nodes || []).map(p => ({
+                    nodes: (f.parameterDefinitions?.nodes || []).map(p => ({
                         __typename: "NodeParameter",
                         parameterDefinition: {
                             __typename: "ParameterDefinition",
-                            id: p.identifier as any,
-                            identifier: p.identifier
+                            id: p?.identifier as any,
+                            identifier: p?.identifier
                         },
                         value: null
                     }))