cloudflare-next-intl 0.8.19 → 0.8.21

package/dist/src/db/connection.js

@@ -115,6 +115,29 @@ export default async function connectToPostgres(config, resolved) {
             connectionString = resolved ?? await resolveConnectionString(db);
             const { Client } = await import('pg');
             const created = serializeQueries(new Client({ connectionString }));
+            // The shared client outlives a single request (see the module doc)
+            // and Hyperdrive/Postgres can close its idle socket at any time. `pg`
+            // surfaces that as an `'error'` event on the `Client`, which is an
+            // `EventEmitter` — with no listener, Node treats it as unhandled and
+            // throws, crashing whatever unrelated request happens to be running
+            // in the isolate at that moment. Listening here converts it into a
+            // clean reset so the next call reconnects instead.
+            created.on('error', (error) => {
+                if (client === created) {
+                    client = null;
+                    connectionString = null;
+                    connectionPromise = null;
+                }
+                // `pg` emits "Connection terminated"/"Connection terminated
+                // unexpectedly" (lib/client.js) — never "Connection closed" —
+                // when the idle socket dies outside a query. That's the
+                // expected shape of this event (Hyperdrive/Postgres recycling
+                // the connection, not a query failure): swallow it entirely,
+                // don't report or log it.
+                if (/connection terminated/i.test(error.message))
+                    return;
+                void reportError({ errorHandling: config.errorHandling, generate: config.generate }, { error, classOrMethodName: 'db.connectToPostgres.clientError' });
+            });
             client = created;
             await created.connect();
             return created;

package/dist/src/error_handling/install_console_error_override.d.ts

@@ -34,7 +34,8 @@ import { type ReportErrorConfig } from './report_error';
  * `config.errorHandling.ignoreConsoleErrors` (default
  * `defaultIgnoredConsoleErrors` — this package's own Firebase Auth error
  * codes for expected user-input failures) and `ignoreConsoleError` both
- * skip reporting a matching call while still logging it normally.
+ * skip reporting a matching call while still logging it normally — checked
+ * inside `reportError` itself, so this override doesn't duplicate the check.
  *
  * @param config Pass the relevant slices of your `RoutingConfig` directly —
  *   `{ errorHandling: config.errorHandling, generate: config.generate }`.

package/dist/src/error_handling/install_console_error_override.js

@@ -1,6 +1,4 @@
 import reportError, { consoleOverrideState } from './report_error';
-import stringifyUnknown from './stringify_unknown';
-import { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
 /**
  * Replaces the global `console.error` so every `console.error(...)` call is
  * also routed through `config.errorHandling.onError`/`reportError` — the
@@ -36,7 +34,8 @@ import { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
  * `config.errorHandling.ignoreConsoleErrors` (default
  * `defaultIgnoredConsoleErrors` — this package's own Firebase Auth error
  * codes for expected user-input failures) and `ignoreConsoleError` both
- * skip reporting a matching call while still logging it normally.
+ * skip reporting a matching call while still logging it normally — checked
+ * inside `reportError` itself, so this override doesn't duplicate the check.
  *
  * @param config Pass the relevant slices of your `RoutingConfig` directly —
  *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
@@ -58,12 +57,6 @@ export default function installConsoleErrorOverride(config, isClient) {
         if (!suppressOnClient) {
             originalConsoleError(message, ...optionalParams);
         }
-        const stringified = stringifyUnknown(message, isClient);
-        const ignoreList = config.errorHandling?.ignoreConsoleErrors ?? defaultIgnoredConsoleErrors;
-        if (ignoreList.some((ignored) => stringified.includes(ignored)))
-            return;
-        if (config.errorHandling?.ignoreConsoleError?.(stringified))
-            return;
         void reportError(config, { error: message, classOrMethodName: 'Global Console Error Handler', params: optionalParams, isClient });
     };
     override.__isErrorHandlingOverride = true;

package/dist/src/error_handling/report_error.js

@@ -1,5 +1,6 @@
 import formatErrorMessage from './format_error_message';
 import stringifyUnknown from './stringify_unknown';
+import { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
 const DEFAULT_THROTTLE_MS = 5000;
 // Set by `installConsoleErrorOverride` once it patches `console.error`.
 // When active, THAT override is the sole place that ever calls the real
@@ -105,6 +106,18 @@ export default async function reportError(config, params) {
         return;
     if (params.consent !== undefined && params.consent !== true)
         return;
+    // `ignoreConsoleErrors`/`ignoreConsoleError` used to only be consulted by
+    // `installConsoleErrorOverride`'s patched `console.error` — any direct
+    // `reportError`/`reportClientError` call (a caught DB/query error, an
+    // error boundary's `reportClientError(error, ...)`, etc.) skipped this
+    // check entirely and always reached `onError`. Checking it here instead
+    // makes every path share the one ignore list.
+    const stringified = stringifyUnknown(params.error, params.isClient);
+    const ignoreList = errorHandling?.ignoreConsoleErrors ?? defaultIgnoredConsoleErrors;
+    if (ignoreList.some((ignored) => stringified.includes(ignored)))
+        return;
+    if (errorHandling?.ignoreConsoleError?.(stringified))
+        return;
     if (errorHandling?.dedup !== false) {
         const throttleMs = errorHandling?.throttleMs ?? DEFAULT_THROTTLE_MS;
         const dedupKey = buildDedupKey(params);

package/dist/src/firebase_auth/client/auth_actions.d.ts

@@ -44,3 +44,40 @@ export declare function createSignUpAction(locale: string, messages: AuthActionM
  * <form action={action}>...</form>
  */
 export declare function createForgotPasswordAction(locale: string, actionCodeSettings?: AuthActionCodeSettings): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;
+/**
+ * Builds a "send sign-in link" server action for React's `useActionState`
+ * form hook, for passwordless email-link sign-in. Same shape as
+ * {@link createLoginAction}.
+ *
+ * `formData` must contain an `email` field.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param actionCodeSettings Required. `actionCodeSettings.url` is the page
+ *   the emailed link points to (must handle completion via a future
+ *   `completeSignInWithLink` action); `handleCodeInApp` should be `true`.
+ * @returns A form action: `{ success: true, email }` on success (the
+ *   trimmed email, for the caller to persist as `emailForSignIn` before
+ *   the user leaves this device/tab), `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(
+ *     createSendSignInLinkAction(locale, { url: completeUrl, handleCodeInApp: true }),
+ *     {},
+ * );
+ * <form action={action}>...</form>
+ */
+export declare function createSendSignInLinkAction(locale: string, actionCodeSettings: AuthActionCodeSettings): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;
+/**
+ * Completes a passwordless email-link sign-in. Called directly (not via
+ * `useActionState`) from an effect on the link-landing page, once the URL
+ * and the user's email (recovered from `localStorage`, or re-entered if
+ * the link was opened on a different device) are both known.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param url The full URL the user landed on (`window.location.href`).
+ * @param email The email address to complete sign-in for.
+ * @returns `{ success: true }` on success, `{ error }` if the URL isn't a
+ *   valid sign-in link or sign-in otherwise fails.
+ * @example
+ * const result = await completeSignInWithLink(locale, window.location.href, email);
+ */
+export declare function completeSignInWithLink(locale: string, url: string, email: string): Promise<AuthFormState>;

package/dist/src/firebase_auth/client/auth_actions.js

@@ -100,3 +100,68 @@ export function createForgotPasswordAction(locale, actionCodeSettings) {
         }
     };
 }
+/**
+ * Builds a "send sign-in link" server action for React's `useActionState`
+ * form hook, for passwordless email-link sign-in. Same shape as
+ * {@link createLoginAction}.
+ *
+ * `formData` must contain an `email` field.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param actionCodeSettings Required. `actionCodeSettings.url` is the page
+ *   the emailed link points to (must handle completion via a future
+ *   `completeSignInWithLink` action); `handleCodeInApp` should be `true`.
+ * @returns A form action: `{ success: true, email }` on success (the
+ *   trimmed email, for the caller to persist as `emailForSignIn` before
+ *   the user leaves this device/tab), `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(
+ *     createSendSignInLinkAction(locale, { url: completeUrl, handleCodeInApp: true }),
+ *     {},
+ * );
+ * <form action={action}>...</form>
+ */
+export function createSendSignInLinkAction(locale, actionCodeSettings) {
+    return async function sendSignInLinkAction(_prevState, formData) {
+        requireFirebaseAuthConfig(config.firebaseAuth);
+        const { auth } = await getFirebaseAuthClient();
+        const { sendSignInLinkToEmail } = await getFirebaseAuthModule();
+        const email = (formData.get('email')?.toString() ?? '').trim();
+        try {
+            await sendSignInLinkToEmail(auth, email, actionCodeSettings);
+            return { success: true, email };
+        }
+        catch (e) {
+            return { error: firebaseAuthErrorMessage(locale, e) };
+        }
+    };
+}
+/**
+ * Completes a passwordless email-link sign-in. Called directly (not via
+ * `useActionState`) from an effect on the link-landing page, once the URL
+ * and the user's email (recovered from `localStorage`, or re-entered if
+ * the link was opened on a different device) are both known.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param url The full URL the user landed on (`window.location.href`).
+ * @param email The email address to complete sign-in for.
+ * @returns `{ success: true }` on success, `{ error }` if the URL isn't a
+ *   valid sign-in link or sign-in otherwise fails.
+ * @example
+ * const result = await completeSignInWithLink(locale, window.location.href, email);
+ */
+export async function completeSignInWithLink(locale, url, email) {
+    requireFirebaseAuthConfig(config.firebaseAuth);
+    const { auth } = await getFirebaseAuthClient();
+    const { isSignInWithEmailLink, signInWithEmailLink } = await getFirebaseAuthModule();
+    if (!isSignInWithEmailLink(auth, url)) {
+        return { error: firebaseAuthErrorMessage(locale, { code: 'auth/invalid-action-code' }) };
+    }
+    try {
+        await signInWithEmailLink(auth, email, url);
+        return { success: true };
+    }
+    catch (e) {
+        return { error: firebaseAuthErrorMessage(locale, e) };
+    }
+}

package/dist/src/firebase_auth/index.d.ts

@@ -2,7 +2,7 @@ export { default as FirebaseAuthClientProvider } from './client/auth_user_provid
 export { default as FirebaseAuthServerProvider } from './server/auth_user_server_provider';
 export { default as useFirebaseAuthUserClient } from './client/use_auth_user';
 export { default as useFirebaseAuthUserServer } from './server/use_auth_user_server';
-export { createLoginAction, createSignUpAction, createForgotPasswordAction } from './client/auth_actions';
+export { createLoginAction, createSignUpAction, createForgotPasswordAction, createSendSignInLinkAction, completeSignInWithLink, } from './client/auth_actions';
 export { default as clearFirebaseAuthSession } from './server/clear_session_action';
 export { default as updateFirebaseAuthSession, defaultSessionCookieName as firebaseAuthSessionCookieName } from './middleware/update_session';
 export { getFirebaseAuthClient, getFirebasePerformanceSync } from './client/firebase_client';

package/dist/src/firebase_auth/index.js

@@ -8,7 +8,7 @@ export { default as FirebaseAuthServerProvider } from './server/auth_user_server
 // DOES resolve correctly per-environment) rather than through this barrel.
 export { default as useFirebaseAuthUserClient } from './client/use_auth_user';
 export { default as useFirebaseAuthUserServer } from './server/use_auth_user_server';
-export { createLoginAction, createSignUpAction, createForgotPasswordAction } from './client/auth_actions';
+export { createLoginAction, createSignUpAction, createForgotPasswordAction, createSendSignInLinkAction, completeSignInWithLink, } from './client/auth_actions';
 export { default as clearFirebaseAuthSession } from './server/clear_session_action';
 export { default as updateFirebaseAuthSession, defaultSessionCookieName as firebaseAuthSessionCookieName } from './middleware/update_session';
 export { getFirebaseAuthClient, getFirebasePerformanceSync } from './client/firebase_client';

package/dist/src/firebase_auth/types.d.ts

@@ -13,6 +13,7 @@ export interface SerializedAuthUser {
 export type AuthFormState = {
     error?: string;
     success?: boolean;
+    email?: string;
 };
 /** Overrides for the default English auth error/status messages. */
 export interface AuthActionMessages {

package/llms.txt

@@ -34,7 +34,7 @@ other subpath can be used.
 - `./firebaseAuthServerProvider` — server-side equivalent provider (not used by the default auto-wiring path — see its doc comment).
 - `./useFirebaseAuthUser` — `useAuthUser()`; resolves to RSC or client implementation via the `react-server` condition. Client variant throws `"useAuthUser must be used within an AuthUserProvider"` if called outside one.
 - `./getFirebaseAuthUser` — `getAuthUser()`; unconditional server-only export of the same RSC implementation `useFirebaseAuthUser` resolves to via `react-server`. Use this when you want `await` to be visible from the type itself — TypeScript doesn't evaluate the `react-server` condition, so `useFirebaseAuthUser` always types as its client (sync) signature in editors regardless of call site.
-- `./firebaseAuthActions` — `createLoginAction`/`createSignUpAction`/`createForgotPasswordAction`: factories returning React `useActionState`-shaped form actions.
+- `./firebaseAuthActions` — `createLoginAction`/`createSignUpAction`/`createForgotPasswordAction`: factories returning React `useActionState`-shaped form actions. `createSendSignInLinkAction`: same factory shape, for passwordless email-link sign-in — returns `{ success: true, email }` so the caller can persist the trimmed email (e.g. to `localStorage`) for the completion step. `completeSignInWithLink(locale, url, email)`: plain async function (not `useActionState`-shaped) that completes a passwordless sign-in from the emailed link's landing page — call from an effect on mount, not a form submit.
 - `./firebaseAuthMiddleware` — `updateSession`: session-cookie refresh, called automatically by `./middleware`'s default handler.
 
 ## `cookieConsent*` subpaths (require `cookieConsent` set on your `RoutingConfig`)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cloudflare-next-intl",
-	"version": "0.8.19",
+	"version": "0.8.21",
 	"description": "Optimized Next Intl Package Special for App Router and Cloudflare",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",