fix: add logic to handle multiple errors returned from api call

Author: EstebanRomero84

src/SfCommandError.ts

@@ -7,7 +7,7 @@
 import { inspect } from 'node:util';
 import { SfError, StructuredMessage } from '@salesforce/core';
 import { AnyJson } from '@salesforce/ts-types';
-import { computeErrorCode } from './errorHandling.js';
+import { computeErrorCode, computeErrorData } from './errorHandling.js';
 
 // These types are 90% the same as SfErrorOptions (but they aren't exported to extend)
 type ErrorDataProperties = AnyJson;
@@ -75,7 +75,7 @@ export class SfCommandError extends SfError {
       code: 'code' in err && err.code ? err.code : exitCode.toString(10),
       cause: sfError.cause,
       commandName: 'commandName' in err ? err.commandName : commandName,
-      data: 'data' in err ? err.data : undefined,
+      data: computeErrorData(err),
       result: 'result' in err ? err.result : undefined,
       context: 'context' in err ? err.context : commandName,
       warnings,

src/errorFormatting.ts

@@ -10,6 +10,7 @@ import type { Ansis } from 'ansis';
 import { Mode, Messages, envVars } from '@salesforce/core';
 import { StandardColors } from './ux/standardColors.js';
 import { SfCommandError } from './SfCommandError.js';
+import { Ux } from './ux/ux.js';
 
 Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
 const messages = Messages.loadMessages('@salesforce/sf-plugins-core', 'messages');
@@ -44,6 +45,7 @@ export const formatActions = (
 export const formatError = (error: SfCommandError): string =>
   [
     `${formatErrorPrefix(error)} ${error.message}`,
+    ...formatMultipleErrorMessages(error),
     ...formatActions(error.actions ?? []),
     error.stack && envVars.getString('SF_ENV') === Mode.DEVELOPMENT
       ? StandardColors.info(`\n*** Internal Diagnostic ***\n\n${inspect(error)}\n******\n`)
@@ -55,3 +57,25 @@ const formatErrorPrefix = (error: SfCommandError): string =>
 
 const formatErrorCode = (error: SfCommandError): string =>
   typeof error.code === 'string' || typeof error.code === 'number' ? ` (${error.code})` : '';
+
+const formatMultipleErrorMessages = (error: SfCommandError): string[] => {
+  if (!error.data || !Array.isArray(error.data) || error.data.length === 0) {
+    return [];
+  }
+
+  const errorData = error.data.map((d) => ({
+    errorCode: (d as { errorCode: string }).errorCode || '',
+    message: (d as { message: string }).message || '',
+  }));
+
+  const ux = new Ux();
+  return [
+    ux.makeTable({
+      data: errorData,
+      columns: [
+        { key: 'errorCode', name: 'Error Code' },
+        { key: 'message', name: 'Message' },
+      ],
+    }),
+  ];
+};

src/errorHandling.ts

@@ -7,6 +7,7 @@
 
 import { SfError } from '@salesforce/core/sfError';
 import { Errors } from '@oclif/core';
+import { AnyJson } from '@salesforce/ts-types';
 
 /**
  *
@@ -44,6 +45,27 @@ export const computeErrorCode = (e: Error | SfError | Errors.CLIError): number =
   return typeof process.exitCode === 'number' ? process.exitCode : 1;
 };
 
+/**
+ * Computes and extracts error data from different error types.
+ *
+ * 1. If the error has a 'data' property with a value, returns that data
+ * 2. If the error has a 'cause' property with a value:
+ *    - If the cause has a 'data' property, returns cause.data
+ *    - If not, returns undefined
+ * 3. If none of the above conditions are met, returns undefined
+ *
+ * @param e - The error object to extract data from. Can be a standard Error, SfError, or CLIError
+ * @returns The extracted data as AnyJson or undefined if no data is found
+ */
+export const computeErrorData = (e: Error | SfError | Errors.CLIError): AnyJson | undefined =>
+  'data' in e && e.data
+    ? e.data
+    : 'cause' in e && e.cause
+    ? 'data' in (e.cause as { data: AnyJson | undefined })
+      ? (e.cause as { data: AnyJson | undefined }).data
+      : undefined
+    : undefined;
+
 /** identifies gacks via regex.  Searches the error message, stack, and recursively checks the cause chain */
 export const errorIsGack = (error: Error | SfError): boolean => {
   /** see test for samples  */

test/unit/errorFormatting.test.ts

@@ -79,4 +79,23 @@ describe('errorFormatting.formatError()', () => {
     expect(errorOutput).to.contain('warnings: undefined');
     expect(errorOutput).to.contain('result: undefined');
   });
+
+  it('should have correct output for multiple errors in table format ', () => {
+    const sfError = SfError.create({
+      name: 'myError',
+      message: 'foo',
+      actions: ['bar'],
+      context: 'myContext',
+      exitCode: 8,
+      data: [
+        { errorCode: 'ERROR_1', message: 'error 1' },
+        { errorCode: 'ERROR_2', message: 'error 2' },
+      ],
+    });
+    const err = SfCommandError.from(sfError, 'thecommand');
+    const errorOutput = formatError(err);
+    expect(errorOutput).to.match(/Error Code.+Message/);
+    expect(errorOutput).to.match(/ERROR_1.+error 1/);
+    expect(errorOutput).to.match(/ERROR_2.+error 2/);
+  });
 });

test/unit/errorHandling.test.ts

@@ -6,7 +6,9 @@
  */
 import { expect } from 'chai';
 import { SfError } from '@salesforce/core/sfError';
-import { computeErrorCode, errorIsGack, errorIsTypeError } from '../../src/errorHandling.js';
+import { AnyJson } from '@salesforce/ts-types';
+import { Errors } from '@oclif/core';
+import { computeErrorCode, computeErrorData, errorIsGack, errorIsTypeError } from '../../src/errorHandling.js';
 import { SfCommandError } from '../../src/SfCommandError.js';
 
 describe('typeErrors', () => {
@@ -197,3 +199,52 @@ describe('SfCommandError.toJson()', () => {
     });
   });
 });
+
+describe('computeErrorData', () => {
+  interface ErrorWithData extends Error {
+    data?: AnyJson;
+  }
+
+  it('should return data from error.data when present', () => {
+    const sfError = SfError.create({
+      name: 'myError',
+      message: 'foo',
+      actions: ['bar'],
+      context: 'myContext',
+      exitCode: 8,
+      data: { foo: 'bar' },
+    });
+    expect(computeErrorData(sfError)).to.deep.equal({ foo: 'bar' });
+  });
+
+  it('should return cause.data when error.data is not present but cause.data is', () => {
+    const sfError = SfError.create({
+      name: 'myError',
+      message: 'foo',
+      actions: ['bar'],
+      context: 'myContext',
+      exitCode: 8,
+    });
+    const err: ErrorWithData = { name: 'testError', message: 'baz', data: { foo: 'baz' } };
+    sfError.cause = err;
+    expect(computeErrorData(sfError)).to.deep.equal({ foo: 'baz' });
+  });
+
+  it('should return undefined when no data or cause is present', () => {
+    const error = new Error('test error') as ErrorWithData;
+    expect(computeErrorData(error)).to.be.undefined;
+  });
+
+  it('should handle SfError with data', () => {
+    const error = new SfError('test error', 'TestError', [], 1, undefined);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    (error as any).data = { foo: 'bar' };
+    expect(computeErrorData(error)).to.deep.equal({ foo: 'bar' });
+  });
+
+  it('should handle CLIError with data', () => {
+    const err = new Errors.CLIError('Nonexistent flag: --INVALID\nSee more help with --help') as ErrorWithData;
+    err.data = { foo: 'bar' };
+    expect(computeErrorData(err)).to.deep.equal({ foo: 'bar' });
+  });
+});