Schema doesn't include Dictionary-Interface

[evilstiefel]

I'm using the generator to create a schema for serialized state that I want to later load into my application and check if it still matches the specification.

My state contains properties that look like this

export interface EntityState<T> {
    ids: string[] | number[];
    entities: Dictionary<T>;
}

However, the generated schemas then only contain a generic object-property, even when I declare the property with an interface, like so:

"definitions": {
    "EntityState<IPersonalInterface>": {
      "type": "object",
      "properties": {
        "ids": {
          "anyOf": [
            {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            {
              "type": "array",
              "items": {
                "type": "number"
              }
            }
          ]
        },
        "entities": {
          "$ref": "#/definitions/Dictionary<IPersonalInterface>"
        }
      },
      "additionalProperties": false,
      "required": [
        "entities",
        "ids"
      ]
    },
    "Dictionary<IPersonalInterface>": {
      "type": "object",
      "additionalProperties": {
        "$ref": "#/definitions/T"
      }
    },
    "T": {
      "type": "object",
      "additionalProperties": false
    },

I'd expect "Dictionary<IPersonalInterface>" so be extended to IPersonalInterface, and not just T in the result. Right now, schema validation fails because all the properties of IPersonalInterface are counted as additional properties. Is there any way I can get the full schema to be generated?

[domoritz]

This looks incorrect. Can you try to find a minimal example, create a test case, and send a PR to fix the issue?

[evilstiefel]

Sorry for the long delay, but this is an example to reproduce the behavior:

Example file, let's say types.ts:

export interface DictionaryNum<T> {
    [id: number]: T | undefined;
}

export declare abstract class Dictionary<T> implements DictionaryNum<T> {
    [id: string]: T | undefined;
}

export interface EntityState<T> {
    ids: string[] | number[];
    entities: Dictionary<T>;
}

export interface IProtocol {
    id: number;
    type: number;
    links: number[];
}

export interface State {
    list: EntityState<IProtocol>,
    initialized: boolean;
}

Then run typescript-json-schema types.ts State, and the output will produce a schema like above, with the generic T object instead of the proper interface definitions. Unfortunately I'm not an expert in this field, so I cannot create a PR that fixes this behavior.

Edit:
The problem seems to be the abstract Dictionary, without that "intermediary" definition (removing the abstract class and renaming DictionaryNum to Dictionary), the generated interface is correct.