feat: add ReturnType parser

factory/parser.ts

@@ -61,6 +61,7 @@ import { SatisfiesNodeParser } from "../src/NodeParser/SatisfiesNodeParser.js";
 import { PromiseNodeParser } from "../src/NodeParser/PromiseNodeParser.js";
 import { SpreadElementNodeParser } from "../src/NodeParser/SpreadElementNodeParser.js";
 import { IdentifierNodeParser } from "../src/NodeParser/IdentifierNodeParser.js";
+import { ReturnTypeNodeParser } from "../src/NodeParser/ReturnTypeNodeParser.js";
 
 export type ParserAugmentor = (parser: MutableParser) => void;
 
@@ -130,6 +131,7 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new ParenthesizedNodeParser(chainNodeParser))
 
         .addNodeParser(new PromiseNodeParser(typeChecker, chainNodeParser))
+        .addNodeParser(new ReturnTypeNodeParser(chainNodeParser, typeChecker))
         .addNodeParser(new TypeReferenceNodeParser(typeChecker, chainNodeParser))
         .addNodeParser(new ExpressionWithTypeArgumentsNodeParser(typeChecker, chainNodeParser))
         .addNodeParser(new IndexedAccessTypeNodeParser(typeChecker, chainNodeParser))

src/NodeParser/ReturnTypeNodeParser.ts

@@ -0,0 +1,134 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
+import { ObjectType } from "../Type/ObjectType.js";
+
+export class ReturnTypeNodeParser implements SubNodeParser {
+    constructor(
+        private readonly childNodeParser: NodeParser,
+        private readonly checker: ts.TypeChecker,
+    ) {}
+
+    supportsNode(node: ts.Node): boolean {
+        if (!ts.isTypeReferenceNode(node)) {
+            return false;
+        }
+
+        // Check if it's a ReturnType reference
+        try {
+            const typeName = ts.isIdentifier(node.typeName) 
+                ? node.typeName.text 
+                : node.typeName.getText();
+            return typeName === 'ReturnType' && node.typeArguments?.length === 1;
+        } catch {
+            return false;
+        }
+    }
+
+    createType(node: ts.TypeReferenceNode, context: Context): BaseType {
+        try {
+            if (!node.typeArguments || node.typeArguments.length !== 1) {
+                throw new UnknownNodeError(node);
+            }
+
+            const typeArg = node.typeArguments[0];
+
+            // Handle different types of type arguments
+            if (ts.isTypeQueryNode(typeArg)) {
+                // Case: ReturnType<typeof functionName>
+                // Get the symbol for the identifier
+                const symbol = this.checker.getSymbolAtLocation(typeArg.exprName);
+                if (!symbol) {
+                    throw new UnknownNodeError(node);
+                }
+
+                // Get the declarations of the symbol
+                const declarations = symbol.getDeclarations() || [];
+
+                // Try multiple methods to extract return type
+                for (const decl of declarations) {
+                    let returnTypeNode: ts.TypeNode | undefined;
+
+                    // If declaration is a function/method with explicit return type
+                    if (
+                        (ts.isFunctionDeclaration(decl) || ts.isMethodDeclaration(decl) || 
+                         ts.isArrowFunction(decl) || ts.isFunctionExpression(decl)) && 
+                        decl.type
+                    ) {
+                        returnTypeNode = decl.type;
+                    } 
+                    // If declaration is a variable with function type annotation
+                    else if (
+                        ts.isVariableDeclaration(decl) && 
+                        decl.type && 
+                        ts.isFunctionTypeNode(decl.type)
+                    ) {
+                        returnTypeNode = decl.type.type;
+                    }
+
+                    // If we found a return type node, process it
+                    if (returnTypeNode) {
+                        const baseType = this.childNodeParser.createType(returnTypeNode, context);
+                        return baseType;
+                    }
+                }
+
+                // Fallback to type checking method
+                const type = this.checker.getTypeOfSymbolAtLocation(symbol, typeArg);
+                const signatures = type.getCallSignatures();
+
+                if (signatures.length > 0) {
+                    // Use getReturnType directly from the signature
+                    const returnType = signatures[0].getReturnType();
+
+                    const returnTypeNode = this.checker.typeToTypeNode(
+                        returnType, 
+                        undefined, 
+                        ts.NodeBuilderFlags.NoTruncation
+                    );
+
+                    if (returnTypeNode) {
+                        return this.childNodeParser.createType(returnTypeNode, context);
+                    }
+                }
+            } else {
+                // Case: ReturnType<SomeType["methodName"]> or other complex types
+                // Get the type directly from TypeScript's type system
+                const argType = this.checker.getTypeAtLocation(typeArg);
+
+                // If it's a function type, get its return type
+                const signatures = argType.getCallSignatures();
+                if (signatures.length > 0) {
+                    const returnType = signatures[0].getReturnType();
+                    const returnTypeNode = this.checker.typeToTypeNode(
+                        returnType,
+                        undefined,
+                        ts.NodeBuilderFlags.NoTruncation
+                    );
+
+                    if (returnTypeNode) {
+                        return this.childNodeParser.createType(returnTypeNode, context);
+                    }
+                }
+
+                // Final fallback: try to get type directly
+                const type = this.checker.getTypeAtLocation(typeArg);
+                const typeNode = this.checker.typeToTypeNode(
+                    type, 
+                    undefined, 
+                    ts.NodeBuilderFlags.NoTruncation
+                );
+
+                if (typeNode) {
+                    return this.childNodeParser.createType(typeNode, context);
+                }
+            }
+
+            throw new UnknownNodeError(node);
+        } catch (error) {
+            throw error;
+        }
+    }
+}

test/valid-data-type.test.ts

@@ -156,4 +156,13 @@ describe("valid-data-type", () => {
         "export-star-prune-unreachable",
         assertValidSchema("export-star-prune-unreachable", "*", undefined, { mainTsOnly: true }),
     );
+
+    it(
+        "type-return-type", 
+        assertValidSchema("type-return-type", "Greeting")
+    );
+    it(
+        "type-return-type-complex", 
+        assertValidSchema("type-return-type-complex", "TestAppState")
+    );
 });

test/valid-data/type-return-type-complex/main.ts

@@ -0,0 +1,15 @@
+// Simulated Redux Toolkit scenario
+export interface TestState {
+  counter: number;
+  name: string;
+}
+
+export function createTestStore() {
+  return {
+    getState: () => ({ counter: 0, name: "test" } as TestState),
+    dispatch: (action: any) => {},
+  };
+}
+
+export type TestAppStore = ReturnType<typeof createTestStore>;
+export type TestAppState = ReturnType<TestAppStore["getState"]>;

test/valid-data/type-return-type-complex/schema.json

@@ -0,0 +1,25 @@
+{
+  "$ref": "#/definitions/TestAppState",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "TestAppState": {
+      "$ref": "#/definitions/TestState"
+    },
+    "TestState": {
+      "additionalProperties": false,
+      "properties": {
+        "counter": {
+          "type": "number"
+        },
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "counter",
+        "name"
+      ],
+      "type": "object"
+    }
+  }
+}

test/valid-data/type-return-type/main.ts

@@ -0,0 +1,5 @@
+export function greet(name: string): { message: string } {
+    return { message: `Hello, ${name}!` };
+}
+
+export type Greeting = ReturnType<typeof greet>;

test/valid-data/type-return-type/schema.json

@@ -0,0 +1,18 @@
+{
+  "$ref": "#/definitions/Greeting",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "Greeting": {
+      "additionalProperties": false,
+      "properties": {
+        "message": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "message"
+      ],
+      "type": "object"
+    }
+  }
+}