chore: Add support for refs with property path (#309)

Author: sschw

plugins/typescript/src/core/schemaToTypeAliasDeclaration.test.ts

@@ -89,6 +89,49 @@ describe("schemaToTypeAliasDeclaration", () => {
     `);
   });
 
+  it("should resolve ref in object properties to deep linking", () => {
+    const schema: SchemaObject = {
+      type: "object",
+      properties: {
+        age: { $ref: "#/components/schemas/Age/properties/age" },
+        breed: { $ref: "#/components/schemas/Breeds/items/properties/name" },
+        color: {
+          $ref: "#/components/schemas/Breeds/items/properties/color/items",
+        },
+      },
+      required: ["age", "breed"],
+    };
+
+    expect(
+      printSchema(schema, "Dog", "schemas", {
+        schemas: {
+          Breeds: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                color: { type: "array", items: { type: "string" } },
+              },
+            },
+          },
+          Age: {
+            type: "object",
+            properties: {
+              age: { type: "integer" },
+            },
+          },
+        },
+      })
+    ).toMatchInlineSnapshot(`
+      "export type Dog = {
+          age: Age["age"];
+          breed: Breeds[number]["name"];
+          color?: Breeds[number]["color"][number];
+      };"
+    `);
+  });
+
   it("should generate enums (strings)", () => {
     const schema: SchemaObject = {
       type: "string",

plugins/typescript/src/core/schemaToTypeAliasDeclaration.ts

@@ -79,22 +79,38 @@ export const getType = (
   isNodeEnum?: boolean
 ): ts.TypeNode => {
   if (isReferenceObject(schema)) {
-    const [hash, topLevel, namespace, name] = schema.$ref.split("/");
+    const [hash, topLevel, namespace, name, ...propertyPath] =
+      schema.$ref.split("/");
     if (hash !== "#" || topLevel !== "components") {
       throw new Error(
         "This library only resolve $ref that are include into `#/components/*` for now"
       );
     }
-    if (namespace === context.currentComponent) {
-      return f.createTypeReferenceNode(f.createIdentifier(pascal(name)));
-    }
 
-    return f.createTypeReferenceNode(
-      f.createQualifiedName(
-        f.createIdentifier(pascal(namespace)),
-        f.createIdentifier(pascal(name))
-      )
+    let refNode: ts.TypeNode = f.createTypeReferenceNode(
+      namespace === context.currentComponent
+        ? f.createIdentifier(pascal(name))
+        : f.createQualifiedName(
+            f.createIdentifier(pascal(namespace)),
+            f.createIdentifier(pascal(name))
+          )
     );
+
+    for (let i = 0; i < propertyPath.length; i++) {
+      if (propertyPath[i] === "properties" && propertyPath[i + 1]) {
+        refNode = f.createIndexedAccessTypeNode(
+          refNode,
+          f.createLiteralTypeNode(f.createStringLiteral(propertyPath[++i]))
+        );
+      } else if (propertyPath[i] === "items") {
+        refNode = f.createIndexedAccessTypeNode(
+          refNode,
+          f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+        );
+      }
+    }
+
+    return refNode;
   }
 
   if (schema["x-openapi-codegen"]?.type === "never") {