fix: proper error handling in CLI (#187)

* fix: proper error handling in CLI

* test: add CLI error handling tests

Author: artus9033

packages/cli/src/brownfield/commands/packageIos.ts

@@ -47,7 +47,7 @@ export const packageIosCommand = curryOptions(
 
     options.buildFolder ??= path.join(brownieCacheDir, 'build');
 
-    packageIosAction(
+    await packageIosAction(
       options,
       {
         projectRoot,

packages/cli/src/shared/utils/__tests__/cli.test.ts

@@ -0,0 +1,62 @@
+import * as rockTools from '@rock-js/tools';
+
+import { expect, Mock, test, vi } from 'vitest';
+
+import { actionRunner } from '../cli.js';
+
+vi.mock('@rock-js/tools', async (importOriginal) => {
+  const actual = await importOriginal<typeof rockTools>();
+  return {
+    ...actual,
+    logger: {
+      ...actual.logger,
+      error: vi.fn(),
+      warn: vi.fn(),
+      info: vi.fn(),
+      success: vi.fn(),
+    },
+  };
+});
+
+// @ts-expect-error - override typings
+const processExitMock = vi.spyOn(process, 'exit').mockImplementation(() => {
+  // no-op
+});
+
+const mockLoggerError = rockTools.logger.error as Mock;
+
+const FAILING_ACTION_ERROR_MESSAGE = 'Test error';
+
+const createWrappedFailingAction = (ErrorCls: new (message: string) => Error) =>
+  actionRunner(async (_a: number, _b: number) => {
+    throw new ErrorCls(FAILING_ACTION_ERROR_MESSAGE);
+  });
+
+test('actionRunner should call the wrapped function', async () => {
+  const mockAction = vi.fn(async () => Promise.resolve());
+  const wrappedAction = actionRunner(mockAction);
+
+  await wrappedAction();
+
+  expect(mockAction).toHaveBeenCalledOnce();
+});
+
+test('actionRunner should gracefully handle Errors', async () => {
+  const wrappedActionExpectation = expect(
+    createWrappedFailingAction(Error)(1, 2)
+  );
+
+  await wrappedActionExpectation.resolves.not.toThrowError();
+  expect(processExitMock).toHaveBeenCalledExactlyOnceWith(1);
+  expect(mockLoggerError).toHaveBeenCalled();
+});
+
+test('actionRunner should gracefully handle RockErrors', async () => {
+  const wrappedActionExpectation = expect(
+    createWrappedFailingAction(rockTools.RockError)(1, 2)
+  );
+
+  await wrappedActionExpectation.resolves.not.toThrowError();
+  expect(processExitMock).toHaveBeenCalledExactlyOnceWith(1);
+  expect(mockLoggerError).toHaveBeenCalled();
+});

packages/cli/src/shared/utils/cli.ts

@@ -1,4 +1,4 @@
-import { logger, type RockCLIOptions } from '@rock-js/tools';
+import { logger, RockError, type RockCLIOptions } from '@rock-js/tools';
 
 import type { Command } from 'commander';
 
@@ -23,11 +23,25 @@ export function curryOptions(programCommand: Command, options: RockCLIOptions) {
   return programCommand;
 }
 
-function handleActionError(error: Error) {
-  logger.error(`Error running command: ${error.message}`);
-  process.exit(1);
-}
-
 export function actionRunner<T, R>(fn: (...args: T[]) => Promise<R>) {
-  return (...args: T[]) => fn(...args).catch(handleActionError);
+  return async function wrappedCLIAction(...args: T[]) {
+    try {
+      await fn(...args);
+    } catch (error) {
+      if (error instanceof RockError) {
+        if (logger.isVerbose()) {
+          logger.error(error);
+        } else {
+          logger.error(error.message);
+          if (error.cause) {
+            logger.error(`Cause: ${error.cause}`);
+          }
+        }
+      } else {
+        logger.error(`Unexpected error while running command:`, error);
+      }
+
+      process.exit(1);
+    }
+  };
 }