feat: support for sourceless nodes.

src/NodeParser/AnnotatedNodeParser.ts

@@ -31,7 +31,8 @@ export class AnnotatedNodeParser implements SubNodeParser {
         const baseType = this.childNodeParser.createType(node, context, reference);
 
         // Don't return annotations for lib types such as Exclude.
-        if (node.getSourceFile().fileName.match(/[/\\]typescript[/\\]lib[/\\]lib\.[^/\\]+\.d\.ts$/i)) {
+        // Sourceless nodes may not have a fileName, just ignore them.
+        if (node.getSourceFile()?.fileName.match(/[/\\]typescript[/\\]lib[/\\]lib\.[^/\\]+\.d\.ts$/i)) {
             let specialCase = false;
 
             // Special case for Exclude<T, U>: use the annotation of T.

src/NodeParser/TypeLiteralNodeParser.ts

@@ -37,9 +37,12 @@ export class TypeLiteralNodeParser implements SubNodeParser {
             .filter(ts.isPropertySignature)
             .filter((propertyNode) => !isNodeHidden(propertyNode))
             .map((propertyNode) => {
-                const propertySymbol: ts.Symbol = (propertyNode as any).symbol;
                 const type = this.childNodeParser.createType(propertyNode.type!, context);
-                const objectProperty = new ObjectProperty(propertySymbol.getName(), type, !propertyNode.questionToken);
+
+                // The following avoids errors when propertySymbol is undefined
+                const name = (propertyNode as any).symbol?.getName() || (propertyNode.name as any).escapedText;
+
+                const objectProperty = new ObjectProperty(name, type, !propertyNode.questionToken);
 
                 return objectProperty;
             })

src/NodeParser/TypeReferenceNodeParser.ts

@@ -1,13 +1,14 @@
 import ts from "typescript";
+
 import { Context, NodeParser } from "../NodeParser";
-import { SubNodeParser } from "../SubNodeParser";
+import type { SubNodeParser } from "../SubNodeParser";
 import { AnnotatedType } from "../Type/AnnotatedType";
+import { AnyType } from "../Type/AnyType";
 import { ArrayType } from "../Type/ArrayType";
-import { BaseType } from "../Type/BaseType";
-import { NeverType } from "../Type/NeverType";
+import type { BaseType } from "../Type/BaseType";
 import { StringType } from "../Type/StringType";
 
-const invalidTypes: { [index: number]: boolean } = {
+const invalidTypes: Record<number, boolean> = {
     [ts.SyntaxKind.ModuleDeclaration]: true,
     [ts.SyntaxKind.VariableDeclaration]: true,
 };
@@ -20,41 +21,61 @@ export class TypeReferenceNodeParser implements SubNodeParser {
     }
 
     public createType(node: ts.TypeReferenceNode, context: Context): BaseType {
-        const typeSymbol = this.typeChecker.getSymbolAtLocation(node.typeName)!;
+        const typeSymbol =
+            this.typeChecker.getSymbolAtLocation(node.typeName) ??
+            // When the node doesn't have a valid source file, its position is -1, so we can't
+            // search for a symbol based on its location. In that case, the ts.factory defines a symbol
+            // 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);
+
             return this.childNodeParser.createType(
-                aliasedSymbol.declarations!.filter((n: ts.Declaration) => !invalidTypes[n.kind])[0],
+                aliasedSymbol.declarations!.filter((n: ts.Declaration) => !invalidTypes[n.kind])[0]!,
+
                 this.createSubContext(node, context)
             );
-        } else if (typeSymbol.flags & ts.SymbolFlags.TypeParameter) {
+        }
+
+        if (typeSymbol.flags & ts.SymbolFlags.TypeParameter) {
             return context.getArgument(typeSymbol.name);
-        } else if (typeSymbol.name === "Array" || typeSymbol.name === "ReadonlyArray") {
+        }
+
+        if (typeSymbol.name === "Array" || typeSymbol.name === "ReadonlyArray") {
             const type = this.createSubContext(node, context).getArguments()[0];
-            if (type === undefined || type instanceof NeverType) {
-                return new NeverType();
-            }
-            return new ArrayType(type);
-        } else if (typeSymbol.name === "Date") {
+
+            return type === undefined ? new AnyType() : new ArrayType(type);
+        }
+
+        if (typeSymbol.name === "Date") {
             return new AnnotatedType(new StringType(), { format: "date-time" }, false);
-        } else if (typeSymbol.name === "RegExp") {
+        }
+
+        if (typeSymbol.name === "RegExp") {
             return new AnnotatedType(new StringType(), { format: "regex" }, false);
-        } else {
-            return this.childNodeParser.createType(
-                typeSymbol.declarations!.filter((n: ts.Declaration) => !invalidTypes[n.kind])[0],
-                this.createSubContext(node, context)
-            );
         }
+
+        return this.childNodeParser.createType(
+            typeSymbol.declarations!.filter((n: ts.Declaration) => !invalidTypes[n.kind])[0]!,
+            this.createSubContext(node, context)
+        );
     }
 
     protected createSubContext(node: ts.TypeReferenceNode, parentContext: Context): Context {
         const subContext = new Context(node);
+
         if (node.typeArguments?.length) {
             for (const typeArg of node.typeArguments) {
-                const type = this.childNodeParser.createType(typeArg, parentContext);
-                subContext.pushArgument(type);
+                subContext.pushArgument(this.childNodeParser.createType(typeArg, parentContext));
             }
         }
+
         return subContext;
     }
 }

src/TypeFormatter/DefinitionTypeFormatter.ts

@@ -11,10 +11,14 @@ export class DefinitionTypeFormatter implements SubTypeFormatter {
     public supportsType(type: DefinitionType): boolean {
         return type instanceof DefinitionType;
     }
+
     public getDefinition(type: DefinitionType): Definition {
         const ref = type.getName();
-        return { $ref: `#/definitions/${this.encodeRefs ? encodeURIComponent(ref) : ref}` };
+        return {
+            $ref: `#/references/${this.encodeRefs ? encodeURIComponent(ref) : ref}`,
+        };
     }
+
     public getChildren(type: DefinitionType): BaseType[] {
         return uniqueArray([type, ...this.childTypeFormatter.getChildren(type.getType())]);
     }

src/TypeFormatter/ReferenceTypeFormatter.ts

@@ -13,7 +13,9 @@ export class ReferenceTypeFormatter implements SubTypeFormatter {
     }
     public getDefinition(type: ReferenceType): Definition {
         const ref = type.getName();
-        return { $ref: `#/definitions/${this.encodeRefs ? encodeURIComponent(ref) : ref}` };
+        return {
+            $ref: `#/definitions/${this.encodeRefs ? encodeURIComponent(ref) : ref}`,
+        };
     }
     public getChildren(type: ReferenceType): BaseType[] {
         const referredType = type.getType();

src/Utils/nodeKey.ts

@@ -32,15 +32,19 @@ export function hash(a: unknown): string | number {
 
 export function getKey(node: Node, context: Context): string {
     const ids: (number | string)[] = [];
+
     while (node) {
-        const file = node
-            .getSourceFile()
-            .fileName.substr(process.cwd().length + 1)
-            .replace(/\//g, "_");
+        const source = node.getSourceFile();
+        const file = !source
+            ? // TODO: Use better filename for unknown files (See #1386)
+              "unresolved"
+            : source.fileName.substring(process.cwd().length + 1).replace(/\//g, "_");
+
         ids.push(hash(file), node.pos, node.end);
 
         node = node.parent;
     }
+
     const id = ids.join("-");
 
     const argumentIds = context.getArguments().map((arg) => arg?.getId());

test/config.test.ts

@@ -3,10 +3,10 @@ import addFormats from "ajv-formats";
 import { readFileSync } from "fs";
 import { resolve } from "path";
 import ts from "typescript";
-import { BaseType, Context, DefinitionType, ReferenceType, SubNodeParser } from "../index";
 import { createFormatter, FormatterAugmentor } from "../factory/formatter";
 import { createParser, ParserAugmentor } from "../factory/parser";
 import { createProgram } from "../factory/program";
+import { BaseType, Context, DefinitionType, ReferenceType, SubNodeParser } from "../index";
 import { Config, DEFAULT_CONFIG } from "../src/Config";
 import { Definition } from "../src/Schema/Definition";
 import { SchemaGenerator } from "../src/SchemaGenerator";

test/sourceless-nodes/index.test.ts

@@ -0,0 +1,53 @@
+import path from "path";
+import ts from "typescript";
+import { createParser } from "../../factory";
+import { Context } from "../../src/NodeParser";
+import { LiteralType } from "../../src/Type/LiteralType";
+import { NumberType } from "../../src/Type/NumberType";
+import { ObjectType } from "../../src/Type/ObjectType";
+
+const SOURCE = path.resolve(__dirname, "./source.ts");
+
+describe("sourceless-nodes", () => {
+    it("tests creating json schemas with ts.Nodes without valid source files", () => {
+        const program = ts.createProgram([SOURCE], {});
+        const parser = createParser(program, {});
+
+        // Finds the typescript function declaration node
+        const source = program.getSourceFile(SOURCE);
+        const fn = source!.statements[0] as ts.FunctionDeclaration;
+
+        // Creates a sourceless type by inferring the function return type.
+        const inferredReturnType = getReturnType(fn, program.getTypeChecker());
+
+        // Checks that the inferred return type does not have any real source file.
+        expect(inferredReturnType.getSourceFile()).toBeUndefined();
+
+        // Generates the json schema of this inferred return type
+        const baseType = parser.createType(inferredReturnType, new Context(inferredReturnType));
+
+        const objectType = (baseType as any).type as ObjectType;
+        expect(objectType).toBeDefined();
+        expect(objectType).toBeInstanceOf(ObjectType);
+
+        const [propA, propB] = objectType.getProperties();
+
+        expect(propA.getName()).toBe("a");
+        expect(propA.getType()).toBeInstanceOf(NumberType);
+
+        expect(propB.getName()).toBe("b");
+        expect(propB.getType()).toBeInstanceOf(LiteralType);
+    });
+});
+
+// github.com/arthurfiorette/kita/blob/main/packages/generator/src/util/type-resolver.ts
+function getReturnType(node: ts.SignatureDeclaration, typeChecker: ts.TypeChecker) {
+    if (node.type) {
+        return node.type;
+    }
+
+    const signature = typeChecker.getSignatureFromDeclaration(node);
+    const implicitType = typeChecker.getReturnTypeOfSignature(signature!);
+
+    return typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation) as ts.TypeNode;
+}

test/sourceless-nodes/source.ts

@@ -0,0 +1,4 @@
+// Async function to test promise unwrapping.
+export async function withInferredReturnType() {
+    return { a: 1, b: `constant` as const };
+}