Error: Reference type not set yet

[domoritz]

In vega/vega-lite#5290 and https://travis-ci.org/vega/vega-lite/jobs/571493756.

[domoritz]

We can reproduce this with keyof HTMLBodyElementEventMap and also Window. It looks like the Window type has some complications we don't deal with well.

Two solutions are: 1) support Window 2) ignore the values if we do keyof.

[dartess]

Omit + recursion give the same error:

export interface Comment {
    text: string;
    reply: Omit<Comment, 'reply'>;
}

[zsalzbank]

I'm getting something similar with this example:

export interface X {
  x: string;
}

export interface Y {
  y: string;
}

export type Inner<T> = {
  inner: Wrapper<T>[];
};

export type Wrapper<T> = T & Inner<Y>;

export type Output = Wrapper<X>;

[zsalzbank]

I'd love to fix this if somebody could point me in the right direction.

[domoritz]

The issue is somewhere in the cycle tracking, I think. The best way to debug this is to setup the repo, create a small example, and then step through the code with a debugger (follow package.json debug).

[domoritz]

From @cyrus-d

in my repository, I have implemented the FunctionTypeFormatter to fulfil my needs. so to reproduce the problem In your repository I have changed the test as follow:

export type MyType = MyElement;

type MyFunction = MyElement | null;

interface MyElement<T extends string | MyFunction = string | MyFunction> {
    type: T;
}

this will throw Reference type ID not set yet error.

I think the problem is related to UnionType that trying to access ReferenceType to early for this line:

type MyFunction = MyElement | null;

For now, to solve it I have added the following line of the code to the CircularReferenceNodeParser file.

it will work however it will use ids for the interface names:

interface-572149719-68-159-572149719-0-160

I can overcome this by setting expose: "all", not sure if its normal behaviour?

here is the repository:

https://github.com/Cyrus-d/ts-to-json/tree/original

Test result with expose: "all":

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "$ref": "#/definitions/MyType",
    "definitions": {
        "MyType": {
            "$ref": "#/definitions/MyElement"
        },
        "MyElement": {
            "type": "object",
            "properties": {
                "type": {
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "$ref": "#/definitions/MyFunction"
                        }
                    ]
                }
            },
            "required": [
                "type"
            ],
            "additionalProperties": false
        },
        "MyFunction": {
            "anyOf": [
                {
                    "$ref": "#/definitions/MyElement"
                },
                {
                    "type": "null"
                }
            ]
        }
    }
}

Test result with expose: "export":

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "$ref": "#/definitions/MyType",
    "definitions": {
        "MyType": {
            "type": "object",
            "properties": {
                "type": {
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "anyOf": [
                                {
                                    "$ref": "#/definitions/interface-572149719-68-159-572149719-0-160"
                                },
                                {
                                    "type": "null"
                                }
                            ]
                        }
                    ]
                }
            },
            "required": [
                "type"
            ],
            "additionalProperties": false
        },
        "interface-572149719-68-159-572149719-0-160": {
            "type": "object",
            "properties": {
                "type": {
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "anyOf": [
                                {
                                    "$ref": "#/definitions/interface-572149719-68-159-572149719-0-160"
                                },
                                {
                                    "type": "null"
                                }
                            ]
                        }
                    ]
                }
            },
            "required": [
                "type"
            ],
            "additionalProperties": false
        }
    }
}

[orgads]

Hi,

Here's an example that reproduces the issue for me:
test.ts

import { Test2 } from './test2';

export interface Test {
  test2: Test2;
}

test2.ts

import { Test } from './test';

export interface Test2 {
  test?: Partial<Test>;
}

Run:

ts-json-schema-generator --path test.ts --tsconfig tsconfig.json --type Test --out test.json

[randygylling]

Has anyone discovered a work around for this?

[darkowic]

I have created a repository with different schema generators to compare its capability: https://github.com/Guidewire/ts-to-json-schema-tests. By introducing the custom formatters feature here (it's exactly what we need!), I was able to parse simple type with a callback. This problem still occurs for more advanced types. I've fixed recursive problems in typescript-json-schema in this PR so, it may be useful to fix this.

I didn't have time to dive into this codebase and actually this one is a bit harder to understand (much more abstraction), but the custom formatters functionality is something we need so maybe we will do something with this soon :P

[broofa]

[Edited to provide better test case examples]

Is there a status update on this?

I'm currently running into this issue (circular type references) in the following cases (in case more test cases are needed):

• typescript@4.1.2 module's CompilerOptions type
• stylelint@14.6.1 module's Config type (very similar to @dartess's <Omit> case)
• babel@7.17.5 module's TransformOptions type

(Note: I'm using custom generator to handle unknown function types.)