@openmrs/esm-error-handling 10.0.1-pre.5664 → 10.0.1-pre.5670

package/.turbo/turbo-build.log

@@ -1 +1 @@
-Successfully compiled: 1 file with swc (201.53ms)
+Successfully compiled: 1 file with swc (223.09ms)

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,QAKvC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,KAExB,aAAa,OAAO,UAK7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,QAKvC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,KAExB,aAAa,OAAO,UAK7B"}

package/dist/index.js

@@ -5,7 +5,7 @@
 window.onerror = function(message, _source, _lineno, _colno, error) {
     console.error('Unexpected error: ', error ?? message);
     dispatchToastShown({
-        description: getErrorMessage(error ?? message, 'Oops! An unexpected error occurred.'),
+        description: toToastDescription(error, 'Oops! An unexpected error occurred.'),
         kind: 'error',
         title: 'Error'
     });
@@ -14,27 +14,18 @@ window.onerror = function(message, _source, _lineno, _colno, error) {
 window.onunhandledrejection = function(event) {
     console.error('Unhandled rejection: ', event.reason);
     dispatchToastShown({
-        // `event.reason` is whatever the promise rejected with, frequently an Error
-        // object. `showToast` expects `description` to be a renderable, non-empty
-        // value, so resolve it to a string message rather than passing the raw
-        // rejection (which renders as "[object Object]" and fails the non-empty check).
-        description: getErrorMessage(event.reason, 'Oops! An unhandled promise rejection occurred.'),
+        description: toToastDescription(event.reason, 'Oops! An unhandled promise rejection occurred.'),
         kind: 'error',
         title: 'Error'
     });
 };
 /**
- * Resolves an arbitrary thrown/rejected value to a user-facing, non-empty
- * message string suitable for use as a toast description, falling back to the
- * provided message when no usable message can be derived.
- */ function getErrorMessage(reason, fallback) {
-    if (reason instanceof Error) {
-        return reason.message || fallback;
-    }
-    if (typeof reason === 'string' && reason.trim().length > 0) {
-        return reason;
-    }
-    return fallback;
+ * Tries to turn whatever reached the global error handler into
+ * a sensible string, returning the caller's fallback if a non-empty
+ * string could not be constructed.
+ */ function toToastDescription(thing, fallback) {
+    const { message } = ensureErrorObject(thing);
+    return typeof message === 'string' && message ? message : fallback;
 }
 /**
  * Reports an error to the global error handler. The error will be displayed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-error-handling",
-  "version": "10.0.1-pre.5664",
+  "version": "10.0.1-pre.5670",
   "license": "MPL-2.0",
   "description": "An ES module to help with error handling",
   "type": "module",
@@ -46,10 +46,10 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@openmrs/esm-globals": "^10.0.1-pre.5664"
+    "@openmrs/esm-globals": "^10.0.1-pre.5670"
   },
   "devDependencies": {
-    "@openmrs/esm-globals": "10.0.1-pre.5664",
+    "@openmrs/esm-globals": "10.0.1-pre.5670",
     "@swc/cli": "0.8.1",
     "@swc/core": "1.15.21",
     "@vitest/coverage-v8": "^4.1.2",

package/src/index.ts

@@ -7,7 +7,7 @@ import { dispatchToastShown } from '@openmrs/esm-globals';
 window.onerror = function (message, _source, _lineno, _colno, error) {
   console.error('Unexpected error: ', error ?? message);
   dispatchToastShown({
-    description: getErrorMessage(error ?? message, 'Oops! An unexpected error occurred.'),
+    description: toToastDescription(error, 'Oops! An unexpected error occurred.'),
     kind: 'error',
     title: 'Error',
   });
@@ -17,31 +17,20 @@ window.onerror = function (message, _source, _lineno, _colno, error) {
 window.onunhandledrejection = function (event: PromiseRejectionEvent) {
   console.error('Unhandled rejection: ', event.reason);
   dispatchToastShown({
-    // `event.reason` is whatever the promise rejected with, frequently an Error
-    // object. `showToast` expects `description` to be a renderable, non-empty
-    // value, so resolve it to a string message rather than passing the raw
-    // rejection (which renders as "[object Object]" and fails the non-empty check).
-    description: getErrorMessage(event.reason, 'Oops! An unhandled promise rejection occurred.'),
+    description: toToastDescription(event.reason, 'Oops! An unhandled promise rejection occurred.'),
     kind: 'error',
     title: 'Error',
   });
 };
 
 /**
- * Resolves an arbitrary thrown/rejected value to a user-facing, non-empty
- * message string suitable for use as a toast description, falling back to the
- * provided message when no usable message can be derived.
+ * Tries to turn whatever reached the global error handler into
+ * a sensible string, returning the caller's fallback if a non-empty
+ * string could not be constructed.
  */
-function getErrorMessage(reason: unknown, fallback: string): string {
-  if (reason instanceof Error) {
-    return reason.message || fallback;
-  }
-
-  if (typeof reason === 'string' && reason.trim().length > 0) {
-    return reason;
-  }
-
-  return fallback;
+function toToastDescription(thing: unknown, fallback: string) {
+  const { message } = ensureErrorObject(thing);
+  return typeof message === 'string' && message ? message : fallback;
 }
 
 /**

package/src/openmrs-esm-error-handling.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { beforeEach, describe, it, expect, vi } from 'vitest';
 import { dispatchToastShown } from '@openmrs/esm-globals';
 import { reportError } from './index';
 
@@ -10,6 +10,33 @@ vi.useFakeTimers();
 
 const mockDispatchToastShown = vi.mocked(dispatchToastShown);
 
+function errorWithObjectMessage() {
+  const error = new Error('replaced below');
+  (error as unknown as { message: unknown }).message = { nested: 'value' };
+  return error;
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+
+/**
+ * The shapes a thrown value can take when it reaches the global handlers, as the `error`
+ * argument of `window.onerror` or as `event.reason` in `window.onunhandledrejection`.
+ * `null` in `expected` means the handler's fallback text is expected.
+ */
+const errorShapes: Array<{ label: string; reason: unknown; expected: string | null }> = [
+  { label: 'an Error instance', reason: new Error('something exploded'), expected: 'something exploded' },
+  { label: 'an Error with an empty message', reason: new Error(''), expected: null },
+  { label: 'a string', reason: 'something failed', expected: 'something failed' },
+  { label: 'a plain object', reason: { foo: 'bar' }, expected: 'Object thrown as error: {"foo":"bar"}' },
+  { label: 'null', reason: null, expected: "'null' was thrown as an error" },
+  { label: 'undefined', reason: undefined, expected: "'undefined' was thrown as an error" },
+  // `Error#message` is writable, so an Error can reach the handlers carrying a non-string message.
+  // `ensureErrorObject()` passes such an Error through untouched, so the guard has to be downstream.
+  { label: 'an Error whose message is not a string', reason: errorWithObjectMessage(), expected: null },
+];
+
 describe('error handler', () => {
   it('transforms non-Error inputs into valid Error objects', () => {
     expect(() => {
@@ -34,40 +61,38 @@ describe('error handler', () => {
   });
 });
 
-describe('window.onunhandledrejection', () => {
-  beforeEach(() => {
-    mockDispatchToastShown.mockClear();
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
+describe('Global error handler', () => {
+  // Browsers call `window.onerror` with the message first and the thrown value fifth.
+  function triggerOnError(error: unknown) {
+    window.onerror?.('Uncaught error', undefined, undefined, undefined, error as Error);
+  }
 
-  // The handler only reads `event.reason`, so a minimal stand-in avoids
-  // constructing a real (and itself-unhandled) PromiseRejectionEvent.
-  const fireRejection = (reason: unknown) => window.onunhandledrejection?.({ reason } as PromiseRejectionEvent);
+  const fallback = 'Oops! An unexpected error occurred.';
 
-  it('shows a toast with the Error message as a string description', () => {
-    fireRejection(new Error('Something broke'));
+  it.each(errorShapes)('shows a string description for $label', ({ reason, expected }) => {
+    triggerOnError(reason);
 
-    expect(mockDispatchToastShown).toHaveBeenCalledWith(
-      expect.objectContaining({ description: 'Something broke', kind: 'error', title: 'Error' }),
-    );
-    expect(typeof mockDispatchToastShown.mock.calls[0][0].description).toBe('string');
+    expect(mockDispatchToastShown).toHaveBeenCalledOnce();
+    const { description } = mockDispatchToastShown.mock.calls[0][0];
+    // The regression itself: an object here is unrenderable as a React child, so the toast never appears.
+    expect(typeof description).toBe('string');
+    expect(description).toBe(expected ?? fallback);
   });
+});
 
-  it('shows a string reason directly', () => {
-    fireRejection('plain string reason');
+describe('Global rejection handler', () => {
+  function triggerOnUnhandledRejection(reason: unknown) {
+    (window.onunhandledrejection as (event: PromiseRejectionEvent) => void)({ reason } as PromiseRejectionEvent);
+  }
 
-    expect(mockDispatchToastShown).toHaveBeenCalledWith(
-      expect.objectContaining({ description: 'plain string reason' }),
-    );
-  });
+  const fallback = 'Oops! An unhandled promise rejection occurred.';
+
+  it.each(errorShapes)('shows a string description for $label', ({ reason, expected }) => {
+    triggerOnUnhandledRejection(reason);
 
-  it('falls back to a friendly message for empty/non-string reasons', () => {
-    for (const reason of [undefined, null, new Error(''), { some: 'object' }]) {
-      mockDispatchToastShown.mockClear();
-      fireRejection(reason);
-      expect(mockDispatchToastShown.mock.calls[0][0].description).toBe(
-        'Oops! An unhandled promise rejection occurred.',
-      );
-    }
+    expect(mockDispatchToastShown).toHaveBeenCalledOnce();
+    const { description } = mockDispatchToastShown.mock.calls[0][0];
+    expect(typeof description).toBe('string');
+    expect(description).toBe(expected ?? fallback);
   });
 });