@cparra/apexdocs 2.25.0-alpha.4 → 2.25.0-alpha.6

package/src/core/markdown/__test__/test-helpers.ts

@@ -0,0 +1,22 @@
+import { SourceFile } from '../../shared/types';
+import { generateDocs as gen, MarkdownGeneratorConfig } from '../generate-docs';
+import { referenceGuideTemplate } from '../templates/reference-guide';
+
+export function apexBundleFromRawString(raw: string, rawMetadata?: string): SourceFile {
+  return {
+    filePath: 'test.cls',
+    content: raw,
+    metadataContent: rawMetadata ?? null,
+  };
+}
+
+export function generateDocs(apexBundles: SourceFile[], config?: Partial<MarkdownGeneratorConfig>) {
+  return gen(apexBundles, {
+    targetDir: 'target',
+    scope: ['global', 'public'],
+    defaultGroupName: 'Miscellaneous',
+    sortMembersAlphabetically: true,
+    referenceGuideTemplate: referenceGuideTemplate,
+    ...config,
+  });
+}

package/src/core/{adapters → markdown/adapters}/__tests__/interface-adapter.spec.ts

@@ -1,23 +1,41 @@
 import { typeToRenderable } from '../apex-types';
-import { InterfaceMirrorBuilder } from '../../../test-helpers/InterfaceMirrorBuilder';
-import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
-import { MethodMirrorBuilder, ParameterBuilder } from '../../../test-helpers/MethodMirrorBuilder';
+import { InterfaceMirrorBuilder } from '../../../../test-helpers/InterfaceMirrorBuilder';
+import { AnnotationBuilder } from '../../../../test-helpers/AnnotationBuilder';
+import { MethodMirrorBuilder, ParameterBuilder } from '../../../../test-helpers/MethodMirrorBuilder';
+import { MarkdownGeneratorConfig } from '../../generate-docs';
 
 function linkGenerator(type: string): string {
   return type;
 }
 
+const defaultMarkdownGeneratorConfig: MarkdownGeneratorConfig = {
+  targetDir: '',
+  scope: ['global', 'public'],
+  namespace: '',
+  defaultGroupName: 'Miscellaneous',
+  referenceGuideTemplate: '',
+  sortMembersAlphabetically: false,
+};
+
 describe('Conversion from InterfaceMirror to InterfaceSource understandable by the templating engine', () => {
   it('converts the name', () => {
     const interfaceMirror = new InterfaceMirrorBuilder().withName('SampleInterface').build();
-    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(
+      { filePath: '', type: interfaceMirror },
+      linkGenerator,
+      defaultMarkdownGeneratorConfig,
+    );
 
     expect(interfaceSource.name).toBe('SampleInterface');
   });
 
   it('converts the access modifier', () => {
     const interfaceMirror = new InterfaceMirrorBuilder().build();
-    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(
+      { filePath: '', type: interfaceMirror },
+      linkGenerator,
+      defaultMarkdownGeneratorConfig,
+    );
 
     expect(interfaceSource.meta.accessModifier).toBe('public');
   });
@@ -26,7 +44,11 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
     const interfaceMirror = new InterfaceMirrorBuilder()
       .addAnnotation(new AnnotationBuilder().withName('MyAnnotation').build())
       .build();
-    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(
+      { filePath: '', type: interfaceMirror },
+      linkGenerator,
+      defaultMarkdownGeneratorConfig,
+    );
 
     expect(interfaceSource.doc.annotations).toEqual(['MYANNOTATION']);
   });
@@ -44,7 +66,11 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
       )
       .build();
 
-    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(
+      { filePath: '', type: interfaceMirror },
+      linkGenerator,
+      defaultMarkdownGeneratorConfig,
+    );
 
     expect(interfaceSource.methods.value).toHaveLength(1);
     expect(interfaceSource.methods.value[0].signature.value.content[0]).toBe('public String sampleMethod()');
@@ -72,7 +98,11 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
       )
       .build();
 
-    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(
+      { filePath: '', type: interfaceMirror },
+      linkGenerator,
+      defaultMarkdownGeneratorConfig,
+    );
 
     expect(interfaceSource.methods.value).toHaveLength(1);
     expect(interfaceSource.methods.value[0].signature.value.content[0]).toBe(

package/src/core/{adapters → markdown/adapters}/apex-types.ts

@@ -14,6 +14,7 @@ import {
 import { adaptDescribable, adaptDocumentable } from './documentables';
 import { adaptConstructor, adaptMethod } from './methods-and-constructors';
 import { adaptFieldOrProperty } from './fields-and-properties';
+import { MarkdownGeneratorConfig } from '../generate-docs';
 
 type GetReturnRenderable<T extends Type> = T extends InterfaceMirror
   ? RenderableInterface
@@ -22,11 +23,12 @@ type GetReturnRenderable<T extends Type> = T extends InterfaceMirror
     : RenderableEnum;
 
 export function typeToRenderable<T extends Type>(
-  type: T,
+  parsedFile: { filePath: string; type: T },
   linkGenerator: GetRenderableContentByTypeName,
-  namespace?: string,
-): GetReturnRenderable<T> {
+  config: MarkdownGeneratorConfig,
+): GetReturnRenderable<T> & { filePath: string; namespace?: string } {
   function getRenderable(): RenderableInterface | RenderableClass | RenderableEnum {
+    const { type } = parsedFile;
     switch (type.type_name) {
       case 'enum':
         return enumTypeToEnumSource(type as EnumMirror, linkGenerator) as RenderableEnum;
@@ -39,7 +41,8 @@ export function typeToRenderable<T extends Type>(
 
   return {
     ...(getRenderable() as GetReturnRenderable<T>),
-    namespace,
+    filePath: parsedFile.filePath,
+    namespace: config.namespace,
   };
 }
 

package/src/core/{adapters → markdown/adapters}/inline.ts

@@ -1,6 +1,6 @@
 import { InlineCode, Link, RenderableContent } from './types';
 import { pipe } from 'fp-ts/function';
-import { apply } from '../../util/fp';
+import { apply } from '#utils/fp';
 
 type InlineRenderableContent = InlineCode | Link | string;
 

package/src/core/markdown/adapters/renderable-bundle.ts

@@ -0,0 +1,144 @@
+import { ParsedFile } from '../../shared/types';
+import { Link, RenderableBundle, StringOrLink } from './types';
+import { typeToRenderable } from './apex-types';
+import { adaptDescribable } from './documentables';
+import { Type } from '@cparra/apex-reflection';
+import { MarkdownGeneratorConfig } from '../generate-docs';
+
+export function parsedFilesToRenderableBundle(
+  config: MarkdownGeneratorConfig,
+  parsedFiles: ParsedFile[],
+): RenderableBundle {
+  return parsedFiles.reduce<RenderableBundle>(
+    (acc, parsedFile) => {
+      const renderable = typeToRenderable(
+        parsedFile,
+        (referenceName) => {
+          return linkFromTypeNameGenerator(
+            parsedFile.type,
+            parsedFiles.map((file) => file.type),
+            referenceName,
+            config,
+          );
+        },
+        config,
+      );
+      acc.renderables.push(renderable);
+
+      const descriptionLines = parsedFile.type.docComment?.descriptionLines;
+      const reference = {
+        typeName: parsedFile.type.name,
+        directory: getDirectoryFromRoot(config, parsedFile.type),
+        title: getLinkFromRoot(config, parsedFile.type),
+        description: adaptDescribable(descriptionLines, (referenceName) =>
+          getPossibleLinkFromRoot(
+            config,
+            referenceName,
+            findType(
+              parsedFiles.map((file) => file.type),
+              referenceName,
+            ),
+          ),
+        ).description,
+      };
+
+      const group = getTypeGroup(parsedFile.type, config);
+      if (!acc.references[group]) {
+        acc.references[group] = [];
+      }
+      acc.references[group].push(reference);
+
+      return acc;
+    },
+    {
+      references: {},
+      renderables: [],
+    },
+  );
+}
+
+function linkFromTypeNameGenerator(
+  typeBeingDocumented: Type,
+  repository: Type[],
+  referenceName: string,
+  config: MarkdownGeneratorConfig,
+): StringOrLink {
+  const type = findType(repository, referenceName);
+  if (!type) {
+    // If the type is not found, we return the type name as a string.
+    return referenceName;
+  }
+
+  const [fullClassName, fileLink] = getFileLinkTuple(typeBeingDocumented, type, config);
+  return {
+    __type: 'link',
+    title: fullClassName,
+    url: fileLink,
+  };
+}
+
+function getPossibleLinkFromRoot(config: MarkdownGeneratorConfig, fallback: string, type?: Type): StringOrLink {
+  if (!type) {
+    return fallback;
+  }
+  const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
+  const title = `${namespacePrefix}${type.name}`;
+  return {
+    __type: 'link',
+    title: title,
+    url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
+  };
+}
+
+function getDirectoryFromRoot(config: MarkdownGeneratorConfig, type?: Type): string {
+  if (!type) {
+    return '';
+  }
+  return `./${getSanitizedGroup(type, config)}`;
+}
+
+function findType(repository: Type[], referenceName: string) {
+  return repository.find((currentType: Type) => currentType.name.toLowerCase() === referenceName.toLowerCase());
+}
+
+function getFileLinkTuple(
+  typeBeingDocumented: Type,
+  referencedType: Type,
+  config: MarkdownGeneratorConfig,
+): [string, string] {
+  const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
+  const directoryRoot = `${getDirectoryRoot(typeBeingDocumented, referencedType, config)}`;
+  // TODO: Instead of adding a "." to the name when there is a namespace, maybe we want to create a folder for everything
+  // within that namespace and put the files in there.
+  const fullClassName = `${namespacePrefix}${referencedType.name}`;
+  return [fullClassName, `${directoryRoot}${fullClassName}.md`];
+}
+
+function getDirectoryRoot(typeBeingDocumented: Type, referencedType: Type, config: MarkdownGeneratorConfig) {
+  if (getTypeGroup(typeBeingDocumented, config) === getTypeGroup(referencedType, config)) {
+    // If the types the same groups then we simply link directly to that file
+    return './';
+  } else {
+    // If the types have different groups, then we have to go up a directory
+    return `../${getSanitizedGroup(referencedType, config)}/`;
+  }
+}
+
+function getTypeGroup(type: Type, config: MarkdownGeneratorConfig): string {
+  const groupAnnotation = type.docComment?.annotations.find((annotation) => annotation.name.toLowerCase() === 'group');
+  return groupAnnotation?.body ?? config.defaultGroupName;
+}
+
+function getSanitizedGroup(classModel: Type, config: MarkdownGeneratorConfig) {
+  return getTypeGroup(classModel, config).replace(/ /g, '-').replace('.', '');
+}
+
+function getLinkFromRoot(config: MarkdownGeneratorConfig, type: Type): Link {
+  const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
+  const title = `${namespacePrefix}${type.name}`;
+  return {
+    __type: 'link',
+    title: title,
+    url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
+  };
+}

package/src/core/markdown/adapters/renderable-to-page-data.ts

@@ -0,0 +1,92 @@
+import { ReferenceGuideReference, Renderable, RenderableBundle, RenderableEnum } from './types';
+import { DocPageData, DocumentationBundle } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+import { CompilationRequest, Template } from '../templates/template';
+import { enumMarkdownTemplate } from '../templates/enum-template';
+import { interfaceMarkdownTemplate } from '../templates/interface-template';
+import { classMarkdownTemplate } from '../templates/class-template';
+
+export const convertToDocumentationBundle = (
+  referenceGuideTemplate: string,
+  { references, renderables }: RenderableBundle,
+): DocumentationBundle => ({
+  referenceGuide: {
+    directory: '',
+    frontmatter: null,
+    content: referencesToReferenceGuideContent(references, referenceGuideTemplate),
+    fileExtension: 'md',
+    fileName: 'index',
+  },
+  docs: renderables.map((renderable: Renderable) => renderableToPageData(Object.values(references).flat(), renderable)),
+});
+
+function referencesToReferenceGuideContent(
+  references: { [key: string]: ReferenceGuideReference[] },
+  template: string,
+): string {
+  function alphabetizeReferences(references: { [key: string]: ReferenceGuideReference[] }): {
+    [key: string]: ReferenceGuideReference[];
+  } {
+    return Object.keys(references)
+      .sort((a, b) => a.localeCompare(b))
+      .reduce<{ [key: string]: ReferenceGuideReference[] }>((acc, key) => {
+        acc[key] = references[key].sort((a, b) => a.title.toString().localeCompare(b.title.toString()));
+        return acc;
+      }, {});
+  }
+
+  return pipe(references, alphabetizeReferences, (references) =>
+    compile({
+      template: template,
+      source: references,
+    }),
+  );
+}
+
+function renderableToPageData(referenceGuideReference: ReferenceGuideReference[], renderable: Renderable): DocPageData {
+  function buildDocOutput(renderable: Renderable, docContents: string): DocPageData {
+    const reference = referenceGuideReference.find(
+      (ref) => ref.typeName.toLowerCase() === renderable.name.toLowerCase(),
+    );
+
+    const namespacePrefix = renderable.namespace ? `${renderable.namespace}.` : '';
+
+    return {
+      source: {
+        filePath: renderable.filePath,
+        name: renderable.name,
+        type: renderable.type,
+      },
+      fileName: `${namespacePrefix}${renderable.name}`,
+      fileExtension: 'md',
+      directory: `${reference?.directory}`,
+      frontmatter: null,
+      content: docContents,
+      group: renderable.doc.group ?? 'Miscellaneous',
+    };
+  }
+
+  return pipe(renderable, resolveApexTypeTemplate, compile, (docContents) => buildDocOutput(renderable, docContents));
+}
+
+function resolveApexTypeTemplate(renderable: Renderable): CompilationRequest {
+  function getTemplate(renderable: Renderable): string {
+    switch (renderable.type) {
+      case 'enum':
+        return enumMarkdownTemplate;
+      case 'interface':
+        return interfaceMarkdownTemplate;
+      case 'class':
+        return classMarkdownTemplate;
+    }
+  }
+
+  return {
+    template: getTemplate(renderable),
+    source: renderable as RenderableEnum,
+  };
+}
+
+function compile(request: CompilationRequest): string {
+  return Template.getInstance().compile(request);
+}

package/src/core/{adapters → markdown/adapters}/types.d.ts

@@ -20,10 +20,24 @@ export type ClassMirrorWithInheritanceChain = ClassMirror & { inheritanceChain:
 export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
 export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
 export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
-export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;
 
 // Renderable types
 
+export type ReferenceGuideReference = {
+  typeName: string;
+  directory: string;
+  title: Link;
+  description: RenderableContent[] | undefined;
+};
+
+export type RenderableBundle = {
+  // References are grouped by their defined @group annotation
+  references: {
+    [key: string]: ReferenceGuideReference[];
+  };
+  renderables: Renderable[];
+};
+
 export type Link = {
   readonly __type: 'link';
   title: string;
@@ -166,4 +180,4 @@ export type RenderableEnum = RenderableType & {
   values: RenderableSection<EnumValue[]>;
 };
 
-export type Renderable = RenderableClass | RenderableInterface | RenderableEnum;
+export type Renderable = (RenderableClass | RenderableInterface | RenderableEnum) & { filePath: string };

package/src/core/markdown/generate-docs.ts

@@ -0,0 +1,158 @@
+import { pipe } from 'fp-ts/function';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+import yaml from 'js-yaml';
+
+import { apply } from '#utils/fp';
+import {
+  DocPageData,
+  DocumentationBundle,
+  Frontmatter,
+  PostHookDocumentationBundle,
+  ReferenceGuidePageData,
+  SourceFile,
+  TransformDocPage,
+  TransformDocs,
+  TransformReferenceGuide,
+  UserDefinedMarkdownConfig,
+} from '../shared/types';
+import { parsedFilesToRenderableBundle } from './adapters/renderable-bundle';
+import { reflectSourceCode } from './reflection/reflect-source';
+import { checkForReflectionErrors } from './reflection/error-handling';
+import { addInheritanceChainToTypes } from './reflection/inheritance-chain-expanion';
+import { addInheritedMembersToTypes } from './reflection/inherited-member-expansion';
+import { convertToDocumentationBundle } from './adapters/renderable-to-page-data';
+import { filterScope } from './reflection/filter-scope';
+import { Template } from './templates/template';
+import { hookableTemplate } from './templates/hookable';
+import { sortMembers } from './reflection/sort-members';
+import { isSkip } from '../shared/utils';
+
+export type MarkdownGeneratorConfig = Pick<
+  UserDefinedMarkdownConfig,
+  | 'targetDir'
+  | 'scope'
+  | 'namespace'
+  | 'defaultGroupName'
+  | 'transformReferenceGuide'
+  | 'transformDocs'
+  | 'transformDocPage'
+> & {
+  referenceGuideTemplate: string;
+  sortMembersAlphabetically: boolean;
+};
+
+export class HookError {
+  readonly _tag = 'HookError';
+
+  constructor(public error: unknown) {}
+}
+
+export function generateDocs(apexBundles: SourceFile[], config: MarkdownGeneratorConfig) {
+  const filterOutOfScope = apply(filterScope, config.scope);
+  const convertToRenderableBundle = apply(parsedFilesToRenderableBundle, config);
+  const convertToDocumentationBundleForTemplate = apply(convertToDocumentationBundle, config.referenceGuideTemplate);
+  const sortTypeMembers = apply(sortMembers, config.sortMembersAlphabetically);
+
+  return pipe(
+    apexBundles,
+    reflectSourceCode,
+    checkForReflectionErrors,
+    E.map(filterOutOfScope),
+    E.map(addInheritedMembersToTypes),
+    E.map(addInheritanceChainToTypes),
+    E.map(sortTypeMembers),
+    E.map(convertToRenderableBundle),
+    E.map(convertToDocumentationBundleForTemplate),
+    TE.fromEither,
+    TE.flatMap((bundle) =>
+      TE.tryCatch(
+        () => documentationBundleHook(bundle, config),
+        (error) => new HookError(error),
+      ),
+    ),
+    TE.map((bundle: PostHookDocumentationBundle) => ({
+      referenceGuide: isSkip(bundle.referenceGuide)
+        ? bundle.referenceGuide
+        : {
+            ...bundle.referenceGuide,
+            content: Template.getInstance().compile({
+              source: {
+                frontmatter: toFrontmatterString(bundle.referenceGuide.frontmatter),
+                content: bundle.referenceGuide.content,
+              },
+              template: hookableTemplate,
+            }),
+          },
+      docs: bundle.docs.map((doc) => ({
+        ...doc,
+        content: Template.getInstance().compile({
+          source: {
+            frontmatter: toFrontmatterString(doc.frontmatter),
+            content: doc.content,
+          },
+          template: hookableTemplate,
+        }),
+      })),
+    })),
+  );
+}
+
+function toFrontmatterString(frontmatter: Frontmatter): string {
+  if (typeof frontmatter === 'string') {
+    return frontmatter;
+  }
+
+  if (!frontmatter) {
+    return '';
+  }
+
+  const yamlString = yaml.dump(frontmatter);
+  return `---\n${yamlString}---\n`;
+}
+
+// Configurable hooks
+function passThroughHook<T>(value: T): T {
+  return value;
+}
+
+const documentationBundleHook = async (
+  bundle: DocumentationBundle,
+  config: MarkdownGeneratorConfig,
+): Promise<PostHookDocumentationBundle> => {
+  return {
+    referenceGuide: await transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
+    docs: await transformDocs(bundle.docs, config.transformDocs, config.transformDocPage),
+  };
+};
+
+const transformReferenceGuide = async (
+  referenceGuide: ReferenceGuidePageData,
+  hook: TransformReferenceGuide = passThroughHook,
+) => {
+  const result = await hook(referenceGuide);
+  if (isSkip(result)) {
+    return result;
+  }
+
+  return {
+    ...referenceGuide,
+    ...(await hook(referenceGuide)),
+  };
+};
+
+const transformDocs = async (
+  docs: DocPageData[],
+  transformDocsHook: TransformDocs = passThroughHook,
+  transformDocPageHook: TransformDocPage = passThroughHook,
+): Promise<Awaited<DocPageData[]>> => {
+  const transformed = await transformDocsHook(docs);
+  return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
+};
+
+const transformDocPage = async (doc: DocPageData, hook: TransformDocPage = passThroughHook) => {
+  return {
+    ...doc,
+    ...(await hook(doc)),
+  };
+};

package/src/core/markdown/reflection/error-handling.ts

@@ -0,0 +1,37 @@
+import * as E from 'fp-ts/Either';
+import { ParsedFile } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+
+export class ReflectionErrors {
+  readonly _tag = 'ReflectionErrors';
+  constructor(public errors: ReflectionError[]) {}
+}
+
+export class ReflectionError {
+  constructor(
+    public file: string,
+    public message: string,
+  ) {}
+}
+
+export function checkForReflectionErrors(reflectionResult: E.Either<ReflectionError, ParsedFile>[]) {
+  function reduceReflectionResultIntoSingleEither(results: E.Either<ReflectionError, ParsedFile>[]): {
+    errors: ReflectionError[];
+    parsedFiles: ParsedFile[];
+  } {
+    return results.reduce<{ errors: ReflectionError[]; parsedFiles: ParsedFile[] }>(
+      (acc, result) => {
+        E.isLeft(result) ? acc.errors.push(result.left) : acc.parsedFiles.push(result.right);
+        return acc;
+      },
+      {
+        errors: [],
+        parsedFiles: [],
+      },
+    );
+  }
+
+  return pipe(reflectionResult, reduceReflectionResultIntoSingleEither, ({ errors, parsedFiles }) =>
+    errors.length ? E.left(new ReflectionErrors(errors)) : E.right(parsedFiles),
+  );
+}

package/src/core/markdown/reflection/filter-scope.ts

@@ -0,0 +1,13 @@
+import { ParsedFile } from '../../shared/types';
+import Manifest from '../../manifest';
+
+export function filterScope(scopes: string[], parsedFiles: ParsedFile[]): ParsedFile[] {
+  return parsedFiles
+    .filter(({ type }) => Manifest.shouldFilterType(type, scopes))
+    .map((parsedFile) => {
+      return {
+        ...parsedFile,
+        type: Manifest.filterSingleType(parsedFile.type, scopes, false),
+      };
+    });
+}

package/src/core/markdown/reflection/inheritance-chain-expanion.ts

@@ -0,0 +1,22 @@
+import { ClassMirror, Type } from '@cparra/apex-reflection';
+import { createInheritanceChain } from './inheritance-chain';
+import { ParsedFile } from '../../shared/types';
+import { parsedFilesToTypes } from '../utils';
+
+export const addInheritanceChainToTypes = (parsedFiles: ParsedFile[]) =>
+  parsedFiles.map((parsedFile) => ({
+    ...parsedFile,
+    type: addInheritanceChain(parsedFile.type, parsedFilesToTypes(parsedFiles)),
+  }));
+
+function addInheritanceChain<T extends Type>(current: T, repository: Type[]): T {
+  if (current.type_name === 'enum' || current.type_name === 'interface') {
+    return current;
+  } else {
+    const inheritanceChain = createInheritanceChain(repository, current as ClassMirror);
+    return {
+      ...current,
+      inheritanceChain,
+    };
+  }
+}