cloudflare-next-intl 0.8.3 → 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,21 +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, or a sync/async function
-  returning one (resolved on each connect, so the value can come from a secret
-  store). 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.
+  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
@@ -443,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`

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,7 +1,6 @@
 import reportError from '../error_handling/report_error';
 import requireDbConfig from './require_config';
 import resolveConfigValue from './resolve_config_value';
-const DEFAULT_BINDING = 'HYPERDRIVE';
 const DEFAULT_DISCONNECT_TIMEOUT_MS = 2000;
 let connectionString = null;
 let client = null;
@@ -27,24 +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) {
+async function resolveConnectionString(db) {
     const configured = await resolveConfigValue(db.connectionString);
     if (configured)
         return configured;
-    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.');
+    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
@@ -75,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;
@@ -84,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/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_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/types/types.d.ts

@@ -846,19 +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. May be a function
-     * (sync or async) resolved on each connect.
+     * 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`.
      */
     connectionString?: ConfigValue<string | undefined>;
-    /**
-     * 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.
-     */
-    hyperdriveBinding?: string;
     /**
      * Whether the pooled client is closed once the last in-flight
      * `withPublicDb`/`withUserDb` call of the request finishes.
@@ -889,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,7 +50,7 @@ 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 or a sync/async function returning one (resolved on each connect); 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).
+- 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).
@@ -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.3",
+  "version": "0.8.4",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",