Get return type from ArrowFunction

[marviobezerra]

I want to get the return type of an arrow function. Is it possible?

Here is my sample code

export const mySample = () => {
    const result = {
        name: 'Foo',
        today: new Date()
    }

    return result;
}

export type MySampleType = ReturnType<typeof mySample>;

I'm using a simple configuration as following

import { createGenerator } from "ts-json-schema-generator";

const config = {
    path: "./src/sample.ts",
    tsconfig: "./tsconfig.json",
    type: "*",
};

const schema = createGenerator(config)
    .createSchema(config.type);

console.log(JSON.stringify(schema, null, 2));

It prints this output

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "NamedParameters<typeof mySample>": {
      "type": "object",
      "additionalProperties": false
    },
    "MySampleType": {}
  }
}

I was expecting to get something like this.

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "NamedParameters<typeof mySample>": {
      "type": "object",
      "additionalProperties": false
    },
    "MySampleType": {
        "name": "string",
        "today" "date"
    }
  }
}

[domoritz]

You code looks reasonable and it would be nice if this worked. Looks like there is a bug somewhere. Can you help fix it?

[domoritz]

I upgraded function support significantly in #1910. Please send a pull request to add return values.

[GrtDev]

I needed this functionality as well and was able to get it working using a custom parser. Haven't fully tested it yet but maybe this helps someone else. It uses the ts.TypeChecker to resolve the actual type and the parser itself to create the Json type.

/**
 * Attempts to parse generic type aliases.
 * E.g. 
 * type Foo = Nullable<T>;
 * type Bar = ReturnType<T>.
 */
export class GenericTypeAliasParser implements SubNodeParser {
    constructor(
        private program: ts.Program,
        private chainNodeParser: ChainNodeParser
    ) {}

    supportsNode(node: ts.Node): boolean {
        return node.kind === ts.SyntaxKind.TypeAliasDeclaration && node.type?.typeArguments?.length;
    }

    createType(
        node: ts.TypeAliasDeclaration,
        context: Context,
        reference?: ReferenceType
    ): BaseType | undefined {
        const name = node.name.escapedText;
        const typeChecker = this.program.getTypeChecker();
        const resolvedType = typeChecker.getTypeAtLocation(node);
        const typeNode = typeChecker.typeToTypeNode(
            resolvedType,
            undefined,
            1 /* NodeBuilderFlags.NoTruncation */
        );

        const jsonType = !!typeNode
            ? this.chainNodeParser.createType(typeNode, new Context())
            : new UnknownType();

        return new DefinitionType(name, jsonType);
    }
}


...


const program = createProgram(config);
const parser = createParser(program, config, (prs) => {
    prs.addNodeParser(new GenericTypeAliasParser(program, prs as ChainNodeParser));
});

const formatter = createFormatter(config);
const generator = new SchemaGenerator(program, parser, formatter, config);
const schema = generator.createSchema(config.type);

const schemaString = JSON.stringify(schema, null, 2);
writeFileSync(outputFile, schemaString);