npm - @open-kingdom/shared-frontend-feature-error-autologger - Versions diffs - 0.0.2-14 → 0.0.2-16 - Mend

@open-kingdom/shared-frontend-feature-error-autologger 0.0.2-14 → 0.0.2-16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md +148 -3
package/dist/index.js +55 -60
package/dist/lib/middlewares/rtk-error.middleware.d.ts.map +1 -1
package/package.json +2 -1

package/README.md CHANGED Viewed

@@ -1,7 +1,152 @@
 # @open-kingdom/shared-frontend-feature-error-autologger
-This library was generated with [Nx](https://nx.dev).
+React feature library that automatically captures uncaught errors, unhandled promise rejections, and RTK Query rejected actions, routing them to configurable logger and notification callbacks.
-## Running unit tests
+---
-Run `nx test @open-kingdom/shared-frontend-feature-error-autologger` to execute the unit tests via [Vitest](https://vitest.dev/).
+## Exports
+| Export                          | Type               | Description                                                                                   |
+| ------------------------------- | ------------------ | --------------------------------------------------------------------------------------------- |
+| `ErrorBoundary`                 | `class Component`  | React error boundary — catches render errors and calls logger/notification handlers           |
+| `useGlobalErrorListener`        | hook               | Attaches `window.error` and `unhandledrejection` listeners on mount; cleans up on unmount     |
+| `useErrorReporter`              | hook               | Returns a stable `report(error, options?)` function for manual error reporting                |
+| `createReduxRTKErrorMiddleware` | middleware factory | Redux middleware that intercepts `/rejected` RTK actions and dispatches Redux action creators |
+| `createRTKErrorMiddleware`      | middleware factory | Redux middleware variant that calls plain callbacks instead of dispatching action creators    |
+---
+## Configuration
+### `ErrorBoundaryProps`
+| Property              | Type                                           | Required | Default                                     | Description                                             |
+| --------------------- | ---------------------------------------------- | -------- | ------------------------------------------- | ------------------------------------------------------- |
+| `children`            | `ReactNode`                                    | Yes      | —                                           | Content to render                                       |
+| `fallback`            | `ReactNode \| ((error: Error) => ReactNode)`   | No       | —                                           | Rendered when an error is caught; accepts a render prop |
+| `logger`              | `(message: string) => void`                    | No       | —                                           | Called with the error message on catch                  |
+| `notificationHandler` | `(message: string) => void`                    | No       | —                                           | Called with the user-facing message on catch            |
+| `userMessage`         | `string`                                       | No       | `'Something went wrong. Please try again.'` | Message passed to `notificationHandler`                 |
+| `notify`              | `boolean`                                      | No       | `true`                                      | Whether to call `notificationHandler`                   |
+| `log`                 | `boolean`                                      | No       | `true`                                      | Whether to call `logger`                                |
+| `onError`             | `(error: Error, errorInfo: ErrorInfo) => void` | No       | —                                           | Additional callback after the error is reported         |
+### `ErrorListenerConfig` (for `useGlobalErrorListener`)
+| Property              | Type                        | Required | Default                          | Description                            |
+| --------------------- | --------------------------- | -------- | -------------------------------- | -------------------------------------- |
+| `logger`              | `(message: string) => void` | No       | —                                | Called with the error message          |
+| `notificationHandler` | `(message: string) => void` | No       | —                                | Called with the user-facing message    |
+| `notify`              | `boolean`                   | No       | `true`                           | Whether to call `notificationHandler`  |
+| `log`                 | `boolean`                   | No       | `true`                           | Whether to call `logger`               |
+| `defaultMessage`      | `string`                    | No       | `'An unexpected error occurred'` | Fallback when the error has no message |
+### `HandleErrorOptions` (per-call options for `useErrorReporter`)
+| Property      | Type                      | Required | Default | Description                              |
+| ------------- | ------------------------- | -------- | ------- | ---------------------------------------- |
+| `notify`      | `boolean`                 | No       | `true`  | Whether to call `notificationHandler`    |
+| `log`         | `boolean`                 | No       | `true`  | Whether to call `logger`                 |
+| `userMessage` | `string`                  | No       | —       | Override the user-facing message         |
+| `context`     | `Record<string, unknown>` | No       | —       | Additional context attached to the error |
+### `ReduxRTKErrorMiddlewareConfig` (for `createReduxRTKErrorMiddleware`)
+| Property         | Type                                                       | Required | Default | Description                                            |
+| ---------------- | ---------------------------------------------------------- | -------- | ------- | ------------------------------------------------------ |
+| `logAction`      | `(payload: { message: string; level: 'error' }) => Action` | Yes      | —       | Action creator dispatched for logging                  |
+| `notifyAction`   | `(message: string) => Action`                              | Yes      | —       | Action creator dispatched for notifications            |
+| `notify`         | `boolean`                                                  | No       | `true`  | Whether to dispatch `notifyAction`                     |
+| `log`            | `boolean`                                                  | No       | `true`  | Whether to dispatch `logAction`                        |
+| `defaultMessage` | `string`                                                   | No       | —       | Fallback message for errors without one                |
+| `shouldHandle`   | `(action: unknown) => boolean`                             | No       | —       | Predicate to filter which rejected actions are handled |
+---
+## Usage
+### ErrorBoundary
+```tsx
+import { ErrorBoundary } from '@open-kingdom/shared-frontend-feature-error-autologger';
+function App() {
+  const dispatch = useDispatch();
+  return (
+    <ErrorBoundary logger={(msg) => dispatch(logError(msg))} notificationHandler={(msg) => dispatch(showErrorNotification(msg))} fallback={(error) => <div>Something went wrong: {error.message}</div>}>
+      <YourAppContent />
+    </ErrorBoundary>
+  );
+}
+```
+### useGlobalErrorListener
+```tsx
+import { useGlobalErrorListener } from '@open-kingdom/shared-frontend-feature-error-autologger';
+function AppRoot() {
+  const dispatch = useDispatch();
+  useGlobalErrorListener({
+    logger: (msg) => dispatch(logError(msg)),
+    notificationHandler: (msg) => dispatch(showErrorNotification(msg)),
+  });
+  return <App />;
+}
+```
+### useErrorReporter
+```tsx
+import { useErrorReporter } from '@open-kingdom/shared-frontend-feature-error-autologger';
+function DataFetcher() {
+  const dispatch = useDispatch();
+  const report = useErrorReporter({
+    logger: (msg) => dispatch(logError(msg)),
+  });
+  const fetchData = async () => {
+    try {
+      await api.getData();
+    } catch (err) {
+      report(err, { notify: false, context: { component: 'DataFetcher' } });
+    }
+  };
+}
+```
+### createReduxRTKErrorMiddleware (recommended for Redux apps)
+```typescript
+import { createReduxRTKErrorMiddleware } from '@open-kingdom/shared-frontend-feature-error-autologger';
+configureStore({
+  middleware: (getDefault) =>
+    getDefault().concat(
+      createReduxRTKErrorMiddleware({
+        logAction: ({ message }) => logError(message),
+        notifyAction: (message) => showErrorNotification(message),
+      })
+    ),
+});
+```
+### createRTKErrorMiddleware (callback-based)
+```typescript
+import { createRTKErrorMiddleware } from '@open-kingdom/shared-frontend-feature-error-autologger';
+const middleware = createRTKErrorMiddleware({
+  logger: (msg) => console.error('[RTK Error]', msg),
+  notificationHandler: (msg) => alert(msg),
+});
+```
+---
+## Testing
+```bash
+nx test shared-frontend-feature-error-autologger
+```

package/dist/index.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { Component as m, useMemo as y, useCallback as E, useEffect as w } from "react";
-class M {
+import { Component as p, useMemo as h, useCallback as m, useEffect as y } from "react";
+class E {
   adapt(e, r) {
     return e instanceof Error ? {
       message: e.message,
@@ -60,27 +60,27 @@ class M {
     return "Request failed";
   }
 }
-const j = (n) => console.error("[Error]", n), H = (n) => console.warn("[Notification]", n);
-class g {
+const w = (n) => console.error("[Error]", n), M = (n) => console.warn("[Notification]", n);
+class c {
   logger;
   notificationHandler;
   adapter;
   constructor(e = {}) {
-    this.logger = e.logger ?? j, this.notificationHandler = e.notificationHandler ?? H, this.adapter = e.adapter ?? new M();
+    this.logger = e.logger ?? w, this.notificationHandler = e.notificationHandler ?? M, this.adapter = e.adapter ?? new E();
   }
   report(e, r = {}) {
-    const { notify: t = !0, log: o = !0, userMessage: i, context: s } = r, u = this.adapter.adapt(e, s), l = i || u.message;
+    const { notify: t = !0, log: o = !0, userMessage: i, context: a } = r, l = this.adapter.adapt(e, a), s = i || l.message;
     if (o) {
-      const a = s ? `${u.message} | Context: ${JSON.stringify(s)}` : u.message;
-      this.logger(a);
+      const u = a ? `${l.message} | Context: ${JSON.stringify(a)}` : l.message;
+      this.logger(u);
     }
-    t && this.notificationHandler(l);
+    t && this.notificationHandler(s);
   }
 }
-class A extends m {
+class b extends p {
   reporter;
   constructor(e) {
-    super(e), this.state = { hasError: !1, error: null }, this.reporter = new g({
+    super(e), this.state = { hasError: !1, error: null }, this.reporter = new c({
       logger: e.logger,
       notificationHandler: e.notificationHandler
     });
@@ -96,11 +96,11 @@ class A extends m {
       onError: t,
       userMessage: o = "Something went wrong. Please try again.",
       notify: i = !0,
-      log: s = !0
+      log: a = !0
     } = this.props;
     this.reporter.report(e, {
       notify: i,
-      log: s,
+      log: a,
       userMessage: o,
       context: {
         type: "error-boundary",
@@ -113,17 +113,17 @@ class A extends m {
     return e && r ? typeof o == "function" ? o(r) : o ?? null : t;
   }
 }
-function k(n = {}) {
-  const { logger: e, notificationHandler: r, adapter: t } = n, o = y(
-    () => new g({ logger: e, notificationHandler: r, adapter: t }),
+function x(n = {}) {
+  const { logger: e, notificationHandler: r, adapter: t } = n, o = h(
+    () => new c({ logger: e, notificationHandler: r, adapter: t }),
     [e, r, t]
   );
-  return E(
-    (i, s = {}) => o.report(i, s),
+  return m(
+    (i, a = {}) => o.report(i, a),
     [o]
   );
 }
-class b {
+class j {
   reporter;
   notify;
   log;
@@ -134,9 +134,9 @@ class b {
       notificationHandler: t,
       notify: o = !0,
       log: i = !0,
-      defaultMessage: s = "An unexpected error occurred"
+      defaultMessage: a = "An unexpected error occurred"
     } = e;
-    this.reporter = new g({ logger: r, notificationHandler: t }), this.notify = o, this.log = i, this.defaultMessage = s;
+    this.reporter = new c({ logger: r, notificationHandler: t }), this.notify = o, this.log = i, this.defaultMessage = a;
   }
   attach() {
     const e = (t) => {
@@ -164,8 +164,8 @@ class b {
     };
   }
 }
-function S(n = {}) {
-  w(() => new b(n).attach(), [
+function k(n = {}) {
+  y(() => new j(n).attach(), [
     n.logger,
     n.notificationHandler,
     n.notify,
@@ -173,20 +173,19 @@ function S(n = {}) {
     n.defaultMessage
   ]);
 }
-const d = "An error occurred while processing your request";
-function f(n) {
+function g(n) {
   if (typeof n != "object" || n === null)
     return !1;
   const e = n;
   return typeof e.type == "string" && (e.type.endsWith("/rejected") || e.meta?.rejectedWithValue === !0);
 }
-function p(n) {
+function d(n) {
   return {
     type: "rtk-query",
     endpoint: n.meta?.arg?.endpointName || "unknown"
   };
 }
-function h(n) {
+function f(n) {
   return n.payload || n.error;
 }
 function R(n = {}) {
@@ -195,59 +194,55 @@ function R(n = {}) {
     notificationHandler: r,
     notify: t = !0,
     log: o = !0,
-    defaultMessage: i = d,
-    shouldHandle: s
-  } = n, u = new g({ logger: e, notificationHandler: r });
-  return () => (l) => (a) => {
-    if (f(a)) {
-      if (s && !s(a))
-        return l(a);
-      u.report(h(a), {
+    shouldHandle: i
+  } = n, a = new c({ logger: e, notificationHandler: r });
+  return () => (l) => (s) => {
+    if (g(s)) {
+      if (i && !i(s))
+        return l(s);
+      a.report(f(s), {
         notify: t,
         log: o,
-        userMessage: i,
-        context: p(a)
+        context: d(s)
       });
     }
-    return l(a);
+    return l(s);
   };
 }
-function L(n) {
+function A(n) {
   const {
     logAction: e,
     notifyAction: r,
     notify: t = !0,
     log: o = !0,
-    defaultMessage: i = d,
-    shouldHandle: s
+    shouldHandle: i
   } = n;
-  return ({ dispatch: u }) => {
-    const l = new g({
-      logger: (a) => u(e({ message: a, level: "error" })),
-      notificationHandler: (a) => u(r(a))
+  return ({ dispatch: a }) => {
+    const l = new c({
+      logger: (s) => a(e({ message: s, level: "error" })),
+      notificationHandler: (s) => a(r(s))
     });
-    return (a) => (c) => {
-      if (f(c)) {
-        if (s && !s(c))
-          return a(c);
-        l.report(h(c), {
+    return (s) => (u) => {
+      if (g(u)) {
+        if (i && !i(u))
+          return s(u);
+        l.report(f(u), {
           notify: t,
           log: o,
-          userMessage: i,
-          context: p(c)
+          context: d(u)
         });
       }
-      return a(c);
+      return s(u);
     };
   };
 }
 export {
-  M as ErrorAdapter,
-  A as ErrorBoundary,
-  g as ErrorReporter,
-  b as GlobalErrorListener,
+  E as ErrorAdapter,
+  b as ErrorBoundary,
+  c as ErrorReporter,
+  j as GlobalErrorListener,
   R as createRTKErrorMiddleware,
-  L as createReduxRTKErrorMiddleware,
-  k as useErrorReporter,
-  S as useGlobalErrorListener
+  A as createReduxRTKErrorMiddleware,
+  x as useErrorReporter,
+  k as useGlobalErrorListener
 };

package/dist/lib/middlewares/rtk-error.middleware.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"rtk-error.middleware.d.ts","sourceRoot":"","sources":["../../../src/lib/middlewares/rtk-error.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EACV,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,2BAA2B,CAAC;~~AAwCnC~~,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,wBAA6B,GACpC,UAAU,~~CA4BZ~~;AAGD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,6BAA6B,GACpC,UAAU,~~CAiCZ~~"}
1	+ {"version":3,"file":"rtk-error.middleware.d.ts","sourceRoot":"","sources":["../../../src/lib/middlewares/rtk-error.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EACV,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,2BAA2B,CAAC;AAsCnC,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,wBAA6B,GACpC,UAAU,CA0BZ;AAGD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,6BAA6B,GACpC,UAAU,CA+BZ"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@open-kingdom/shared-frontend-feature-error-autologger",
-  "version": "0.0.2-14",
+  "version": "0.0.2-16",
   "publishConfig": {
     "access": "public"
   },
@@ -18,6 +18,7 @@
     }
   },
   "files": [
+    "README.md",
     "dist",
     "!**/*.tsbuildinfo"
   ],