cloudflare-next-intl 0.8.3 → 0.8.5

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`
@@ -559,6 +558,38 @@ re-export of `drizzle-orm`'s common query-building primitives (`eq`, `and`,
 `drizzle-orm` directly — this package re-exports the query-operator surface
 only, not the whole library.
 
+#### Schema codegen (`cfni-db-codegen`)
+
+The package ships a `cfni-db-codegen` binary that regenerates Drizzle models by
+introspecting a live Postgres with `drizzle-kit pull`, patches drizzle-kit's
+bare function-call defaults into raw-SQL-wrapped ones, and writes a
+`manifest.json` next to the schema so `--check` can fail CI when the DDL
+changed without regenerating.
+
+```bash
+npx cfni-db-codegen
+npx cfni-db-codegen --check
+```
+
+| Flag | Env | Default |
+| --- | --- | --- |
+| `--ddl-dir=` | `CFNI_DB_DDL_DIR` | `supabase/data-base` |
+| `--out-dir=` | `CFNI_DB_OUT_DIR` | `src/shared/db/generated` |
+| `--out-file=` | `CFNI_DB_OUT_FILE` | `schema.ts` |
+| `--db-url=` | `CODEGEN_DATABASE_URL` | `postgresql://postgres:postgres@127.0.0.1:54322/postgres` |
+| `--drizzle-config=` | `CFNI_DB_DRIZZLE_CONFIG` | none |
+| `--check` | — | off |
+
+`--out-dir` may be repeated, or given a comma-separated list, to generate the
+same schema into several projects in one run (`CFNI_DB_OUT_DIR` accepts a
+comma-separated list too). The database is introspected once and the identical
+schema plus manifest is written to every target; `--check` verifies all of
+them and fails naming the first one that is stale.
+
+```bash
+npx cfni-db-codegen --out-dir=src/shared/db/generated --out-dir=../other-app/src/db/generated
+```
+
 #### Testing code that calls `withPublicDb`/`withUserDb`
 
 `cloudflare-next-intl/dbTesting` exports a fake `DrizzleDb` so repository/unit

package/bin/db_codegen.mjs

@@ -2,6 +2,10 @@
 // Regenerates Drizzle models by introspecting a live Postgres with drizzle-kit.
 // Usage: cfni-db-codegen [--check] [--ddl-dir=…] [--out-dir=…] [--out-file=…] [--db-url=…] [--drizzle-config=…]
 //
+// --out-dir may be repeated, or given a comma-separated list, to generate the
+// same schema into several projects at once (CFNI_DB_OUT_DIR accepts a
+// comma-separated list too).
+//
 // Needs a reachable Postgres to introspect — any Postgres, not specifically
 // a Docker one. Set CODEGEN_DATABASE_URL to point at whichever you have:
 // local Supabase (./supabase/scripts/db_start.sh --reset, needs Docker), a
@@ -55,9 +59,10 @@ function ddlHash() {
 const hash = ddlHash();
 
 if (paths.check) {
-    const previous = existsSync(paths.manifest) ? JSON.parse(readFileSync(paths.manifest, "utf8")).ddlHash : null;
-    if (previous !== hash) {
-        console.error(`❌ ${relative(process.cwd(), paths.ddlDir)} changed without regenerating models. Run: npm run db:codegen`);
+    for (const target of paths.targets) {
+        const previous = existsSync(target.manifest) ? JSON.parse(readFileSync(target.manifest, "utf8")).ddlHash : null;
+        if (previous === hash) continue;
+        console.error(`❌ ${relative(process.cwd(), paths.ddlDir)} changed without regenerating models in ${relative(process.cwd(), target.outDir)}. Run: npm run db:codegen`);
         process.exit(1);
     }
     console.log(`✅ Drizzle models are in sync with ${relative(process.cwd(), paths.ddlDir)}`);
@@ -69,7 +74,6 @@ await assertReachable(paths.dbUrl);
 rmSync(paths.pullDir, { recursive: true, force: true });
 execFileSync('npx', ['drizzle-kit', 'pull', ...(paths.drizzleConfig ? [`--config=${paths.drizzleConfig}`] : [])], { stdio: 'inherit' });
 
-mkdirSync(paths.outDir, { recursive: true });
 const pulled = join(paths.pullDir, "schema.ts");
 if (!existsSync(pulled)) {
     console.error(`❌ drizzle-kit pull produced no schema at ${pulled}`);
@@ -104,7 +108,10 @@ function patchBareFunctionCallDefaults(source) {
 
 const banner = `// GENERATED by cfni-db-codegen from ${relative(process.cwd(), paths.ddlDir)} — do not edit.\n`;
 const pulledSource = patchBareFunctionCallDefaults(readFileSync(pulled, "utf8"));
-writeFileSync(paths.outFile, banner + pulledSource);
 rmSync(paths.pullDir, { recursive: true, force: true });
-writeFileSync(paths.manifest, `${JSON.stringify({ ddlHash: hash }, null, 2)}\n`);
-console.log(`✅ Generated ${relative(process.cwd(), paths.outFile)}`);
+for (const target of paths.targets) {
+    mkdirSync(target.outDir, { recursive: true });
+    writeFileSync(target.outFile, banner + pulledSource);
+    writeFileSync(target.manifest, `${JSON.stringify({ ddlHash: hash }, null, 2)}\n`);
+    console.log(`✅ Generated ${relative(process.cwd(), target.outFile)}`);
+}

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

@@ -1,5 +1,11 @@
+export interface CodegenTarget {
+    outDir: string;
+    outFile: string;
+    manifest: string;
+}
 export interface CodegenPaths {
     ddlDir: string;
+    targets: CodegenTarget[];
     outDir: string;
     outFile: string;
     pullDir: string;

package/dist/src/db/codegen_paths.js

@@ -4,6 +4,13 @@ const DEFAULT_OUT_DIR = 'src/shared/db/generated';
 const DEFAULT_OUT_FILE = 'schema.ts';
 const DEFAULT_DB_URL = 'postgresql://postgres:postgres@127.0.0.1:54322/postgres';
 const DEFAULT_TIMEOUT_MS = 5000;
+function flags(argv, name) {
+    const prefix = `--${name}=`;
+    return argv.filter((arg) => arg.startsWith(prefix)).map((arg) => arg.slice(prefix.length));
+}
+function list(value) {
+    return value.split(',').map((part) => part.trim()).filter(Boolean);
+}
 function flag(argv, name) {
     const prefix = `--${name}=`;
     const hit = argv.find((arg) => arg.startsWith(prefix));
@@ -15,11 +22,22 @@ function abs(cwd, value) {
 /** Resolves every codegen path from flags, then env, then the documented defaults. */
 export default function resolveCodegenPaths(argv, env, cwd) {
     const ddlDir = abs(cwd, flag(argv, 'ddl-dir') ?? env.CFNI_DB_DDL_DIR ?? DEFAULT_DDL_DIR);
-    const outDir = abs(cwd, flag(argv, 'out-dir') ?? env.CFNI_DB_OUT_DIR ?? DEFAULT_OUT_DIR);
+    const outDirArgs = flags(argv, 'out-dir').flatMap(list);
+    const outDirs = (outDirArgs.length > 0
+        ? outDirArgs
+        : list(env.CFNI_DB_OUT_DIR ?? '')).map((dir) => abs(cwd, dir));
+    if (outDirs.length === 0)
+        outDirs.push(abs(cwd, DEFAULT_OUT_DIR));
+    const outDir = outDirs[0];
     const outFileName = flag(argv, 'out-file') ?? env.CFNI_DB_OUT_FILE ?? DEFAULT_OUT_FILE;
     const drizzleConfig = flag(argv, 'drizzle-config') ?? env.CFNI_DB_DRIZZLE_CONFIG ?? null;
     return {
         ddlDir,
+        targets: outDirs.map((dir) => ({
+            outDir: dir,
+            outFile: join(dir, outFileName),
+            manifest: join(dir, 'manifest.json'),
+        })),
         outDir,
         outFile: join(outDir, outFileName),
         pullDir: resolve(outDir, '..', '.drizzle-pull'),

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).
@@ -60,6 +60,7 @@ Two transports, picked by which `db` fields are set — `pg`/`drizzle-orm`/`@sup
 - `withPublicDb(fn)` — anonymous role. Direct-Postgres mode: the request's pooled connection, no transaction, no role switch. Supabase mode: the anon key as the PostgREST bearer token. Either way, no user id is attached — RLS keyed on `auth.jwt()` denies access.
 - `withUserDb(fn, uid?)` — signed-in-user role. Direct-Postgres mode: a transaction with `set_config('request.jwt.claims', ...)` + `set local role`, `uid` resolution order explicit arg → `db.getUserId()` → Firebase auth uid → throws. Supabase mode: identity rides on the JWT from `db.getAccessToken`/Firebase instead (`uid` param is ignored), no transaction wraps the call.
 - `./dbHelpers` functions are plain Drizzle `sql`-building utilities with no config dependency — usable standalone.
+- `cfni-db-codegen` binary — regenerates Drizzle models via `drizzle-kit pull`. Flags/env: `--ddl-dir`/`CFNI_DB_DDL_DIR`, `--out-dir`/`CFNI_DB_OUT_DIR`, `--out-file`/`CFNI_DB_OUT_FILE`, `--db-url`/`CODEGEN_DATABASE_URL`, `--drizzle-config`/`CFNI_DB_DRIZZLE_CONFIG`, `--check`. `--out-dir` is repeatable and accepts a comma-separated list, so one run generates the same schema (and `manifest.json`) into several projects; `--check` verifies every target.
 
 ```typescript
 // src/i18n/intl_config.ts
@@ -69,7 +70,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.5",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",