Support inheritance when parsing interfaces

packages/studio-plugin/src/parsers/helpers/StaticParsingHelpers.ts

@@ -18,6 +18,7 @@ import {
   JsxExpression,
   TypeAliasDeclaration,
   JsxAttribute,
+  LeftHandSideExpression,
 } from "ts-morph";
 import {
   ArrayProp,
@@ -203,7 +204,11 @@ export default class StaticParsingHelpers {
   }
 
   static getEscapedName(
-    p: PropertySignature | PropertyAssignment | TypeAliasDeclaration
+    p:
+      | PropertySignature
+      | PropertyAssignment
+      | TypeAliasDeclaration
+      | LeftHandSideExpression
   ): string {
     return p.getSymbolOrThrow().getEscapedName();
   }

packages/studio-plugin/src/parsers/helpers/TypeNodeParsingHelper.ts

@@ -137,12 +137,49 @@ export default class TypeNodeParsingHelper {
     }
   }
 
+  private static getInheritedShape(
+    shapeDeclaration: InterfaceDeclaration | TypeLiteralNode,
+    parseTypeReference: (identifier: string) => ParsedType | undefined
+  ): ParsedShape {
+    if (!shapeDeclaration.isKind(SyntaxKind.InterfaceDeclaration)) {
+      return {};
+    }
+
+    const heritageClause = shapeDeclaration.getHeritageClauseByKind(
+      SyntaxKind.ExtendsKeyword
+    );
+    if (!heritageClause) {
+      return {};
+    }
+
+    const inheritedTypes = heritageClause.getTypeNodes();
+    return inheritedTypes.reduce((inheritedShape, inheritedType) => {
+      const typeName = StaticParsingHelpers.getEscapedName(
+        inheritedType.getExpression()
+      );
+      const parsedType = parseTypeReference(typeName);
+      if (parsedType?.kind === ParsedTypeKind.Object) {
+        return {
+          ...inheritedShape,
+          ...parsedType.type,
+        };
+      } else {
+        throw new Error(
+          `Error parsing interface: Unable to resolve inherited type ${typeName} to an object type.`
+        );
+      }
+    }, {} as ParsedShape);
+  }
+
   private static handleObjectType(
     shapeDeclaration: InterfaceDeclaration | TypeLiteralNode,
     parseTypeReference: (identifier: string) => ParsedType | undefined
   ): ObjectParsedType {
     const properties = shapeDeclaration.getProperties();
-    const parsedShape: ParsedShape = {};
+    const parsedShape = this.getInheritedShape(
+      shapeDeclaration,
+      parseTypeReference
+    );
 
     properties.forEach((p) => {
       const propertyName = StaticParsingHelpers.getEscapedName(p);

packages/studio-plugin/tests/parsers/StudioSourceFileParser.test.ts

@@ -200,6 +200,59 @@ describe("parseShape", () => {
     });
   });
 
+  it("can parse an interface with inherited properties", () => {
+    const parser = createParser(
+      `interface BaseProps {
+        title?: string
+      }
+
+      interface HelloProps {
+        hello: {
+          world?: string
+        }
+      }
+
+      export interface Props extends BaseProps, HelloProps {
+        hello: {
+          world: string
+        }
+      }`
+    );
+
+    expect(parser.parseTypeReference("Props")?.type).toEqual({
+      title: {
+        kind: ParsedTypeKind.Simple,
+        required: false,
+        type: "string",
+      },
+      hello: {
+        kind: ParsedTypeKind.Object,
+        required: true,
+        type: {
+          world: {
+            kind: ParsedTypeKind.Simple,
+            required: true,
+            type: "string",
+          },
+        },
+      },
+    });
+  });
+
+  it("throws an error if the inherited type is not an object type", () => {
+    const parser = createParser(
+      `import { MyString } from "../__fixtures__/StudioSourceFileParser/exportedTypes";
+
+      export interface Props extends MyString {
+        title: string;
+      }`
+    );
+
+    expect(() => parser.parseTypeReference("Props")).toThrowError(
+      "Error parsing interface: Unable to resolve inherited type MyString to an object type."
+    );
+  });
+
   it("can parse a sub-property with a renamed nested type from an external package", () => {
     const parser = createParser(
       `import { ApplyFiltersButtonProps } from "@yext/search-ui-react";

packages/studio-plugin/tests/parsers/TypeNodeParsingHelper.test.ts → packages/studio-plugin/tests/parsers/helpers/TypeNodeParsingHelper.test.ts

@@ -1,9 +1,9 @@
 import { SyntaxKind } from "ts-morph";
 import TypeNodeParsingHelper, {
   ParsedTypeKind,
-} from "../../src/parsers/helpers/TypeNodeParsingHelper";
-import createTestSourceFile from "../__utils__/createTestSourceFile";
-import { PropValueType } from "../../src/types";
+} from "../../../src/parsers/helpers/TypeNodeParsingHelper";
+import createTestSourceFile from "../../__utils__/createTestSourceFile";
+import { PropValueType } from "../../../src/types";
 
 const externalShapeParser = jest.fn();