@cparra/apexdocs 2.25.0-alpha.8 → 2.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "2.25.0-alpha.8",
+  "version": "2.25.0",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",
@@ -10,18 +10,23 @@
     "apex-docs",
     "docs"
   ],
-  "exports": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "lib/index.js",
   "bin": {
-    "apexdocs": "./dist/cli/generate.js"
+    "apexdocs-generate": "lib/cli/generate.js"
   },
+  "types": "lib/index.d.ts",
   "scripts": {
-    "test": "npm run build && jest",
-    "build": "rimraf ./lib && npm run lint && tsc --noEmit && pkgroll",
+    "test": "jest --coverage",
+    "build": "rimraf ./lib && npm run lint && tsc --declaration",
     "lint": "eslint \"./src/**/*.{js,ts}\" --quiet --fix",
     "prepare": "npm run build",
     "version": "npm run format && git add -A src",
-    "postversion": "git push && git push --tags"
+    "postversion": "git push && git push --tags",
+    "docs:init": "docsify init docs",
+    "docs:serve": "docsify serve docs",
+    "execute:example": "rimraf ./docs/types && node lib/cli/generate.js -s examples/force-app -t docs/types --scope global public private protected -g docsify --defaultGroupName \"Misc Group\" --namespace nspc --title \"Sample Documentation\" --documentationRootDir types",
+    "execute:example:index:only": "node lib/cli/generate.js -s examples/force-app -t docs --scope global public private -g docsify --indexOnly",
+    "execute:example:openapi": "node lib/cli/generate.js -s examples/force-app -t docs -g openapi --openApiTitle \"Sample REST Api\" --namespace nspc --openApiFileName restapi"
   },
   "author": "Cesar Parra",
   "license": "MIT",
@@ -30,22 +35,26 @@
     "url": "https://github.com/cesarParra/apexdocs"
   },
   "devDependencies": {
-    "@eslint/js": "^9.6.0",
-    "@types/eslint__js": "^8.42.3",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.10",
-    "@types/shelljs": "^0.8.15",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "husky": "^9.0.11",
-    "jest": "^29.7.0",
-    "lint-staged": "^15.2.7",
-    "pkgroll": "^2.4.2",
-    "prettier": "^3.3.2",
-    "rimraf": "^6.0.0",
-    "ts-jest": "^29.2.0",
-    "typescript": "^5.5.3",
-    "typescript-eslint": "^7.16.0"
+    "@types/html-entities": "^1.3.4",
+    "@types/jest": "^27.4.1",
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^13.7.4",
+    "@types/shelljs": "^0.8.6",
+    "@types/yargs": "^15.0.3",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.41.0",
+    "docsify": "^4.13.1",
+    "docsify-cli": "^4.4.4",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "husky": "^8.0.3",
+    "jest": "^27.5.1",
+    "lint-staged": "^13.2.1",
+    "prettier": "^2.4.1",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.8.4"
   },
   "husky": {
     "hooks": {
@@ -58,21 +67,13 @@
     ]
   },
   "dependencies": {
-    "@cparra/apex-reflection": "2.11.3",
-    "@types/js-yaml": "^4.0.9",
-    "@types/yargs": "^17.0.32",
+    "@cparra/apex-reflection": "2.12.1",
     "chalk": "^4.1.2",
     "cosmiconfig": "^9.0.0",
-    "cosmiconfig-typescript-loader": "^5.0.0",
-    "fast-xml-parser": "^4.4.0",
-    "fp-ts": "^2.16.8",
-    "handlebars": "^4.7.8",
+    "fast-xml-parser": "^4.0.1",
     "js-yaml": "^4.1.0",
     "log-update": "4.0.0",
-    "type-fest": "^4.23.0",
-    "yargs": "^17.7.2"
-  },
-  "imports": {
-    "#utils/*": "./src/util/*.ts"
+    "xss": "^1.0.11",
+    "yargs": "^16.0.3"
   }
 }

package/src/application/Apexdocs.ts

@@ -1,10 +1,17 @@
-import markdown from './generators/markdown';
-import openApi from './generators/openapi';
-
-import { ApexFileReader } from './apex-file-reader';
-import { DefaultFileSystem } from './file-system';
-import { Logger } from '#utils/logger';
-import { UserDefinedConfig } from '../core/shared/types';
+import { ApexFileReader } from '../service/apex-file-reader';
+import { DefaultFileSystem } from '../service/file-system';
+import { ReflectionResult, reflect, Type } from '@cparra/apex-reflection';
+import { Logger } from '../util/logger';
+import { createManifest } from '../service/manifest-factory';
+import { RawBodyParser } from '../service/parser';
+import { Settings, TargetFile } from '../settings';
+import Transpiler from '../transpiler/transpiler';
+import { FileWriter } from '../service/file-writer';
+import ErrorLogger from '../util/error-logger';
+import ApexBundle from '../model/apex-bundle';
+import Manifest from '../model/manifest';
+import { TypesRepository } from '../model/types-repository';
+import { TypeTranspilerFactory } from '../transpiler/factory';
 
 /**
  * Application entry-point to generate documentation out of Apex source files.
@@ -13,18 +20,64 @@ export class Apexdocs {
   /**
    * Generates documentation out of Apex source files.
    */
-  static async generate(config: UserDefinedConfig): Promise<void> {
-    Logger.logSingle('Initializing...', false);
+  static generate(): void {
+    Logger.log('Initializing...');
+    const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem());
+    const manifest = createManifest(new RawBodyParser(fileBodies), this._reflectionWithLogger);
+    TypesRepository.getInstance().populateAll(manifest.types);
+    const filteredTypes = this.filterByScopes(manifest);
+    TypesRepository.getInstance().populateScoped(filteredTypes);
+    const processor = TypeTranspilerFactory.get(Settings.getInstance().targetGenerator);
+    Transpiler.generate(filteredTypes, processor);
+    const generatedFiles = processor.fileBuilder().files();
+
+    const files: TargetFile[] = [];
+    FileWriter.write(generatedFiles, (file: TargetFile) => {
+      Logger.logSingle(`${file.name} processed.`, false, 'green', false);
+      files.push(file);
+    });
 
-    const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
+    Settings.getInstance().onAfterProcess(files);
+
+    // Error logging
+    ErrorLogger.logErrors(filteredTypes);
+  }
 
-    switch (config.targetGenerator) {
-      case 'markdown':
-        await markdown(fileBodies, config);
-        break;
-      case 'openapi':
-        openApi(fileBodies, config);
-        break;
+  private static filterByScopes(manifest: Manifest) {
+    let filteredTypes: Type[];
+    let filteredLogMessage;
+    if (Settings.getInstance().config.targetGenerator !== 'openapi') {
+      filteredTypes = manifest.filteredByAccessModifierAndAnnotations(Settings.getInstance().scope);
+      filteredLogMessage = `Filtered ${manifest.types.length - filteredTypes.length} file(s) based on scope: ${
+        Settings.getInstance().scope
+      }`;
+    } else {
+      // If we are dealing with an OpenApi generator, we ignore the passed in access modifiers, and instead
+      // we only keep classes annotated as @RestResource
+      filteredTypes = manifest.filteredByAccessModifierAndAnnotations([
+        'restresource',
+        'httpdelete',
+        'httpget',
+        'httppatch',
+        'httppost',
+        'httpput',
+      ]);
+      filteredLogMessage = `Filtered ${
+        manifest.types.length - filteredTypes.length
+      } file(s), only keeping classes annotated as @RestResource.`;
     }
+    Logger.clear();
+
+    Logger.logSingle(filteredLogMessage, false, 'green', false);
+    Logger.logSingle(`Creating documentation for ${filteredTypes.length} file(s)`, false, 'green', false);
+    return filteredTypes;
   }
+
+  static _reflectionWithLogger = (apexBundle: ApexBundle): ReflectionResult => {
+    const result = reflect(apexBundle.rawTypeContent);
+    if (result.error) {
+      Logger.error(`${apexBundle.filePath} - Parsing error ${result.error?.message}`);
+    }
+    return result;
+  };
 }

package/src/cli/generate.ts

@@ -1,16 +1,137 @@
 #!/usr/bin/env node
+import * as yargs from 'yargs';
+
+import { Settings } from '../settings';
 import { Apexdocs } from '../application/Apexdocs';
-import { extractArgs } from './args';
+import { GeneratorChoices } from '../transpiler/generator-choices';
+import { cosmiconfig } from 'cosmiconfig';
 
-function main() {
-  function cathError(error: Error) {
-    console.error(error);
-    process.exit(1);
+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;
+
+  if (config) {
+    argv = { ...config.config, ...argv };
   }
 
-  extractArgs()
-    .then((config) => Apexdocs.generate(config).catch(cathError))
-    .catch(cathError);
-}
+  Settings.build({
+    sourceDirectory: argv.sourceDir,
+    recursive: argv.recursive,
+    scope: argv.scope,
+    outputDir: argv.targetDir,
+    targetGenerator: argv.targetGenerator as GeneratorChoices,
+    indexOnly: argv.indexOnly,
+    defaultGroupName: argv.defaultGroupName,
+    sanitizeHtml: argv.sanitizeHtml,
+    openApiTitle: argv.openApiTitle,
+    title: argv.title,
+    namespace: argv.namespace,
+    openApiFileName: argv.openApiFileName,
+    sortMembersAlphabetically: argv.sortMembersAlphabetically,
+    includeMetadata: argv.includeMetadata,
+    rootDir: argv.documentationRootDir,
+    onAfterProcess: config?.config?.onAfterProcess,
+    onBeforeFileWrite: config?.config?.onBeforeFileWrite,
+    frontMatterHeader: config?.config?.frontMatterHeader,
+  });
 
-main();
+  try {
+    Apexdocs.generate();
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});

package/src/index.ts

@@ -1,35 +1 @@
-import { SetOptional } from 'type-fest';
-import type {
-  ConfigurableHooks,
-  Skip,
-  UserDefinedMarkdownConfig,
-  ReferenceGuidePageData,
-  DocPageData,
-} from './core/shared/types';
-import { defaults } from './defaults';
-
-type ConfigurableMarkdownConfig = Omit<
-  SetOptional<
-    UserDefinedMarkdownConfig,
-    'targetDir' | 'scope' | 'defaultGroupName' | 'includeMetadata' | 'sortMembersAlphabetically'
-  >,
-  'targetGenerator'
->;
-
-function defineMarkdownConfig(config: ConfigurableMarkdownConfig): UserDefinedMarkdownConfig {
-  return {
-    ...defaults,
-    ...config,
-    targetGenerator: 'markdown',
-  };
-}
-
-function skip(): Skip {
-  return {
-    _tag: 'Skip',
-  };
-}
-
-// Exports
-
-export { defineMarkdownConfig, skip, ConfigurableHooks, ReferenceGuidePageData, DocPageData };
+export * from './service/manifest-factory';

package/src/model/__tests__/manifest-diff.spec.ts

@@ -0,0 +1,147 @@
+import Manifest from '../manifest';
+import { EnumMirror } from '@cparra/apex-reflection';
+import { ManifestDiff } from '../manifest-diff';
+import { Annotation } from '@cparra/apex-reflection/index';
+
+const deprecatedAnnotation: Annotation = {
+  rawDeclaration: '@deprecated',
+  name: 'deprecated',
+  type: 'deprecated',
+};
+
+const namespaceAccessibleAnnotation: Annotation = {
+  rawDeclaration: '@NamespaceAccessible',
+  name: 'namespaceaccessible',
+  type: 'namespaceaccessible',
+};
+
+it('detects when new types are added', () => {
+  const commonType = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+
+  const originalManifest = new Manifest([commonType]);
+
+  const addedType = {
+    annotations: [],
+    name: 'NewEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+  const newManifest = new Manifest([addedType, commonType]);
+
+  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
+  expect(manifestDiff.added.length).toBe(1);
+  expect(manifestDiff.added[0].name).toBe('NewEnum');
+});
+
+it('detects when types are deleted', () => {
+  const commonType = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+
+  const deletedType = {
+    annotations: [],
+    name: 'OldEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+  const originalManifest = new Manifest([commonType, deletedType]);
+  const newManifest = new Manifest([commonType]);
+
+  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
+  expect(manifestDiff.deleted.length).toBe(1);
+  expect(manifestDiff.deleted[0].name).toBe('OldEnum');
+});
+
+it('does not add enums that have no changes', () => {
+  const originalEnum = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+
+  const modifiedEnum = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+
+  const originalManifest = new Manifest([originalEnum]);
+  const newManifest = new Manifest([modifiedEnum]);
+
+  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
+  expect(manifestDiff.changes.length).toBe(0);
+});
+
+it('detects changes to access modifiers within an enum', () => {
+  const originalEnum = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+    values: [],
+  } as EnumMirror;
+
+  const modifiedEnum = {
+    annotations: [],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'private',
+    values: [],
+  } as EnumMirror;
+
+  const originalManifest = new Manifest([originalEnum]);
+  const newManifest = new Manifest([modifiedEnum]);
+
+  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
+  expect(manifestDiff.changes.length).toBe(1);
+  expect(manifestDiff.changes[0].originalType).toBe(originalEnum);
+  expect(manifestDiff.changes[0].newType).toBe(modifiedEnum);
+  expect(manifestDiff.changes[0].accessModifierChange).not.toBeNull();
+  expect(manifestDiff.changes[0].accessModifierChange?.oldAccessModifier).toBe('public');
+  expect(manifestDiff.changes[0].accessModifierChange?.newAccessModifier).toBe('private');
+});
+
+it('detects changes to annotations within an enum', () => {
+  const originalEnum = {
+    annotations: [deprecatedAnnotation],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'public',
+  } as EnumMirror;
+
+  const modifiedEnum = {
+    annotations: [namespaceAccessibleAnnotation],
+    name: 'CommonEnum',
+    type_name: 'enum',
+    access_modifier: 'private',
+  } as EnumMirror;
+
+  const originalManifest = new Manifest([originalEnum]);
+  const newManifest = new Manifest([modifiedEnum]);
+
+  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
+  expect(manifestDiff.changes.length).toBe(1);
+  expect(manifestDiff.changes[0].annotationChanges.length).toBe(2);
+  expect(manifestDiff.changes[0].annotationChanges.find((change) => change.type === 'added')?.annotation.name).toBe(
+    namespaceAccessibleAnnotation.name,
+  );
+  expect(manifestDiff.changes[0].annotationChanges.find((change) => change.type === 'removed')?.annotation.name).toBe(
+    deprecatedAnnotation.name,
+  );
+});

package/src/model/apex-bundle.ts

@@ -0,0 +1,3 @@
+export default class ApexBundle {
+  constructor(public filePath: string, public rawTypeContent: string, public rawMetadataContent: string | null) {}
+}

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

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

package/src/model/inheritance.ts

@@ -0,0 +1,7 @@
+import { FieldMirror, MethodMirror, PropertyMirror } from '@cparra/apex-reflection';
+
+export type InheritanceSupport = { inherited: boolean };
+export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
+export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
+export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
+export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;

package/src/model/manifest-diff.ts

@@ -0,0 +1,94 @@
+import Manifest from './manifest';
+import { Type } from '@cparra/apex-reflection';
+import { Annotation } from '@cparra/apex-reflection/index';
+
+export class ManifestDiff {
+  added: Type[] = [];
+  deleted: Type[] = [];
+  changes: DiffChange[] = [];
+
+  static build(originalManifest: Manifest, newManifest: Manifest) {
+    const addedTypes = newManifest.types.filter(
+      (currentType) => !originalManifest.types.find((originalType) => currentType.name === originalType.name),
+    );
+    const deletedTypes = originalManifest.types.filter(
+      (currentType) => !newManifest.types.find((newType) => currentType.name === newType.name),
+    );
+
+    const changes: DiffChange[] = [];
+    for (const newType of newManifest.types) {
+      const oldType = originalManifest.types.find((oldType) => oldType.name === newType.name);
+      if (!oldType) {
+        continue;
+      }
+
+      const change = new DiffChange(oldType, newType);
+      if (change.hasChanges()) {
+        changes.push(change);
+      }
+    }
+
+    const diff = new ManifestDiff();
+    diff.added = addedTypes;
+    diff.deleted = deletedTypes;
+    diff.changes = changes;
+    return diff;
+  }
+}
+
+class DiffChange {
+  accessModifierChange?: AccessModifierChange;
+  annotationChanges: AnnotationChange[] = [];
+
+  constructor(public originalType: Type, public newType: Type) {
+    this.parse();
+  }
+
+  public hasChanges(): boolean {
+    return !!this.accessModifierChange || this.annotationChanges.length > 0;
+  }
+
+  private parse() {
+    // Access modifier changes
+    if (this.originalType.access_modifier !== this.newType.access_modifier) {
+      this.accessModifierChange = {
+        oldAccessModifier: this.originalType.access_modifier,
+        newAccessModifier: this.newType.access_modifier,
+      };
+    }
+
+    // Annotation changes
+    const addedAnnotations = this.newType.annotations.filter(
+      (currentAnnotation) =>
+        !this.originalType.annotations.find((originalAnnotation) => currentAnnotation.name === originalAnnotation.name),
+    );
+    const removedAnnotations = this.originalType.annotations.filter(
+      (currentAnnotation) =>
+        !this.newType.annotations.find((newAnnotation) => currentAnnotation.name === newAnnotation.name),
+    );
+    const annotationChangeMapper = (annotation: Annotation, changeType: 'added' | 'removed') => {
+      return {
+        annotation: annotation,
+        type: changeType,
+      } as AnnotationChange;
+    };
+    this.annotationChanges = [
+      ...addedAnnotations.map((annotation) => {
+        return annotationChangeMapper(annotation, 'added');
+      }),
+      ...removedAnnotations.map((annotation) => {
+        return annotationChangeMapper(annotation, 'removed');
+      }),
+    ];
+  }
+}
+
+interface AccessModifierChange {
+  oldAccessModifier: string;
+  newAccessModifier: string;
+}
+
+interface AnnotationChange {
+  annotation: Annotation;
+  type: 'added' | 'removed';
+}