ts-json-schema-generator 2.1.2-next.1 → 2.2.0-next.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.1.2-next.1",
+  "version": "2.2.0-next.0",
   "description": "Generate JSON schema from your Typescript sources",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -65,6 +65,7 @@
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.7",
     "@types/normalize-path": "^3.0.2",
+    "@types/ts-expose-internals": "npm:ts-expose-internals@^5.4.5",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "auto": "^11.1.6",
@@ -94,6 +95,5 @@
     "debug": "tsx --inspect-brk ts-json-schema-generator.ts",
     "run": "tsx ts-json-schema-generator.ts",
     "release": "yarn build && auto shipit"
-  },
-  "packageManager": "yarn@1.22.19"
+  }
 }

package/src/NodeParser/FunctionNodeParser.ts

@@ -18,8 +18,11 @@ export class FunctionNodeParser implements SubNodeParser {
     public supportsNode(node: ts.TypeNode): boolean {
         return (
             node.kind === ts.SyntaxKind.FunctionType ||
+            // @ts-expect-error internals type bug
             node.kind === ts.SyntaxKind.FunctionExpression ||
+            // @ts-expect-error internals type bug
             node.kind === ts.SyntaxKind.ArrowFunction ||
+            // @ts-expect-error internals type bug
             node.kind === ts.SyntaxKind.FunctionDeclaration
         );
     }

package/src/NodeParser/PromiseNodeParser.ts

@@ -0,0 +1,98 @@
+import ts from "typescript";
+import { Context, type NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import { AliasType } from "../Type/AliasType.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { DefinitionType } from "../Type/DefinitionType.js";
+import { getKey } from "../Utils/nodeKey.js";
+
+/**
+ * Needs to be registered before 261, 260, 230, 262 node kinds
+ */
+export class PromiseNodeParser implements SubNodeParser {
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser,
+    ) {}
+
+    public supportsNode(node: ts.Node): boolean {
+        if (
+            // 261  interface PromiseInterface extends Promise<T>
+            !ts.isInterfaceDeclaration(node) &&
+            // 260  class PromiseClass implements Promise<T>
+            !ts.isClassDeclaration(node) &&
+            // 230  Promise<T>
+            !ts.isExpressionWithTypeArguments(node) &&
+            // 262  type PromiseAlias = Promise<T>;
+            !ts.isTypeAliasDeclaration(node)
+        ) {
+            return false;
+        }
+
+        const type = this.typeChecker.getTypeAtLocation(node);
+
+        const awaitedType = this.typeChecker.getAwaitedType(type);
+
+        // ignores non awaitable types
+        if (!awaitedType) {
+            return false;
+        }
+
+        // If the awaited type differs from the original type, the type extends promise
+        // Awaited<Promise<T>> -> T (Promise<T> !== T)
+        // Awaited<Y> -> Y (Y === Y)
+        if (awaitedType === type) {
+            return false;
+        }
+
+        // In types like: A<T> = T, type C = A<1>, C has the same type as A<1> and 1,
+        // the awaitedType is NOT the same reference as the type, so a assignability
+        // check is needed
+        return (
+            !this.typeChecker.isTypeAssignableTo(type, awaitedType) &&
+            !this.typeChecker.isTypeAssignableTo(awaitedType, type)
+        );
+    }
+
+    public createType(
+        node: ts.InterfaceDeclaration | ts.ClassDeclaration | ts.ExpressionWithTypeArguments | ts.TypeAliasDeclaration,
+        context: Context,
+    ): BaseType {
+        const type = this.typeChecker.getTypeAtLocation(node);
+        const awaitedType = this.typeChecker.getAwaitedType(type)!; // supportsNode ensures this
+        const awaitedNode = this.typeChecker.typeToTypeNode(awaitedType, undefined, ts.NodeBuilderFlags.IgnoreErrors);
+
+        if (!awaitedNode) {
+            throw new Error(
+                `Could not find awaited node for type ${node.pos === -1 ? "<unresolved>" : node.getText()}`,
+            );
+        }
+
+        const baseNode = this.childNodeParser.createType(awaitedNode, new Context(node));
+
+        const name = this.getNodeName(node);
+
+        // Nodes without name should just be their awaited type
+        // export class extends Promise<T> {} -> T
+        // export class A extends Promise<T> {} -> A (ref to T)
+        if (!name) {
+            return baseNode;
+        }
+
+        return new DefinitionType(name, new AliasType(`promise-${getKey(node, context)}`, baseNode));
+    }
+
+    private getNodeName(
+        node: ts.InterfaceDeclaration | ts.ClassDeclaration | ts.ExpressionWithTypeArguments | ts.TypeAliasDeclaration,
+    ) {
+        if (ts.isExpressionWithTypeArguments(node)) {
+            if (!ts.isHeritageClause(node.parent)) {
+                throw new Error("Expected ExpressionWithTypeArguments to have a HeritageClause parent");
+            }
+
+            return node.parent.parent.name?.getText();
+        }
+
+        return node.name?.getText();
+    }
+}

package/src/NodeParser/TypeReferenceNodeParser.ts

@@ -1,6 +1,5 @@
 import ts from "typescript";
-
-import { Context, NodeParser } from "../NodeParser.js";
+import { Context, type NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import { AnnotatedType } from "../Type/AnnotatedType.js";
 import { AnyType } from "../Type/AnyType.js";
@@ -31,11 +30,6 @@ export class TypeReferenceNodeParser implements SubNodeParser {
             // property on the node itself.
             (node.typeName as unknown as ts.Type).symbol;
 
-        // Wraps promise type to avoid resolving to a empty Object type.
-        if (typeSymbol.name === "Promise") {
-            return this.childNodeParser.createType(node.typeArguments![0], this.createSubContext(node, context));
-        }
-
         if (typeSymbol.flags & ts.SymbolFlags.Alias) {
             const aliasedSymbol = this.typeChecker.getAliasedSymbol(typeSymbol);
 
@@ -53,6 +47,16 @@ export class TypeReferenceNodeParser implements SubNodeParser {
             return context.getArgument(typeSymbol.name);
         }
 
+        // Wraps promise type to avoid resolving to a empty Object type.
+        if (typeSymbol.name === "Promise" || typeSymbol.name === "PromiseLike") {
+            // Promise without type resolves to Promise<any>
+            if (!node.typeArguments || node.typeArguments.length === 0) {
+                return new AnyType();
+            }
+
+            return this.childNodeParser.createType(node.typeArguments[0], this.createSubContext(node, context));
+        }
+
         if (typeSymbol.name === "Array" || typeSymbol.name === "ReadonlyArray") {
             const type = this.createSubContext(node, context).getArguments()[0];