@cparra/apexdocs 2.25.0-alpha.0 → 2.25.0-alpha.2

package/src/cli/generate.ts

@@ -9,99 +9,102 @@ import { cosmiconfig } from 'cosmiconfig';
 const result = cosmiconfig('apexdocs').search();
 result.then((config) => {
   yargs.config(config?.config);
-  let argv = yargs.options({
-    sourceDir: {
-      type: 'string',
-      alias: 's',
-      demandOption: true,
-      describe: 'The directory location which contains your apex .cls classes.',
-    },
-    targetDir: {
-      type: 'string',
-      alias: 't',
-      default: './docs/',
-      describe: 'The directory location where documentation will be generated to.',
-    },
-    recursive: {
-      type: 'boolean',
-      alias: 'r',
-      default: true,
-      describe: 'Whether .cls classes will be searched for recursively in the directory provided.',
-    },
-    scope: {
-      type: 'array',
-      alias: 'p',
-      default: ['global'],
-      describe:
-        'A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. ' +
-        'Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled. ' +
-        'Note that this setting is ignored if generating an OpenApi REST specification since that looks for classes annotated with @RestResource.',
-    },
-    targetGenerator: {
-      type: 'string',
-      alias: 'g',
-      default: 'jekyll',
-      choices: ['jekyll', 'docsify', 'plain-markdown', 'openapi'],
-      describe:
-        'Define the static file generator for which the documents will be created. ' +
-        'Currently supports jekyll, docsify, plain markdown, and OpenAPI v3.1.0.',
-    },
-    indexOnly: {
-      type: 'boolean',
-      default: false,
-      describe: 'Defines whether only the index file should be generated.',
-    },
-    defaultGroupName: {
-      type: 'string',
-      default: 'Miscellaneous',
-      describe: 'Defines the @group name to be used when a file does not specify it.',
-    },
-    sanitizeHtml: {
-      type: 'boolean',
-      default: true,
-      describe:
-        'When on, any special character within your ApexDocs is converted into its HTML code representation. ' +
-        'This is specially useful when generic objects are described within the docs, e.g. "List< Foo>", "Map<Foo, Bar>" ' +
-        'because otherwise the content within < and > would be treated as HTML tags and not shown in the output. ' +
-        'Content in @example blocks are never sanitized.',
-    },
-    openApiTitle: {
-      type: 'string',
-      default: 'Apex REST Api',
-      describe: 'If using "openapi" as the target generator, this allows you to specify the OpenApi title value.',
-    },
-    title: {
-      type: 'string',
-      describe: "If this allows you to specify the title of the generated documentation's home file.",
-      default: 'Classes',
-    },
-    namespace: {
-      type: 'string',
-      describe:
-        'The package namespace, if any. If this value is provided the namespace will be added as a prefix to all of the parsed files. ' +
-        "If generating an OpenApi definition, it will be added to the file's Server Url.",
-    },
-    openApiFileName: {
-      type: 'string',
-      describe: 'If using "openapi" as the target generator, this allows you to specify the name of the output file.',
-      default: 'openapi',
-    },
-    sortMembersAlphabetically: {
-      type: 'boolean',
-      describe: 'Whether to sort members alphabetically.',
-      default: false,
-    },
-    includeMetadata: {
-      type: 'boolean',
-      describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
-      default: false,
-    },
-    documentationRootDir: {
-      type: 'string',
-      describe:
-        'Allows you to specify the root documentation directory where the files are being generated. This can be helpful when embedding the generated docs into an existing site so that the links are generated correctly.',
-    },
-  }).argv;
+  let argv = yargs
+    .options({
+      sourceDir: {
+        type: 'string',
+        alias: 's',
+        demandOption: true,
+        describe: 'The directory location which contains your apex .cls classes.',
+      },
+      targetDir: {
+        type: 'string',
+        alias: 't',
+        default: './docs/',
+        describe: 'The directory location where documentation will be generated to.',
+      },
+      recursive: {
+        type: 'boolean',
+        alias: 'r',
+        default: true,
+        describe: 'Whether .cls classes will be searched for recursively in the directory provided.',
+      },
+      scope: {
+        type: 'string',
+        array: true,
+        alias: 'p',
+        default: ['global'],
+        describe:
+          'A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. ' +
+          'Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled. ' +
+          'Note that this setting is ignored if generating an OpenApi REST specification since that looks for classes annotated with @RestResource.',
+      },
+      targetGenerator: {
+        type: 'string',
+        alias: 'g',
+        default: 'jekyll',
+        choices: ['jekyll', 'docsify', 'plain-markdown', 'openapi'],
+        describe:
+          'Define the static file generator for which the documents will be created. ' +
+          'Currently supports jekyll, docsify, plain markdown, and OpenAPI v3.1.0.',
+      },
+      indexOnly: {
+        type: 'boolean',
+        default: false,
+        describe: 'Defines whether only the index file should be generated.',
+      },
+      defaultGroupName: {
+        type: 'string',
+        default: 'Miscellaneous',
+        describe: 'Defines the @group name to be used when a file does not specify it.',
+      },
+      sanitizeHtml: {
+        type: 'boolean',
+        default: true,
+        describe:
+          'When on, any special character within your ApexDocs is converted into its HTML code representation. ' +
+          'This is specially useful when generic objects are described within the docs, e.g. "List< Foo>", "Map<Foo, Bar>" ' +
+          'because otherwise the content within < and > would be treated as HTML tags and not shown in the output. ' +
+          'Content in @example blocks are never sanitized.',
+      },
+      openApiTitle: {
+        type: 'string',
+        default: 'Apex REST Api',
+        describe: 'If using "openapi" as the target generator, this allows you to specify the OpenApi title value.',
+      },
+      title: {
+        type: 'string',
+        describe: "If this allows you to specify the title of the generated documentation's home file.",
+        default: 'Classes',
+      },
+      namespace: {
+        type: 'string',
+        describe:
+          'The package namespace, if any. If this value is provided the namespace will be added as a prefix to all of the parsed files. ' +
+          "If generating an OpenApi definition, it will be added to the file's Server Url.",
+      },
+      openApiFileName: {
+        type: 'string',
+        describe: 'If using "openapi" as the target generator, this allows you to specify the name of the output file.',
+        default: 'openapi',
+      },
+      sortMembersAlphabetically: {
+        type: 'boolean',
+        describe: 'Whether to sort members alphabetically.',
+        default: false,
+      },
+      includeMetadata: {
+        type: 'boolean',
+        describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
+        default: false,
+      },
+      documentationRootDir: {
+        type: 'string',
+        describe:
+          'Allows you to specify the root documentation directory where the files are being generated. This can be helpful when embedding the generated docs into an existing site so that the links are generated correctly.',
+      },
+    })
+    .parseSync();
 
   if (config) {
     argv = { ...config.config, ...argv };
@@ -126,9 +129,6 @@ result.then((config) => {
     onAfterProcess: config?.config?.onAfterProcess,
     onBeforeFileWrite: config?.config?.onBeforeFileWrite,
     frontMatterHeader: config?.config?.frontMatterHeader,
-    singleFile: config?.config?.singleFile,
-    fileName: config?.config?.fileName,
-    templateFilePath: config?.config?.templateFilePath,
   });
 
   try {

package/src/core/__test__/inheritance-chain.test.ts

@@ -0,0 +1,54 @@
+import { ClassMirrorBuilder } from '../../test-helpers/ClassMirrorBuilder';
+import { createInheritanceChain } from '../inheritance-chain';
+
+describe('inheritance chain for classes', () => {
+  test('returns an empty list of the class does not extend any other class', () => {
+    const classMirror = new ClassMirrorBuilder().build();
+    const repository = [classMirror];
+
+    const inheritanceChain = createInheritanceChain(repository, classMirror);
+
+    expect(inheritanceChain).toEqual([]);
+  });
+
+  test('returns the name of the extended class if it is not found in the repository', () => {
+    const classMirror = new ClassMirrorBuilder().withExtendedClass('ExtendedClass').build();
+    const repository = [classMirror];
+
+    const inheritanceChain = createInheritanceChain(repository, classMirror);
+
+    expect(inheritanceChain).toEqual(['ExtendedClass']);
+  });
+
+  test('returns the extended class when it is present in the repository', () => {
+    const classMirror = new ClassMirrorBuilder().withExtendedClass('ExtendedClass').build();
+    const extendedClass = new ClassMirrorBuilder().withName('ExtendedClass').build();
+    const repository = [classMirror, extendedClass];
+
+    const inheritanceChain = createInheritanceChain(repository, classMirror);
+
+    expect(inheritanceChain).toEqual(['ExtendedClass']);
+  });
+
+  test('returns the full inheritance chain when the extended class is also extended', () => {
+    const classMirror = new ClassMirrorBuilder().withExtendedClass('ExtendedClass').build();
+    const extendedClass = new ClassMirrorBuilder().withName('ExtendedClass').withExtendedClass('SuperClass').build();
+    const superClass = new ClassMirrorBuilder().withName('SuperClass').build();
+    const repository = [classMirror, extendedClass, superClass];
+
+    const inheritanceChain = createInheritanceChain(repository, classMirror);
+
+    expect(inheritanceChain).toEqual(['ExtendedClass', 'SuperClass']);
+  });
+
+  test('returns the inheritance for a class that extends an inner class', () => {
+    const classMirror = new ClassMirrorBuilder().withExtendedClass('OuterClass.InnerClass').build();
+    const innerClass = new ClassMirrorBuilder().withName('InnerClass').build();
+    const outerClass = new ClassMirrorBuilder().withName('OuterClass').addInnerClass(innerClass).build();
+    const repository = [classMirror, outerClass];
+
+    const inheritanceChain = createInheritanceChain(repository, classMirror);
+
+    expect(inheritanceChain).toEqual(['OuterClass.InnerClass']);
+  });
+});

package/src/core/generate-docs.ts

@@ -0,0 +1,396 @@
+import { ClassMirror, InterfaceMirror, reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
+import { typeToRenderableType } from '../adapters/apex-types';
+import { Link, Renderable, RenderableContent, RenderableEnum, StringOrLink } from './renderable/types';
+import { classMarkdownTemplate } from '../transpiler/markdown/plain-markdown/class-template';
+import { enumMarkdownTemplate } from '../transpiler/markdown/plain-markdown/enum-template';
+import { interfaceMarkdownTemplate } from '../transpiler/markdown/plain-markdown/interface-template';
+import * as E from 'fp-ts/Either';
+import { flow, pipe } from 'fp-ts/function';
+import { CompilationRequest, Template } from './template';
+import Manifest from '../model/manifest';
+import { referenceGuideTemplate } from './templates/reference-guide';
+import { adaptDescribable } from '../adapters/documentables';
+import { createInheritanceChain } from './inheritance-chain';
+
+export const documentType = flow(typeToRenderableType, resolveApexTypeTemplate, compile);
+
+export type DocumentationBundle = {
+  format: 'markdown';
+  referenceGuide: string; // Output file with links to all other files (e.g. index/table of contents)
+  docs: DocOutput[];
+};
+
+type DocumentationConfig = {
+  scope: string[];
+  outputDir: string;
+  namespace?: string;
+  sortMembersAlphabetically?: boolean;
+  defaultGroupName: string;
+  referenceGuideTemplate: string;
+};
+
+type DocOutput = {
+  directory: string;
+  docContents: string;
+  typeName: string;
+  type: 'class' | 'interface' | 'enum';
+};
+
+const configDefaults: DocumentationConfig = {
+  scope: ['public'],
+  outputDir: 'docs',
+  defaultGroupName: 'Miscellaneous',
+  referenceGuideTemplate: referenceGuideTemplate,
+};
+
+export function generateDocs(
+  input: string[],
+  config?: Partial<DocumentationConfig>,
+): E.Either<string[], DocumentationBundle> {
+  const configWithDefaults = { ...configDefaults, ...config };
+  return pipe(
+    input,
+    (input) => input.map(reflectSourceBody),
+    checkForReflectionErrors,
+    E.map((types) => filterTypesOutOfScope(types, configWithDefaults.scope)),
+    E.map((types) => types.map((type) => addInheritedMembers(type, types))),
+    E.map((types) => types.map((type) => addInheritanceChain(type, types))),
+    E.map((types) => typesToRenderableBundle(types, configWithDefaults)),
+    E.map(({ references, renderables }) => ({
+      referenceGuide: pipe(referencesToReferenceGuide(references, configWithDefaults.referenceGuideTemplate)),
+      docs: renderables.map((renderable) => renderableToOutputDoc(Object.values(references).flat(), renderable)),
+    })),
+    E.map(({ referenceGuide, docs }) => ({ format: 'markdown', referenceGuide: referenceGuide, docs })),
+  );
+}
+
+type ReferenceGuideReference = {
+  typeName: string;
+  directory: string;
+  title: Link;
+  description: RenderableContent[] | undefined;
+};
+
+type RenderableBundle = {
+  // References are grouped by their defined @group annotation
+  references: {
+    [key: string]: ReferenceGuideReference[];
+  };
+  renderables: Renderable[];
+};
+
+function typesToRenderableBundle(types: Type[], config: DocumentationConfig) {
+  return types.reduce<RenderableBundle>(
+    (acc, type) => {
+      const renderable = typeToRenderableType(
+        type,
+        (referenceName) => {
+          return linkFromTypeNameGenerator(type, types, referenceName, config);
+        },
+        config.namespace,
+      );
+      acc.renderables.push(renderable);
+
+      const descriptionLines = type.docComment?.descriptionLines;
+      const reference = {
+        typeName: type.name,
+        directory: getDirectoryFromRoot(config, type),
+        title: getLinkFromRoot(config, type),
+        description: adaptDescribable(descriptionLines, (referenceName) =>
+          getPossibleLinkFromRoot(config, referenceName, findType(types, referenceName)),
+        ).description,
+      };
+
+      const group = getTypeGroup(type, config);
+      if (!acc.references[group]) {
+        acc.references[group] = [];
+      }
+      acc.references[group].push(reference);
+
+      return acc;
+    },
+    {
+      references: {},
+      renderables: [],
+    },
+  );
+}
+
+function renderableToOutputDoc(referenceGuideReference: ReferenceGuideReference[], renderable: Renderable): DocOutput {
+  function buildDocOutput(renderable: Renderable, docContents: string): DocOutput {
+    const reference = referenceGuideReference.find(
+      (ref) => ref.typeName.toLowerCase() === renderable.name.toLowerCase(),
+    );
+    return {
+      directory: reference!.directory,
+      docContents,
+      typeName: renderable.name,
+      type: renderable.type,
+    };
+  }
+
+  return pipe(renderable, resolveApexTypeTemplate, compile, (docContents) => buildDocOutput(renderable, docContents));
+}
+
+function referencesToReferenceGuide(
+  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 filterTypesOutOfScope(types: Type[], scope: string[]): Type[] {
+  return new Manifest(types).filteredByAccessModifierAndAnnotations(scope);
+}
+
+function checkForReflectionErrors(reflectionResult: E.Either<string, Type>[]) {
+  function reduceReflectionResultIntoSingleEither(results: E.Either<string, Type>[]): {
+    errors: string[];
+    types: Type[];
+  } {
+    return results.reduce<{ errors: string[]; types: Type[] }>(
+      (acc, result) => {
+        E.isLeft(result) ? acc.errors.push(result.left) : acc.types.push(result.right);
+        return acc;
+      },
+      {
+        errors: [],
+        types: [],
+      },
+    );
+  }
+
+  return pipe(reflectionResult, reduceReflectionResultIntoSingleEither, ({ errors, types }) =>
+    errors.length ? E.left(errors) : E.right(types),
+  );
+}
+
+function reflectSourceBody(input: string): E.Either<string, Type> {
+  const result = mirrorReflection(input);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return result.error ? E.left(result.error.message) : E.right(result.typeMirror!);
+}
+
+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);
+}
+
+function findType(repository: Type[], referenceName: string) {
+  return repository.find((currentType: Type) => currentType.name.toLowerCase() === referenceName.toLowerCase());
+}
+
+function addInheritedMembers<T extends Type>(current: T, repository: Type[]): T {
+  if (current.type_name === 'enum') {
+    return current;
+  } else if (current.type_name === 'interface') {
+    return addInheritedInterfaceMethods(current as InterfaceMirror, repository) as T;
+  } else {
+    return addInheritedClassMembers(current as ClassMirror, repository) as T;
+  }
+}
+
+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,
+    };
+  }
+}
+
+function getParents<T extends Type>(
+  extendedNamesExtractor: (current: T) => string[],
+  current: T,
+  repository: Type[],
+): T[] {
+  return pipe(
+    extendedNamesExtractor(current),
+    (interfaces: string[]) => interfaces.map((interfaceName) => repository.find((type) => type.name === interfaceName)),
+    (interfaces = []) => interfaces.filter((type) => type !== undefined) as T[],
+    (interfaces) =>
+      interfaces.reduce<T[]>(
+        (acc, current) => [...acc, ...getParents(extendedNamesExtractor, current, repository)],
+        interfaces,
+      ),
+  );
+}
+
+function addInheritedInterfaceMethods(interfaceMirror: InterfaceMirror, repository: Type[]): InterfaceMirror {
+  function methodAlreadyExists(memberName: string, members: { name: string }[]) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+
+  function parentExtractor(interfaceMirror: InterfaceMirror): string[] {
+    return interfaceMirror.extended_interfaces;
+  }
+
+  const parents = getParents(parentExtractor, interfaceMirror, repository);
+  return {
+    ...interfaceMirror,
+    methods: parents.reduce(
+      (acc, currentValue) => [
+        ...acc,
+        ...currentValue.methods
+          .filter((method) => !methodAlreadyExists(method.name, acc))
+          .map((method) => ({
+            ...method,
+            inherited: true,
+          })),
+      ],
+      interfaceMirror.methods,
+    ),
+  };
+}
+
+function addInheritedClassMembers(classMirror: ClassMirror, repository: Type[]): ClassMirror {
+  function memberAlreadyExists(memberName: string, members: { name: string }[]) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+
+  function parentExtractor(classMirror: ClassMirror): string[] {
+    return classMirror.extended_class ? [classMirror.extended_class] : [];
+  }
+
+  function filterMember<T extends { name: string; access_modifier: string }>(members: T[], existing: T[]): T[] {
+    return members
+      .filter((member) => member.access_modifier.toLowerCase() !== 'private')
+      .filter((member) => !memberAlreadyExists(member.name, existing))
+      .map((member) => ({
+        ...member,
+        inherited: true,
+      }));
+  }
+
+  const parents = getParents(parentExtractor, classMirror, repository);
+  return {
+    ...classMirror,
+    fields: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.fields, acc)],
+      classMirror.fields,
+    ),
+    properties: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.properties, acc)],
+      classMirror.properties,
+    ),
+    methods: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.methods, acc)],
+      classMirror.methods,
+    ),
+  };
+}
+
+function linkFromTypeNameGenerator(
+  typeBeingDocumented: Type,
+  repository: Type[],
+  referenceName: string,
+  config: DocumentationConfig,
+): 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 {
+    title: fullClassName,
+    url: fileLink,
+  };
+}
+
+function getFileLinkTuple(
+  typeBeingDocumented: Type,
+  referencedType: Type,
+  config: DocumentationConfig,
+): [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 getDirectoryFromRoot(config: DocumentationConfig, type?: Type): string {
+  if (!type) {
+    return '';
+  }
+  return `./${getSanitizedGroup(type, config)}`;
+}
+
+function getPossibleLinkFromRoot(config: DocumentationConfig, fallback: string, type?: Type): StringOrLink {
+  if (!type) {
+    return fallback;
+  }
+  const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
+  const title = `${namespacePrefix}${type.name}`;
+  return {
+    title: title,
+    url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
+  };
+}
+
+function getLinkFromRoot(config: DocumentationConfig, type: Type): Link {
+  const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
+  const title = `${namespacePrefix}${type.name}`;
+  return {
+    title: title,
+    url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
+  };
+}
+
+function getDirectoryRoot(typeBeingDocumented: Type, referencedType: Type, config: DocumentationConfig) {
+  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: DocumentationConfig): string {
+  const groupAnnotation = type.docComment?.annotations.find((annotation) => annotation.name.toLowerCase() === 'group');
+  return groupAnnotation?.body ?? config.defaultGroupName;
+}
+
+function getSanitizedGroup(classModel: Type, config: DocumentationConfig) {
+  return getTypeGroup(classModel, config).replace(/ /g, '-').replace('.', '');
+}

package/src/core/inheritance-chain.ts

@@ -0,0 +1,23 @@
+import { ClassMirror, Type } from '@cparra/apex-reflection';
+import { pipe } from 'fp-ts/function';
+import * as O from 'fp-ts/Option';
+
+export function createInheritanceChain(repository: Type[], classMirror: ClassMirror): string[] {
+  return pipe(
+    O.fromNullable(classMirror.extended_class),
+    O.match(
+      () => [],
+      (extendedClassName) => inheritanceChainFromParentClassName(repository, extendedClassName),
+    ),
+  );
+}
+
+function inheritanceChainFromParentClassName(repository: Type[], className: string): string[] {
+  return pipe(
+    O.fromNullable(repository.find((type) => type.name.toLowerCase() === className.toLowerCase())),
+    O.match(
+      () => [className],
+      (extendedClass: Type) => [className, ...createInheritanceChain(repository, extendedClass as ClassMirror)],
+    ),
+  );
+}