fix: resolve unrepresentable type references via type checker fallback

Resolving a type reference whose declaration drives the parser into
third-party type-level machinery (e.g. zod's `z.infer<typeof schema>`,
which is built from deep generics) crashed with "Unhandled error while
creating Base Type" because the AST could not be statically re-derived.

When structural re-parsing throws an unexpected error, fall back to the
type checker's already-resolved type for the reference
(getTypeFromTypeNode + typeToTypeNode). The fallback only accepts
concrete types and never silently substitutes `any`/`unknown`, so
controlled errors still surface and existing behavior is unchanged.

Adds a regression test (depends on zod as a devDependency).

Author: heunghingwan

package-lock.json

@@ -88,7 +88,8 @@
     "tsx": "^4.21.0",
     "typescript-eslint": "^8.57.2",
     "vega": "^6.2.0",
-    "vega-lite": "^6.4.2"
+    "vega-lite": "^6.4.2",
+    "zod": "^4.4.3"
   },
   "packageManager": "npm@11.12.1",
   "publishConfig": {

package.json

@@ -7,6 +7,7 @@ import { ArrayType } from "../Type/ArrayType.js";
 import type { BaseType } from "../Type/BaseType.js";
 import { StringType } from "../Type/StringType.js";
 import { UnknownType } from "../Type/UnknownType.js";
+import { UnhandledError } from "../Error/Errors.js";
 import { symbolAtNode } from "../Utils/symbolAtNode.js";
 
 const invalidTypes: Record<number, boolean> = {
@@ -42,7 +43,7 @@ export class TypeReferenceNodeParser implements SubNodeParser {
                 return new AnyType();
             }
 
-            return this.childNodeParser.createType(declaration, this.createSubContext(node, context));
+            return this.createTypeFromDeclaration(declaration, node, context);
         }
 
         if (typeSymbol.flags & ts.SymbolFlags.TypeParameter) {
@@ -77,12 +78,71 @@ export class TypeReferenceNodeParser implements SubNodeParser {
             return new AnnotatedType(new StringType(), { format: "uri" }, false);
         }
 
-        return this.childNodeParser.createType(
+        return this.createTypeFromDeclaration(
             typeSymbol.declarations!.filter((n: ts.Declaration) => !invalidTypes[n.kind])[0],
-            this.createSubContext(node, context),
+            node,
+            context,
         );
     }
 
+    /**
+     * Resolves a referenced declaration through the child parser, falling back to the
+     * type checker's already-resolved type when structural re-parsing crashes.
+     *
+     * Re-parsing the AST can drive the parser into type-level machinery of third-party
+     * libraries (e.g. `zod`'s `z.infer<typeof schema>` conditional types, whose return
+     * type is built from deep generics) that cannot be statically re-derived. When that
+     * happens an unexpected (non-controlled) error is thrown; in that case we delegate to
+     * the type checker, which has already resolved such references to a concrete type.
+     */
+    protected createTypeFromDeclaration(
+        declaration: ts.Declaration,
+        node: ts.TypeReferenceNode,
+        context: Context,
+    ): BaseType {
+        try {
+            return this.childNodeParser.createType(declaration, this.createSubContext(node, context));
+        } catch (error) {
+            if (error instanceof UnhandledError) {
+                const resolved = this.createTypeFromChecker(node, context);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Builds a base type from the type checker's fully-resolved type for the given
+     * reference node. Returns undefined when the checker cannot offer a trustworthy
+     * concrete type (e.g. it collapses to `any`/`unknown`), so callers can rethrow the
+     * original error instead of silently substituting a meaningless schema.
+     */
+    protected createTypeFromChecker(node: ts.TypeReferenceNode, context: Context): BaseType | undefined {
+        let resolvedType: ts.Type;
+        try {
+            resolvedType = this.typeChecker.getTypeFromTypeNode(node);
+        } catch {
+            return undefined;
+        }
+
+        const typeNode = this.typeChecker.typeToTypeNode(resolvedType, node, ts.NodeBuilderFlags.IgnoreErrors);
+
+        if (!typeNode || typeNode.kind === ts.SyntaxKind.AnyKeyword || typeNode.kind === ts.SyntaxKind.UnknownKeyword) {
+            return undefined;
+        }
+        try {
+            const result = this.childNodeParser.createType(typeNode, context);
+            if (result instanceof AnyType || result instanceof UnknownType) {
+                return undefined;
+            }
+            return result;
+        } catch {
+            return undefined;
+        }
+    }
+
     protected createSubContext(node: ts.TypeReferenceNode, parentContext: Context): Context {
         const subContext = new Context(node);
 

src/NodeParser/TypeReferenceNodeParser.ts

@@ -0,0 +1,4 @@
+import { assertValidSchema } from "../../utils";
+import { test } from "node:test";
+
+test("valid-data - type-typeof-zod-infer", assertValidSchema("type-typeof-zod-infer", "MyObject"));

test/valid-data/type-typeof-zod-infer/index.test.ts

@@ -0,0 +1,27 @@
+import * as zod from "zod";
+
+// Regression test for resolving types derived via zod's `z.infer<typeof schema>`.
+// The schema builder's return type is built from deep generics that the generator
+// cannot re-derive by statically re-parsing the AST. The type checker, however,
+// resolves `z.infer<...>` to a concrete type, which the generator now falls back to.
+// See https://github.com/vega/ts-json-schema-generator/issues/758
+
+const NumberSchema = zod.number();
+type NumberType = zod.infer<typeof NumberSchema>;
+
+const ObjectSchema = zod.object({
+    name: zod.string(),
+    age: zod.number().optional(),
+    role: zod.enum(["admin", "user"]),
+});
+
+const UnionSchema = zod.discriminatedUnion("kind", [
+    zod.object({ kind: zod.literal("a"), value: zod.string() }),
+    zod.object({ kind: zod.literal("b"), count: zod.number() }),
+]);
+
+export interface MyObject {
+    numberField: NumberType;
+    objectField: zod.infer<typeof ObjectSchema>;
+    unionField: zod.infer<typeof UnionSchema>;
+}

test/valid-data/type-typeof-zod-infer/main.ts

@@ -0,0 +1,81 @@
+{
+  "$ref": "#/definitions/MyObject",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyObject": {
+      "additionalProperties": false,
+      "properties": {
+        "numberField": {
+          "type": "number"
+        },
+        "objectField": {
+          "additionalProperties": false,
+          "properties": {
+            "age": {
+              "type": "number"
+            },
+            "name": {
+              "type": "string"
+            },
+            "role": {
+              "enum": [
+                "admin",
+                "user"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "name",
+            "role"
+          ],
+          "type": "object"
+        },
+        "unionField": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "kind": {
+                  "const": "a",
+                  "type": "string"
+                },
+                "value": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "kind",
+                "value"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "count": {
+                  "type": "number"
+                },
+                "kind": {
+                  "const": "b",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "kind",
+                "count"
+              ],
+              "type": "object"
+            }
+          ]
+        }
+      },
+      "required": [
+        "numberField",
+        "objectField",
+        "unionField"
+      ],
+      "type": "object"
+    }
+  }
+}