cloudflare-next-intl 0.8.16 → 0.8.18

package/README.md

@@ -584,17 +584,9 @@ below for the `.transaction()` API that does.
 
 Call `.transaction(...)` on the handle `withUserDb`/`withPublicDb` hand your
 callback whenever a write needs more than one statement to succeed or fail
-together — same method name in both transport modes.
+together — same method name and same signature in both transport modes.
 
-In connection-string mode this is a real Drizzle transaction: `await
-db.transaction(async (tx) => { await tx.insert(...); await tx.update(...); })`,
-and a later statement may use an earlier one's result, exactly like plain
-Drizzle usage.
-
-In Supabase mode there is no shared session for `.transaction()` to open, so
-its callback instead **builds** queries rather than executing them — call
-`.toSQL()` on each Drizzle query and return the array, rather than `await`ing
-the query directly:
+To achieve mode-transparency between Postgres/connection-string mode and Supabase/REST mode, the callback **builds** queries rather than executing them directly: call `.toSQL()` on each Drizzle query and return the array, rather than `await`ing the query directly.
 
 ```typescript
 import { withUserDb } from "cloudflare-next-intl/db";
@@ -608,26 +600,13 @@ const [invitationResult, grantResult] = await withUserDb((db) =>
 );
 ```
 
-Every query in the array is rendered and sent to Postgres as **one**
-`cfni_exec_batch` call: the function runs each statement in order inside a
-single plpgsql call, which is itself an implicit transaction, so a failure on
-any statement rolls back every statement that ran before it in the same
-batch. `cfni_exec_batch` ships alongside `cfni_exec` in the same
-`supabase/cfni_exec.sql` file (installed the same way — see
-[Schema codegen](#schema-codegen-cfni-db-codegen) below) and is available
-whenever `cfni_exec` is: there is no separate config flag, and
-`db.supabase.rawSql: false` turns off both.
-
-Each result is the same `{ rows, rowCount }` shape a single `cfni_exec` call
-returns — decode rows the same way you would from `db.execute(sql\`...\`)`.
-
-`await`ing a query directly inside the Supabase-mode `.transaction()`
-callback (instead of calling `.toSQL()`) throws immediately, naming the
-mistake, rather than hanging or silently running that one statement outside
-the batch with no atomicity. This also means, unlike connection-string mode,
-a later statement in a Supabase-mode `.transaction()` callback cannot read an
-earlier one's result — build every statement from arguments/closures you
-already have.
+Every query in the array is executed sequentially in a single transaction blocks/batch:
+- In **Supabase mode**, they are sent in one round-trip to `cfni_exec_batch` which runs them inside a single `plpgsql` block.
+- In **connection-string mode**, they are run sequentially over the Postgres client inside a standard Drizzle transaction.
+
+Either way, a failure on any statement rolls back every statement that ran before it in the transaction.
+
+Each result is the `{ rows, rowCount }` shape. Because the callback only builds queries, a later statement in a `.transaction()` callback cannot read an earlier one's result — build every statement from arguments/closures you already have. `await`ing a query directly inside `.transaction()` throws immediately to prevent running queries outside the transaction boundary.
 
 #### Supabase mode and REST translation
 

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

@@ -1,6 +1,19 @@
 import type { Client } from 'pg';
 import type { LocalePrefixMode, Locales, RoutingConfig } from '../types/types';
 export type DbConfig = RoutingConfig<Locales, LocalePrefixMode>;
+/**
+ * Runs `fn` exclusively against the shared client: no other
+ * `withSessionLock` caller's queries can interleave with `fn`'s until it
+ * settles. `serializeQueries` alone only orders individual `.query()` calls —
+ * it does nothing to stop a *different* concurrent request's queries from
+ * landing between, say, a transaction's `BEGIN`/`SET LOCAL ROLE` and its
+ * `COMMIT` on the one `pg.Client` every request in the isolate shares. That
+ * gap let one request's role/RLS identity leak into another's queries
+ * whenever two requests overlapped in the same Worker isolate. Every caller
+ * that opens a transaction, or otherwise depends on session-scoped state
+ * (`SET LOCAL`, `set_config(..., true)`), MUST run inside this lock.
+ */
+export declare function withSessionLock<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Forgets the cached client and connection string so the next
  * `connectToPostgres` call builds both from scratch. Intended for tests and

package/dist/src/db/connection.js

@@ -5,9 +5,33 @@ const DEFAULT_DISCONNECT_TIMEOUT_MS = 2000;
 let connectionString = null;
 let client = null;
 let connectionPromise = null;
-let connectingPromise = null;
 let disconnectionPromise = null;
 let activeUsers = 0;
+let sessionLock = Promise.resolve();
+/**
+ * Runs `fn` exclusively against the shared client: no other
+ * `withSessionLock` caller's queries can interleave with `fn`'s until it
+ * settles. `serializeQueries` alone only orders individual `.query()` calls —
+ * it does nothing to stop a *different* concurrent request's queries from
+ * landing between, say, a transaction's `BEGIN`/`SET LOCAL ROLE` and its
+ * `COMMIT` on the one `pg.Client` every request in the isolate shares. That
+ * gap let one request's role/RLS identity leak into another's queries
+ * whenever two requests overlapped in the same Worker isolate. Every caller
+ * that opens a transaction, or otherwise depends on session-scoped state
+ * (`SET LOCAL`, `set_config(..., true)`), MUST run inside this lock.
+ */
+export async function withSessionLock(fn) {
+    const previous = sessionLock;
+    let release;
+    sessionLock = new Promise((resolve) => { release = resolve; });
+    await previous;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
 /**
  * Forgets the cached client and connection string so the next
  * `connectToPostgres` call builds both from scratch. Intended for tests and
@@ -21,9 +45,9 @@ export function resetConnectionState() {
     connectionString = null;
     client = null;
     connectionPromise = null;
-    connectingPromise = null;
     disconnectionPromise = null;
     activeUsers = 0;
+    sessionLock = Promise.resolve();
 }
 /**
  * Resolves the connection string from `db.connectionString`, awaiting it when
@@ -76,31 +100,35 @@ export default async function connectToPostgres(config, resolved) {
     const db = config.db;
     requireDbConfig(db);
     await disconnectionPromise;
-    if (connectingPromise === null) {
-        connectingPromise = (async () => {
-            try {
-                connectionString ?? (connectionString = resolved ?? await resolveConnectionString(db));
-                const { Client } = await import('pg');
-                const created = serializeQueries(new Client({ connectionString }));
-                client = created;
-                connectionPromise = created.connect();
-                await connectionPromise;
-                return created;
-            }
-            catch (error) {
-                // A failed connect must not be cached forever — clear state so the
-                // next call retries instead of replaying the same rejection for the
-                // life of the Worker isolate.
-                connectingPromise = null;
-                connectionString = null;
-                client = null;
-                connectionPromise = null;
-                throw error;
-            }
+    // Guards the race between concurrent callers that both see `client ===
+    // null` before either has awaited anything: `connectionPromise` is set
+    // synchronously (before the `await`s below) so every caller in the same
+    // microtask tick shares the one client being created instead of each
+    // starting its own.
+    if (connectionPromise === null) {
+        connectionPromise = (async () => {
+            connectionString = resolved ?? await resolveConnectionString(db);
+            const { Client } = await import('pg');
+            const created = serializeQueries(new Client({ connectionString }));
+            client = created;
+            await created.connect();
+            return created;
         })();
     }
     activeUsers++;
-    return connectingPromise;
+    try {
+        return await connectionPromise;
+    }
+    catch (error) {
+        // A failed connect must not be cached forever — clear state so the
+        // next call retries instead of replaying the same rejection for the
+        // life of the Worker isolate.
+        activeUsers = Math.max(0, activeUsers - 1);
+        connectionString = null;
+        client = null;
+        connectionPromise = null;
+        throw error;
+    }
 }
 /**
  * Releases one caller's hold on the shared client, closing it once the last
@@ -127,7 +155,6 @@ export function disconnectPostgres(config) {
     // instead of reusing one that is about to close.
     client = null;
     connectionPromise = null;
-    connectingPromise = null;
     const endPromise = closing.end();
     disconnectionPromise = endPromise;
     const timeoutMs = db.disconnectTimeoutMs ?? DEFAULT_DISCONNECT_TIMEOUT_MS;

package/dist/src/db/context.js

@@ -1,11 +1,12 @@
 import config from '../config/intl_config';
 import requireDbConfig from './require_config';
-import connectToPostgres, { disconnectPostgres } from './connection';
+import connectToPostgres, { disconnectPostgres, withSessionLock } from './connection';
 import resolveDbMode from './resolve_mode';
 import resolveSupabaseEndpoint from './supabase_config';
 import createSupabaseTransport from './supabase_transport';
 import resolveAccessToken from './access_token';
 import runTransactionBatch from './transaction_batch';
+import inlineParams from './inline_params';
 const DEFAULT_ROLE = 'authenticated';
 /**
  * Resolves the user id for `withUserDb`, trying, in order: the explicit `uid`
@@ -51,6 +52,36 @@ async function supabaseDb(supabase, bearerToken) {
         },
     });
 }
+/**
+ * Wraps a live Drizzle postgres transaction handle with a `.transaction()`
+ * override that mirrors the Supabase-mode batch API: `build` receives a
+ * build-only proxy, must return an array of `.toSQL()` objects (same shape),
+ * and this function executes each one sequentially on the real pg session,
+ * collecting `ExecResult[]`. Both modes therefore share the identical
+ * callback shape — callers never need to detect the transport themselves.
+ */
+async function postgresDb(drizzleHandle, rawClient) {
+    return Object.assign(drizzleHandle, {
+        async transaction(build) {
+            return runPostgresTransaction(rawClient, build);
+        },
+    });
+}
+/**
+ * Postgres-mode equivalent of `runTransaction`: calls `build` with a
+ * build-only handle, then executes each returned query on the raw pg client
+ * via an inline-parameterised `query()` call and returns `ExecResult[]`.
+ */
+async function runPostgresTransaction(rawClient, build) {
+    const queries = await build(buildOnlyDb());
+    const results = [];
+    for (const q of queries) {
+        const statement = inlineParams(q.sql, q.params);
+        const res = await rawClient.query(statement);
+        results.push({ rows: res.rows ?? [], rowCount: res.rowCount ?? null });
+    }
+    return results;
+}
 /**
  * Builds a Drizzle handle with no working transport, for Supabase-mode
  * `db.transaction(...)` callbacks. Query builders' `.toSQL()` never touches
@@ -100,8 +131,12 @@ export async function withPublicDb(fn) {
     }
     const client = await connectToPostgres(config, resolved.connectionString);
     try {
-        const { drizzle } = await import('drizzle-orm/node-postgres');
-        return await fn(drizzle(client));
+        return await withSessionLock(async () => {
+            const { drizzle } = await import('drizzle-orm/node-postgres');
+            const drizzleHandle = drizzle(client);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return await fn(await postgresDb(drizzleHandle, client));
+        });
     }
     finally {
         disconnectPostgres(config);
@@ -153,12 +188,17 @@ export async function withUserDb(fn, uid) {
     const client = await connectToPostgres(config, resolved.connectionString);
     const role = db.authenticatedRole ?? DEFAULT_ROLE;
     try {
-        const { drizzle } = await import('drizzle-orm/node-postgres');
-        const { sql } = await import('drizzle-orm');
-        return await drizzle(client).transaction(async (transaction) => {
-            await transaction.execute(sql `select set_config('request.jwt.claims', ${JSON.stringify({ sub: userId })}, true)`);
-            await transaction.execute(sql `set local role ${sql.raw(role)}`);
-            return fn(transaction);
+        return await withSessionLock(async () => {
+            const { drizzle } = await import('drizzle-orm/node-postgres');
+            const { sql } = await import('drizzle-orm');
+            return await drizzle(client).transaction(async (transaction) => {
+                await transaction.execute(sql `select set_config('request.jwt.claims', ${JSON.stringify({ sub: userId })}, true)`);
+                await transaction.execute(sql `set local role ${sql.raw(role)}`);
+                // The transaction handle's session.client is the live pg socket — use it directly.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const txClient = transaction.session?.client ?? client;
+                return fn(await postgresDb(transaction, txClient));
+            });
         });
     }
     finally {

package/package.json

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