@cparra/apexdocs 3.19.9-beta.4 → 3.19.9-beta.5

package/dist/cli/generate.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger$1 = require('../logger-Bm8lUpMI.js');
+var errorCollector = require('../error-collector-8w5-IHGX.js');
 var cosmiconfig = require('cosmiconfig');
 var yargs = require('yargs');
 var E = require('fp-ts/Either');
@@ -79,42 +79,42 @@ const markdownOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.markdownDefaults.targetDir,
+    default: errorCollector.markdownDefaults.targetDir,
     describe: "The directory location where documentation will be generated to."
   },
   scope: {
     type: "string",
     array: true,
     alias: "p",
-    default: logger$1.markdownDefaults.scope,
+    default: errorCollector.markdownDefaults.scope,
     describe: "A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled."
   },
   customObjectVisibility: {
     type: "string",
     array: true,
     alias: "v",
-    default: logger$1.markdownDefaults.customObjectVisibility,
+    default: errorCollector.markdownDefaults.customObjectVisibility,
     choices: ["public", "protected", "packageprotected"],
     describe: "Controls which custom objects are documented. Values should be separated by a space."
   },
   defaultGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.defaultGroupName,
+    default: errorCollector.markdownDefaults.defaultGroupName,
     describe: "Defines the @group name to be used when a file does not specify it."
   },
   customObjectsGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.customObjectsGroupName,
+    default: errorCollector.markdownDefaults.customObjectsGroupName,
     describe: "The name under which custom objects will be grouped in the Reference Guide"
   },
   triggersGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.triggersGroupName,
+    default: errorCollector.markdownDefaults.triggersGroupName,
     describe: "The name under which triggers will be grouped in the Reference Guide"
   },
   lwcGroupName: {
     type: "string",
-    default: logger$1.markdownDefaults.lwcGroupName,
+    default: errorCollector.markdownDefaults.lwcGroupName,
     describe: "The name under which Lightning Web Components will be grouped in the Reference Guide"
   },
   namespace: {
@@ -124,28 +124,28 @@ const markdownOptions = {
   sortAlphabetically: {
     type: "boolean",
     describe: "Whether to sort files and members alphabetically.",
-    default: logger$1.markdownDefaults.sortAlphabetically
+    default: errorCollector.markdownDefaults.sortAlphabetically
   },
   includeMetadata: {
     type: "boolean",
     describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
-    default: logger$1.markdownDefaults.includeMetadata
+    default: errorCollector.markdownDefaults.includeMetadata
   },
   linkingStrategy: {
     type: "string",
     describe: "The strategy to use when linking to other documentation pages.",
     choices: ["relative", "no-link", "none"],
-    default: logger$1.markdownDefaults.linkingStrategy
+    default: errorCollector.markdownDefaults.linkingStrategy
   },
   referenceGuideTitle: {
     type: "string",
     describe: "The title of the reference guide.",
-    default: logger$1.markdownDefaults.referenceGuideTitle
+    default: errorCollector.markdownDefaults.referenceGuideTitle
   },
   includeFieldSecurityMetadata: {
     type: "boolean",
     describe: "Whether to include the compliance category and security classification for fields in the generated files.",
-    default: logger$1.markdownDefaults.includeFieldSecurityMetadata
+    default: errorCollector.markdownDefaults.includeFieldSecurityMetadata
   },
   includeInlineHelpTextMetadata: {
     type: "boolean",
@@ -154,17 +154,17 @@ const markdownOptions = {
   experimentalLwcSupport: {
     type: "boolean",
     describe: "Enable experimental support for documenting Lightning Web Components (LWC).",
-    default: logger$1.markdownDefaults.experimentalLwcSupport
+    default: errorCollector.markdownDefaults.experimentalLwcSupport
   },
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.markdownDefaults.parallelReflection
+    default: errorCollector.markdownDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.markdownDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.markdownDefaults.parallelReflectionMaxWorkers
   }
 };
 
@@ -200,12 +200,12 @@ const openApiOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.openApiDefaults.targetDir,
+    default: errorCollector.openApiDefaults.targetDir,
     describe: "The directory location where the OpenApi file will be generated."
   },
   fileName: {
     type: "string",
-    default: logger$1.openApiDefaults.fileName,
+    default: errorCollector.openApiDefaults.fileName,
     describe: "The name of the OpenApi file to be generated."
   },
   namespace: {
@@ -214,23 +214,23 @@ const openApiOptions = {
   },
   title: {
     type: "string",
-    default: logger$1.openApiDefaults.title,
+    default: errorCollector.openApiDefaults.title,
     describe: "The title of the OpenApi file."
   },
   apiVersion: {
     type: "string",
-    default: logger$1.openApiDefaults.apiVersion,
+    default: errorCollector.openApiDefaults.apiVersion,
     describe: "The version of the OpenApi file."
   },
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.openApiDefaults.parallelReflection
+    default: errorCollector.openApiDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.openApiDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.openApiDefaults.parallelReflectionMaxWorkers
   }
 };
 
@@ -249,12 +249,12 @@ const changeLogOptions = {
   parallelReflection: {
     type: "boolean",
     describe: "Parallelize CPU-heavy reflection via worker threads.",
-    default: logger$1.markdownDefaults.parallelReflection
+    default: errorCollector.markdownDefaults.parallelReflection
   },
   parallelReflectionMaxWorkers: {
     type: "number",
     describe: "Maximum number of worker threads to use for parallel reflection. Defaults to a reasonable value based on CPU count.",
-    default: logger$1.markdownDefaults.parallelReflectionMaxWorkers
+    default: errorCollector.markdownDefaults.parallelReflectionMaxWorkers
   },
   previousVersionDir: {
     type: "string",
@@ -273,32 +273,32 @@ const changeLogOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: logger$1.changeLogDefaults.targetDir,
+    default: errorCollector.changeLogDefaults.targetDir,
     describe: "The directory location where the changelog file will be generated."
   },
   fileName: {
     type: "string",
-    default: logger$1.changeLogDefaults.fileName,
+    default: errorCollector.changeLogDefaults.fileName,
     describe: "The name of the changelog file to be generated."
   },
   scope: {
     type: "string",
     array: true,
     alias: "s",
-    default: logger$1.changeLogDefaults.scope,
+    default: errorCollector.changeLogDefaults.scope,
     describe: "The list of scope to respect when generating the changelog. Values should be separated by a space, e.g --scope global public namespaceaccessible. Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled."
   },
   customObjectVisibility: {
     type: "string",
     array: true,
     alias: "v",
-    default: logger$1.changeLogDefaults.customObjectVisibility,
+    default: errorCollector.changeLogDefaults.customObjectVisibility,
     choices: ["public", "protected", "packageprotected"],
     describe: "Controls which custom objects are documented. Values should be separated by a space."
   },
   skipIfNoChanges: {
     type: "boolean",
-    default: logger$1.changeLogDefaults.skipIfNoChanges,
+    default: errorCollector.changeLogDefaults.skipIfNoChanges,
     describe: "Skip the changelog generation if there are no changes between the previous and current version."
   }
 };
@@ -406,13 +406,13 @@ function extractArgsForCommandProvidedThroughCli(extractFromProcessFn, config) {
   switch (mergedConfig.targetGenerator) {
     case "markdown":
       return _function.pipe(
-        logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+        errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
         E__namespace.mapLeft((error) => new Error(`Invalid markdown configuration: ${error.message}`)),
         E__namespace.map(() => __spreadValues(__spreadValues({}, configOnlyMarkdownDefaults), mergedConfig))
       );
     case "openapi":
       return _function.pipe(
-        logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+        errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
         E__namespace.mapLeft((error) => new Error(`Invalid openapi configuration: ${error.message}`)),
         E__namespace.map(() => __spreadValues(__spreadValues({}, configOnlyOpenApiDefaults), mergedConfig))
       );
@@ -440,7 +440,7 @@ function extractArgsForCommandsProvidedInConfig(extractFromProcessFn, config) {
           E__namespace.flatMap((cliArgs) => {
             const mergedConfig = __spreadValues(__spreadValues(__spreadValues({}, configOnlyMarkdownDefaults), generatorConfig), cliArgs);
             return _function.pipe(
-              logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+              errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
               E__namespace.mapLeft((error) => new Error(`Invalid markdown configuration: ${error.message}`)),
               E__namespace.map(() => mergedConfig)
             );
@@ -452,7 +452,7 @@ function extractArgsForCommandsProvidedInConfig(extractFromProcessFn, config) {
           E__namespace.flatMap((cliArgs) => {
             const mergedConfig = __spreadValues(__spreadValues(__spreadValues({}, configOnlyOpenApiDefaults), generatorConfig), cliArgs);
             return _function.pipe(
-              logger$1.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
+              errorCollector.validateSourceDirectoryConfig(extractSourceDirectoryConfig(mergedConfig)),
               E__namespace.mapLeft((error) => new Error(`Invalid openapi configuration: ${error.message}`)),
               E__namespace.map(() => mergedConfig)
             );
@@ -557,8 +557,8 @@ function validateChangelogConfig(config) {
   };
   return _function.pipe(
     E__namespace.Do,
-    E__namespace.bind("previousValid", () => logger$1.validateSourceDirectoryConfig(previousVersionConfig)),
-    E__namespace.bind("currentValid", () => logger$1.validateSourceDirectoryConfig(currentVersionConfig)),
+    E__namespace.bind("previousValid", () => errorCollector.validateSourceDirectoryConfig(previousVersionConfig)),
+    E__namespace.bind("currentValid", () => errorCollector.validateSourceDirectoryConfig(currentVersionConfig)),
     E__namespace.map(() => config)
   );
 }
@@ -586,77 +586,67 @@ var __async = (__this, __arguments, generator) => {
 function isDebugEnabledFromProcessArgs() {
   return process.argv.includes("--debug");
 }
-const logger = new logger$1.StdOutLogger();
+const logger = new errorCollector.StdOutLogger();
 logger.setDebug(isDebugEnabledFromProcessArgs());
-const reflectionDebugLogger = logger$1.createReflectionDebugLogger(logger);
 function main() {
-  const aggregatedFailures = [];
-  let aggregatedFailureCount = 0;
   let commandsRun = 0;
-  function printDebugSummary() {
-    if (!logger.isDebugEnabled()) {
+  function printFailuresAtEnd(collector, config) {
+    if (!collector.hasErrors()) {
       return;
     }
-    logger.debug(`commandsRun=${commandsRun}`);
-    logger.debug(`aggregatedFailures=${aggregatedFailureCount}`);
-  }
-  function failureToErrorItems(failure) {
-    const maybeFailureWithErrors = failure;
-    if (maybeFailureWithErrors && Array.isArray(maybeFailureWithErrors.errors)) {
-      return maybeFailureWithErrors.errors;
-    }
-    if (Array.isArray(failure)) {
-      return failure;
+    const count = collector.count();
+    logger.logSingle(
+      `\u26A0\uFE0F ${config.targetGenerator}: ${count} error item(s) occurred. Please review the following:`,
+      "red"
+    );
+    for (const item of collector.all()) {
+      logger.error(errorCollector.ErrorCollector.format(item));
     }
-    return [failure];
   }
-  function printFailuresAtEnd() {
-    if (aggregatedFailures.length === 0) {
+  function printDebugSummary(collector) {
+    if (!logger.isDebugEnabled()) {
       return;
     }
-    const flattened = aggregatedFailures.flatMap(failureToErrorItems);
-    const count = flattened.length;
-    logger.logSingle(`\u26A0\uFE0F ${count} error item(s) occurred. Please review the following issues:`, "red");
-    for (const item of flattened) {
-      logger.error(item);
-    }
-  }
-  function parseResult(result, config) {
-    E__namespace.match(
-      (failure) => {
-        logger.logSingle(`${config.targetGenerator}: completed with errors`, "red");
-        aggregatedFailures.push(failure);
-        aggregatedFailureCount += failureToErrorItems(failure).length;
-      },
-      (successMessage) => {
-        logger.logSingle(successMessage);
-      }
-    )(result);
+    logger.debug(`commandsRun=${commandsRun}`);
+    logger.debug(`aggregatedFailures=${collector.count()}`);
   }
   function catchUnexpectedError(error) {
     logger.error(`\u274C An error occurred while processing the request: ${error}`);
     process.exit(1);
   }
+  function printResultMessage(result) {
+    if (E__namespace.isRight(result)) {
+      logger.logSingle("Documentation generated successfully");
+    }
+  }
   extractArgs().then((maybeConfigs) => __async(null, null, function* () {
     E__namespace.match(catchUnexpectedError, (configs) => __async(null, null, function* () {
       for (const config of configs) {
         commandsRun++;
+        const errorCollector$1 = new errorCollector.ErrorCollector(config.targetGenerator);
+        const reflectionDebugLogger = errorCollector.createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+          errorCollector$1.addFailure("other", filePath, errorMessage);
+        });
         if (logger.isDebugEnabled()) {
           logger.debug(`Currently processing generator: ${config.targetGenerator}`);
         }
-        const result = yield logger$1.Apexdocs.generate(config, { logger, reflectionDebugLogger });
+        const result = yield errorCollector.Apexdocs.generate(config, {
+          logger,
+          reflectionDebugLogger,
+          errorCollector: errorCollector$1
+        });
+        printResultMessage(result);
         if (logger.isDebugEnabled()) {
           logger.logSingle(
             `${config.targetGenerator}: ${E__namespace.isRight(result) ? "success" : "failure"}`,
             E__namespace.isRight(result) ? "green" : "red"
           );
         }
-        parseResult(result, config);
-      }
-      printFailuresAtEnd();
-      printDebugSummary();
-      if (aggregatedFailures.length > 0) {
-        process.exitCode = 1;
+        printFailuresAtEnd(errorCollector$1, config);
+        printDebugSummary(errorCollector$1);
+        if (errorCollector$1.hasErrors()) {
+          process.exitCode = 1;
+        }
       }
     }))(maybeConfigs);
   })).catch(catchUnexpectedError);

package/dist/{logger-Bm8lUpMI.js → error-collector-8w5-IHGX.js}

@@ -3671,7 +3671,7 @@ function generateDocs(unparsedBundles, config, debugLogger) {
       const allParsed = [...apex.parsed, ...objects, ...triggers, ...lwcs];
       const sorted = sort(filterOutCustomFieldsAndMetadata(allParsed));
       if (apex.reflectionErrors.errors.length > 0) {
-        return TE__namespace.left(apex.reflectionErrors);
+        return TE__namespace.left(new ReflectionErrors([]));
       }
       return TE__namespace.right(sorted);
     }),
@@ -4854,40 +4854,31 @@ class OpenApiDocsProcessor {
   }
 }
 
-function createReflectionDebugLogger(logger) {
-  if (!logger.isDebugEnabled()) {
+function createReflectionDebugLogger(logger, recordFailure) {
+  if (!logger.isDebugEnabled() && !recordFailure) {
     return noopReflectionDebugLogger;
   }
   return {
     onStart: (filePath) => {
-      logger.debug(`Parsing: ${filePath}...`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath}...`);
+      }
     },
     onSuccess: (filePath) => {
-      logger.debug(`Parsing: ${filePath} OK`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath} OK`);
+      }
     },
     onFailure: (filePath, errorMessage) => {
-      logger.debug(`Parsing: ${filePath} FAILED`);
-      logger.debug(`Parsing error: ${filePath} - ${errorMessage}`);
+      if (logger.isDebugEnabled()) {
+        logger.debug(`Parsing: ${filePath} FAILED`);
+        logger.debug(`Parsing error: ${filePath} - ${errorMessage}`);
+      }
+      recordFailure == null ? void 0 : recordFailure(filePath, errorMessage);
     }
   };
 }
 
-var __defProp$2 = Object.defineProperty;
-var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$2.call(b, prop))
-      __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b)) {
-      if (__propIsEnum$2.call(b, prop))
-        __defNormalProp$2(a, prop, b[prop]);
-    }
-  return a;
-};
 var __async$2 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -4908,7 +4899,7 @@ var __async$2 = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-function openApi(logger, fileBodies, config) {
+function openApi(logger, fileBodies, config, errorCollector) {
   return __async$2(this, null, function* () {
     const sourceDirectory = (Array.isArray(config.sourceDir) ? config.sourceDir[0] : config.sourceDir) || (fileBodies.length > 0 ? fileBodies[0].filePath.split("/").slice(0, -1).join("/") : process.cwd());
     OpenApiSettings.build({
@@ -4919,7 +4910,9 @@ function openApi(logger, fileBodies, config) {
       namespace: config.namespace,
       version: config.apiVersion
     });
-    const debugLogger = createReflectionDebugLogger(logger);
+    const debugLogger = createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+      errorCollector.addFailure("apex", filePath, errorMessage);
+    });
     const reflectedEither = yield reflectApexSourceBestEffort(
       fileBodies,
       {
@@ -4937,11 +4930,6 @@ function openApi(logger, fileBodies, config) {
         `\u26A0\uFE0F ${recoverableErrors.errors.length} file(s) failed to parse/reflect. Continuing with successfully reflected files.`,
         "red"
       );
-      logger.error(
-        new ReflectionErrors(
-          recoverableErrors.errors.map((e) => __spreadValues$2({}, e))
-        )
-      );
     }
     const reflectionByPath = /* @__PURE__ */ new Map();
     for (const parsed of parsedFiles) {
@@ -4975,11 +4963,12 @@ function openApi(logger, fileBodies, config) {
     }
     ErrorLogger.logErrors(logger, filteredTypes);
     if (recoverableErrors.errors.length > 0) {
-      return E__namespace.left(
-        new ReflectionErrors(
-          recoverableErrors.errors.map((e) => __spreadValues$2({}, e))
-        )
+      errorCollector.addGlobalFailure(
+        "other",
+        `OpenAPI generation completed with ${recoverableErrors.errors.length} reflection error item(s).`,
+        recoverableErrors
       );
+      return E__namespace.left(new ReflectionErrors([]));
     }
     return E__namespace.right(void 0);
   });
@@ -5598,21 +5587,21 @@ function changelogToSourceChangelog(changelog) {
   };
 }
 
-var __defProp$1 = Object.defineProperty;
+var __defProp$2 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
 var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
@@ -5743,11 +5732,14 @@ function generateChangeLog(oldBundles, newBundles, config, debugLogger) {
       page: postHookCompile(page),
       combinedReflectionErrors
     })),
-    // Fail at the very end if we had any recoverable Apex reflection errors,
-    // so the CLI can present them after completing the work.
+    // Fail at the very end if we had any recoverable reflection errors,
+    // so the CLI can set an exit code after completing the work.
+    //
+    // We intentionally do NOT propagate individual error item details here.
+    // Those are recorded via the per-generator ErrorCollector as they happen.
     TE__namespace.flatMap(({ page, combinedReflectionErrors }) => {
       if (combinedReflectionErrors.errors.length > 0) {
-        return TE__namespace.left(combinedReflectionErrors);
+        return TE__namespace.left(new ReflectionErrors([]));
       }
       return TE__namespace.right(page);
     })
@@ -5773,7 +5765,7 @@ function compile(translations) {
   return (renderable) => {
     const compilationRequest = {
       template: changelogTemplate,
-      source: __spreadProps$1(__spreadValues$1({}, renderable), {
+      source: __spreadProps$1(__spreadValues$2({}, renderable), {
         title: translations.changelog.title
       })
     };
@@ -5799,14 +5791,14 @@ function transformChangelogPage(_0) {
     if (isSkip(page)) {
       return page;
     }
-    return __spreadValues$1(__spreadValues$1({}, page), yield hook(page));
+    return __spreadValues$2(__spreadValues$2({}, page), yield hook(page));
   });
 }
 function postHookCompile(page) {
   if (isSkip(page)) {
     return page;
   }
-  return __spreadProps$1(__spreadValues$1({}, page), {
+  return __spreadProps$1(__spreadValues$2({}, page), {
     content: Template.getInstance().compile({
       source: {
         frontmatter: toFrontmatterString(page.frontmatter),
@@ -5837,21 +5829,21 @@ function writeFilesToSystem(pageData, outputDir) {
   );
 }
 
-var __defProp = Object.defineProperty;
+var __defProp$1 = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
     }
   return a;
 };
@@ -6045,7 +6037,7 @@ function processFiles(fileSystem, config) {
         (components) => {
           return components.map((component) => {
             const pathLocation = component.type.name === "ApexClass" ? component.content : component.xml;
-            return __spreadProps(__spreadValues({}, component), {
+            return __spreadProps(__spreadValues$1({}, component), {
               filePath: pathLocation
             });
           });
@@ -6243,15 +6235,15 @@ class Apexdocs {
    */
   static generate(config, deps) {
     return __async(this, null, function* () {
-      const { logger, reflectionDebugLogger } = deps;
+      const { logger, reflectionDebugLogger, errorCollector } = deps;
       logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
       try {
         switch (config.targetGenerator) {
           case "markdown": {
-            return (yield processMarkdown(config, logger, reflectionDebugLogger))();
+            return (yield processMarkdown(config, logger, reflectionDebugLogger, errorCollector))();
           }
           case "openapi": {
-            const task = yield processOpenApi(config, logger);
+            const task = yield processOpenApi(config, logger, errorCollector);
             const openApiResult = yield task();
             if (E__namespace.isLeft(openApiResult)) {
               return E__namespace.left([openApiResult.left]);
@@ -6259,48 +6251,58 @@ class Apexdocs {
             return E__namespace.right("\u2714\uFE0F Documentation generated successfully!");
           }
           case "changelog": {
-            return (yield processChangeLog(config, logger, reflectionDebugLogger))();
+            return (yield processChangeLog(config, logger, reflectionDebugLogger, errorCollector))();
           }
         }
       } catch (error) {
+        errorCollector.addGlobalFailure("other", String(error), error);
         return E__namespace.left([error]);
       }
     });
   }
 }
 const readFiles = apply(processFiles, new DefaultFileSystem());
-function processMarkdown(config, logger, reflectionDebugLogger) {
+function processMarkdown(config, logger, reflectionDebugLogger, errorCollector) {
   return __async(this, null, function* () {
     const debugLogger = reflectionDebugLogger;
     return _function.pipe(
       resolveAndValidateSourceDirectories(config),
-      E__namespace.mapLeft((error) => new FileReadingError(`Failed to resolve source directories: ${error.message}`, error)),
+      E__namespace.mapLeft((error) => {
+        errorCollector.addGlobalFailure("read", `Failed to resolve source directories: ${error.message}`, error);
+        return new FileReadingError(`Failed to resolve source directories: ${error.message}`, error);
+      }),
       E__namespace.flatMap(
         (sourceDirs) => E__namespace.tryCatch(
           () => readFiles({ experimentalLwcSupport: config.experimentalLwcSupport })(allComponentTypes, {
             includeMetadata: config.includeMetadata
           })(sourceDirs, config.exclude),
-          (e) => new FileReadingError("An error occurred while reading files.", e)
+          (e) => {
+            errorCollector.addGlobalFailure("read", "An error occurred while reading files.", e);
+            return new FileReadingError("An error occurred while reading files.", e);
+          }
         )
       ),
       TE__namespace.fromEither,
       TE__namespace.flatMap((fileBodies) => generate$1(fileBodies, config, debugLogger)),
       TE__namespace.map(() => "\u2714\uFE0F Documentation generated successfully!"),
       TE__namespace.mapLeft((err) => {
-        const errors = toErrors(err);
+        errorCollector.addGlobalFailure("other", "Markdown generation completed with errors.", err);
         if (logger.isDebugEnabled()) {
-          logger.debug(`markdown generator finished with ${Array.isArray(errors) ? errors.length : 1} error item(s)`);
+          logger.debug(`markdown generator finished with errors (see collector for details)`);
         }
-        return errors;
+        return toErrors(err);
       })
     );
   });
 }
-function processOpenApi(config, logger) {
+function processOpenApi(config, logger, errorCollector) {
   return __async(this, null, function* () {
     return _function.pipe(
       resolveAndValidateSourceDirectories(config),
-      E__namespace.mapLeft((error) => new FileReadingError(`Failed to resolve source directories: ${error.message}`, error)),
+      E__namespace.mapLeft((error) => {
+        errorCollector.addGlobalFailure("read", `Failed to resolve source directories: ${error.message}`, error);
+        return new FileReadingError(`Failed to resolve source directories: ${error.message}`, error);
+      }),
       TE__namespace.fromEither,
       TE__namespace.flatMap(
         (sourceDirs) => TE__namespace.tryCatch(
@@ -6309,15 +6311,18 @@ function processOpenApi(config, logger) {
               sourceDirs,
               config.exclude
             );
-            return openApi(logger, fileBodies, config);
+            return openApi(logger, fileBodies, config, errorCollector);
           },
-          (e) => new FileReadingError("An error occurred while generating OpenAPI documentation.", e)
+          (e) => {
+            errorCollector.addGlobalFailure("other", "An error occurred while generating OpenAPI documentation.", e);
+            return new FileReadingError("An error occurred while generating OpenAPI documentation.", e);
+          }
         )
       )
     );
   });
 }
-function processChangeLog(config, logger, reflectionDebugLogger) {
+function processChangeLog(config, logger, reflectionDebugLogger, errorCollector) {
   return __async(this, null, function* () {
     function loadFiles() {
       const previousVersionConfig = {
@@ -6332,24 +6337,47 @@ function processChangeLog(config, logger, reflectionDebugLogger) {
           "previousVersionDirs",
           () => _function.pipe(
             resolveAndValidateSourceDirectories(previousVersionConfig),
-            E__namespace.mapLeft(
-              (error) => new FileReadingError(`Failed to resolve previous version source directories: ${error.message}`, error)
-            )
+            E__namespace.mapLeft((error) => {
+              errorCollector.addGlobalFailure(
+                "read",
+                `Failed to resolve previous version source directories: ${error.message}`,
+                error
+              );
+              return new FileReadingError(
+                `Failed to resolve previous version source directories: ${error.message}`,
+                error
+              );
+            })
           )
         ),
         E__namespace.bind(
           "currentVersionDirs",
           () => _function.pipe(
             resolveAndValidateSourceDirectories(currentVersionConfig),
-            E__namespace.mapLeft(
-              (error) => new FileReadingError(`Failed to resolve current version source directories: ${error.message}`, error)
-            )
+            E__namespace.mapLeft((error) => {
+              errorCollector.addGlobalFailure(
+                "read",
+                `Failed to resolve current version source directories: ${error.message}`,
+                error
+              );
+              return new FileReadingError(
+                `Failed to resolve current version source directories: ${error.message}`,
+                error
+              );
+            })
           )
         ),
-        E__namespace.map(({ previousVersionDirs, currentVersionDirs }) => [
-          readFiles({ experimentalLwcSupport: false })(allComponentTypes)(previousVersionDirs, config.exclude),
-          readFiles({ experimentalLwcSupport: false })(allComponentTypes)(currentVersionDirs, config.exclude)
-        ])
+        E__namespace.map(({ previousVersionDirs, currentVersionDirs }) => {
+          const previous = readFiles({ experimentalLwcSupport: false })(allComponentTypes)(
+            previousVersionDirs,
+            config.exclude
+          );
+          const current = readFiles({ experimentalLwcSupport: false })(allComponentTypes)(
+            currentVersionDirs,
+            config.exclude
+          );
+          return [previous, current];
+        })
       );
     }
     return _function.pipe(
@@ -6357,11 +6385,11 @@ function processChangeLog(config, logger, reflectionDebugLogger) {
       TE__namespace.fromEither,
       TE__namespace.flatMap(([previous, current]) => generate(previous, current, config, reflectionDebugLogger)),
       TE__namespace.mapLeft((err) => {
-        const errors = toErrors(err);
+        errorCollector.addGlobalFailure("other", "Changelog generation completed with errors.", err);
         if (logger.isDebugEnabled()) {
-          logger.debug(`changelog generator finished with ${Array.isArray(errors) ? errors.length : 1} error item(s)`);
+          logger.debug(`changelog generator finished with errors (see collector for details)`);
         }
-        return errors;
+        return toErrors(err);
       })
     );
   });
@@ -6452,7 +6480,98 @@ class NoLogger {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class ErrorCollector {
+  constructor(generator) {
+    this.items = [];
+    // Basic de-dupe to avoid double-recording the same failure if the same layer reports it twice.
+    // Keyed by generator|stage|filePath|message.
+    this.seen = /* @__PURE__ */ new Set();
+    this.generator = generator;
+  }
+  add(item) {
+    var _a, _b, _c;
+    const fullItem = __spreadValues({
+      generator: this.generator,
+      at: (_a = item.at) != null ? _a : (/* @__PURE__ */ new Date()).toISOString()
+    }, item);
+    const key = [
+      fullItem.generator,
+      fullItem.stage,
+      (_b = fullItem.filePath) != null ? _b : "",
+      // Normalize whitespace a bit so trivial formatting differences don't explode the log.
+      ((_c = fullItem.message) != null ? _c : "").trim().replace(/\s+/g, " ")
+    ].join("|");
+    if (this.seen.has(key)) {
+      return;
+    }
+    this.seen.add(key);
+    this.items.push(fullItem);
+  }
+  addFailure(stage, filePath, message, raw) {
+    this.add({
+      stage,
+      filePath,
+      message,
+      raw
+    });
+  }
+  addGlobalFailure(stage, message, raw) {
+    this.add({
+      stage,
+      message,
+      raw
+    });
+  }
+  hasErrors() {
+    return this.items.length > 0;
+  }
+  /** Count of collected error items (post de-duplication). */
+  count() {
+    return this.items.length;
+  }
+  all() {
+    return this.items;
+  }
+  /**
+   * Groups error items by file path. Items with no file path are grouped under `__global__`.
+   */
+  groupByFilePath() {
+    return this.items.reduce((acc, item) => {
+      var _a, _b;
+      const key = (_a = item.filePath) != null ? _a : "__global__";
+      acc[key] = (_b = acc[key]) != null ? _b : [];
+      acc[key].push(item);
+      return acc;
+    }, {});
+  }
+  /**
+   * A compact human-readable representation of the error item.
+   * Useful for CLI output.
+   */
+  static format(item) {
+    const location = item.filePath ? `${item.filePath}` : "(no file)";
+    return `[${item.generator}/${item.stage}] ${location}: ${item.message}`;
+  }
+}
+
 exports.Apexdocs = Apexdocs;
+exports.ErrorCollector = ErrorCollector;
 exports.NoLogger = NoLogger;
 exports.StdOutLogger = StdOutLogger;
 exports.changeLogDefaults = changeLogDefaults;

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger = require('./logger-Bm8lUpMI.js');
+var errorCollector = require('./error-collector-8w5-IHGX.js');
 var E = require('fp-ts/Either');
 require('fp-ts/function');
 require('fp-ts/TaskEither');
@@ -82,15 +82,26 @@ var __async = (__this, __arguments, generator) => {
 };
 function process(config) {
   return __async(this, null, function* () {
-    const logger$1 = new logger.NoLogger();
-    const reflectionDebugLogger = logger.createReflectionDebugLogger(logger$1);
+    const logger = new errorCollector.NoLogger();
     const configWithDefaults = __spreadValues$1(__spreadValues$1({}, getDefault(config)), config);
     if (!configWithDefaults.sourceDir) {
       throw new Error("sourceDir is required");
     }
-    const result = yield logger.Apexdocs.generate(configWithDefaults, { logger: logger$1, reflectionDebugLogger });
+    const errorCollector$1 = new errorCollector.ErrorCollector(configWithDefaults.targetGenerator);
+    const reflectionDebugLogger = errorCollector.createReflectionDebugLogger(logger, (filePath, errorMessage) => {
+      errorCollector$1.addFailure("other", filePath, errorMessage);
+    });
+    const result = yield errorCollector.Apexdocs.generate(configWithDefaults, {
+      logger,
+      reflectionDebugLogger,
+      errorCollector: errorCollector$1
+    });
     E__namespace.match(
       (errors) => {
+        if (errorCollector$1.hasErrors()) {
+          const details = errorCollector$1.all().map(errorCollector.ErrorCollector.format).join("\n");
+          throw new Error(details);
+        }
         throw errors;
       },
       () => {
@@ -101,11 +112,11 @@ function process(config) {
 function getDefault(config) {
   switch (config.targetGenerator) {
     case "markdown":
-      return logger.markdownDefaults;
+      return errorCollector.markdownDefaults;
     case "openapi":
-      return logger.openApiDefaults;
+      return errorCollector.openApiDefaults;
     case "changelog":
-      return logger.changeLogDefaults;
+      return errorCollector.changeLogDefaults;
     default:
       throw new Error("Unknown target generator");
   }
@@ -131,23 +142,23 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 function defineMarkdownConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.markdownDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.markdownDefaults), config), {
     targetGenerator: "markdown"
   });
 }
 function defineOpenApiConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.openApiDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.openApiDefaults), config), {
     targetGenerator: "openapi"
   });
 }
 function defineChangelogConfig(config) {
-  return __spreadProps(__spreadValues(__spreadValues({}, logger.changeLogDefaults), config), {
+  return __spreadProps(__spreadValues(__spreadValues({}, errorCollector.changeLogDefaults), config), {
     targetGenerator: "changelog"
   });
 }
 
-exports.skip = logger.skip;
-exports.templateHelpers = logger.templateHelpers;
+exports.skip = errorCollector.skip;
+exports.templateHelpers = errorCollector.templateHelpers;
 exports.defineChangelogConfig = defineChangelogConfig;
 exports.defineMarkdownConfig = defineMarkdownConfig;
 exports.defineOpenApiConfig = defineOpenApiConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.19.9-beta.4",
+  "version": "3.19.9-beta.5",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "engines": {
     "node": ">=18"