fix: support for generic functions (#2159)

arthurfiorette · domoritz · web-flow · commit c8ea3ed63590 · 2025-02-18T00:29:46.000-03:00
Co-authored-by: Dominik Moritz &lt;domoritz@gmail.com&gt;
diff --git a/package.json b/package.json
@@ -93,6 +93,7 @@
     "vega": "^5.31.0",
     "vega-lite": "^5.23.0"
   },
+  "packageManager": "npm@10.8.2",
   "engines": {
     "node": ">=18.0.0"
   }
diff --git a/src/ChainNodeParser.ts b/src/ChainNodeParser.ts
@@ -31,6 +31,7 @@ export class ChainNodeParser implements SubNodeParser, MutableParser {
         }
         const contextCacheKey = context.getCacheKey();
         let type = typeCache.get(contextCacheKey);
+
         if (!type) {
             try {
                 type = this.getNodeParser(node).createType(node, context, reference);
@@ -41,6 +42,11 @@ export class ChainNodeParser implements SubNodeParser, MutableParser {
                 typeCache.set(contextCacheKey, type);
             }
         }
+
+        if (!type) {
+            throw new UnknownNodeError(node);
+        }
+
         return type;
     }
 
diff --git a/src/NodeParser/CallExpressionParser.ts b/src/NodeParser/CallExpressionParser.ts
@@ -7,6 +7,7 @@ import type { BaseType } from "../Type/BaseType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { LiteralType } from "../Type/LiteralType.js";
 import { SymbolType } from "../Type/SymbolType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
 
 export class CallExpressionParser implements SubNodeParser {
     public constructor(
@@ -33,9 +34,21 @@ export class CallExpressionParser implements SubNodeParser {
         }
 
         const symbol = type.symbol || type.aliasSymbol;
-        const decl = symbol.valueDeclaration || symbol.declarations![0];
-        const subContext = this.createSubContext(node, context);
-        return this.childNodeParser.createType(decl, subContext);
+
+        // For funtions like <T>(type: T) => T, there won't be any reference to the original
+        // type. Using type checker to infer the actual return type without mapping the whole
+        // function and back referencing its generic type based on parameter index is a better
+        // approach.
+        const decl =
+            this.typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.IgnoreErrors) ||
+            symbol.valueDeclaration ||
+            symbol.declarations?.[0];
+
+        if (!decl) {
+            throw new UnknownNodeError(node);
+        }
+
+        return this.childNodeParser.createType(decl, this.createSubContext(node, context));
     }
 
     protected createSubContext(node: ts.CallExpression, parentContext: Context): Context {
diff --git a/src/NodeParser/IndexedAccessTypeNodeParser.ts b/src/NodeParser/IndexedAccessTypeNodeParser.ts
@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { LogicError } from "../Error/Errors.js";
 import type { Context, NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import type { BaseType } from "../Type/BaseType.js";
@@ -9,9 +10,9 @@ import { ReferenceType } from "../Type/ReferenceType.js";
 import { StringType } from "../Type/StringType.js";
 import { TupleType } from "../Type/TupleType.js";
 import { UnionType } from "../Type/UnionType.js";
+import { isErroredUnknownType } from "../Type/UnknownType.js";
 import { derefType } from "../Utils/derefType.js";
 import { getTypeByKey } from "../Utils/typeKeys.js";
-import { LogicError } from "../Error/Errors.js";
 
 export class IndexedAccessTypeNodeParser implements SubNodeParser {
     public constructor(
@@ -49,7 +50,7 @@ export class IndexedAccessTypeNodeParser implements SubNodeParser {
         const indexType = derefType(this.childNodeParser.createType(node.indexType, context));
         const indexedType = this.createIndexedType(node.objectType, context, indexType);
 
-        if (indexedType) {
+        if (indexedType && !isErroredUnknownType(indexedType)) {
             return indexedType;
         }
 
diff --git a/src/NodeParser/TypeReferenceNodeParser.ts b/src/NodeParser/TypeReferenceNodeParser.ts
@@ -6,6 +6,7 @@ import { AnyType } from "../Type/AnyType.js";
 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 { symbolAtNode } from "../Utils/symbolAtNode.js";
 
 const invalidTypes: Record<number, boolean> = {
@@ -45,7 +46,7 @@ export class TypeReferenceNodeParser implements SubNodeParser {
         }
 
         if (typeSymbol.flags & ts.SymbolFlags.TypeParameter) {
-            return context.getArgument(typeSymbol.name);
+            return context.getArgument(typeSymbol.name) ?? new UnknownType(true);
         }
 
         // Wraps promise type to avoid resolving to a empty Object type.
diff --git a/src/NodeParser/UnknownTypeNodeParser.ts b/src/NodeParser/UnknownTypeNodeParser.ts
@@ -1,5 +1,4 @@
 import ts from "typescript";
-import type { Context } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import type { BaseType } from "../Type/BaseType.js";
 import { UnknownType } from "../Type/UnknownType.js";
@@ -8,7 +7,8 @@ export class UnknownTypeNodeParser implements SubNodeParser {
     public supportsNode(node: ts.KeywordTypeNode): boolean {
         return node.kind === ts.SyntaxKind.UnknownKeyword;
     }
-    public createType(node: ts.KeywordTypeNode, context: Context): BaseType {
-        return new UnknownType();
+
+    public createType(): BaseType {
+        return new UnknownType(false);
     }
 }
diff --git a/src/Type/UnknownType.ts b/src/Type/UnknownType.ts
@@ -1,10 +1,23 @@
 import { BaseType } from "./BaseType.js";
 
 export class UnknownType extends BaseType {
-    constructor() {
+    constructor(
+        /**
+         * If the source for this UnknownType was from a failed operation than to an actual `unknown` type present in the source code.
+         */
+        readonly erroredSource: boolean,
+    ) {
         super();
     }
+
     public getId(): string {
         return "unknown";
     }
 }
+
+/**
+ * Checks for an UnknownType with an errored source.
+ */
+export function isErroredUnknownType(type: BaseType): type is UnknownType {
+    return type instanceof UnknownType && type.erroredSource;
+}
diff --git a/src/TypeFormatter/UnknownTypeFormatter.ts b/src/TypeFormatter/UnknownTypeFormatter.ts
@@ -7,10 +7,16 @@ export class UnknownTypeFormatter implements SubTypeFormatter {
     public supportsType(type: BaseType): boolean {
         return type instanceof UnknownType;
     }
+
     public getDefinition(type: UnknownType): Definition {
+        if (type.erroredSource) {
+            return { description: "Failed to correctly infer type" };
+        }
+
         return {};
     }
-    public getChildren(type: UnknownType): BaseType[] {
+
+    public getChildren(): BaseType[] {
         return [];
     }
 }
diff --git a/test/valid-data-other.test.ts b/test/valid-data-other.test.ts
@@ -84,6 +84,7 @@ describe("valid-data-other", () => {
     it("array-function-generics", assertValidSchema("array-function-generics", "*"));
     it("array-max-items-optional", assertValidSchema("array-max-items-optional", "MyType"));
     it("shorthand-array", assertValidSchema("shorthand-array", "MyType"));
+    it("function-generic", assertValidSchema("function-generic", "MyType"));
 
     it(
         "object-required",
diff --git a/test/valid-data/array-function-generics/schema.json b/test/valid-data/array-function-generics/schema.json
@@ -9,11 +9,15 @@
           "additionalProperties": false,
           "properties": {
             "a": {
-              "items": {},
+              "items": {
+                "description": "Failed to correctly infer type"
+              },
               "type": "array"
             },
             "b": {
-              "items": {},
+              "items": {
+                "description": "Failed to correctly infer type"
+              },
               "type": "array"
             }
           },
diff --git a/test/valid-data/function-generic/main.ts b/test/valid-data/function-generic/main.ts
@@ -0,0 +1,12 @@
+function fn<A, B, C>(a: A, b: B, c: C, any: A | B | C) {
+    return { a, b, c, any };
+}
+
+const value = {
+    litNum: fn(1, "2", true, 1),
+    litStr: fn("1", 2, true, "2"),
+    litBool: fn(true, 2, "3", true),
+    obj: fn({ a: 1 }, { b: "2" }, { c: true }, { a: 1 }),
+};
+
+export type MyType = typeof value;
diff --git a/test/valid-data/function-generic/schema.json b/test/valid-data/function-generic/schema.json
@@ -0,0 +1,190 @@
+{
+  "$ref": "#/definitions/MyType",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyType": {
+      "additionalProperties": false,
+      "properties": {
+        "litBool": {
+          "additionalProperties": false,
+          "properties": {
+            "a": {
+              "type": "boolean"
+            },
+            "any": {
+              "type": [
+                "string",
+                "number",
+                "boolean"
+              ]
+            },
+            "b": {
+              "type": "number"
+            },
+            "c": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "a",
+            "b",
+            "c",
+            "any"
+          ],
+          "type": "object"
+        },
+        "litNum": {
+          "additionalProperties": false,
+          "properties": {
+            "a": {
+              "type": "number"
+            },
+            "any": {
+              "type": [
+                "string",
+                "number",
+                "boolean"
+              ]
+            },
+            "b": {
+              "type": "string"
+            },
+            "c": {
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "a",
+            "b",
+            "c",
+            "any"
+          ],
+          "type": "object"
+        },
+        "litStr": {
+          "additionalProperties": false,
+          "properties": {
+            "a": {
+              "type": "string"
+            },
+            "any": {
+              "type": [
+                "string",
+                "number",
+                "boolean"
+              ]
+            },
+            "b": {
+              "type": "number"
+            },
+            "c": {
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "a",
+            "b",
+            "c",
+            "any"
+          ],
+          "type": "object"
+        },
+        "obj": {
+          "additionalProperties": false,
+          "properties": {
+            "a": {
+              "additionalProperties": false,
+              "properties": {
+                "a": {
+                  "type": "number"
+                }
+              },
+              "required": [
+                "a"
+              ],
+              "type": "object"
+            },
+            "any": {
+              "anyOf": [
+                {
+                  "additionalProperties": false,
+                  "properties": {
+                    "a": {
+                      "type": "number"
+                    }
+                  },
+                  "required": [
+                    "a"
+                  ],
+                  "type": "object"
+                },
+                {
+                  "additionalProperties": false,
+                  "properties": {
+                    "b": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "b"
+                  ],
+                  "type": "object"
+                },
+                {
+                  "additionalProperties": false,
+                  "properties": {
+                    "c": {
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "c"
+                  ],
+                  "type": "object"
+                }
+              ]
+            },
+            "b": {
+              "additionalProperties": false,
+              "properties": {
+                "b": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "b"
+              ],
+              "type": "object"
+            },
+            "c": {
+              "additionalProperties": false,
+              "properties": {
+                "c": {
+                  "type": "boolean"
+                }
+              },
+              "required": [
+                "c"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "a",
+            "b",
+            "c",
+            "any"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "litNum",
+        "litStr",
+        "litBool",
+        "obj"
+      ],
+      "type": "object"
+    }
+  }
+}
diff --git a/ts-json-schema-generator.ts b/ts-json-schema-generator.ts

Original file line number	Diff line number	Diff line change
`@@ -93,6 +93,7 @@`
`93`	`93`	`"vega": "^5.31.0",`
`94`	`94`	`"vega-lite": "^5.23.0"`
`95`	`95`	`},`
	`96`	`+ "packageManager": "npm@10.8.2",`
`96`	`97`	`"engines": {`
`97`	`98`	`"node": ">=18.0.0"`
`98`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ export class ChainNodeParser implements SubNodeParser, MutableParser {`
`31`	`31`	`}`
`32`	`32`	`const contextCacheKey = context.getCacheKey();`
`33`	`33`	`let type = typeCache.get(contextCacheKey);`
	`34`	`+`
`34`	`35`	`if (!type) {`
`35`	`36`	`try {`
`36`	`37`	`type = this.getNodeParser(node).createType(node, context, reference);`
`@@ -41,6 +42,11 @@ export class ChainNodeParser implements SubNodeParser, MutableParser {`
`41`	`42`	`typeCache.set(contextCacheKey, type);`
`42`	`43`	`}`
`43`	`44`	`}`
	`45`	`+`
	`46`	`+ if (!type) {`
	`47`	`+ throw new UnknownNodeError(node);`
	`48`	`+ }`
	`49`	`+`
`44`	`50`	`return type;`
`45`	`51`	`}`
`46`	`52`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ import { AnyType } from "../Type/AnyType.js";`
`6`	`6`	`import { ArrayType } from "../Type/ArrayType.js";`
`7`	`7`	`import type { BaseType } from "../Type/BaseType.js";`
`8`	`8`	`import { StringType } from "../Type/StringType.js";`
	`9`	`+import { UnknownType } from "../Type/UnknownType.js";`
`9`	`10`	`import { symbolAtNode } from "../Utils/symbolAtNode.js";`
`10`	`11`
`11`	`12`	`const invalidTypes: Record<number, boolean> = {`
`@@ -45,7 +46,7 @@ export class TypeReferenceNodeParser implements SubNodeParser {`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`if (typeSymbol.flags & ts.SymbolFlags.TypeParameter) {`
`48`		`- return context.getArgument(typeSymbol.name);`
	`49`	`+ return context.getArgument(typeSymbol.name) ?? new UnknownType(true);`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`// Wraps promise type to avoid resolving to a empty Object type.`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`import ts from "typescript";`
`2`		`-import type { Context } from "../NodeParser.js";`
`3`	`2`	`import type { SubNodeParser } from "../SubNodeParser.js";`
`4`	`3`	`import type { BaseType } from "../Type/BaseType.js";`
`5`	`4`	`import { UnknownType } from "../Type/UnknownType.js";`
`@@ -8,7 +7,8 @@ export class UnknownTypeNodeParser implements SubNodeParser {`
`8`	`7`	`public supportsNode(node: ts.KeywordTypeNode): boolean {`
`9`	`8`	`return node.kind === ts.SyntaxKind.UnknownKeyword;`
`10`	`9`	`}`
`11`		`- public createType(node: ts.KeywordTypeNode, context: Context): BaseType {`
`12`		`- return new UnknownType();`
	`10`	`+`
	`11`	`+ public createType(): BaseType {`
	`12`	`+ return new UnknownType(false);`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,16 @@ export class UnknownTypeFormatter implements SubTypeFormatter {`
`7`	`7`	`public supportsType(type: BaseType): boolean {`
`8`	`8`	`return type instanceof UnknownType;`
`9`	`9`	`}`
	`10`	`+`
`10`	`11`	`public getDefinition(type: UnknownType): Definition {`
	`12`	`+ if (type.erroredSource) {`
	`13`	`+ return { description: "Failed to correctly infer type" };`
	`14`	`+ }`
	`15`	`+`
`11`	`16`	`return {};`
`12`	`17`	`}`
`13`		`- public getChildren(type: UnknownType): BaseType[] {`
	`18`	`+`
	`19`	`+ public getChildren(): BaseType[] {`
`14`	`20`	`return [];`
`15`	`21`	`}`
`16`	`22`	`}`