cloudflare-next-intl 0.8.2 → 0.8.4

package/README.md

@@ -14,7 +14,7 @@ and Cloudflare environment.
 - **Error handling**: shared, opt-in `console.error` override and
   `reportError`/`withErrorHandling` helpers, GDPR-aware (consent-gated).
 - **Database**: optional Postgres/Drizzle data-access layer, reachable either
-  directly (Cloudflare Hyperdrive or a connection string) or through the
+  directly (a connection string, e.g. from Cloudflare Hyperdrive) or through the
   Supabase Data API (project URL + anon key only), with request-scoped
   public/user contexts and RLS wiring in both modes.
 
@@ -390,8 +390,8 @@ third party without consent can itself be GDPR-relevant.
 
 ### Database (`db`)
 
-Thin Postgres/Drizzle data-access layer over a Cloudflare Hyperdrive binding
-(or a plain connection string). `pg` and `drizzle-orm` ship as dependencies of
+Thin Postgres/Drizzle data-access layer over a Postgres connection string
+(which may come from a Cloudflare Hyperdrive binding). `pg` and `drizzle-orm` ship as dependencies of
 this package, so there is nothing extra to install. They are loaded through
 dynamic `import()` inside the `db` exports, so an app that never calls a `db`
 export never pulls them into its bundle. Enable it by setting `db` on your
@@ -405,19 +405,20 @@ export default setIntlConfig({
     locales: ["en", "uk"] as const,
     defaultLocale: "en",
     generate: { getCloudflareContext },
-    db: { hyperdriveBinding: "HYPERDRIVE" },
+    db: {
+        connectionString: async () =>
+            (await getCloudflareContext({ async: true })).env.HYPERDRIVE
+                .connectionString,
+    },
 });
 ```
 
 `db` fields (all optional):
 
-- `connectionString` — a Postgres connection string. Omit to resolve it from
-  the Hyperdrive binding named by `hyperdriveBinding` instead (the normal
-  production setup); a value here always wins over the binding, which is
-  what makes local dev / build-time evaluation work.
-- `hyperdriveBinding` — name of the Hyperdrive binding on `env` to read a
-  connection string from when `connectionString` is not set. Defaults to
-  `'HYPERDRIVE'`. Requires `generate.getCloudflareContext` to be configured.
+- `connectionString` — a Postgres connection string, or a sync/async function
+  returning one (resolved on each connect). The function form is how you reach
+  a value that isn't available at module scope — a Cloudflare Hyperdrive
+  binding, or a secret store — as in the example above.
 - `disconnectAfterRequest` — whether the pooled client is closed once the
   last in-flight `withPublicDb`/`withUserDb` call of the request
   finishes. Defaults to `true` (one connection per request, released to
@@ -441,7 +442,7 @@ query code is identical either way — switching is a config change only.
 
 | Config | Transport | Use when |
 |---|---|---|
-| `connectionString` or `hyperdriveBinding` | Direct Postgres via `pg` | You have a Postgres password or a Hyperdrive binding. |
+| `connectionString` | Direct Postgres via `pg` | You have a Postgres connection string, or a Hyperdrive binding to read one from. |
 | `supabase` | Supabase Data API (PostgREST) | You only have `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_ANON_KEY`. |
 
 A direct connection always wins if both are configured, so adding a `supabase`
@@ -472,11 +473,35 @@ bundles any of them.
 
 `db.supabase` fields (all optional):
 
-- `url` — project URL. Defaults to `NEXT_PUBLIC_SUPABASE_URL`.
-- `anonKey` — anon/publishable key. Defaults to `NEXT_PUBLIC_SUPABASE_ANON_KEY`.
-  Never put a service-role key here.
+- `url` — project URL, or a sync/async function returning one. Defaults to
+  `NEXT_PUBLIC_SUPABASE_URL`.
+- `anonKey` — anon/publishable key, or a sync/async function returning one.
+  Defaults to `NEXT_PUBLIC_SUPABASE_ANON_KEY`. Never put a service-role key
+  here.
 - `execFunction` — name of the exec function. Defaults to `'cfni_exec'`.
 
+Any of `connectionString`, `supabase.url`, and `supabase.anonKey` may be a
+function instead of a string, resolved (and awaited) at use time rather than
+when the config object is built — useful when the value lives in a secret
+store or a Cloudflare binding rather than an environment variable:
+
+```typescript
+export default setIntlConfig({
+    locales: ["en", "uk"] as const,
+    defaultLocale: "en",
+    generate: { getCloudflareContext },
+    db: {
+        supabase: {
+            url: "https://abc.supabase.co",
+            anonKey: async () => {
+                const { env } = await getCloudflareContext({ async: true });
+                return env.SUPABASE_ANON_KEY.get();
+            },
+        },
+    },
+});
+```
+
 `db.getAccessToken` resolves the JWT `withUserDb` sends as
 `Authorization: Bearer`, which is what makes PostgREST resolve the caller as
 `authenticated`. Omit it when `firebaseAuth` is configured — the signed-in

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

@@ -23,7 +23,7 @@ export declare function resetConnectionState(): void;
  * @param config Your routing config; `config.db` must be set.
  * @returns The connected, shared client.
  * @throws If `db` is not set, or no connection string can be resolved from
- * `db.connectionString` or the Hyperdrive binding.
+ * `db.connectionString`.
  */
 export default function connectToPostgres(config: DbConfig): Promise<Client>;
 /**

package/dist/src/db/connection.js

@@ -1,6 +1,6 @@
 import reportError from '../error_handling/report_error';
 import requireDbConfig from './require_config';
-const DEFAULT_BINDING = 'HYPERDRIVE';
+import resolveConfigValue from './resolve_config_value';
 const DEFAULT_DISCONNECT_TIMEOUT_MS = 2000;
 let connectionString = null;
 let client = null;
@@ -26,23 +26,16 @@ export function resetConnectionState() {
     activeUsers = 0;
 }
 /**
- * Resolves the connection string from `db.connectionString` first, then the
- * Cloudflare Hyperdrive binding named by `db.hyperdriveBinding`.
+ * Resolves the connection string from `db.connectionString`, awaiting it when
+ * it was given as a function.
  */
-async function resolveConnectionString(config, db) {
-    if (db.connectionString)
-        return db.connectionString;
-    const getContext = config.generate?.getCloudflareContext;
-    if (getContext) {
-        const context = await getContext({ async: true });
-        const env = context?.env;
-        const binding = env?.[db.hyperdriveBinding ?? DEFAULT_BINDING];
-        if (binding?.connectionString)
-            return binding.connectionString;
-    }
-    throw new Error('db: could not resolve a Postgres connection string. Set `db.connectionString`, or ' +
-        `configure \`generate.getCloudflareContext\` and a \`${db.hyperdriveBinding ?? DEFAULT_BINDING}\` ` +
-        'Hyperdrive binding on your Worker.');
+async function resolveConnectionString(db) {
+    const configured = await resolveConfigValue(db.connectionString);
+    if (configured)
+        return configured;
+    throw new Error('db: could not resolve a Postgres connection string. Set `db.connectionString` ' +
+        'to a connection string, or to a function returning one (e.g. reading a ' +
+        'Hyperdrive binding off `getCloudflareContext().env`).');
 }
 // A single `pg.Client` is not safe for concurrent queries; Next.js fires many
 // in parallel per request. Serializing every `query` through one promise chain
@@ -73,7 +66,7 @@ function serializeQueries(raw) {
  * @param config Your routing config; `config.db` must be set.
  * @returns The connected, shared client.
  * @throws If `db` is not set, or no connection string can be resolved from
- * `db.connectionString` or the Hyperdrive binding.
+ * `db.connectionString`.
  */
 export default async function connectToPostgres(config) {
     const db = config.db;
@@ -82,7 +75,7 @@ export default async function connectToPostgres(config) {
     if (connectingPromise === null) {
         connectingPromise = (async () => {
             try {
-                connectionString ?? (connectionString = await resolveConnectionString(config, db));
+                connectionString ?? (connectionString = await resolveConnectionString(db));
                 const { Client } = await import('pg');
                 const created = serializeQueries(new Client({ connectionString }));
                 client = created;

package/dist/src/db/context.js

@@ -60,7 +60,7 @@ export async function withPublicDb(fn) {
     requireDbConfig(db);
     if (resolveDbMode(db) === 'supabase') {
         const supabase = db.supabase;
-        const { anonKey } = resolveSupabaseEndpoint(supabase);
+        const { anonKey } = await resolveSupabaseEndpoint(supabase);
         return fn(await supabaseDb(supabase, anonKey));
     }
     const client = await connectToPostgres(config);

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

@@ -60,5 +60,21 @@ export declare function maxOf<T = unknown>(expression: unknown): SQL<T>;
 export declare function roundReal(expression: unknown, digits: number): SQL<number>;
 /** Multiplies an expression by a factor. */
 export declare function multiply(expression: unknown, factor: number): SQL<number>;
+/**
+ * Wraps an aggregate over a subquery/CTE as a scalar subquery:
+ * `(select <expr> from <source>)`.
+ *
+ * Unlike {@link scalarFromCte} this takes the Drizzle CTE/subquery object
+ * rather than its name, so the source is referenced through the query builder
+ * and its columns stay typed.
+ *
+ * @param source A Drizzle CTE or subquery to read from.
+ * @param expression The aggregate expression to select.
+ * @returns A scalar subquery usable directly in a `select({...})`.
+ *
+ * @example
+ * select({ lowest: scalarFrom(filtered, minOf(filtered.price)) })
+ */
+export declare function scalarFrom<T = unknown>(source: unknown, expression: unknown): SQL<T>;
 /** Wraps an expression as a scalar subquery over a named CTE: `(select <expr> from <cte>)`. */
 export declare function scalarFromCte<T = unknown>(cte: string, expression: unknown): SQL<T>;

package/dist/src/db/helpers.js

@@ -113,6 +113,24 @@ export function roundReal(expression, digits) {
 export function multiply(expression, factor) {
     return sql `${expression} * ${factor}`;
 }
+/**
+ * Wraps an aggregate over a subquery/CTE as a scalar subquery:
+ * `(select <expr> from <source>)`.
+ *
+ * Unlike {@link scalarFromCte} this takes the Drizzle CTE/subquery object
+ * rather than its name, so the source is referenced through the query builder
+ * and its columns stay typed.
+ *
+ * @param source A Drizzle CTE or subquery to read from.
+ * @param expression The aggregate expression to select.
+ * @returns A scalar subquery usable directly in a `select({...})`.
+ *
+ * @example
+ * select({ lowest: scalarFrom(filtered, minOf(filtered.price)) })
+ */
+export function scalarFrom(source, expression) {
+    return sql `(select ${expression} from ${source})`;
+}
 /** Wraps an expression as a scalar subquery over a named CTE: `(select <expr> from <cte>)`. */
 export function scalarFromCte(cte, expression) {
     return sql `(select ${expression} from ${sql.raw(cte)})`;

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

@@ -8,10 +8,9 @@
  * - {@link withUserDb} — the signed-in user, with RLS applied to their id.
  *
  * Two transports reach Postgres behind that same Drizzle query API, chosen by
- * `resolveDbMode` from which `db` config fields are set: `connectionString`/
- * `hyperdriveBinding` for a direct connection (wins if both are configured),
- * or `supabase` for the Supabase Data API when only a project URL and anon
- * key are available. `pg`, `drizzle-orm`, and `@supabase/supabase-js` all
+ * `resolveDbMode` from which `db` config fields are set: `connectionString`
+ * for a direct connection (wins if both are configured), or `supabase` for
+ * the Supabase Data API when only a project URL and anon key are available. `pg`, `drizzle-orm`, and `@supabase/supabase-js` all
  * load through dynamic `import()` inside these functions, so an app that
  * never calls a `db` export never bundles any of them.
  *

package/dist/src/db/index.js

@@ -8,10 +8,9 @@
  * - {@link withUserDb} — the signed-in user, with RLS applied to their id.
  *
  * Two transports reach Postgres behind that same Drizzle query API, chosen by
- * `resolveDbMode` from which `db` config fields are set: `connectionString`/
- * `hyperdriveBinding` for a direct connection (wins if both are configured),
- * or `supabase` for the Supabase Data API when only a project URL and anon
- * key are available. `pg`, `drizzle-orm`, and `@supabase/supabase-js` all
+ * `resolveDbMode` from which `db` config fields are set: `connectionString`
+ * for a direct connection (wins if both are configured), or `supabase` for
+ * the Supabase Data API when only a project URL and anon key are available. `pg`, `drizzle-orm`, and `@supabase/supabase-js` all
  * load through dynamic `import()` inside these functions, so an app that
  * never calls a `db` export never bundles any of them.
  *

package/dist/src/db/require_config.js

@@ -14,7 +14,7 @@
 export default function requireDbConfig(db) {
     if (!db) {
         throw new Error('db: `db` is not set on your RoutingConfig. Add a `db` object ' +
-            '(connectionString or hyperdriveBinding) to the config passed to ' +
+            '(connectionString or supabase) to the config passed to ' +
             '`setIntlConfig` before using any db export.');
     }
 }

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

@@ -0,0 +1,9 @@
+import type { ConfigValue } from '../types/types';
+/**
+ * Resolves a config value that may have been supplied directly or as a
+ * sync/async function.
+ *
+ * @param value The configured value or resolver.
+ * @returns The resolved value, or `undefined` when nothing was configured.
+ */
+export default function resolveConfigValue<T>(value: ConfigValue<T | undefined> | undefined): Promise<T | undefined>;

package/dist/src/db/resolve_config_value.js

@@ -0,0 +1,10 @@
+/**
+ * Resolves a config value that may have been supplied directly or as a
+ * sync/async function.
+ *
+ * @param value The configured value or resolver.
+ * @returns The resolved value, or `undefined` when nothing was configured.
+ */
+export default async function resolveConfigValue(value) {
+    return typeof value === 'function' ? value() : value;
+}

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

@@ -8,10 +8,10 @@ export type DbMode = 'postgres' | 'supabase';
  * block to an existing config never silently reroutes live traffic. With
  * neither set the result is still `'postgres'`, which lets
  * `connectToPostgres` raise its existing, more specific error about the
- * missing Hyperdrive binding.
+ * missing connection string.
  *
  * @param db The `db` field off your routing config.
- * @returns `'postgres'` for connection-string/Hyperdrive access, `'supabase'`
+ * @returns `'postgres'` for direct connection-string access, `'supabase'`
  * for PostgREST access.
  */
 export default function resolveDbMode(db: DbRoutingConfig): DbMode;

package/dist/src/db/resolve_mode.js

@@ -5,14 +5,14 @@
  * block to an existing config never silently reroutes live traffic. With
  * neither set the result is still `'postgres'`, which lets
  * `connectToPostgres` raise its existing, more specific error about the
- * missing Hyperdrive binding.
+ * missing connection string.
  *
  * @param db The `db` field off your routing config.
- * @returns `'postgres'` for connection-string/Hyperdrive access, `'supabase'`
+ * @returns `'postgres'` for direct connection-string access, `'supabase'`
  * for PostgREST access.
  */
 export default function resolveDbMode(db) {
-    if (db.connectionString || db.hyperdriveBinding)
+    if (db.connectionString)
         return 'postgres';
     return db.supabase ? 'supabase' : 'postgres';
 }

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

@@ -13,6 +13,7 @@ export interface ResolvedSupabaseEndpoint {
  *
  * @param supabase The `db.supabase` config block.
  * @returns The project URL and anon key to build a Supabase client from.
+ * Values given as functions are resolved here.
  * @throws If neither config nor environment supplies a URL or an anon key.
  */
-export default function resolveSupabaseEndpoint(supabase: SupabaseDbConfig): ResolvedSupabaseEndpoint;
+export default function resolveSupabaseEndpoint(supabase: SupabaseDbConfig): Promise<ResolvedSupabaseEndpoint>;

package/dist/src/db/supabase_config.js

@@ -1,3 +1,4 @@
+import resolveConfigValue from './resolve_config_value';
 /**
  * Resolves the Supabase project URL and anon key, preferring explicit config
  * over the `NEXT_PUBLIC_SUPABASE_URL`/`NEXT_PUBLIC_SUPABASE_ANON_KEY`
@@ -5,15 +6,16 @@
  *
  * @param supabase The `db.supabase` config block.
  * @returns The project URL and anon key to build a Supabase client from.
+ * Values given as functions are resolved here.
  * @throws If neither config nor environment supplies a URL or an anon key.
  */
-export default function resolveSupabaseEndpoint(supabase) {
-    const url = supabase.url ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
+export default async function resolveSupabaseEndpoint(supabase) {
+    const url = (await resolveConfigValue(supabase.url)) ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
     if (!url) {
         throw new Error('db: could not resolve a Supabase project URL. Set `db.supabase.url` ' +
             'or the NEXT_PUBLIC_SUPABASE_URL environment variable.');
     }
-    const anonKey = supabase.anonKey ?? process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+    const anonKey = (await resolveConfigValue(supabase.anonKey)) ?? process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
     if (!anonKey) {
         throw new Error('db: could not resolve a Supabase anon key. Set `db.supabase.anonKey` ' +
             'or the NEXT_PUBLIC_SUPABASE_ANON_KEY environment variable.');

package/dist/src/db/supabase_transport.js

@@ -21,11 +21,11 @@ const DEFAULT_EXEC_FUNCTION = 'cfni_exec';
  * @returns A callback suitable for `drizzle-orm/pg-proxy`'s `drizzle()`.
  */
 export default function createSupabaseTransport(supabase, bearerToken) {
-    const { url, anonKey } = resolveSupabaseEndpoint(supabase);
     const execFunction = supabase.execFunction ?? DEFAULT_EXEC_FUNCTION;
     let clientPromise = null;
     async function getClient() {
         clientPromise ?? (clientPromise = (async () => {
+            const { url, anonKey } = await resolveSupabaseEndpoint(supabase);
             const { createClient } = await import('@supabase/supabase-js');
             return createClient(url, anonKey, { accessToken: async () => bearerToken });
         })());

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

@@ -1 +1 @@
-export type { CookieAttributes, LocalePrefixMode, Locales, ReturnType, RoutingConfig, TranslationEntry, TranslationObject, TranslatorReturnType, Alternates, changeFrequency, IntlSitemap, CookieConsentRoutingConfig, CookieConsentAnalyticsConfig, CookieConsentCloudflareContext, CookieConsentGetCloudflareContext, DbRoutingConfig, SupabaseDbConfig, } from './types';
+export type { CookieAttributes, LocalePrefixMode, Locales, ReturnType, RoutingConfig, TranslationEntry, TranslationObject, TranslatorReturnType, Alternates, changeFrequency, IntlSitemap, CookieConsentRoutingConfig, CookieConsentAnalyticsConfig, CookieConsentCloudflareContext, CookieConsentGetCloudflareContext, DbRoutingConfig, SupabaseDbConfig, ConfigValue, } from './types';

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

@@ -817,18 +817,27 @@ export interface IntlSitemap {
     lastModified: Date | string | undefined;
     videos?: Videos[] | undefined;
 }
+/**
+ * A config value that may be given directly, or as a sync/async function
+ * resolved at use time. The function form lets a value come from a secret
+ * store, a Cloudflare binding, or any other source that isn't available when
+ * the config object is first created.
+ */
+export type ConfigValue<T> = T | (() => T | Promise<T>);
 export interface SupabaseDbConfig {
     /**
      * Supabase project URL, e.g. `https://abc.supabase.co`. Defaults to
-     * `process.env.NEXT_PUBLIC_SUPABASE_URL`.
+     * `process.env.NEXT_PUBLIC_SUPABASE_URL`. May be a function (sync or
+     * async) resolved on each use.
      */
-    url?: string;
+    url?: ConfigValue<string | undefined>;
     /**
      * Supabase anon (publishable) key. Defaults to
      * `process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY`. This is the only key the
-     * `db` module ever needs — never put a service-role key here.
+     * `db` module ever needs — never put a service-role key here. May be a
+     * function (sync or async) resolved on each use.
      */
-    anonKey?: string;
+    anonKey?: ConfigValue<string | undefined>;
     /**
      * Name of the Postgres function that runs the generated SQL. Defaults to
      * `'cfni_exec'` — the function shipped in `supabase/cfni_exec.sql`.
@@ -837,18 +846,13 @@ export interface SupabaseDbConfig {
 }
 export interface DbRoutingConfig {
     /**
-     * Postgres connection string. Omit to resolve it from the Cloudflare
-     * Hyperdrive binding named by `hyperdriveBinding` instead (the normal
-     * production setup); a value here always wins over the binding, which is
-     * what makes local dev / build-time evaluation work.
-     */
-    connectionString?: string;
-    /**
-     * Name of the Hyperdrive binding on `env` whose `connectionString` is used
-     * when `connectionString` is not set. Defaults to `'HYPERDRIVE'`. Requires
-     * `generate.getCloudflareContext` to be configured.
+     * Postgres connection string, or a function (sync or async) returning one,
+     * resolved on each connect. The function form is how you reach a value that
+     * isn't available at module scope — e.g. a Cloudflare Hyperdrive binding:
+     * `connectionString: async () => (await getCloudflareContext({ async: true
+     * })).env.HYPERDRIVE.connectionString`.
      */
-    hyperdriveBinding?: string;
+    connectionString?: ConfigValue<string | undefined>;
     /**
      * Whether the pooled client is closed once the last in-flight
      * `withPublicDb`/`withUserDb` call of the request finishes.
@@ -879,7 +883,7 @@ export interface DbRoutingConfig {
      * `withUserDb` behave the same either way, so switching is a config change
      * with no app-code change.
      *
-     * Ignored when `connectionString` or `hyperdriveBinding` is set: a direct
+     * Ignored when `connectionString` is set: a direct
      * connection always wins, so adding this block cannot silently reroute
      * live traffic. Requires the `cfni_exec` function from
      * `supabase/cfni_exec.sql` to be installed in your database.

package/llms.txt

@@ -50,8 +50,8 @@ other subpath can be used.
 
 Two transports, picked by which `db` fields are set — `pg`/`drizzle-orm`/`@supabase/supabase-js` ship as dependencies and load via dynamic `import()`, so nothing bundles unless a `db` export is called.
 
-- Direct Postgres (wins if configured): `db.connectionString` — Postgres connection string; when omitted, resolved from the Hyperdrive binding named by `db.hyperdriveBinding` (default `'HYPERDRIVE'`) via `generate.getCloudflareContext`. An explicit `connectionString` always wins (enables local dev / build-time evaluation).
-- Supabase Data API (used only when neither of the above is set): `db.supabase` — `{ url?, anonKey?, execFunction? }`, defaulting `url`/`anonKey` to `NEXT_PUBLIC_SUPABASE_URL`/`NEXT_PUBLIC_SUPABASE_ANON_KEY`. Requires installing `supabase/cfni_exec.sql` (a `security invoker` SQL-exec function) in your database. No multi-statement transactions — each statement in a `withUserDb` callback is its own round-trip.
+- Direct Postgres (wins if configured): `db.connectionString` — Postgres connection string, or a sync/async function returning one (resolved on each connect). The function form is the way to read a value unavailable at module scope, e.g. a Cloudflare Hyperdrive binding: `connectionString: async () => (await getCloudflareContext({ async: true })).env.HYPERDRIVE.connectionString`. There is no separate `hyperdriveBinding` option.
+- Supabase Data API (used only when neither of the above is set): `db.supabase` — `{ url?, anonKey?, execFunction? }` where `url`/`anonKey` each accept a string or a sync/async function returning one, defaulting `url`/`anonKey` to `NEXT_PUBLIC_SUPABASE_URL`/`NEXT_PUBLIC_SUPABASE_ANON_KEY`. Requires installing `supabase/cfni_exec.sql` (a `security invoker` SQL-exec function) in your database. No multi-statement transactions — each statement in a `withUserDb` callback is its own round-trip.
 - `db.disconnectAfterRequest` — direct-Postgres mode only: closes the pooled client once the last in-flight `withPublicDb`/`withUserDb` call of the request finishes. Defaults to `true`; set `false` to keep the connection open for the isolate's lifetime (holds a Hyperdrive slot between requests).
 - `db.authenticatedRole` — direct-Postgres mode only: Postgres role assumed inside `withUserDb`'s transaction. Defaults to `'authenticated'` (Supabase RLS convention).
 - `db.getUserId` — direct-Postgres mode only: resolves the user id injected as `request.jwt.claims->>'sub'` in `withUserDb`. Omit when `firebaseAuth` is configured — the uid is then taken automatically from the signed-in Firebase user via this package's own `getAuthUser()`.
@@ -69,7 +69,11 @@ export default setIntlConfig({
     locales: ["en", "uk"] as const,
     defaultLocale: "en",
     generate: { getCloudflareContext },
-    db: { hyperdriveBinding: "HYPERDRIVE" },
+    db: {
+        connectionString: async () =>
+            (await getCloudflareContext({ async: true })).env.HYPERDRIVE
+                .connectionString,
+    },
 });
 
 // anywhere on the server

package/package.json

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