@cparra/apexdocs 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/cli/generate.js

@@ -13,7 +13,6 @@ var Handlebars = require('handlebars');
 var defaults = require('../defaults-DGKfeZq-.js');
 var fs = require('fs');
 var chalk = require('chalk');
-var ora = require('ora');
 var cosmiconfig = require('cosmiconfig');
 var yargs = require('yargs');
 var cosmiconfigTypescriptLoader = require('cosmiconfig-typescript-loader');
@@ -1526,7 +1525,7 @@ var __spreadValues$7 = (a, b) => {
   return a;
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-var __async$3 = (__this, __arguments, generator) => {
+var __async$4 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -1578,7 +1577,7 @@ function generateDocs(apexBundles, config) {
 }
 function transformReferenceHook(config) {
   function _execute(references, parsedFiles, transformReference) {
-    return __async$3(this, null, function* () {
+    return __async$4(this, null, function* () {
       return {
         references: yield execTransformReferenceHook(Object.values(references), transformReference),
         parsedFiles
@@ -1599,8 +1598,8 @@ function transformDocumentationBundleHook(config) {
 function passThroughHook(value) {
   return value;
 }
-const execTransformReferenceHook = (_0, ..._1) => __async$3(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
-  const hooked = references.map((reference) => __async$3(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);
   }));
@@ -1610,24 +1609,24 @@ const execTransformReferenceHook = (_0, ..._1) => __async$3(void 0, [_0, ..._1],
     return acc;
   }, {});
 });
-const documentationBundleHook = (bundle, config) => __async$3(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$3(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$3(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$3(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) {
@@ -1690,7 +1689,7 @@ class FileWriter {
       const { outputDocPath, content } = this.getTargetLocation(file, outputDir);
       fs__namespace.mkdirSync(path__namespace.dirname(outputDocPath), { recursive: true });
       fs__namespace.writeFileSync(outputDocPath, content, "utf8");
-      onWriteCallback(file);
+      onWriteCallback == null ? void 0 : onWriteCallback(file);
     });
   }
   static getTargetLocation(file, outputDir) {
@@ -1734,17 +1733,8 @@ class Logger {
   static getChalkFn(color) {
     return color === "green" ? chalk.green : chalk.red;
   }
-  // TODO: This isn't really working and I don't think its worth it. Let's just completely remove the ora dependency.
-  static startSpinner(text) {
-    this.spinner.text = text;
-    this.spinner.start();
-  }
-  static succeedSpinner(text) {
-    this.spinner.succeed(text);
-  }
 }
 Logger.currentFrame = 0;
-Logger.spinner = ora();
 
 const referenceGuideTemplate = `
 # Apex Reference Guide
@@ -1780,45 +1770,35 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
-var __async$2 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
+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.flatMap((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;
       }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
+      if (error._tag === "FileWritingError") {
+        Logger.error(error.message);
+        Logger.error(error.error);
+        return;
       }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-function generate(bundles, config) {
-  return __async$2(this, null, function* () {
-    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);
-      })
-    )();
-  });
+      const errorMessages = [
+        "Error(s) occurred while parsing files. Please review the following issues:",
+        ...error.errors.map(formatReflectionError)
+      ].join("\n");
+      Logger.error(errorMessages);
+    })
+  )();
 }
 function generateDocumentationBundle(bundles, config) {
   return generateDocs(bundles, __spreadProps$5(__spreadValues$5({}, config), {
@@ -1826,12 +1806,15 @@ function generateDocumentationBundle(bundles, config) {
   }));
 }
 function writeFilesToSystem(files, outputDir) {
-  FileWriter.write(
-    [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
-    outputDir,
-    () => {
-    }
-  );
+  try {
+    FileWriter.write(
+      [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
+      outputDir
+    );
+    return TE__namespace.right(void 0);
+  } catch (error) {
+    return TE__namespace.left(new FileWritingError("An error occurred while writing files to the system.", error));
+  }
 }
 function formatReflectionError(error) {
   return `Source file: ${error.file}
@@ -2814,47 +2797,134 @@ function filterByScopes(manifest) {
   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);
@@ -2890,10 +2960,13 @@ class Apexdocs {
    */
   static generate(config) {
     return __async$1(this, null, function* () {
-      Logger.logSingle("Initializing...");
-      Logger.startSpinner("Processing files...");
+      Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
       try {
-        const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
+        const fileBodies = yield ApexFileReader.processFiles(
+          new DefaultFileSystem(),
+          config.sourceDir,
+          config.includeMetadata
+        );
         switch (config.targetGenerator) {
           case "markdown":
             yield generate(fileBodies, config);
@@ -2902,8 +2975,9 @@ class Apexdocs {
             openApi(fileBodies, config);
             break;
         }
-      } finally {
-        Logger.succeedSpinner("Files processed.");
+        Logger.logSingle("\u2714\uFE0F Documentation generated successfully!");
+      } catch (error) {
+        Logger.logSingle("\u274C An error occurred while generating the documentation.", "red");
       }
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-alpha.8",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",
@@ -68,7 +68,6 @@
     "fp-ts": "^2.16.8",
     "handlebars": "^4.7.8",
     "js-yaml": "^4.1.0",
-    "ora": "^5.4.1",
     "type-fest": "^4.23.0",
     "yargs": "^17.7.2"
   },

package/src/application/Apexdocs.ts

@@ -14,11 +14,14 @@ export class Apexdocs {
    * Generates documentation out of Apex source files.
    */
   static async generate(config: UserDefinedConfig): Promise<void> {
-    Logger.logSingle('Initializing...');
-    Logger.startSpinner('Processing files...');
+    Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
 
     try {
-      const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
+      const fileBodies = await ApexFileReader.processFiles(
+        new DefaultFileSystem(),
+        config.sourceDir,
+        config.includeMetadata,
+      );
 
       switch (config.targetGenerator) {
         case 'markdown':
@@ -28,9 +31,10 @@ export class Apexdocs {
           openApi(fileBodies, config);
           break;
       }
-    } finally {
-      // TODO: Allow for failures
-      Logger.succeedSpinner('Files processed.');
+
+      Logger.logSingle('✔️ Documentation generated successfully!');
+    } catch (error) {
+      Logger.logSingle('❌ An error occurred while generating the documentation.', 'red');
     }
   }
 }

package/src/application/__tests__/apex-file-reader.spec.ts

@@ -18,24 +18,24 @@ describe('File Reader', () => {
     } as SettingsConfig);
   });
 
-  it('returns an empty list when there are no files in the directory', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns an empty list when there are no files in the directory', async () => {
+    const result = await ApexFileReader.processFiles(
       {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        isDirectory(_: string): boolean {
-          return false;
+        isDirectory(_: string): Promise<boolean> {
+          return Promise.resolve(false);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         joinPath(_: string): string {
           return '';
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readDirectory(_: string): string[] {
-          return [];
+        readDirectory(_: string): Promise<string[]> {
+          return Promise.resolve([]);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readFile(_: string): string {
-          return '';
+        readFile(_: string): Promise<string> {
+          return Promise.resolve('');
         },
         exists(): boolean {
           return true;
@@ -47,20 +47,20 @@ describe('File Reader', () => {
     expect(result.length).toBe(0);
   });
 
-  it('returns an empty list when there are no Apex files in the directory', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns an empty list when there are no Apex files in the directory', async () => {
+    const result = await ApexFileReader.processFiles(
       {
-        isDirectory(): boolean {
-          return false;
+        isDirectory(): Promise<boolean> {
+          return Promise.resolve(false);
         },
         joinPath(): string {
           return '';
         },
-        readDirectory(): string[] {
-          return ['SomeFile.md'];
+        readDirectory(): Promise<string[]> {
+          return Promise.resolve(['SomeFile.md']);
         },
-        readFile(): string {
-          return '';
+        readFile(): Promise<string> {
+          return Promise.resolve('');
         },
         exists(): boolean {
           return true;
@@ -72,24 +72,24 @@ describe('File Reader', () => {
     expect(result.length).toBe(0);
   });
 
-  it('returns the file contents for an Apex file', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns the file contents for an Apex file', async () => {
+    const result = await ApexFileReader.processFiles(
       {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        isDirectory(_: string): boolean {
-          return false;
+        isDirectory(_: string): Promise<boolean> {
+          return Promise.resolve(false);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         joinPath(_: string): string {
-          return '';
+          return 'SomeApexFile.cls';
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readDirectory(_: string): string[] {
-          return ['SomeApexFile.cls'];
+        readDirectory(_: string): Promise<string[]> {
+          return Promise.resolve(['SomeApexFile.cls']);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readFile(_: string): string {
-          return 'public class MyClass{}';
+        readFile(_: string): Promise<string> {
+          return Promise.resolve('public class MyClass{}');
         },
         exists(): boolean {
           return true;

package/src/application/apex-file-reader.ts

@@ -10,30 +10,43 @@ export class ApexFileReader {
   /**
    * Reads from .cls files and returns their raw body.
    */
-  static processFiles(fileSystem: FileSystem, rootPath: string, includeMetadata: boolean): UnparsedSourceFile[] {
-    let bundles: UnparsedSourceFile[] = [];
+  static async processFiles(
+    fileSystem: FileSystem,
+    rootPath: string,
+    includeMetadata: boolean,
+  ): Promise<UnparsedSourceFile[]> {
+    const filePaths = await 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);
+  }
 
-    const directoryContents = fileSystem.readDirectory(rootPath);
-    directoryContents.forEach((filePath) => {
+  private static async getFilePaths(fileSystem: FileSystem, rootPath: string): Promise<string[]> {
+    const directoryContents = await fileSystem.readDirectory(rootPath);
+    const paths: string[] = [];
+    for (const filePath of directoryContents) {
       const currentPath = fileSystem.joinPath(rootPath, filePath);
-      if (fileSystem.isDirectory(currentPath)) {
-        bundles = bundles.concat(this.processFiles(fileSystem, currentPath, includeMetadata));
-      }
-
-      if (!this.isApexFile(filePath)) {
-        return;
+      if (await fileSystem.isDirectory(currentPath)) {
+        paths.push(...(await this.getFilePaths(fileSystem, currentPath)));
       }
+      paths.push(currentPath);
+    }
+    return paths;
+  }
 
-      const rawTypeContent = fileSystem.readFile(currentPath);
-      const metadataPath = fileSystem.joinPath(rootPath, `${filePath}-meta.xml`);
-      let rawMetadataContent = null;
-      if (includeMetadata) {
-        rawMetadataContent = fileSystem.exists(metadataPath) ? fileSystem.readFile(metadataPath) : null;
-      }
+  private static async processFile(
+    fileSystem: FileSystem,
+    filePath: string,
+    includeMetadata: boolean,
+  ): Promise<UnparsedSourceFile> {
+    const rawTypeContent = await fileSystem.readFile(filePath);
+    const metadataPath = `${filePath}-meta.xml`;
+    let rawMetadataContent = null;
+    if (includeMetadata) {
+      rawMetadataContent = fileSystem.exists(metadataPath) ? await fileSystem.readFile(metadataPath) : null;
+    }
 
-      bundles.push({ filePath: currentPath, content: rawTypeContent, metadataContent: rawMetadataContent });
-    });
-    return bundles;
+    return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
   }
 
   private static isApexFile(currentFile: string): boolean {

package/src/application/file-system.ts

@@ -2,25 +2,61 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 export interface FileSystem {
-  readDirectory: (sourceDirectory: string) => string[];
-  isDirectory: (path: string) => boolean;
-  readFile: (path: string) => string;
+  isDirectory: (path: string) => Promise<boolean>;
+  readDirectory: (sourceDirectory: string) => Promise<string[]>;
+  readFile: (path: string) => Promise<string>;
   joinPath: (...paths: string[]) => string;
   exists: (path: string) => boolean;
 }
 
+function stat(path: string): Promise<fs.Stats> {
+  return new Promise((resolve, reject) => {
+    fs.stat(path, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+
+function readdir(path: string): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    fs.readdir(path, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+
+function readFile(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+}
+
 export class DefaultFileSystem implements FileSystem {
-  isDirectory(pathToRead: string): boolean {
-    return fs.statSync(pathToRead).isDirectory();
+  async isDirectory(pathToRead: string): Promise<boolean> {
+    const stats = await stat(pathToRead);
+    return stats.isDirectory();
   }
 
-  readDirectory(sourceDirectory: string): string[] {
-    return fs.readdirSync(sourceDirectory);
+  readDirectory(sourceDirectory: string): Promise<string[]> {
+    return readdir(sourceDirectory);
   }
 
-  readFile(pathToRead: string): string {
-    const rawFile = fs.readFileSync(pathToRead);
-    return rawFile.toString();
+  readFile(pathToRead: string): Promise<string> {
+    return readFile(pathToRead);
   }
 
   joinPath(...paths: string[]): string {

package/src/application/file-writer.ts

@@ -3,12 +3,12 @@ import * as path from 'path';
 import { PageData } from '../core/shared/types';
 
 export class FileWriter {
-  static write(files: PageData[], outputDir: string, onWriteCallback: (file: PageData) => void) {
+  static write(files: PageData[], outputDir: string, onWriteCallback?: (file: PageData) => void) {
     files.forEach((file) => {
       const { outputDocPath, content } = this.getTargetLocation(file, outputDir);
       fs.mkdirSync(path.dirname(outputDocPath), { recursive: true });
       fs.writeFileSync(outputDocPath, content, 'utf8');
-      onWriteCallback(file);
+      onWriteCallback?.(file);
     });
   }
 

package/src/application/generators/markdown.ts

@@ -13,10 +13,18 @@ import { referenceGuideTemplate } from '../../core/markdown/templates/reference-
 import * as TE from 'fp-ts/TaskEither';
 import { isSkip } from '../../core/shared/utils';
 
-export default async function generate(bundles: UnparsedSourceFile[], config: UserDefinedMarkdownConfig) {
+class FileWritingError {
+  readonly _tag = 'FileWritingError';
+  constructor(
+    public message: string,
+    public error: unknown,
+  ) {}
+}
+
+export default function generate(bundles: UnparsedSourceFile[], config: UserDefinedMarkdownConfig) {
   return pipe(
     generateDocumentationBundle(bundles, config),
-    TE.map((files) => writeFilesToSystem(files, config.targetDir)),
+    TE.flatMap((files) => writeFilesToSystem(files, config.targetDir)),
     TE.mapLeft((error) => {
       if (error._tag === 'HookError') {
         Logger.error('Error(s) occurred while processing hooks. Please review the following issues:');
@@ -24,6 +32,12 @@ export default async function generate(bundles: UnparsedSourceFile[], config: Us
         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),
@@ -42,16 +56,17 @@ function generateDocumentationBundle(bundles: UnparsedSourceFile[], config: User
 }
 
 function writeFilesToSystem(files: PostHookDocumentationBundle, outputDir: string) {
-  FileWriter.write(
-    [files.referenceGuide, ...files.docs]
-      // Filter out any files that should be skipped
-      .filter((file) => !isSkip(file)) as PageData[],
-    outputDir,
-    () => {
-      // TODO: Don't do this here, send things back up.
-      //Logger.logSingle(`${file.outputDocPath} processed.`, 'green');
-    },
-  );
+  try {
+    FileWriter.write(
+      [files.referenceGuide, ...files.docs]
+        // Filter out any files that should be skipped
+        .filter((file) => !isSkip(file)) as PageData[],
+      outputDir,
+    );
+    return TE.right(undefined);
+  } catch (error) {
+    return TE.left(new FileWritingError('An error occurred while writing files to the system.', error));
+  }
 }
 
 function formatReflectionError(error: ReflectionError) {

package/src/util/logger.ts

@@ -1,11 +1,9 @@
 import chalk from 'chalk';
-import ora from 'ora';
 /**
  * Logs messages to the console.
  */
 export class Logger {
   static currentFrame = 0;
-  static spinner = ora();
 
   /**
    * Logs a message with optional arguments.
@@ -43,15 +41,4 @@ export class Logger {
   private static getChalkFn(color: 'green' | 'red') {
     return color === 'green' ? chalk.green : chalk.red;
   }
-
-  // TODO: This isn't really working and I don't think its worth it. Let's just completely remove the ora dependency.
-
-  public static startSpinner(text: string) {
-    this.spinner.text = text;
-    this.spinner.start();
-  }
-
-  public static succeedSpinner(text: string) {
-    this.spinner.succeed(text);
-  }
 }