implement inferred type naming

Author: sebbi08

src/metadata/resolveType.ts

@@ -1,4 +1,4 @@
-import { EnumDeclaration, Expression, Type as MorphType, Node, Project, ts } from "ts-morph";
+import { EnumDeclaration, Expression, Type as MorphType, Node, Project, ts, TypeNode } from "ts-morph";
 import { getJSDocDescriptionFromProperty } from "../utils/jsDocUtils";
 import { getNodeAsTsMorphNode } from "../utils/utils";
 import {
@@ -142,6 +142,13 @@ export function resolveType(type?: MorphType, node?: Node): Type {
                 }
             }
 
+            if (Node.isTypeNode(node)) {
+                typeNodeName = node.getText() ?? "";
+                if (typeNodeName.trim().startsWith("{")) {
+                    typeNodeName = "";
+                }
+            }
+
             typeName = typeName || typeNodeName;
 
             typeName = replaceNameText(typeName);
@@ -256,9 +263,17 @@ export function resolveType(type?: MorphType, node?: Node): Type {
                 };
                 return enumType;
             }
+            let unionTypeNodes: TypeNode[] = [];
+            if (Node.isTyped(node)) {
+                let typeNode = node?.getTypeNode();
 
-            const unionTypes = type.getUnionTypes().map((subType) => {
-                return resolveType(subType);
+                if (Node.isUnionTypeNode(typeNode)) {
+                    unionTypeNodes = typeNode.getTypeNodes();
+                }
+            }
+
+            const unionTypes = type.getUnionTypes().map((subType, index) => {
+                return resolveType(subType, unionTypeNodes[index]);
             });
 
             // Remove duplicate types from union

test/data/apis.ts

@@ -30,6 +30,40 @@ export class TestUnionType {
     }
 }
 
+type inferred<T> = T extends {
+    a: {
+        type: any;
+    };
+}
+    ? T["a"]["type"]
+    : never;
+
+const typeToInferA = {
+    a: {
+        type: {
+            a: 123,
+            b: "string"
+        }
+    }
+};
+
+type inferredTypeA = inferred<typeof typeToInferA>;
+
+const typeToInferB = {
+    a: {
+        type: {
+            a: "string",
+            b: 123
+        }
+    }
+};
+
+type inferredTypeB = inferred<typeof typeToInferB>;
+
+type ObjectWithInferredTypeUnion = {
+    data: inferredTypeB | inferredTypeA;
+};
+
 interface Address {
     street: string;
 }
@@ -238,6 +272,18 @@ export class MyService {
     public interfaceWithFunctions(body: InterfaceWithFunctions): any {
         return body;
     }
+
+    @POST
+    @Path("zod-type")
+    public zodType(body: inferredTypeB): any {
+        return body;
+    }
+
+    @POST
+    @Path("zod-union-type")
+    public objectWithZodTypeUnion(body: ObjectWithInferredTypeUnion): any {
+        return body;
+    }
 }
 
 class BaseService {

test/unit/definitions.spec.ts

@@ -574,4 +574,33 @@ describe("Definition generation", () => {
             expect(Object.keys(typeSpec.properties)).toEqual([]);
         });
     });
+
+    describe("Inferred types should be named properly", () => {
+        test("Inferred types should have the right name and definition", async () => {
+            let expression = jsonata("components.schemas.inferredTypeB");
+            let typeSpec = await expression.evaluate(spec);
+            expect(typeSpec).toBeDefined();
+            expect(typeSpec.properties).toBeDefined();
+            expect(typeSpec.properties.a).toBeDefined();
+            expect(typeSpec.properties.a.type).toEqual("string");
+            expect(typeSpec.properties.b).toBeDefined();
+            expect(typeSpec.properties.b.type).toEqual("number");
+        });
+
+        test("Inferred union types should create named types for each instance", async () => {
+            let expression = jsonata(
+                'paths."/mypath/zod-union-type".post.requestBody.content."application/json".schema."$ref"'
+            );
+            let reqBodyRef: string = await expression.evaluate(spec);
+
+            expect(reqBodyRef).toEqual("#/components/schemas/ObjectWithInferredTypeUnion");
+
+            expression = jsonata("components.schemas.ObjectWithInferredTypeUnion.properties.data");
+            let propSpec = await expression.evaluate(spec);
+            expect(propSpec.oneOf).toBeDefined();
+            expect(propSpec.oneOf.length).toEqual(2);
+            expect(propSpec.oneOf[0].$ref).toEqual("#/components/schemas/inferredTypeB");
+            expect(propSpec.oneOf[1].$ref).toEqual("#/components/schemas/inferredTypeA");
+        });
+    });
 });