cloudflare-next-intl 0.9.35 → 0.9.37

package/README.md

@@ -754,6 +754,38 @@ query code is identical either way — switching is a config change only.
 A direct connection always wins if both are configured, so adding a `supabase`
 block cannot silently reroute live traffic.
 
+#### Reading as the user from a cached function
+
+`withUserDb` normally resolves the caller from the request — cookies, the
+Firebase session — every time it runs. Next forbids that inside a function
+wrapped in `unstable_cache`, and the background revalidation it runs for one
+happens after the response is gone, so both fail with ``` `cookies()` cannot be
+called inside a function cached with `unstable_cache()` ```.
+
+Resolve the caller once, while the request still exists, and pass the plain
+values in:
+
+```typescript
+import { resolveUserDbCredentials, withUserDb } from "cloudflare-next-intl/db";
+import { unstable_cache } from "next/cache";
+
+const credentials = await resolveUserDbCredentials();
+if (credentials.uid === null) return null;
+
+const row = await unstable_cache(
+    () => withUserDb((db) => db.select().from(profiles).where(eq(profiles.id, credentials.uid!)), credentials),
+    ["profile-row", credentials.uid],
+    { tags: [`profile:${credentials.uid}`], revalidate: 60 },
+)();
+```
+
+`resolveUserDbCredentials()` returns `{ uid, accessToken, role }`, each `null`
+when it cannot be resolved — a signed-out visitor gets nulls rather than a
+throw, so the check above is yours to make. Passing the object to `withUserDb`
+in place of a bare `uid` makes it use those values and read nothing
+request-scoped; it throws naming the missing field if the one that mode needs
+is `null`.
+
 #### Standalone usage (no Next.js / `@intl-config`)
 
 `withPublicDb`/`withUserDb` normally read their `db` config from

package/dist/src/db/context.d.ts

@@ -1,6 +1,12 @@
 import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import type { DbRoutingConfig } from '../types/types.js';
 export type DrizzleDb = NodePgDatabase<Record<string, never>>;
+export interface UserDbCredentials {
+    uid: string | null;
+    accessToken: string | null;
+    role: string | null;
+}
+export declare function resolveUserDbCredentials(dbOverride?: DbRoutingConfig): Promise<UserDbCredentials>;
 export declare function withPublicDb<T>(fn: (db: DrizzleDb) => Promise<T>, dbOverride?: DbRoutingConfig): Promise<T>;
-export declare function withUserDb<T>(fn: (db: DrizzleDb) => Promise<T>, uid?: string | null, dbOverride?: DbRoutingConfig): Promise<T>;
+export declare function withUserDb<T>(fn: (db: DrizzleDb) => Promise<T>, auth?: string | null | UserDbCredentials, dbOverride?: DbRoutingConfig): Promise<T>;
 export type { ExecResult as TransactionResult } from './supabase_transport.js';

package/dist/src/db/context.js

@@ -8,6 +8,38 @@ import resolveAccessToken from './access_token.js';
 import runTransactionBatch from './transaction_batch.js';
 import inlineParams from './inline_params.js';
 const DEFAULT_ROLE = 'authenticated';
+function isCredentials(value) {
+    return typeof value === 'object' && value !== null;
+}
+function throwMissingCredential(what) {
+    throw new Error(`db: withUserDb was given credentials without ${what}. resolveUserDbCredentials() ` +
+        'returns nulls when nobody is signed in — check for that before calling withUserDb.');
+}
+export async function resolveUserDbCredentials(dbOverride) {
+    const config = await resolveDbConfig(dbOverride);
+    const db = config.db;
+    requireDbConfig(db);
+    const fromConfigUid = (await db.getUserId?.()) ?? null;
+    const fromConfigToken = (await db.getAccessToken?.()) ?? null;
+    let uid = fromConfigUid;
+    let accessToken = fromConfigToken;
+    let role = null;
+    if (config.firebaseAuth && (uid === null || accessToken === null || db.authenticatedRoleClaim !== false)) {
+        const { getAuthUser } = await import('../firebase_auth/server/use_auth_user_server.js');
+        const { user } = await getAuthUser();
+        if (user) {
+            uid ?? (uid = user.uid ?? null);
+            accessToken ?? (accessToken = (await user.getIdToken(false)) ?? null);
+            if (db.authenticatedRoleClaim !== false && typeof user.getIdTokenResult === 'function') {
+                const { claims } = await user.getIdTokenResult();
+                const claimValue = claims[db.authenticatedRoleClaim ?? 'role'];
+                if (typeof claimValue === 'string' && claimValue)
+                    role = claimValue;
+            }
+        }
+    }
+    return { uid, accessToken, role };
+}
 async function resolveUserId(config, uid) {
     if (uid)
         return uid;
@@ -25,9 +57,11 @@ async function resolveUserId(config, uid) {
     throw new Error('db: withUserDb could not resolve a user id. Pass one explicitly, set ' +
         '`db.getUserId`, or configure `firebaseAuth` so the signed-in Firebase uid is used.');
 }
-async function resolveAuthenticatedRole(config, db) {
+async function resolveAuthenticatedRole(config, db, claimed) {
+    if (claimed)
+        return claimed;
     const claimField = db.authenticatedRoleClaim;
-    if (config.firebaseAuth && claimField !== false) {
+    if (config.firebaseAuth && claimField !== false && claimed === undefined) {
         const { getAuthUser } = await import('../firebase_auth/server/use_auth_user_server.js');
         const { user } = await getAuthUser();
         if (user && typeof user.getIdTokenResult === 'function') {
@@ -127,17 +161,21 @@ function injectUidComment(sql, userId) {
     }
     return sql;
 }
-export async function withUserDb(fn, uid, dbOverride) {
+export async function withUserDb(fn, auth, dbOverride) {
     const config = await resolveDbConfig(dbOverride);
     const db = config.db;
     requireDbConfig(db);
+    const credentials = isCredentials(auth) ? auth : null;
+    const uid = credentials ? credentials.uid : auth ?? null;
     const resolved = await resolveDbMode(db, config.generate);
     if (resolved.mode === 'supabase') {
-        const token = await resolveAccessToken(config);
+        const token = credentials
+            ? credentials.accessToken ?? throwMissingCredential('an access token')
+            : await resolveAccessToken(config);
         return fn(await supabaseDb(resolved.supabase, token));
     }
-    const userId = await resolveUserId(config, uid);
-    const role = await resolveAuthenticatedRole(config, db);
+    const userId = credentials ? uid ?? throwMissingCredential('a user id') : await resolveUserId(config, uid);
+    const role = await resolveAuthenticatedRole(config, db, credentials ? credentials.role : undefined);
     return await withDbClient(config, async (client) => {
         const rawClient = client;
         const setSessionState = async () => {

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

@@ -1,4 +1,5 @@
-export { withPublicDb, withUserDb } from './context.js';
+export { withPublicDb, withUserDb, resolveUserDbCredentials } from './context.js';
+export type { UserDbCredentials } from './context.js';
 export type { DrizzleDb, TransactionResult } from './context.js';
 export { withDbClient, connectToPostgres, disconnectPostgres, resetConnectionState } from './connection.js';
 export type { DbRoutingConfig } from '../types/types.js';

package/dist/src/db/index.js

@@ -1,2 +1,2 @@
-export { withPublicDb, withUserDb } from './context.js';
+export { withPublicDb, withUserDb, resolveUserDbCredentials } from './context.js';
 export { withDbClient, connectToPostgres, disconnectPostgres, resetConnectionState } from './connection.js';

package/dist/src/error_handling/create_server_error_action.js

@@ -1,33 +1,6 @@
-import reportError from './report_error.js';
-import stringifyUnknown from './stringify_unknown.js';
-async function resolveRequestContext() {
-    try {
-        const { headers } = await import('next/headers.js');
-        const headerList = await headers();
-        return {
-            path: headerList.get('x-pathname') ?? undefined,
-            userAgent: headerList.get('user-agent') ?? undefined,
-            referer: headerList.get('referer') ?? undefined,
-        };
-    }
-    catch {
-        return {};
-    }
-}
+import { reportClientErrorCore } from './report_client_error_core.js';
 export default function createServerErrorAction(config) {
     return async function reportClientError(error, classOrMethodName, params) {
-        const requestContext = await resolveRequestContext();
-        const isPlainParamsObject = typeof params === 'object' && params !== null && !Array.isArray(params);
-        const mergedParams = params === undefined
-            ? { requestContext }
-            : isPlainParamsObject
-                ? { ...params, requestContext }
-                : { params, requestContext };
-        await reportError(config, {
-            error: stringifyUnknown(error, true),
-            classOrMethodName,
-            params: mergedParams,
-            isClient: true,
-        });
+        await reportClientErrorCore(config, error, classOrMethodName, params);
     };
 }

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

@@ -0,0 +1,3 @@
+import type { ReportErrorConfig } from './report_error.js';
+export declare function setErrorHandlingActionConfig(next: ReportErrorConfig | undefined): void;
+export declare function getErrorHandlingActionConfig(): ReportErrorConfig | undefined;

package/dist/src/error_handling/error_handling_action_config.js

@@ -0,0 +1,7 @@
+let config;
+export function setErrorHandlingActionConfig(next) {
+    config = next;
+}
+export function getErrorHandlingActionConfig() {
+    return config;
+}

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

@@ -10,4 +10,5 @@ export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors.js
 export { default as isStaleDeployError, defaultStaleDeployPatterns, setStaleDeployPatterns, getStaleDeployPatterns, } from './is_stale_deploy_error.js';
 export { default as clearClientCache } from './clear_client_cache.js';
 export { default as useStaleDeployRecovery, shouldRecoverFromStaleDeploy } from './use_stale_deploy_recovery.js';
+export { setErrorHandlingActionConfig, getErrorHandlingActionConfig } from './error_handling_action_config.js';
 export type { ErrorHandlingParams, ErrorHandlingRoutingConfig } from '../types/types.js';

package/dist/src/error_handling/index.js

@@ -8,3 +8,4 @@ export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors.js
 export { default as isStaleDeployError, defaultStaleDeployPatterns, setStaleDeployPatterns, getStaleDeployPatterns, } from './is_stale_deploy_error.js';
 export { default as clearClientCache } from './clear_client_cache.js';
 export { default as useStaleDeployRecovery, shouldRecoverFromStaleDeploy } from './use_stale_deploy_recovery.js';
+export { setErrorHandlingActionConfig, getErrorHandlingActionConfig } from './error_handling_action_config.js';

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

@@ -0,0 +1,2 @@
+import type { ErrorHandlingParams } from '../types/types.js';
+export default function reportClientError(error: unknown, classOrMethodName: string, params?: ErrorHandlingParams['params']): Promise<void>;

package/dist/src/error_handling/report_client_error_action.js

@@ -0,0 +1,6 @@
+'use server';
+import { getErrorHandlingActionConfig } from './error_handling_action_config.js';
+import { reportClientErrorCore } from './report_client_error_core.js';
+export default async function reportClientError(error, classOrMethodName, params) {
+    await reportClientErrorCore(getErrorHandlingActionConfig(), error, classOrMethodName, params);
+}

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

@@ -0,0 +1,3 @@
+import type { ErrorHandlingParams } from '../types/types.js';
+import { type ReportErrorConfig } from './report_error.js';
+export declare function reportClientErrorCore(config: ReportErrorConfig | undefined, error: unknown, classOrMethodName: string, params?: ErrorHandlingParams['params']): Promise<void>;

package/dist/src/error_handling/report_client_error_core.js

@@ -0,0 +1,31 @@
+import reportError from './report_error.js';
+import stringifyUnknown from './stringify_unknown.js';
+async function resolveRequestContext() {
+    try {
+        const { headers } = await import('next/headers.js');
+        const headerList = await headers();
+        return {
+            path: headerList.get('x-pathname') ?? undefined,
+            userAgent: headerList.get('user-agent') ?? undefined,
+            referer: headerList.get('referer') ?? undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export async function reportClientErrorCore(config, error, classOrMethodName, params) {
+    const requestContext = await resolveRequestContext();
+    const isPlainParamsObject = typeof params === 'object' && params !== null && !Array.isArray(params);
+    const mergedParams = params === undefined
+        ? { requestContext }
+        : isPlainParamsObject
+            ? { ...params, requestContext }
+            : { params, requestContext };
+    await reportError(config, {
+        error: stringifyUnknown(error, true),
+        classOrMethodName,
+        params: mergedParams,
+        isClient: true,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.35",
+  "version": "0.9.37",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -206,6 +206,10 @@
       "types": "./dist/src/error_handling/create_server_error_action.d.ts",
       "import": "./dist/src/error_handling/create_server_error_action.js"
     },
+    "./reportClientError": {
+      "types": "./dist/src/error_handling/report_client_error_action.d.ts",
+      "import": "./dist/src/error_handling/report_client_error_action.js"
+    },
     "./isStaleDeployError": {
       "types": "./dist/src/error_handling/is_stale_deploy_error.d.ts",
       "import": "./dist/src/error_handling/is_stale_deploy_error.js"