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

package/src/core/markdown/reflection/inherited-member-expansion.ts

@@ -0,0 +1,105 @@
+import { ClassMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
+import { ParsedFile } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+import { parsedFilesToTypes } from '../utils';
+
+export const addInheritedMembersToTypes = (parsedFiles: ParsedFile[]) =>
+  parsedFiles.map((parsedFile) => addInheritedMembers(parsedFilesToTypes(parsedFiles), parsedFile));
+
+export function addInheritedMembers(repository: Type[], parsedFile: ParsedFile): ParsedFile {
+  function addInheritedMembersToType<T extends Type>(repository: Type[], current: T): 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;
+    }
+  }
+
+  return {
+    ...parsedFile,
+    type: addInheritedMembersToType(repository, parsedFile.type),
+  };
+}
+
+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 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,
+      ),
+  );
+}

package/src/core/markdown/reflection/reflect-source.ts

@@ -0,0 +1,41 @@
+import { ParsedFile, SourceFile } from '../../shared/types';
+import * as E from 'fp-ts/Either';
+import { reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
+import { pipe } from 'fp-ts/function';
+import * as O from 'fp-ts/Option';
+import { parseApexMetadata } from '../../parse-apex-metadata';
+import { ReflectionError } from './error-handling';
+
+export function reflectSourceCode(apexBundles: SourceFile[]) {
+  return apexBundles.map(reflectSourceBody);
+}
+
+function reflectSourceBody(apexBundle: SourceFile): E.Either<ReflectionError, ParsedFile> {
+  const { filePath, content: input, metadataContent: metadata } = apexBundle;
+  const result = mirrorReflection(input);
+  return result.error
+    ? E.left(new ReflectionError(filePath, result.error.message))
+    : E.right({
+        filePath,
+        type: addFileMetadataToTypeAnnotation(result.typeMirror!, metadata),
+      });
+}
+
+function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
+  return pipe(
+    O.fromNullable(metadata),
+    O.map((metadata) => {
+      const metadataParams = parseApexMetadata(metadata);
+      metadataParams.forEach((value, key) => {
+        const declaration = `${key}: ${value}`;
+        type.annotations.push({
+          rawDeclaration: declaration,
+          name: declaration,
+          type: declaration,
+        });
+      });
+      return type;
+    }),
+    O.getOrElse(() => type),
+  );
+}

package/src/core/markdown/reflection/sort-members.ts

@@ -0,0 +1,59 @@
+import { ClassMirror, EnumMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
+import { ParsedFile } from '../../shared/types';
+
+type Named = { name: string };
+
+export function sortMembers(shouldSortMembers: boolean, parsedFiles: ParsedFile[]): ParsedFile[] {
+  return parsedFiles.map((parsedFile) => ({
+    ...parsedFile,
+    type: sortTypeMember(parsedFile.type, shouldSortMembers),
+  }));
+}
+
+function sortByNames<T extends Named>(shouldSort: boolean, a: T, b: T): number {
+  if (shouldSort) {
+    return a.name.localeCompare(b.name);
+  }
+  return 0;
+}
+
+function sortNamed<T extends Named>(shouldSort: boolean, items: T[]): T[] {
+  return items.sort((a, b) => sortByNames(shouldSort, a, b));
+}
+
+function sortTypeMember(type: Type, shouldSort: boolean): Type {
+  switch (type.type_name) {
+    case 'enum':
+      return sortEnumValues(shouldSort, type as EnumMirror);
+    case 'interface':
+      return sortInterfaceMethods(shouldSort, type as InterfaceMirror);
+    case 'class':
+      return sortClassMembers(shouldSort, type as ClassMirror);
+  }
+}
+
+function sortEnumValues(shouldSort: boolean, enumType: EnumMirror): EnumMirror {
+  return {
+    ...enumType,
+    values: sortNamed(shouldSort, enumType.values),
+  };
+}
+
+function sortInterfaceMethods(shouldSort: boolean, interfaceType: InterfaceMirror): InterfaceMirror {
+  return {
+    ...interfaceType,
+    methods: sortNamed(shouldSort, interfaceType.methods),
+  };
+}
+
+function sortClassMembers(shouldSort: boolean, classType: ClassMirror): ClassMirror {
+  return {
+    ...classType,
+    fields: sortNamed(shouldSort, classType.fields),
+    classes: sortNamed(shouldSort, classType.classes),
+    enums: sortNamed(shouldSort, classType.enums),
+    interfaces: sortNamed(shouldSort, classType.interfaces),
+    methods: sortNamed(shouldSort, classType.methods),
+    properties: sortNamed(shouldSort, classType.properties),
+  };
+}

package/src/{transpiler/markdown/plain-markdown → core/markdown/templates}/class-template.ts

@@ -8,11 +8,13 @@ export const classMarkdownTemplate = `
 
 {{#if extends.length}}
 **Inheritance**
+
 {{#each extends}}{{link this}}{{#unless @last}} < {{/unless}}{{/each}}
 {{/if}}
 
 {{#if implements}}
 **Implements**
+
 {{#each implements}}
 {{link this}}{{#unless @last}}, {{/unless}}
 {{/each}}

package/src/core/markdown/templates/hookable.ts

@@ -0,0 +1,7 @@
+export const hookableTemplate = `
+{{#if frontmatter}}
+{{{frontmatter}}}
+{{/if}}
+
+{{{content}}}
+`.trim();

package/src/core/{template.ts → markdown/templates/template.ts}

@@ -1,15 +1,15 @@
 import Handlebars from 'handlebars';
-import { typeDocPartial } from '../transpiler/markdown/plain-markdown/type-doc-partial';
-import { documentablePartialTemplate } from '../transpiler/markdown/plain-markdown/documentable-partial-template';
-import { methodsPartialTemplate } from '../transpiler/markdown/plain-markdown/methods-partial-template';
-import { constructorsPartialTemplate } from '../transpiler/markdown/plain-markdown/constructors-partial-template';
-import { fieldsPartialTemplate } from '../transpiler/markdown/plain-markdown/fieldsPartialTemplate';
-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 { CodeBlock, RenderableContent, StringOrLink } from './adapters/types';
-import { isCodeBlock, isEmptyLine, isInlineCode } from './adapters/type-utils';
-import { groupedMembersPartialTemplate } from '../transpiler/markdown/plain-markdown/grouped-members-partial-template';
+import { CodeBlock, RenderableContent, StringOrLink } from '../adapters/types';
+import { isCodeBlock, isEmptyLine, isInlineCode } from '../adapters/type-utils';
+import { typeDocPartial } from './type-doc-partial';
+import { documentablePartialTemplate } from './documentable-partial-template';
+import { methodsPartialTemplate } from './methods-partial-template';
+import { groupedMembersPartialTemplate } from './grouped-members-partial-template';
+import { constructorsPartialTemplate } from './constructors-partial-template';
+import { fieldsPartialTemplate } from './fieldsPartialTemplate';
+import { classMarkdownTemplate } from './class-template';
+import { enumMarkdownTemplate } from './enum-template';
+import { interfaceMarkdownTemplate } from './interface-template';
 
 export type CompilationRequest = {
   template: string;
@@ -90,7 +90,7 @@ const resolveRenderableContent = (description?: RenderableContent[]): string =>
 
   function reduceDescription(acc: string, curr: RenderableContent) {
     if (isEmptyLine(curr)) {
-      return acc + '\n\n';
+      return acc + '\n';
     }
     if (isCodeBlock(curr)) {
       return acc + convertCodeBlock(curr) + '\n';

package/src/core/markdown/utils.ts

@@ -0,0 +1,3 @@
+import { ParsedFile } from '../shared/types';
+
+export const parsedFilesToTypes = (parsedFiles: ParsedFile[]) => parsedFiles.map((parsedFile) => parsedFile.type);

package/src/{transpiler → core}/openapi/__tests__/open-api-docs-processor.spec.ts

@@ -1,5 +1,5 @@
 import { OpenApiDocsProcessor } from '../open-api-docs-processor';
-import { Settings } from '../../../settings';
+import { Settings } from '../../settings';
 import { SettingsBuilder } from '../../../test-helpers/SettingsBuilder';
 import { DocCommentBuilder } from '../../../test-helpers/DocCommentBuilder';
 import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';

package/src/{model → core/openapi}/apex-type-wrappers/__tests__/ClassMirrorWrapper.spec.ts

@@ -1,7 +1,7 @@
-import { ClassMirrorBuilder } from '../../../test-helpers/ClassMirrorBuilder';
 import { ClassMirrorWrapper } from '../ClassMirrorWrapper';
-import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
-import { MethodMirrorBuilder } from '../../../test-helpers/MethodMirrorBuilder';
+import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
+import { MethodMirrorBuilder } from '../../../../test-helpers/MethodMirrorBuilder';
+import { AnnotationBuilder } from '../../../../test-helpers/AnnotationBuilder';
 
 it('should return methods by annotation when they exist', function () {
   const classMirror = new ClassMirrorBuilder()

package/src/core/openapi/file-container.ts

@@ -0,0 +1,13 @@
+import { PageData } from '../shared/types';
+
+export class FileContainer {
+  _files: PageData[] = [];
+
+  files(): PageData[] {
+    return this._files;
+  }
+
+  pushFile(file: PageData): void {
+    this._files.push(file);
+  }
+}

package/src/{service → core/openapi}/manifest-factory.ts

@@ -1,7 +1,7 @@
-import Manifest from '../core/manifest';
+import Manifest from '../manifest';
 import { TypeParser } from './parser';
 import { ReflectionResult } from '@cparra/apex-reflection';
-import ApexBundle from '../core/apex-bundle';
+import { SourceFile } from '../shared/types';
 
 /**
  * Builds a new Manifest object, sourcing its types from the received TypeParser.
@@ -10,7 +10,7 @@ import ApexBundle from '../core/apex-bundle';
  */
 export function createManifest(
   typeParser: TypeParser,
-  reflect: (apexBundle: ApexBundle) => ReflectionResult,
+  reflect: (apexBundle: SourceFile) => ReflectionResult,
 ): Manifest {
   return new Manifest(typeParser.parse(reflect));
 }

package/src/{transpiler → core}/openapi/open-api-docs-processor.ts

@@ -1,19 +1,17 @@
-import ProcessorTypeTranspiler from '../processor-type-transpiler';
-import { FileContainer } from '../file-container';
+import { FileContainer } from './file-container';
 import { ClassMirror, Type } from '@cparra/apex-reflection';
-import { OpenapiTypeFile } from '../../model/openapi/openapi-type-file';
-import { Logger } from '../../util/logger';
-import { OpenApi } from '../../model/openapi/open-api';
-import { Settings } from '../../settings';
+import { Logger } from '#utils/logger';
+import { OpenApi } from './open-api';
+import { Settings } from '../settings';
 import { MethodParser } from './parsers/MethodParser';
-import { camel2title } from '../../util/string-utils';
+import { camel2title } from '#utils/string-utils';
+import { createOpenApiFile } from './openapi-type-file';
 
-export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
+export class OpenApiDocsProcessor {
   protected readonly _fileContainer: FileContainer;
   openApiModel: OpenApi;
 
   constructor() {
-    super();
     this._fileContainer = new FileContainer();
     const title = Settings.getInstance().getOpenApiTitle();
     if (!title) {
@@ -68,7 +66,8 @@ export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
   }
 
   onAfterProcess: ((types: Type[]) => void) | undefined = () => {
-    this._fileContainer.pushFile(new OpenapiTypeFile(this.openApiModel));
+    const page = createOpenApiFile(Settings.getInstance().openApiFileName(), this.openApiModel);
+    this._fileContainer.pushFile(page);
   };
 
   private getEndpointPath(type: Type): string | null {

package/src/core/openapi/openapi-type-file.ts

@@ -0,0 +1,14 @@
+import { OpenApi } from './open-api';
+import { OpenApiPageData } from '../shared/types';
+
+export function createOpenApiFile(fileName: string, openApiModel: OpenApi): OpenApiPageData {
+  const content = JSON.stringify({ ...openApiModel, namespace: undefined }, null, 2);
+  return {
+    fileExtension: 'json',
+    fileName,
+    directory: '',
+    content,
+    frontmatter: null,
+    group: null,
+  };
+}

package/src/{service → core/openapi}/parser.ts

@@ -1,25 +1,25 @@
 import { ClassMirror, InterfaceMirror, ReflectionResult, Type } from '@cparra/apex-reflection';
-import ApexBundle from '../core/apex-bundle';
-import MetadataProcessor from './metadata-processor';
-import { Logger } from '../util/logger';
+import { parseApexMetadata } from '../parse-apex-metadata';
+import { Logger } from '#utils/logger';
+import { SourceFile } from '../shared/types';
 
 export interface TypeParser {
-  parse(reflect: (apexBundle: ApexBundle) => ReflectionResult): Type[];
+  parse(reflect: (apexBundle: SourceFile) => ReflectionResult): Type[];
 }
 
 type NameAware = { name: string };
 
 export class RawBodyParser implements TypeParser {
-  constructor(public typeBundles: ApexBundle[]) {}
+  constructor(public typeBundles: SourceFile[]) {}
 
-  parse(reflect: (apexBundle: ApexBundle) => ReflectionResult): Type[] {
+  parse(reflect: (apexBundle: SourceFile) => ReflectionResult): Type[] {
     const types = this.typeBundles
       .map((currentBundle) => {
         Logger.log(`Parsing file: ${currentBundle.filePath}`);
         const result = reflect(currentBundle);
-        if (!!result.typeMirror && !!currentBundle.rawMetadataContent) {
+        if (!!result.typeMirror && !!currentBundle.metadataContent) {
           // If successful and there is a metadata file
-          const metadataParams = MetadataProcessor.process(currentBundle.rawMetadataContent);
+          const metadataParams = parseApexMetadata(currentBundle.metadataContent);
           metadataParams.forEach((value, key) => {
             const declaration = `${key}: ${value}`;
             result.typeMirror?.annotations.push({

package/src/{transpiler → core}/openapi/parsers/Builder.ts

@@ -1,6 +1,6 @@
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
-import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
-import { SchemaObject } from '../../../model/openapi/open-api-types';
+import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
+import { SchemaObject } from '../../../core/openapi/open-api-types';
 
 export type ApexDocSchemaAware = {
   schema: ApexDocSchemaObject;

package/src/{transpiler → core}/openapi/parsers/MethodParser.ts

@@ -1,7 +1,7 @@
 import { ClassMirror, MethodMirror } from '@cparra/apex-reflection';
-import { OpenApi } from '../../../model/openapi/open-api';
+import { OpenApi } from '../../../core/openapi/open-api';
 import * as yaml from 'js-yaml';
-import { ClassMirrorWrapper } from '../../../model/apex-type-wrappers/ClassMirrorWrapper';
+import { ClassMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/ClassMirrorWrapper';
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
 import { ParameterObjectBuilder } from './ParameterObjectBuilder';
 import { ResponsesBuilder } from './ResponsesBuilder';
@@ -9,11 +9,11 @@ import {
   ApexDocHttpRequestBody,
   ApexDocHttpResponse,
   ApexDocParameterObject,
-} from '../../../model/openapi/apex-doc-types';
+} from '../../../core/openapi/apex-doc-types';
 import { RequestBodyBuilder } from './RequestBodyBuilder';
 import { ApexDocSchemaAware } from './Builder';
-import { PropertiesObject, ReferenceObject } from '../../../model/openapi/open-api-types';
-import { MethodMirrorWrapper } from '../../../model/apex-type-wrappers/MethodMirrorWrapper';
+import { PropertiesObject, ReferenceObject } from '../../../core/openapi/open-api-types';
+import { MethodMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/MethodMirrorWrapper';
 
 type FallbackMethodParser = (methodMirror: MethodMirror) => void;
 type AddToOpenApi<T extends ApexDocSchemaAware> = (input: T, urlValue: string, httpMethodKey: HttpOperations) => void;

package/src/{transpiler → core}/openapi/parsers/ParameterObjectBuilder.ts

@@ -1,6 +1,6 @@
-import { ParameterObject } from '../../../model/openapi/open-api-types';
+import { ParameterObject } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocParameterObject } from '../../../model/openapi/apex-doc-types';
+import { ApexDocParameterObject } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 export class ParameterObjectBuilder extends Builder<ParameterObject, ApexDocParameterObject> {

package/src/{transpiler → core}/openapi/parsers/ReferenceBuilder.ts

@@ -5,11 +5,11 @@ import {
   SchemaObject,
   SchemaObjectArray,
   SchemaObjectObject,
-} from '../../../model/openapi/open-api-types';
-import { TypeBundle, TypesRepository } from '../../../model/types-repository';
+} from '../../../core/openapi/open-api-types';
+import { TypeBundle, TypesRepository } from '../../../core/openapi/types-repository';
 import { ClassMirror, DocCommentAnnotation, FieldMirror, PropertyMirror } from '@cparra/apex-reflection';
 import { ListObjectType, ReferencedType } from '@cparra/apex-reflection';
-import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
+import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
 
 type TypeBundleWithIsCollectionAndReferenceOverrides = TypeBundle & {
   originalTypeName: string;

package/src/{transpiler → core}/openapi/parsers/RequestBodyBuilder.ts

@@ -1,6 +1,6 @@
-import { RequestBody } from '../../../model/openapi/open-api-types';
+import { RequestBody } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpRequestBody } from '../../../model/openapi/apex-doc-types';
+import { ApexDocHttpRequestBody } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 /**

package/src/{transpiler → core}/openapi/parsers/ResponsesBuilder.ts

@@ -1,6 +1,6 @@
-import { ResponseObject } from '../../../model/openapi/open-api-types';
+import { ResponseObject } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpResponse } from '../../../model/openapi/apex-doc-types';
+import { ApexDocHttpResponse } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 export class ResponsesBuilder extends Builder<ResponseObject, ApexDocHttpResponse> {

package/src/{transpiler → core}/openapi/parsers/__tests__/MethodParser.spec.ts

@@ -1,7 +1,7 @@
 import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
 import { MethodMirrorBuilder } from '../../../../test-helpers/MethodMirrorBuilder';
 import { AnnotationBuilder } from '../../../../test-helpers/AnnotationBuilder';
-import { OpenApi } from '../../../../model/openapi/open-api';
+import { OpenApi } from '../../../../core/openapi/open-api';
 import { MethodParser } from '../MethodParser';
 import { DocCommentBuilder } from '../../../../test-helpers/DocCommentBuilder';
 

package/src/{transpiler → core}/openapi/parsers/__tests__/ParameterObjectBuilder.spec.ts

@@ -1,7 +1,7 @@
 import { ParameterObjectBuilder } from '../ParameterObjectBuilder';
 import { Reference } from '../ReferenceBuilder';
-import { ReferenceObject } from '../../../../model/openapi/open-api-types';
-import { ApexDocParameterObject } from '../../../../model/openapi/apex-doc-types';
+import { ReferenceObject } from '../../../../core/openapi/open-api-types';
+import { ApexDocParameterObject } from '../../../../core/openapi/apex-doc-types';
 
 jest.mock('../ReferenceBuilder', () => {
   return {

package/src/{transpiler → core}/openapi/parsers/__tests__/ReferenceBuilder.spec.ts

@@ -1,8 +1,8 @@
-import { TypesRepository } from '../../../../model/types-repository';
+import { TypesRepository } from '../../../../core/openapi/types-repository';
 import { ReferenceBuilder } from '../ReferenceBuilder';
 import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
 import { FieldMirrorBuilder } from '../../../../test-helpers/FieldMirrorBuilder';
-import { SchemaObjectArray, SchemaObjectObject } from '../../../../model/openapi/open-api-types';
+import { SchemaObjectArray, SchemaObjectObject } from '../../../../core/openapi/open-api-types';
 import { DocCommentBuilder } from '../../../../test-helpers/DocCommentBuilder';
 import { DocCommentAnnotationBuilder } from '../../../../test-helpers/DocCommentAnnotationBuilder';
 

package/src/{transpiler → core}/openapi/parsers/__tests__/RequestBodyBuilder.spec.ts

@@ -1,7 +1,7 @@
 import { RequestBodyBuilder } from '../RequestBodyBuilder';
 import { Reference } from '../ReferenceBuilder';
-import { ReferenceObject } from '../../../../model/openapi/open-api-types';
-import { ApexDocHttpRequestBody } from '../../../../model/openapi/apex-doc-types';
+import { ReferenceObject } from '../../../../core/openapi/open-api-types';
+import { ApexDocHttpRequestBody } from '../../../../core/openapi/apex-doc-types';
 
 jest.mock('../ReferenceBuilder', () => {
   return {

package/src/{transpiler → core}/openapi/parsers/__tests__/ResponsesBuilder.spec.ts

@@ -1,6 +1,6 @@
 import { ResponsesBuilder } from '../ResponsesBuilder';
 import { Reference } from '../ReferenceBuilder';
-import { ApexDocHttpResponse } from '../../../../model/openapi/apex-doc-types';
+import { ApexDocHttpResponse } from '../../../../core/openapi/apex-doc-types';
 
 jest.mock('../ReferenceBuilder', () => {
   return {

package/src/{transpiler → core/openapi}/transpiler.ts

@@ -1,24 +1,20 @@
 import { Type } from '@cparra/apex-reflection';
-import ProcessorTypeTranspiler from './processor-type-transpiler';
 import { Settings } from '../settings';
-import State from '../service/state';
+import { OpenApiDocsProcessor } from './open-api-docs-processor';
 
 export default class Transpiler {
-  static generate(types: Type[], processor: ProcessorTypeTranspiler): void {
+  static generate(types: Type[], processor: OpenApiDocsProcessor): void {
     const sortedTypes = types.sort((apexTypeA, apexTypeB) => {
       if (apexTypeA.name < apexTypeB.name) return -1;
       if (apexTypeA.name > apexTypeB.name) return 1;
       return 0;
     });
 
-    processor.onBeforeProcess?.(sortedTypes);
-
     if (Settings.getInstance().indexOnly) {
       return;
     }
 
     sortedTypes.forEach((currentType) => {
-      State.getInstance().setTypeBeingProcessed(currentType);
       processor.onProcess(currentType);
     });
     processor.onAfterProcess?.(sortedTypes);

package/src/{model → core/openapi}/types-repository.ts

@@ -4,7 +4,6 @@ export type TypeBundle = { type: Type; isChild: boolean; parentType?: Type };
 
 export class TypesRepository {
   private static instance: TypesRepository;
-  private scopedTypes: Type[] = [];
   private allTypes: Type[] = [];
 
   public static getInstance(): TypesRepository {
@@ -52,12 +51,4 @@ export class TypesRepository {
     }
     return { type: foundType, isChild: false };
   }
-
-  public populateScoped(types: Type[]) {
-    this.scopedTypes = types;
-  }
-
-  public getFromScopedByName(typeName: string): Type | undefined {
-    return this.scopedTypes.find((currentType: Type) => currentType.name === typeName);
-  }
 }

package/src/core/parse-apex-metadata.ts

@@ -0,0 +1,14 @@
+import { XMLParser } from 'fast-xml-parser';
+
+export function parseApexMetadata(input: string) {
+  const map = new Map<string, string>();
+  const xml = new XMLParser().parse(input);
+
+  map.set('apiVersion', xml.ApexClass.apiVersion ?? '');
+
+  if (xml.ApexClass.status) {
+    map.set('status', xml.ApexClass.status);
+  }
+
+  return map;
+}