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

package/dist/cli/generate.js

@@ -1525,7 +1525,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 {
@@ -1577,7 +1577,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
@@ -1598,8 +1598,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);
   }));
@@ -1609,24 +1609,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) {
@@ -2797,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);
@@ -2875,7 +2962,11 @@ class Apexdocs {
     return __async$1(this, null, function* () {
       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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.8",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",

package/src/application/Apexdocs.ts

@@ -17,7 +17,11 @@ export class Apexdocs {
     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':

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 {