cloudflare-next-intl 0.9.34 → 0.9.36

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/server/components/link.d.ts

@@ -1,5 +1,6 @@
 import { type LinkProps } from 'next/link.js';
 import { type ComponentProps } from 'react';
+export declare const PENDING_NAVIGATION_EVENT = "cloudflare-next-intl:pending-navigation";
 export type PrefetchType = 'custom' | 'eager' | 'default';
 type NextLinkProps = Omit<ComponentProps<'a'>, keyof LinkProps> & Omit<LinkProps, 'locale'> & {
     prefetchType?: PrefetchType;

package/dist/src/server/components/link.js

@@ -5,6 +5,7 @@ import { forwardRef, useCallback, useEffect, useRef, useState, useTransition, }
 import config from '../../config/intl_config.js';
 import { getLocaleCache } from '../../general/cache_variables.js';
 import { usePathname, useRouter } from 'next/navigation.js';
+export const PENDING_NAVIGATION_EVENT = 'cloudflare-next-intl:pending-navigation';
 const prefetchedRoutes = new Set();
 function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPrefetchDelayMs = 100, onClick, onMouseEnter, onMouseLeave, onPointerDown, ...rest }, ref) {
     const localeValue = getLocaleCache();
@@ -25,8 +26,14 @@ function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPref
     const pathname = usePathname();
     const [isPending, startTransition] = useTransition();
     const [isNavigating, setIsNavigating] = useState(false);
+    const isFirstPathnameEffect = useRef(true);
     useEffect(() => {
         setIsNavigating(false);
+        if (isFirstPathnameEffect.current) {
+            isFirstPathnameEffect.current = false;
+            return;
+        }
+        window.dispatchEvent(new CustomEvent(PENDING_NAVIGATION_EVENT, { detail: null }));
     }, [pathname]);
     useEffect(() => {
         if (!isNavigating)
@@ -84,6 +91,8 @@ function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPref
         onClick?.(e);
         if (e.defaultPrevented)
             return;
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0)
+            return;
         if (isCustom && (isNavigating || isPending)) {
             e.preventDefault();
             return;
@@ -92,6 +101,7 @@ function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPref
             const targetPath = typeof pathnames === 'string' ? pathnames : urlString;
             if (pathname !== targetPath) {
                 setIsNavigating(true);
+                window.dispatchEvent(new CustomEvent(PENDING_NAVIGATION_EVENT, { detail: targetPath }));
             }
             startTransition(() => {
                 router.push(targetPath);

package/package.json

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