refactor: inject error texts via sendFeedback hint, preserve default messages

Addresses review feedback that sendFeedback (a public API) was rejecting
with internal codes instead of human-readable strings, changing observable
behavior for non-widget consumers.

sendFeedback now accepts optional errorMessages overrides via its hint
argument, defaulting to the original English strings. The widget wraps
sendFeedback to inject its configured text options, so standalone
consumers of sendFeedback see the same strings as before.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: logaretm

packages/core/src/index.ts

@@ -452,6 +452,8 @@ export type {
   ReplayStopReason,
 } from './types-hoist/replay';
 export type {
+  FeedbackErrorCode,
+  FeedbackErrorMessages,
   FeedbackEvent,
   FeedbackFormData,
   FeedbackInternalOptions,

packages/core/src/types-hoist/feedback/index.ts

@@ -6,10 +6,17 @@ import type {
   FeedbackTextConfiguration,
   FeedbackThemeConfiguration,
 } from './config';
-import type { FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback } from './sendFeedback';
+import type {
+  FeedbackErrorCode,
+  FeedbackErrorMessages,
+  FeedbackEvent,
+  SendFeedback,
+  SendFeedbackParams,
+  UserFeedback,
+} from './sendFeedback';
 
 export type { FeedbackFormData } from './form';
-export type { FeedbackEvent, UserFeedback, SendFeedback, SendFeedbackParams };
+export type { FeedbackErrorCode, FeedbackErrorMessages, FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback };
 
 /**
  * The integration's internal `options` member where every value should be set

packages/core/src/types-hoist/feedback/sendFeedback.ts

@@ -47,7 +47,16 @@ export interface SendFeedbackParams {
   tags?: { [key: string]: Primitive };
 }
 
+export type FeedbackErrorCode =
+  | 'ERROR_EMPTY_MESSAGE'
+  | 'ERROR_NO_CLIENT'
+  | 'ERROR_TIMEOUT'
+  | 'ERROR_FORBIDDEN'
+  | 'ERROR_GENERIC';
+
+export type FeedbackErrorMessages = Partial<Record<FeedbackErrorCode, string>>;
+
 export type SendFeedback = (
   params: SendFeedbackParams,
-  hint?: EventHint & { includeReplay?: boolean },
+  hint?: EventHint & { includeReplay?: boolean; errorMessages?: FeedbackErrorMessages },
 ) => Promise<string>;

packages/feedback/src/core/integration.ts

@@ -2,11 +2,13 @@
 /* eslint-disable complexity */
 
 import type {
+  FeedbackErrorMessages,
   FeedbackInternalOptions,
   FeedbackModalIntegration,
   FeedbackScreenshotIntegration,
   Integration,
   IntegrationFn,
+  SendFeedback,
 } from '@sentry/core';
 import { addIntegration, debug, isBrowser } from '@sentry/core';
 import {
@@ -246,6 +248,16 @@ export const buildFeedbackIntegration = ({
           debug.error('[Feedback] Missing feedback screenshot integration. Proceeding without screenshots.');
       }
 
+      const errorMessages: FeedbackErrorMessages = {
+        ERROR_EMPTY_MESSAGE: options.errorEmptyMessageText,
+        ERROR_NO_CLIENT: options.errorNoClientText,
+        ERROR_TIMEOUT: options.errorTimeoutText,
+        ERROR_FORBIDDEN: options.errorForbiddenText,
+        ERROR_GENERIC: options.errorGenericText,
+      };
+      const wrappedSendFeedback: SendFeedback = (params, hint) =>
+        sendFeedback(params, { includeReplay: true, ...hint, errorMessages });
+
       const dialog = modalIntegration.createDialog({
         options: {
           ...options,
@@ -259,7 +271,7 @@ export const buildFeedbackIntegration = ({
           },
         },
         screenshotIntegration,
-        sendFeedback,
+        sendFeedback: wrappedSendFeedback,
         shadow: _createShadow(options),
       });
 

packages/feedback/src/core/sendFeedback.ts

@@ -1,25 +1,33 @@
-import type { Event, EventHint, SendFeedback, SendFeedbackParams, TransportMakeRequestResponse } from '@sentry/core';
+import type {
+  Event,
+  EventHint,
+  FeedbackErrorMessages,
+  SendFeedback,
+  SendFeedbackParams,
+  TransportMakeRequestResponse,
+} from '@sentry/core';
 import { captureFeedback, getClient, getCurrentScope, getLocationHref } from '@sentry/core';
 import { FEEDBACK_API_SOURCE } from '../constants';
-import type { FeedbackErrorCode } from '../util/createFeedbackError';
-import { createFeedbackError } from '../util/createFeedbackError';
+import { createFeedbackError, resolveFeedbackErrorMessage } from '../util/createFeedbackError';
 
 /**
  * Public API to send a Feedback item to Sentry
  */
 export const sendFeedback: SendFeedback = (
   params: SendFeedbackParams,
-  hint: EventHint & { includeReplay?: boolean } = { includeReplay: true },
+  hint: EventHint & { includeReplay?: boolean; errorMessages?: FeedbackErrorMessages } = { includeReplay: true },
 ): Promise<string> => {
+  const errorMessages = hint.errorMessages;
+
   if (!params.message) {
-    throw createFeedbackError('ERROR_EMPTY_MESSAGE');
+    throw createFeedbackError('ERROR_EMPTY_MESSAGE', errorMessages);
   }
 
   // We want to wait for the feedback to be sent (or not)
   const client = getClient();
 
   if (!client) {
-    throw createFeedbackError('ERROR_NO_CLIENT');
+    throw createFeedbackError('ERROR_NO_CLIENT', errorMessages);
   }
 
   if (params.tags && Object.keys(params.tags).length) {
@@ -39,7 +47,7 @@ export const sendFeedback: SendFeedback = (
     // After 30s, we want to clear anyhow
     const timeout = setTimeout(() => {
       cleanup();
-      reject('ERROR_TIMEOUT' satisfies FeedbackErrorCode);
+      reject(resolveFeedbackErrorMessage('ERROR_TIMEOUT', errorMessages));
     }, 30_000);
 
     const cleanup = client.on('afterSendEvent', (event: Event, response: TransportMakeRequestResponse) => {
@@ -56,10 +64,10 @@ export const sendFeedback: SendFeedback = (
       }
 
       if (response?.statusCode === 403) {
-        return reject('ERROR_FORBIDDEN' satisfies FeedbackErrorCode);
+        return reject(resolveFeedbackErrorMessage('ERROR_FORBIDDEN', errorMessages));
       }
 
-      return reject('ERROR_GENERIC' satisfies FeedbackErrorCode);
+      return reject(resolveFeedbackErrorMessage('ERROR_GENERIC', errorMessages));
     });
   });
 };

packages/feedback/src/modal/components/Form.tsx

@@ -9,7 +9,6 @@ import type { JSX, VNode } from 'preact';
 import { h } from 'preact'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { useCallback, useState } from 'preact/hooks';
 import { FEEDBACK_WIDGET_SOURCE } from '../../constants';
-import type { FeedbackErrorCode } from '../../util/createFeedbackError';
 import { DEBUG_BUILD } from '../../util/debug-build';
 import { getMissingFields } from '../../util/validate';
 
@@ -60,20 +59,7 @@ export function Form({
     namePlaceholder,
     submitButtonLabel,
     isRequiredLabel,
-    errorEmptyMessageText,
-    errorNoClientText,
-    errorTimeoutText,
-    errorForbiddenText,
-    errorGenericText,
   } = options;
-
-  const errorTextByCode: Record<FeedbackErrorCode, string> = {
-    ERROR_EMPTY_MESSAGE: errorEmptyMessageText,
-    ERROR_NO_CLIENT: errorNoClientText,
-    ERROR_TIMEOUT: errorTimeoutText,
-    ERROR_FORBIDDEN: errorForbiddenText,
-    ERROR_GENERIC: errorGenericText,
-  };
   const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
   // TODO: set a ref on the form, and whenever an input changes call processForm() and setError()
   const [error, setError] = useState<null | string>(null);
@@ -146,7 +132,7 @@ export function Form({
         } catch (error) {
           DEBUG_BUILD && debug.error(error);
           const err = error instanceof Error ? error : new Error(String(error));
-          setError(errorTextByCode[err.message as FeedbackErrorCode] ?? errorGenericText);
+          setError(err.message);
           onSubmitError(err);
         }
       } finally {

packages/feedback/src/util/createFeedbackError.ts

@@ -1,10 +1,24 @@
-export type FeedbackErrorCode =
-  | 'ERROR_EMPTY_MESSAGE'
-  | 'ERROR_NO_CLIENT'
-  | 'ERROR_TIMEOUT'
-  | 'ERROR_FORBIDDEN'
-  | 'ERROR_GENERIC';
+import type { FeedbackErrorCode, FeedbackErrorMessages } from '@sentry/core';
+import {
+  ERROR_EMPTY_MESSAGE_TEXT,
+  ERROR_FORBIDDEN_TEXT,
+  ERROR_GENERIC_TEXT,
+  ERROR_NO_CLIENT_TEXT,
+  ERROR_TIMEOUT_TEXT,
+} from '../constants';
 
-export function createFeedbackError(reason: FeedbackErrorCode): Error {
-  return new Error(reason);
+const DEFAULT_MESSAGES: Record<FeedbackErrorCode, string> = {
+  ERROR_EMPTY_MESSAGE: ERROR_EMPTY_MESSAGE_TEXT,
+  ERROR_NO_CLIENT: ERROR_NO_CLIENT_TEXT,
+  ERROR_TIMEOUT: ERROR_TIMEOUT_TEXT,
+  ERROR_FORBIDDEN: ERROR_FORBIDDEN_TEXT,
+  ERROR_GENERIC: ERROR_GENERIC_TEXT,
+};
+
+export function resolveFeedbackErrorMessage(code: FeedbackErrorCode, messages?: FeedbackErrorMessages): string {
+  return messages?.[code] ?? DEFAULT_MESSAGES[code];
+}
+
+export function createFeedbackError(code: FeedbackErrorCode, messages?: FeedbackErrorMessages): Error {
+  return new Error(resolveFeedbackErrorMessage(code, messages));
 }

packages/feedback/test/core/sendFeedback.test.ts

@@ -269,7 +269,7 @@ describe('sendFeedback', () => {
 
   it('throws when message is empty', () => {
     mockSdk();
-    expect(() => sendFeedback({ message: '' })).toThrow('ERROR_EMPTY_MESSAGE');
+    expect(() => sendFeedback({ message: '' })).toThrow('Unable to submit feedback with an empty message');
   });
 
   it('throws when no client is set up', async () => {
@@ -279,7 +279,18 @@ describe('sendFeedback', () => {
     getGlobalScope().setClient(undefined);
     getCurrentScope().setClient(undefined);
     getIsolationScope().setClient(undefined);
-    expect(() => sendFeedback({ message: 'mi' })).toThrow('ERROR_NO_CLIENT');
+    expect(() => sendFeedback({ message: 'mi' })).toThrow('No client setup, cannot send feedback.');
+  });
+
+  it('uses provided errorMessages overrides', async () => {
+    mockSdk();
+    vi.spyOn(getClient()!.getTransport()!, 'send').mockImplementation(() => {
+      return Promise.resolve({ statusCode: 403 });
+    });
+
+    await expect(
+      sendFeedback({ message: 'mi' }, { errorMessages: { ERROR_FORBIDDEN: 'custom forbidden text' } }),
+    ).rejects.toMatch('custom forbidden text');
   });
 
   it('handles 400 transport error', async () => {
@@ -294,7 +305,9 @@ describe('sendFeedback', () => {
         email: 're@example.org',
         message: 'mi',
       }),
-    ).rejects.toMatch('ERROR_GENERIC');
+    ).rejects.toMatch(
+      'Unable to send feedback. This could be because of network issues, or because you are using an ad-blocker.',
+    );
   });
 
   it('handles 0 transport error', async () => {
@@ -309,7 +322,9 @@ describe('sendFeedback', () => {
         email: 're@example.org',
         message: 'mi',
       }),
-    ).rejects.toMatch('ERROR_GENERIC');
+    ).rejects.toMatch(
+      'Unable to send feedback. This could be because of network issues, or because you are using an ad-blocker.',
+    );
   });
 
   it('handles 403 transport error', async () => {
@@ -324,7 +339,9 @@ describe('sendFeedback', () => {
         email: 're@example.org',
         message: 'mi',
       }),
-    ).rejects.toMatch('ERROR_FORBIDDEN');
+    ).rejects.toMatch(
+      'Unable to send feedback. This could be because this domain is not in your list of allowed domains.',
+    );
   });
 
   it('handles 200 transport response', async () => {
@@ -358,7 +375,7 @@ describe('sendFeedback', () => {
 
     vi.advanceTimersByTime(30_000);
 
-    await expect(promise).rejects.toMatch('ERROR_TIMEOUT');
+    await expect(promise).rejects.toMatch('Unable to determine if Feedback was correctly sent.');
 
     vi.useRealTimers();
   });