Skip to content
TheChatArchiveThe Chat Archive
gpt-5.6-luna· openaiHugging Face ibragim-bad/swe_rebench_07_2026_trajectories

ISSUE DESCRIPTION magic-link verify deadlocks: runWithTransaction nests…

  1. User

    ISSUE DESCRIPTION

    magic-link verify deadlocks: runWithTransaction nests adapter.transaction (1.6.11 consumeVerificationValue) instead of reusing the active transaction

    Is this suited for github?

    • Yes, this is suited for github

    Reproduction

    1. better-auth 1.6.11 with the magicLink plugin.
    2. A database adapter whose transaction is a real interactive DB transaction that holds a dedicated connection for its duration (e.g. the Kysely adapter, or @zenstackhq/better-auth, backed by pg).
    3. Limit the client connection pool to one connection: new Pool({ max: 1 }) -- standard when using Cloudflare Hyperdrive, which pools server-side so the worker keeps a tiny client pool.
    4. await auth.api.signInMagicLink({ body: { email } }) -> works (single insert).
    5. await auth.api.magicLinkVerify({ query: { token } }) (or GET /api/auth/magic-link/verify?token=...).

    Minimal trigger: any setup where adapter.transaction acquires a connection and the pool cannot hand out two connections at once.

    Current vs. Expected behavior

    Current: the verify call hangs forever and never returns. Postgres shows the backend stuck idle in transaction (wait_event = ClientRead) right after the verification SELECT; the connection is never released, so every attempt leaks one idle-in-transaction connection.

    Trace of the cause:

    • internalAdapter.consumeVerificationValue (added in 1.6.11) runs inside runWithTransaction -> opens transaction tx1 (BEGIN, takes the only pooled connection).
    • Consuming the row (consumeOne) triggers another runWithTransaction -> calls adapter.transaction again -> transaction tx2, which tries to acquire a second connection.
    • runWithTransaction in @better-auth/core (context/transaction.mjs) always opens a fresh adapter.transaction; it does NOT check adapterAsyncStorage.getStore() to see whether a transaction is already active in the current async context. So tx2 is nested inside tx1 and blocks forever waiting for the connection tx1 holds -> deadlock.

    Note the CRUD path already reuses the active transaction: getCurrentAdapter(adapter) returns the trx adapter from the ALS store. runWithTransaction is inconsistent with this -- it doesn't reuse.

    Expected: runWithTransaction should be reentrant -- when an adapter/transaction is already active in the async-context store, run fn within it instead of opening a nested adapter.transaction (mirroring getCurrentAdapter). Then verify needs only one connection and works on any pool size. (Alternatively/additionally, document that adapters MUST support reentrant nested transactions -- currently adapters like @zenstackhq/better-auth open a brand-new transaction on the base client for each adapter.transaction call, which is a reasonable contract but incompatible with the current nesting.)

    This is security-relevant: the 1.6.11 change that introduced this nesting was the magic-link "mint multiple sessions from one token" race fix, so the fix effectively breaks magic-link verification on connection-limited adapters/pools.

    What version of Better Auth are you using?

    1.6.11

    System info

    > The `auth info` CLI can't introspect this project headlessly because the auth instance is built dynamically via a factory (no static `auth.ts` export), so the values below are assembled manually
    
    {
      "better-auth": { "version": "1.6.11", "@better-auth/core": "1.6.11" },
      "adapter": { "name": "@zenstackhq/better-auth", "version": "3.6.4", "orm": "@zenstackhq/orm 3.6.4 (Kysely 0.28.17)" },
      "database": { "driver": "pg 8.20.0", "pool": { "max": 1 }, "fronted_by": "Cloudflare Hyperdrive" },
      "runtime": { "platform": "Cloudflare Workers (workerd)", "wrangler": "4.95.0", "node_for_tooling": "v22.22.1" },
      "plugins": ["magicLink"],
      "os": "macOS (Darwin 25.5.0)"
    }
    

    Which area(s) are affected? (Select all that apply)

    Backend

    Auth config (if applicable)

    import { betterAuth } from "better-auth"
    export const auth = betterAuth({
      emailAndPassword: {  
        enabled: true
      },
    });
    

    Additional context

    • Bisected away unrelated suspects: the hang reproduces on older framework code and is independent of DI scope changes -- it's purely 1.6.10 -> 1.6.11.
    • Reproduced deterministically in a real workerd integration test (request magic link -> capture token -> verify) that times out before the change.
    • Relevant code: @better-auth/core context/transaction.mjs runWithTransaction (opens adapter.transaction unconditionally) vs getCurrentAdapter (reuses the active trx); internalAdapter.consumeVerificationValue -> consumeOneWithHooks -> adapter consumeOne.
    • Worked around downstream by making the adapter's transaction reentrant (reuse the in-flight transaction via AsyncLocalStorage), which is also the correct semantics (nested transaction = one atomic unit) -- but it seems like runWithTransaction itself should reuse the active transaction.

    Interface

    No new interfaces are introduced.

    ADDITIONAL ADVICE

    Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use git checkout <file> to restore the file to its original state. You can also reset all changes in the repository using git reset --hard command. Additionally, you can use git stash and git stash pop to temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you call submit) using git status or git diff commands. However you don't need to use git add or git commit before submitting your changes. In fact, submit only submits currently unstaged changes because it uses git diff to get the changes that need to be submitted.

    CHECKLIST

    Before submitting your solution, please go over the following checklist and make sure you've done everything:

    • If an error was reported in the issue description, I have successfully reproduced it.
    • If an error was reported in the issue description, I have confirmed that my fix resolves the error.
    • I have thought about edge cases and made sure my fix handles them as well.
    • I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.

    Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!

    (Current directory: /better-auth, current file: none) bash-$

  2. Assistant

    I’ll inspect the repository for runWithTransaction, its async-context transaction store, and related tests. Then I’ll implement reentrant behavior consistent with getCurrentAdapter, run focused tests (without modifying repository tests), and review the diff before submitting.

  3. Assistant

    rg is unavailable in the environment, so I’ll use grep/find instead to locate the implementation and tests.

  4. Assistant

    The request lifecycle already uses runWithAdapter, so reusing any ALS store would incorrectly suppress the first real transaction. I’ll distinguish an actual transaction context from the general adapter context with an internal marker: runWithAdapter remains non-transactional, while runWithTransaction reuses only an active transaction. This preserves existing route behavior and makes nested transactions share the outer transaction and hook queue.

  5. Assistant

    The focused command was interrupted because Corepack requested an interactive pnpm download; no tests ran. I also confirmed the first replacement did not mark runWithAdapter as non-transactional, so I’ll correct that explicitly, then use the repository’s locally available tooling (or npx/direct binaries) for validation.

  6. Assistant

    TypeScript validation passes. The focused Vitest suite cannot start because the workspace package alias @better-auth/core/async_hooks is not built/resolvable in this checkout; this is an environment setup issue rather than a test assertion failure. I’ll run formatting/lint checks and a direct temporary behavioral check through the source build setup if feasible.

  7. Assistant

    Formatting and Biome checks now pass. The implementation preserves the distinction between the top-level adapter context and a transaction context, while nested runWithTransaction calls return the callback directly and therefore keep the outer transaction’s adapter and pending hooks. I’ll run the core build/type validation and inspect the final diff.

  8. Assistant

    The core build succeeds (with one pre-existing unresolved package-alias warning), and a temporary runtime check confirms:

    • nested transactions invoke the adapter transaction exactly once;
    • nested code sees the outer transaction adapter;
    • a transaction invoked inside plain runWithAdapter still opens its first transaction.

    No generated build artifacts are tracked. I’m doing the final status/diff check now, then I’ll submit.

  9. Assistant

    Implemented the transaction deadlock fix.

    Changes:

    • Added an internal isTransaction marker to the async-context store.
    • runWithAdapter explicitly marks contexts as non-transactional.
    • runWithTransaction marks newly created transaction contexts.
    • Nested runWithTransaction calls now reuse the active transaction instead of opening another adapter transaction.
    • Preserved the behavior where a transaction started inside plain runWithAdapter still opens normally.

    Validation:

    • TypeScript check passed.
    • Biome formatting and lint checks passed.
    • Core build passed.
    • Temporary runtime verification confirmed nested transactions use one adapter transaction and reuse the outer transaction adapter.
    • Existing focused Vitest suite could not start because the workspace alias @better-auth/core/async_hooks was not resolvable before package build; this was an environment/setup issue.

    Checklist:

    • Reproduced/validated the reported nested transaction behavior with a temporary runtime test.
    • Confirmed the fix prevents nested transaction acquisition and preserves adapter reuse.
    • Considered edge cases, including runWithAdapter contexts that are not actual transactions.
    • Ran applicable type, formatting, lint, build, and temporary behavioral validation.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.