Support indexed access (#532)

Author: netanel-mce

Diff for: api.md

@@ -1032,6 +1032,45 @@ export interface MyObject {
 ```
 
 
+## [key-in-key-of-multi](./test/programs/key-in-key-of-multi)
+
+```ts
+type Util = {
+    utilKey1: {
+        utilDeepKey11: string;
+        utilDeepKey12: number;
+    };
+    utilKey2: {
+        utilDeepKey21: boolean;
+        utilDeepKey22: null;
+    };
+};
+
+export type Main = {
+    [Key in keyof Util]: {
+        [key: string]: Util[Key];
+    };
+};
+```
+
+
+## [key-in-key-of-single](./test/programs/key-in-key-of-single)
+
+```ts
+type Util = {
+    utilKey: {
+        utilDeepKey: string;
+    };
+};
+
+export type Main = {
+    [Key in keyof Util]: {
+        [key: string]: Util[Key];
+    };
+};
+```
+
+
 ## [map-types](./test/programs/map-types)
 
 ```ts

Diff for: test/programs/key-in-key-of-multi/main.ts

@@ -0,0 +1,16 @@
+type Util = {
+    utilKey1: {
+        utilDeepKey11: string;
+        utilDeepKey12: number;
+    };
+    utilKey2: {
+        utilDeepKey21: boolean;
+        utilDeepKey22: null;
+    };
+};
+
+export type Main = {
+    [Key in keyof Util]: {
+        [key: string]: Util[Key];
+    };
+};

Diff for: test/programs/key-in-key-of-multi/schema.json

@@ -0,0 +1,47 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "properties": {
+        "utilKey1": {
+            "additionalProperties": {
+                "properties": {
+                    "utilDeepKey11": {
+                        "type": "string"
+                    },
+                    "utilDeepKey12": {
+                        "type": "number"
+                    }
+                },
+                "required": [
+                    "utilDeepKey11",
+                    "utilDeepKey12"
+                ],
+                "type": "object"
+            },
+            "type": "object"
+        },
+        "utilKey2": {
+            "additionalProperties": {
+                "properties": {
+                    "utilDeepKey21": {
+                        "type": "boolean"
+                    },
+                    "utilDeepKey22": {
+                        "type": "null"
+                    }
+                },
+                "required": [
+                    "utilDeepKey21",
+                    "utilDeepKey22"
+                ],
+                "type": "object"
+            },
+            "type": "object"
+        }
+    },
+    "required": [
+        "utilKey1",
+        "utilKey2"
+    ],
+    "type": "object"
+}
+

Diff for: test/programs/key-in-key-of-single/main.ts

@@ -0,0 +1,11 @@
+type Util = {
+    utilKey: {
+        utilDeepKey: string;
+    };
+};
+
+export type Main = {
+    [Key in keyof Util]: {
+        [key: string]: Util[Key];
+    };
+};

Diff for: test/programs/key-in-key-of-single/schema.json

@@ -0,0 +1,23 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "utilKey": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "object",
+                "properties": {
+                    "utilDeepKey": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "utilDeepKey"
+                ]
+            }
+        }
+    },
+    "required": [
+        "utilKey"
+    ]
+}

Diff for: test/schema.test.ts

@@ -438,6 +438,11 @@ describe("schema", () => {
     describe("typeof globalThis", () => {
         assertSchema("type-globalThis", "Test");
     });
+
+    describe("key in key of", () => {
+        assertSchema("key-in-key-of-single", "Main");
+        assertSchema("key-in-key-of-multi", "Main");
+    });
 });
 
 describe("tsconfig.json", () => {

Diff for: typescript-json-schema.ts

@@ -1070,8 +1070,24 @@ export class JsonSchemaGenerator {
                     }
 
                     const typ = this.tc.getTypeAtLocation(indexSignature.type!);
-                    const def = this.getTypeDefinition(typ, undefined, "anyOf");
-
+                    let def: Definition | undefined;
+                    if (typ.flags & ts.TypeFlags.IndexedAccess) {
+                        const targetName: string = (<any>clazzType).mapper?.target?.value;
+                        const indexedAccessType = <ts.IndexedAccessType>typ;
+                        const symbols: Map<string, ts.Symbol> = (<any>indexedAccessType.objectType).members;
+                        const targetSymbol = symbols?.get(targetName);
+
+                        if (targetSymbol) {
+                            const targetNode = targetSymbol.getDeclarations()![0];
+                            const targetDef = this.getDefinitionForProperty(targetSymbol, targetNode);
+                            if (targetDef) {
+                                def = targetDef;
+                            }
+                        }
+                    }
+                    if (!def) {
+                        def = this.getTypeDefinition(typ, undefined, "anyOf");
+                    }
                     if (isStringIndexed) {
                         definition.type = "object";
                         definition.additionalProperties = def;