@cparra/apexdocs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/cli/generate.js

@@ -2,18 +2,20 @@
 'use strict';
 
 var _function = require('fp-ts/function');
-var E = require('fp-ts/Either');
 var TE = require('fp-ts/TaskEither');
 var yaml = require('js-yaml');
 var path = require('path');
+var E = require('fp-ts/Either');
+var T = require('fp-ts/Task');
+var A = require('fp-ts/lib/Array');
 var apexReflection = require('@cparra/apex-reflection');
 var O = require('fp-ts/Option');
 var fastXmlParser = require('fast-xml-parser');
 var Handlebars = require('handlebars');
-var defaults = require('../defaults-jLXD2y8-.js');
+var defaults = require('../defaults-DGKfeZq-.js');
 var fs = require('fs');
+var TE$1 = require('fp-ts/lib/TaskEither');
 var chalk = require('chalk');
-var logUpdate = require('log-update');
 var cosmiconfig = require('cosmiconfig');
 var yargs = require('yargs');
 var cosmiconfigTypescriptLoader = require('cosmiconfig-typescript-loader');
@@ -35,12 +37,15 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
 var TE__namespace = /*#__PURE__*/_interopNamespaceDefault(TE);
 var yaml__namespace = /*#__PURE__*/_interopNamespaceDefault(yaml);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
+var T__namespace = /*#__PURE__*/_interopNamespaceDefault(T);
+var A__namespace = /*#__PURE__*/_interopNamespaceDefault(A);
 var O__namespace = /*#__PURE__*/_interopNamespaceDefault(O);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var TE__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(TE$1);
 var yargs__namespace = /*#__PURE__*/_interopNamespaceDefault(yargs);
 
 function apply(fn, ...front) {
@@ -146,25 +151,25 @@ function isInlineCode(content) {
   return Object.keys(content).includes("__type") && content.__type === "inline-code";
 }
 
-var __defProp$f = Object.defineProperty;
-var __defProps$f = Object.defineProperties;
-var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
-var __hasOwnProp$f = Object.prototype.hasOwnProperty;
-var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$f = (a, b) => {
+var __defProp$g = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$f.call(b, prop))
-      __defNormalProp$f(a, prop, b[prop]);
-  if (__getOwnPropSymbols$f)
-    for (var prop of __getOwnPropSymbols$f(b)) {
-      if (__propIsEnum$f.call(b, prop))
-        __defNormalProp$f(a, prop, b[prop]);
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
 function adaptDescribable(describable, linkGenerator) {
   return {
     description: describableToRenderableContent(describable, linkGenerator)
@@ -216,7 +221,7 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
   function extractCustomTags(type) {
     var _a2, _b2;
     const baseTags = ["description", "group", "author", "date", "see", "example", "throws", "exception"];
-    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$f(__spreadValues$f({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
+    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$g(__spreadValues$g({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
       name: currentAnnotation.name
     }))) != null ? _b2 : [];
   }
@@ -230,7 +235,7 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
     var _a2, _b2;
     return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === "see").map((currentAnnotation) => currentAnnotation.body)) != null ? _b2 : [];
   }
-  return __spreadProps$f(__spreadValues$f({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+  return __spreadProps$g(__spreadValues$g({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
     annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
     customTags: extractCustomTags(documentable),
     example: {
@@ -245,25 +250,25 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
   });
 }
 
-var __defProp$e = Object.defineProperty;
-var __defProps$e = Object.defineProperties;
-var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
-var __hasOwnProp$e = Object.prototype.hasOwnProperty;
-var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$e = (a, b) => {
+var __defProp$f = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$e.call(b, prop))
-      __defNormalProp$e(a, prop, b[prop]);
-  if (__getOwnPropSymbols$e)
-    for (var prop of __getOwnPropSymbols$e(b)) {
-      if (__propIsEnum$e.call(b, prop))
-        __defNormalProp$e(a, prop, b[prop]);
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
 function adaptMethod(method, linkGenerator, baseHeadingLevel) {
   var _a, _b, _c;
   function buildTitle(method2) {
@@ -293,7 +298,7 @@ function adaptMethod(method, linkGenerator, baseHeadingLevel) {
     returnType: {
       headingLevel: baseHeadingLevel + 1,
       heading: "Return Type",
-      value: __spreadProps$e(__spreadValues$e({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
+      value: __spreadProps$f(__spreadValues$f({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
         type: linkGenerator(method.typeReference.rawDeclaration)
       })
     },
@@ -352,13 +357,13 @@ function mapParameters(documentable, param, linkGenerator) {
   const paramAnnotation = (_a = documentable.docComment) == null ? void 0 : _a.paramAnnotations.find(
     (pa) => pa.paramName.toLowerCase() === param.name.toLowerCase()
   );
-  return __spreadProps$e(__spreadValues$e({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
+  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
     name: param.name,
     type: linkGenerator(param.typeReference.rawDeclaration)
   });
 }
 function mapThrows(thrown, linkGenerator) {
-  return __spreadProps$e(__spreadValues$e({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
+  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
     type: linkGenerator(thrown.exceptionName)
   });
 }
@@ -393,25 +398,25 @@ function adaptFieldOrProperty(field, linkGenerator, baseHeadingLevel) {
   };
 }
 
-var __defProp$d = Object.defineProperty;
-var __defProps$d = Object.defineProperties;
-var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
-var __hasOwnProp$d = Object.prototype.hasOwnProperty;
-var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$d = (a, b) => {
+var __defProp$e = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
+var __hasOwnProp$e = Object.prototype.hasOwnProperty;
+var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$d.call(b, prop))
-      __defNormalProp$d(a, prop, b[prop]);
-  if (__getOwnPropSymbols$d)
-    for (var prop of __getOwnPropSymbols$d(b)) {
-      if (__propIsEnum$d.call(b, prop))
-        __defNormalProp$d(a, prop, b[prop]);
+    if (__hasOwnProp$e.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b)) {
+      if (__propIsEnum$e.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
 function typeToRenderable(parsedFile, linkGenerator, config) {
   function getRenderable() {
     const { type } = parsedFile;
@@ -424,7 +429,7 @@ function typeToRenderable(parsedFile, linkGenerator, config) {
         return classTypeToClassSource(type, linkGenerator);
     }
   }
-  return __spreadProps$d(__spreadValues$d({}, getRenderable()), {
+  return __spreadProps$e(__spreadValues$e({}, getRenderable()), {
     filePath: parsedFile.source.filePath,
     namespace: config.namespace
   });
@@ -449,7 +454,7 @@ function baseTypeAdapter(type, linkGenerator, baseHeadingLevel) {
   };
 }
 function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "enum"
   }, baseTypeAdapter(enumType, linkGenerator, baseHeadingLevel)), {
     values: {
@@ -457,7 +462,7 @@ function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
       heading: "Values",
       value: enumType.values.map((value) => {
         var _a;
-        return __spreadProps$d(__spreadValues$d({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+        return __spreadProps$e(__spreadValues$e({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
           value: value.name
         });
       })
@@ -465,7 +470,7 @@ function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
   });
 }
 function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "interface"
   }, baseTypeAdapter(interfaceType, linkGenerator, baseHeadingLevel)), {
     extends: interfaceType.extended_interfaces.map(linkGenerator),
@@ -477,7 +482,7 @@ function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadin
   });
 }
 function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "class"
   }, baseTypeAdapter(classType, linkGenerator, baseHeadingLevel)), {
     classModifier: classType.classModifier,
@@ -510,7 +515,7 @@ function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1)
       headingLevel: baseHeadingLevel + 1,
       heading: "Classes",
       value: classType.classes.map(
-        (innerClass) => classTypeToClassSource(__spreadProps$d(__spreadValues$d({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
+        (innerClass) => classTypeToClassSource(__spreadProps$e(__spreadValues$e({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
       )
     },
     innerEnums: {
@@ -569,17 +574,68 @@ function singleGroup(headingLevel, groupName, adapter, members, linkGenerator) {
   };
 }
 
+const generateLink = (strategy) => {
+  switch (strategy) {
+    case "relative":
+      return generateRelativeLink;
+    case "no-link":
+      return generateNoLink;
+    case "none":
+      return returnReferenceAsIs;
+  }
+};
+const generateRelativeLink = (references, from, referenceName) => {
+  function getRelativePath(fromPath, toPath) {
+    return path.relative(path.parse(path.join("/", fromPath)).dir, path.join("/", toPath));
+  }
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+  if (referenceTo && from === "__base__") {
+    return {
+      __type: "link",
+      title: referenceTo.displayName,
+      url: getRelativePath("", referenceTo.referencePath)
+    };
+  }
+  const referenceFrom = references[from];
+  if (!referenceFrom) {
+    return referenceTo.displayName;
+  }
+  return {
+    __type: "link",
+    title: referenceTo.displayName,
+    url: getRelativePath(referenceFrom.referencePath, referenceTo.referencePath)
+  };
+};
+const generateNoLink = (references, _from, referenceName) => {
+  const referenceTo = references[referenceName];
+  return referenceTo ? referenceTo.displayName : referenceName;
+};
+const returnReferenceAsIs = (references, _from, referenceName) => {
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+  return {
+    __type: "link",
+    title: referenceTo.displayName,
+    url: referenceTo.referencePath
+  };
+};
+
 function parsedFilesToRenderableBundle(config, parsedFiles, references) {
-  const referenceFinder = apply(linkGenerator, references, config.documentationRootDir);
+  const referenceFinder = apply(generateLink(config.linkingStrategy), references);
   function toReferenceGuide(parsedFiles2) {
     return parsedFiles2.reduce(
-      addToReferenceGuide(referenceFinder, config, references),
+      addToReferenceGuide(apply(referenceFinder, "__base__"), config, references),
       {}
     );
   }
   function toRenderables(parsedFiles2) {
     return parsedFiles2.reduce((acc, parsedFile) => {
-      const renderable = typeToRenderable(parsedFile, referenceFinder, config);
+      const renderable = typeToRenderable(parsedFile, apply(referenceFinder, parsedFile.source.name), config);
       acc.push(renderable);
       return acc;
     }, []);
@@ -604,17 +660,6 @@ function addToReferenceGuide(findLinkFromHome, config, references) {
     return acc;
   };
 }
-const linkGenerator = (references, documentationRootDir, referenceName) => {
-  const reference = references[referenceName];
-  return reference ? (
-    // Starting the path with a "/" will ensure the link will always be relative to the root of the site.
-    {
-      __type: "link",
-      title: reference.displayName,
-      url: path__namespace.join("/", documentationRootDir, reference.pathFromRoot)
-    }
-  ) : referenceName;
-};
 function getTypeGroup$1(type, config) {
   var _a, _b;
   const groupAnnotation = (_a = type.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === "group");
@@ -622,16 +667,59 @@ function getTypeGroup$1(type, config) {
 }
 
 function parseApexMetadata(input) {
-  var _a;
+  return _function.pipe(input, parse, E__namespace.map(toMap));
+}
+function parse(input) {
+  return E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(input), E__namespace.toError);
+}
+function toMap(metadata) {
   const map = /* @__PURE__ */ new Map();
-  const xml = new fastXmlParser.XMLParser().parse(input);
-  map.set("apiVersion", (_a = xml.ApexClass.apiVersion) != null ? _a : "");
-  if (xml.ApexClass.status) {
-    map.set("status", xml.ApexClass.status);
+  map.set("apiVersion", String(metadata.ApexClass.apiVersion));
+  if (metadata.ApexClass.status) {
+    map.set("status", String(metadata.ApexClass.status));
   }
   return map;
 }
 
+var __defProp$d = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
+var __hasOwnProp$d = Object.prototype.hasOwnProperty;
+var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$d.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b)) {
+      if (__propIsEnum$d.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+var __async$5 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 class ReflectionErrors {
   constructor(errors) {
     this.errors = errors;
@@ -644,59 +732,88 @@ class ReflectionError {
     this.message = message;
   }
 }
-function checkForReflectionErrors(reflectionResult) {
-  function reduceReflectionResultIntoSingleEither(results) {
-    return results.reduce(
-      (acc, result) => {
-        E__namespace.isLeft(result) ? acc.errors.push(result.left) : acc.parsedFiles.push(result.right);
-        return acc;
-      },
-      {
-        errors: [],
-        parsedFiles: []
+function reflectAsync(rawSource) {
+  return __async$5(this, null, function* () {
+    return new Promise((resolve, reject) => {
+      const result = apexReflection.reflect(rawSource);
+      if (result.typeMirror) {
+        return resolve(result.typeMirror);
+      } else if (result.error) {
+        return reject(result.error);
+      } else {
+        return reject(new Error("Unknown error"));
       }
-    );
-  }
-  return _function.pipe(
-    reflectionResult,
-    reduceReflectionResultIntoSingleEither,
-    ({ errors, parsedFiles }) => errors.length ? E__namespace.left(new ReflectionErrors(errors)) : E__namespace.right(parsedFiles)
-  );
+    });
+  });
 }
-
-function reflectSourceCode(apexBundles) {
-  return apexBundles.map(reflectSourceBody);
+function reflectBundles(apexBundles) {
+  const semiGroupReflectionError = {
+    concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
+  };
+  const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
+  return _function.pipe(apexBundles, A__namespace.traverse(Ap)(reflectBundle));
+}
+function reflectBundle(apexBundle) {
+  const convertToParsedFile = apply(toParsedFile, apexBundle.filePath);
+  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
+  return _function.pipe(apexBundle, reflectAsTask, TE__namespace.map(convertToParsedFile), TE__namespace.flatMap(withMetadata));
+}
+function reflectAsTask(apexBundle) {
+  return TE__namespace.tryCatch(
+    () => reflectAsync(apexBundle.content),
+    (error) => new ReflectionErrors([new ReflectionError(apexBundle.filePath, error.message)])
+  );
 }
-function reflectSourceBody(apexBundle) {
-  const { filePath, content: input, metadataContent: metadata } = apexBundle;
-  const result = apexReflection.reflect(input);
-  return result.error ? E__namespace.left(new ReflectionError(filePath, result.error.message)) : E__namespace.right({
+function toParsedFile(filePath, typeMirror) {
+  return {
     source: {
       filePath,
-      name: result.typeMirror.name,
-      type: result.typeMirror.type_name
+      name: typeMirror.name,
+      type: typeMirror.type_name
     },
-    type: addFileMetadataToTypeAnnotation(result.typeMirror, metadata)
-  });
+    type: typeMirror
+  };
+}
+function addMetadata(rawMetadataContent, parsedFile) {
+  return TE__namespace.fromEither(
+    _function.pipe(
+      parsedFile.type,
+      (type) => addFileMetadataToTypeAnnotation(type, rawMetadataContent),
+      E__namespace.map((type) => __spreadProps$d(__spreadValues$d({}, parsedFile), { type })),
+      E__namespace.mapLeft((error) => errorToReflectionErrors(error, parsedFile.source.filePath))
+    )
+  );
+}
+function errorToReflectionErrors(error, filePath) {
+  return new ReflectionErrors([new ReflectionError(filePath, error.message)]);
 }
 function addFileMetadataToTypeAnnotation(type, metadata) {
+  const concatAnnotationToType = apply(concatAnnotations, type);
   return _function.pipe(
     O__namespace.fromNullable(metadata),
-    O__namespace.map((metadata2) => {
-      const metadataParams = parseApexMetadata(metadata2);
-      metadataParams.forEach((value, key) => {
-        const declaration = `${key}: ${value}`;
-        type.annotations.push({
-          rawDeclaration: declaration,
-          name: declaration,
-          type: declaration
-        });
-      });
-      return type;
-    }),
-    O__namespace.getOrElse(() => type)
+    O__namespace.map(concatAnnotationToType),
+    O__namespace.getOrElse(() => E__namespace.right(type))
+  );
+}
+function concatAnnotations(type, metadataInput) {
+  return _function.pipe(
+    metadataInput,
+    parseApexMetadata,
+    E__namespace.map((metadataMap) => __spreadProps$d(__spreadValues$d({}, type), {
+      annotations: [...type.annotations, ...mapToAnnotations(metadataMap)]
+    }))
   );
 }
+function mapToAnnotations(metadata) {
+  return Array.from(metadata.entries()).map(([key, value]) => {
+    const declaration = `${key}: ${value}`;
+    return {
+      name: declaration,
+      type: declaration,
+      rawDeclaration: declaration
+    };
+  });
+}
 
 function createInheritanceChain(repository, classMirror) {
   return _function.pipe(
@@ -1198,7 +1315,7 @@ const convertToDocumentationBundle = (referenceGuideTemplate, { referencesByGrou
   referenceGuide: {
     frontmatter: null,
     content: referencesToReferenceGuideContent(referencesByGroup, referenceGuideTemplate),
-    filePath: "index.md"
+    outputDocPath: "index.md"
   },
   docs: renderables.map(
     (renderable) => renderableToPageData(Object.values(referencesByGroup).flat(), renderable)
@@ -1232,7 +1349,7 @@ function renderableToPageData(referenceGuideReference, renderable) {
         name: renderable2.name,
         type: renderable2.type
       },
-      filePath: reference.reference.pathFromRoot,
+      outputDocPath: reference.reference.outputDocPath,
       frontmatter: null,
       content: docContents,
       group: (_a = renderable2.doc.group) != null ? _a : defaults.defaults.defaultGroupName
@@ -1450,10 +1567,12 @@ function parsedFilesToReferenceGuide(config, parsedFiles) {
   }, {});
 }
 function parsedFileToDocPageReference(config, parsedFile) {
+  const path = `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`;
   return {
     source: parsedFile.source,
     displayName: parsedFile.type.name,
-    pathFromRoot: `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`
+    outputDocPath: path,
+    referencePath: path
   };
 }
 function getTypeGroup(type, config) {
@@ -1484,7 +1603,7 @@ var __spreadValues$7 = (a, b) => {
   return a;
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-var __async$2 = (__this, __arguments, generator) => {
+var __async$4 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -1518,15 +1637,13 @@ function generateDocs(apexBundles, config) {
   const sortTypeMembers = apply(sortMembers, config.sortMembersAlphabetically);
   return _function.pipe(
     apexBundles,
-    reflectSourceCode,
-    checkForReflectionErrors,
-    E__namespace.map(filterOutOfScope),
-    E__namespace.map(addInheritedMembersToTypes),
-    E__namespace.map(addInheritanceChainToTypes),
-    E__namespace.map(sortTypeMembers),
-    E__namespace.bindTo("parsedFiles"),
-    E__namespace.bind("references", ({ parsedFiles }) => E__namespace.right(convertToReferences(parsedFiles))),
-    TE__namespace.fromEither,
+    reflectBundles,
+    TE__namespace.map(filterOutOfScope),
+    TE__namespace.map(addInheritedMembersToTypes),
+    TE__namespace.map(addInheritanceChainToTypes),
+    TE__namespace.map(sortTypeMembers),
+    TE__namespace.bindTo("parsedFiles"),
+    TE__namespace.bind("references", ({ parsedFiles }) => TE__namespace.right(convertToReferences(parsedFiles))),
     TE__namespace.flatMap(({ parsedFiles, references }) => transformReferenceHook(config)({ references, parsedFiles })),
     TE__namespace.map(({ parsedFiles, references }) => convertToRenderableBundle(parsedFiles, references)),
     TE__namespace.map(convertToDocumentationBundleForTemplate),
@@ -1536,7 +1653,7 @@ function generateDocs(apexBundles, config) {
 }
 function transformReferenceHook(config) {
   function _execute(references, parsedFiles, transformReference) {
-    return __async$2(this, null, function* () {
+    return __async$4(this, null, function* () {
       return {
         references: yield execTransformReferenceHook(Object.values(references), transformReference),
         parsedFiles
@@ -1557,8 +1674,8 @@ function transformDocumentationBundleHook(config) {
 function passThroughHook(value) {
   return value;
 }
-const execTransformReferenceHook = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
-  const hooked = references.map((reference) => __async$2(void 0, null, function* () {
+const execTransformReferenceHook = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
+  const hooked = references.map((reference) => __async$4(void 0, null, function* () {
     const hookedResult = yield hook(reference);
     return __spreadValues$7(__spreadValues$7({}, reference), hookedResult);
   }));
@@ -1568,24 +1685,24 @@ const execTransformReferenceHook = (_0, ..._1) => __async$2(void 0, [_0, ..._1],
     return acc;
   }, {});
 });
-const documentationBundleHook = (bundle, config) => __async$2(void 0, null, function* () {
+const documentationBundleHook = (bundle, config) => __async$4(void 0, null, function* () {
   return {
     referenceGuide: yield transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
     docs: yield transformDocs(bundle.docs, config.transformDocs, config.transformDocPage)
   };
 });
-const transformReferenceGuide = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
+const transformReferenceGuide = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
   const result = yield hook(referenceGuide);
   if (isSkip(result)) {
     return result;
   }
   return __spreadValues$7(__spreadValues$7({}, referenceGuide), yield hook(referenceGuide));
 });
-const transformDocs = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
+const transformDocs = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
   const transformed = yield transformDocsHook(docs);
   return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
 });
-const transformDocPage = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
+const transformDocPage = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
   return __spreadValues$7(__spreadValues$7({}, doc), yield hook(doc));
 });
 function postHookCompile(bundle) {
@@ -1623,6 +1740,21 @@ ${yamlString}---
 `;
 }
 
+const referenceGuideTemplate = `
+# Apex Reference Guide
+
+{{#each this}}
+## {{@key}}
+
+{{#each this}}
+### {{link title}}
+
+{{{renderContent description}}}
+
+{{/each}}
+{{/each}}
+`.trim();
+
 var __defProp$6 = Object.defineProperty;
 var __defProps$6 = Object.defineProperties;
 var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
@@ -1642,85 +1774,30 @@ var __spreadValues$6 = (a, b) => {
   return a;
 };
 var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-class FileWriter {
-  static write(files, outputDir, onWriteCallback) {
-    files.forEach((file) => {
-      const { filePath, content } = this.getTargetLocation(file, outputDir);
-      fs__namespace.mkdirSync(path__namespace.dirname(filePath), { recursive: true });
-      fs__namespace.writeFileSync(filePath, content, "utf8");
-      onWriteCallback(file);
-    });
-  }
-  static getTargetLocation(file, outputDir) {
-    return __spreadProps$6(__spreadValues$6({}, file), {
-      filePath: path__namespace.join(outputDir, file.filePath)
-    });
-  }
+const mkdir = TE__namespace$1.taskify(fs__namespace.mkdir);
+const writeFile = TE__namespace$1.taskify(fs__namespace.writeFile);
+function writeFiles(files, outputDir, onWriteCallback) {
+  return _function.pipe(
+    files,
+    TE__namespace$1.traverseArray((file) => writeSingle(file, outputDir, onWriteCallback))
+  );
 }
-
-class Logger {
-  /**
-   * Logs a message with optional arguments.
-   * @param message The message to log.
-   * @param args Optional arguments.
-   */
-  static log(message, ...args) {
-    this.logSingle(message);
-    args.forEach((arg) => {
-      this.logSingle(arg);
-    });
-  }
-  /**
-   * Logs an error message with optional arguments.
-   * @param message The error message to log.
-   * @param args Optional arguments.
-   */
-  static error(message, ...args) {
-    this.logSingle(message, false, "red", false);
-    args.forEach(() => {
-      this.logSingle(message, false, "red", false);
-    });
-  }
-  static logSingle(text, showSpinner = true, color = "green", overrideConsole = true) {
-    if (this.currentFrame > 9) {
-      this.currentFrame = 0;
-    }
-    const spinner = showSpinner ? `${this.frames[this.currentFrame++]}` : "";
-    let logMessage;
-    if (color === "green") {
-      logMessage = `${chalk.green((/* @__PURE__ */ new Date()).toLocaleString() + ": ")}${text}
-`;
-    } else {
-      logMessage = `${chalk.red((/* @__PURE__ */ new Date()).toLocaleString() + ": ")}${text}
-`;
-    }
-    if (overrideConsole) {
-      logUpdate(`${spinner} ${logMessage}`);
-    } else {
-      process.stdout.write(`${spinner} ${logMessage}`);
-    }
-  }
-  static clear() {
-    logUpdate.clear();
-  }
+function writeSingle(file, outputDir, onWriteCallback) {
+  const ensureDirectoryExists = ({ outputDocPath }) => mkdir(path__namespace.dirname(outputDocPath), { recursive: true });
+  const writeContents = (file2) => writeFile(file2.outputDocPath, file2.content, "utf8");
+  return _function.pipe(
+    resolveTargetLocation(file, outputDir),
+    (file2) => TE__namespace$1.right(file2),
+    TE__namespace$1.tapIO(ensureDirectoryExists),
+    TE__namespace$1.flatMap(writeContents),
+    TE__namespace$1.map(() => onWriteCallback == null ? void 0 : onWriteCallback(file))
+  );
+}
+function resolveTargetLocation(file, outputDir) {
+  return __spreadProps$6(__spreadValues$6({}, file), {
+    outputDocPath: path__namespace.join(outputDir, file.outputDocPath)
+  });
 }
-Logger.currentFrame = 0;
-Logger.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-
-const referenceGuideTemplate = `
-# Apex Reference Guide
-
-{{#each this}}
-## {{@key}}
-
-{{#each this}}
-### {{link title}}
-
-{{{renderContent description}}}
-
-{{/each}}
-{{/each}}
-`.trim();
 
 var __defProp$5 = Object.defineProperty;
 var __defProps$5 = Object.defineProperties;
@@ -1741,23 +1818,18 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+class FileWritingError {
+  constructor(message, error) {
+    this.message = message;
+    this.error = error;
+    this._tag = "FileWritingError";
+  }
+}
 function generate(bundles, config) {
   return _function.pipe(
     generateDocumentationBundle(bundles, config),
-    TE__namespace.map((files) => writeFilesToSystem(files, config.targetDir)),
-    TE__namespace.mapLeft((error) => {
-      if (error._tag === "HookError") {
-        Logger.error("Error(s) occurred while processing hooks. Please review the following issues:");
-        Logger.error(error.error);
-        return;
-      }
-      const errorMessages = [
-        "Error(s) occurred while parsing files. Please review the following issues:",
-        ...error.errors.map(formatReflectionError)
-      ].join("\n");
-      Logger.error(errorMessages);
-    })
-  )();
+    TE__namespace.flatMap((files) => writeFilesToSystem(files, config.targetDir))
+  );
 }
 function generateDocumentationBundle(bundles, config) {
   return generateDocs(bundles, __spreadProps$5(__spreadValues$5({}, config), {
@@ -1765,24 +1837,56 @@ function generateDocumentationBundle(bundles, config) {
   }));
 }
 function writeFilesToSystem(files, outputDir) {
-  FileWriter.write(
+  return _function.pipe(
     [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
-    outputDir,
-    (file) => {
-      Logger.logSingle(`${file.filePath} processed.`, false, "green", false);
-    }
+    (files2) => writeFiles(files2, outputDir),
+    TE__namespace.mapLeft((error) => {
+      return new FileWritingError("An error occurred while writing files to the system.", error);
+    })
   );
 }
-function formatReflectionError(error) {
-  return `Source file: ${error.file}
-${error.message}
-`;
-}
 
 function createManifest(typeParser, reflect) {
   return new Manifest(typeParser.parse(reflect));
 }
 
+class Logger {
+  /**
+   * Logs a message with optional arguments.
+   * @param message The message to log.
+   * @param args Optional arguments.
+   */
+  static log(message, ...args) {
+    this.logSingle(message);
+    args.forEach((arg) => {
+      this.logSingle(arg);
+    });
+  }
+  /**
+   * Logs an error message with optional arguments.
+   * @param message The error message to log.
+   * @param args Optional arguments.
+   */
+  static error(message, ...args) {
+    this.logSingle(message, "red");
+    args.forEach(() => {
+      this.logSingle(message, "red");
+    });
+  }
+  static logSingle(text, color = "green") {
+    if (this.currentFrame > 9) {
+      this.currentFrame = 0;
+    }
+    const logMessage = `${this.getChalkFn(color)((/* @__PURE__ */ new Date()).toLocaleString() + ": ")}${text}
+`;
+    process.stdout.write(logMessage);
+  }
+  static getChalkFn(color) {
+    return color === "green" ? chalk.green : chalk.red;
+  }
+}
+Logger.currentFrame = 0;
+
 var __defProp$4 = Object.defineProperty;
 var __defProps$4 = Object.defineProperties;
 var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
@@ -1809,20 +1913,7 @@ class RawBodyParser {
   parse(reflect) {
     const types = this.typeBundles.map((currentBundle) => {
       Logger.log(`Parsing file: ${currentBundle.filePath}`);
-      const result = reflect(currentBundle);
-      if (!!result.typeMirror && !!currentBundle.metadataContent) {
-        const metadataParams = parseApexMetadata(currentBundle.metadataContent);
-        metadataParams.forEach((value, key) => {
-          var _a;
-          const declaration = `${key}: ${value}`;
-          (_a = result.typeMirror) == null ? void 0 : _a.annotations.push({
-            rawDeclaration: declaration,
-            name: declaration,
-            type: declaration
-          });
-        });
-      }
-      return result;
+      return reflect(currentBundle);
     }).filter((reflectionResult) => {
       return reflectionResult.typeMirror;
     }).map((reflectionResult) => reflectionResult.typeMirror);
@@ -2654,7 +2745,7 @@ var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 function createOpenApiFile(fileName, openApiModel) {
   const content = JSON.stringify(__spreadProps$1(__spreadValues$1({}, openApiModel), { namespace: void 0 }), null, 2);
   return {
-    filePath: "",
+    outputDocPath: "",
     content,
     frontmatter: null,
     group: null
@@ -2679,7 +2770,7 @@ class OpenApiDocsProcessor {
   }
   onProcess(type) {
     var _a, _b;
-    Logger.logSingle(`Processing ${type.name}`, false, "green", false);
+    Logger.logSingle(`Processing ${type.name}`, "green");
     const endpointPath = this.getEndpointPath(type);
     if (!endpointPath) {
       return;
@@ -2726,9 +2817,12 @@ function openApi(fileBodies, config) {
   const processor = new OpenApiDocsProcessor();
   Transpiler.generate(filteredTypes, processor);
   const generatedFiles = processor.fileBuilder().files();
-  FileWriter.write(generatedFiles, config.targetDir, (file) => {
-    Logger.logSingle(`${file.filePath} processed.`, false, "green", false);
-  });
+  _function.pipe(
+    writeFiles(generatedFiles, config.targetDir, (file) => {
+      Logger.logSingle(`${file.outputDocPath} processed.`, "green");
+    }),
+    TE__namespace.mapError((error) => Logger.error(error))
+  );
   ErrorLogger.logErrors(filteredTypes);
 }
 function reflectionWithLogger(apexBundle) {
@@ -2749,53 +2843,139 @@ function filterByScopes(manifest) {
     "httpput"
   ]);
   const 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);
+  Logger.logSingle(filteredLogMessage, "green");
+  Logger.logSingle(`Creating documentation for ${filteredTypes.length} file(s)`, "green");
   return filteredTypes;
 }
 
+var __async$3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 const APEX_FILE_EXTENSION = ".cls";
 class ApexFileReader {
   /**
    * Reads from .cls files and returns their raw body.
    */
   static processFiles(fileSystem, rootPath, includeMetadata) {
-    let bundles = [];
-    const directoryContents = fileSystem.readDirectory(rootPath);
-    directoryContents.forEach((filePath) => {
-      const currentPath = fileSystem.joinPath(rootPath, filePath);
-      if (fileSystem.isDirectory(currentPath)) {
-        bundles = bundles.concat(this.processFiles(fileSystem, currentPath, includeMetadata));
-      }
-      if (!this.isApexFile(filePath)) {
-        return;
+    return __async$3(this, null, function* () {
+      const filePaths = yield this.getFilePaths(fileSystem, rootPath);
+      const apexFilePaths = filePaths.filter((filePath) => this.isApexFile(filePath));
+      const filePromises = apexFilePaths.map((filePath) => this.processFile(fileSystem, filePath, includeMetadata));
+      return Promise.all(filePromises);
+    });
+  }
+  static getFilePaths(fileSystem, rootPath) {
+    return __async$3(this, null, function* () {
+      const directoryContents = yield fileSystem.readDirectory(rootPath);
+      const paths = [];
+      for (const filePath of directoryContents) {
+        const currentPath = fileSystem.joinPath(rootPath, filePath);
+        if (yield fileSystem.isDirectory(currentPath)) {
+          paths.push(...yield this.getFilePaths(fileSystem, currentPath));
+        }
+        paths.push(currentPath);
       }
-      const rawTypeContent = fileSystem.readFile(currentPath);
-      const metadataPath = fileSystem.joinPath(rootPath, `${filePath}-meta.xml`);
+      return paths;
+    });
+  }
+  static processFile(fileSystem, filePath, includeMetadata) {
+    return __async$3(this, null, function* () {
+      const rawTypeContent = yield fileSystem.readFile(filePath);
+      const metadataPath = `${filePath}-meta.xml`;
       let rawMetadataContent = null;
       if (includeMetadata) {
-        rawMetadataContent = fileSystem.exists(metadataPath) ? fileSystem.readFile(metadataPath) : null;
+        rawMetadataContent = fileSystem.exists(metadataPath) ? yield fileSystem.readFile(metadataPath) : null;
       }
-      bundles.push({ filePath: currentPath, content: rawTypeContent, metadataContent: rawMetadataContent });
+      return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
     });
-    return bundles;
   }
   static isApexFile(currentFile) {
     return currentFile.endsWith(APEX_FILE_EXTENSION);
   }
 }
 
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function stat(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.stat(path2, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+function readdir(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readdir(path2, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+function readFile(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readFile(path2, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+}
 class DefaultFileSystem {
   isDirectory(pathToRead) {
-    return fs__namespace.statSync(pathToRead).isDirectory();
+    return __async$2(this, null, function* () {
+      const stats = yield stat(pathToRead);
+      return stats.isDirectory();
+    });
   }
   readDirectory(sourceDirectory) {
-    return fs__namespace.readdirSync(sourceDirectory);
+    return readdir(sourceDirectory);
   }
   readFile(pathToRead) {
-    const rawFile = fs__namespace.readFileSync(pathToRead);
-    return rawFile.toString();
+    return readFile(pathToRead);
   }
   joinPath(...paths) {
     return path__namespace.join(...paths);
@@ -2831,19 +3011,56 @@ class Apexdocs {
    */
   static generate(config) {
     return __async$1(this, null, function* () {
-      Logger.logSingle("Initializing...", false);
-      const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
-      switch (config.targetGenerator) {
-        case "markdown":
-          yield generate(fileBodies, config);
-          break;
-        case "openapi":
-          openApi(fileBodies, config);
-          break;
+      Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
+      try {
+        const fileBodies = yield ApexFileReader.processFiles(
+          new DefaultFileSystem(),
+          config.sourceDir,
+          config.includeMetadata
+        );
+        switch (config.targetGenerator) {
+          case "markdown":
+            yield generateMarkdownDocumentation(fileBodies, config)();
+            break;
+          case "openapi":
+            openApi(fileBodies, config);
+            Logger.logSingle("\u2714\uFE0F Documentation generated successfully!");
+            break;
+        }
+      } catch (error) {
+        Logger.logSingle(`\u274C An error occurred while generating the documentation: ${error}`, "red");
       }
     });
   }
 }
+function generateMarkdownDocumentation(fileBodies, config) {
+  return _function.pipe(
+    generate(fileBodies, config),
+    TE__namespace.map(() => Logger.logSingle("\u2714\uFE0F Documentation generated successfully!")),
+    TE__namespace.mapLeft((error) => {
+      if (error._tag === "HookError") {
+        Logger.error("Error(s) occurred while processing hooks. Please review the following issues:");
+        Logger.error(error.error);
+        return;
+      }
+      if (error._tag === "FileWritingError") {
+        Logger.error(error.message);
+        Logger.error(error.error);
+        return;
+      }
+      const errorMessages = [
+        "Error(s) occurred while parsing files. Please review the following issues:",
+        ...error.errors.map(formatReflectionError)
+      ].join("\n");
+      Logger.error(errorMessages);
+    })
+  );
+}
+function formatReflectionError(error) {
+  return `Source file: ${error.file}
+${error.message}
+`;
+}
 
 const markdownOptions = {
   sourceDir: {
@@ -2884,10 +3101,11 @@ const markdownOptions = {
     describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
     default: defaults.defaults.includeMetadata
   },
-  documentationRootDir: {
+  linkingStrategy: {
     type: "string",
-    describe: "The root directory of the documentation. This is used to generate the correct relative paths.",
-    default: defaults.defaults.documentationRootDir
+    describe: "The strategy to use when linking to other documentation pages.",
+    choices: ["relative", "no-link", "none"],
+    default: defaults.defaults.linkingStrategy
   }
 };