feat: add type property to input schema for better type representation

Author: nicosammito

src/util/schema.util.ts

@@ -19,6 +19,12 @@ import {getSubFlows} from "./subflows.util";
 export interface Input {
     /** The type of input (string representation) */
     input?: string;
+    /**
+     * The underlying TypeScript type rendered as a string
+     * (e.g. "NUMBER", "LIST<TEXT>", "string | undefined"), as produced by the
+     * type checker for the type this schema node was generated from.
+     */
+    type?: string;
     /** Array of suggested values (functions, references, or literals) */
     suggestions?: (NodeFunction | ReferenceValue | LiteralValue | SubFlowValue)[];
 }
@@ -148,6 +154,10 @@ export const getSchema = (
         }
     }
 
+    // The raw TypeScript type as a string, carried on every schema node so the
+    // consumer knows the concrete type each input was derived from.
+    const type = checker.typeToString(parameterType);
+
     // Suggestions are filtered by what the surrounding function accepts, not by
     // the narrower type a current value happens to narrow the node-side to.
     // Example: `<T>(value: T)` with a current boolean literal must still surface
@@ -188,33 +198,33 @@ export const getSchema = (
         )
         if (nonNullish.length === 1) {
             const baseSchema = getSchema(checker, node, nonNullish[0], functionDeclarations, functions, false, undefined, visited, recursionCache)
-            return {...baseSchema, ...combinedSuggestions}
+            return {...baseSchema, type, ...combinedSuggestions}
         }
     }
 
     // Boolean is internally represented by TypeScript as the union `true | false`,
     // so it must be detected before the primitive-literal-union check below; otherwise
     // `boolean` (and `true | false`) would incorrectly surface as a select.
     if (isBoolean(parameterType)) {
-        return {input: "boolean", ...combinedSuggestions};
+        return {input: "boolean", type, ...combinedSuggestions};
     }
 
     // Check primitive literal union first (e.g., "a" | "b" | "c") or a single
     // string/number literal (e.g., "GET"). A bare literal has only one allowed
     // value, so it should still surface as a select rather than a free-form text/number input.
     if (isPrimitiveLiteralUnion(parameterType) || isStringOrNumberLiteral(parameterType)) {
-        return {input: "select", ...combinedSuggestions};
+        return {input: "select", type, ...combinedSuggestions};
     }
     if (isNumber(parameterType)) {
-        return {input: "number", ...combinedSuggestions};
+        return {input: "number", type, ...combinedSuggestions};
     }
     if (isString(parameterType)) {
-        return {input: "text", ...combinedSuggestions};
+        return {input: "text", type, ...combinedSuggestions};
     }
 
     // Check if type has call signatures (is callable/sub-flow)
     if (isSubFlow(parameterType)) {
-        return {input: "sub-flow", ...combinedSuggestions};
+        return {input: "sub-flow", type, ...combinedSuggestions};
     }
 
     // Handle array and tuple types
@@ -233,6 +243,7 @@ export const getSchema = (
 
         return {
             input: "list",
+            type,
             items: itemSchemas,
             ...combinedSuggestions,
         };
@@ -252,7 +263,7 @@ export const getSchema = (
             (visited.size >= MAX_SCHEMA_DEPTH &&
                 isRecursiveType(parameterType, checker, recursionCache))
         ) {
-            return {input: "data", ...combinedSuggestions};
+            return {input: "data", type, ...combinedSuggestions};
         }
         visited.add(parameterType);
 
@@ -304,6 +315,7 @@ export const getSchema = (
 
         return {
             input: "data",
+            type,
             properties,
             required,
             ...combinedSuggestions,
@@ -314,6 +326,7 @@ export const getSchema = (
     // suggestions (e.g. references in scope) so the UI is never silently empty.
     return {
         input: "generic",
+        type,
         ...combinedSuggestions,
     };
 };
@@ -435,6 +448,7 @@ const liftGenericIfValued = (schema: Schema, valueProvided: boolean): Schema =>
     if (!valueProvided || schema.input !== "generic") return schema;
     return {
         input: "data",
+        ...(schema.type ? {type: schema.type} : {}),
         properties: {},
         required: [],
         ...(schema.suggestions ? {suggestions: schema.suggestions} : {}),
@@ -464,6 +478,7 @@ const demoteSelect = (schema: Schema): Schema => {
             : "text";
     return {
         input: target,
+        ...(schema.type ? {type: schema.type} : {}),
         ...(suggestions.length > 0 ? {suggestions} : {}),
     };
 };

test/schema/schema.test.ts

@@ -1100,23 +1100,23 @@ describe("Schema", () => {
             const ret = returnOf("std::boolean::as_number", [
                 {value: {__typename: "LiteralValue", value: true}},
             ]);
-            expect(ret).toEqual({input: "number"});
+            expect(ret).toEqual({input: "number", type: "number"});
         });
 
         it("resolves a TEXT return to a text input", () => {
             // std::boolean::as_text → (value: BOOLEAN): TEXT
             const ret = returnOf("std::boolean::as_text", [
                 {value: {__typename: "LiteralValue", value: true}},
             ]);
-            expect(ret).toEqual({input: "text"});
+            expect(ret).toEqual({input: "text", type: "string"});
         });
 
         it("resolves a BOOLEAN return to a boolean input", () => {
             // std::boolean::from_number → (value: NUMBER): BOOLEAN
             const ret = returnOf("std::boolean::from_number", [
                 {value: {__typename: "LiteralValue", value: 1}},
             ]);
-            expect(ret).toEqual({input: "boolean"});
+            expect(ret).toEqual({input: "boolean", type: "boolean"});
         });
 
         it("resolves an object return (HTTP_RESPONSE) to a data input with its properties", () => {
@@ -1151,7 +1151,7 @@ describe("Schema", () => {
                 {value: {__typename: "LiteralValue", value: [10, 20, 30]}},
                 {value: {__typename: "LiteralValue", value: 0}},
             ]);
-            expect(ret).toEqual({input: "number"});
+            expect(ret).toEqual({input: "number", type: "number"});
         });
 
         it("returns a generic input for a void signature and no nodeId at the flow level", () => {
@@ -1164,7 +1164,7 @@ describe("Schema", () => {
             );
             // Flow-level probe: no target node, flow signature is `(): void`.
             expect(result.nodeId).toBeUndefined();
-            expect(result.return).toEqual({input: "generic"});
+            expect(result.return).toEqual({input: "generic", type: "void"});
         });
 
         it("never carries suggestions, whatever the return type", () => {