Hacktoberfest 2026: the issues maintainers tagged for October, open and beginner-friendly. Browse Hacktoberfest issues

Joined-filter window hangs in `drainNoInputContinuations` when a boundary-tie load answers synchronously

Open Beginner friendly
  • Is something wrong?
#2,241 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
2/5
Estimated time
1-3 hours
Newbie friendliness
78/100
Issue type
Bug
Clarity
Clearly specified
Activity status
Active
Tech stack
typescript
Domain
backend, databases, testing-qa

Research direction

Start with drainNoInputContinuations and runContinuation in the query continuation code, then review the joined-filter gate that resumes staged work after joined loads settle. Add a regression test based on tests/query/joined-filter-sync-tie.test.ts for a synchronous tie load and asynchronous joined load. Done means the window settles with all 5 rows and the test passes.

Written by the indexing model from the issue text.

Description

On 0.15.2, an ordered, limited window with one LEFT join and a filter on the joined side never settles under this sequence:

  1. The source answers a page asynchronously, but its boundary-tie load (no limit) synchronously with true, from rows it already holds.
  2. The joined side answers asynchronously.

drainNoInputContinuations consumes the staged more continuation. runContinuation sees hasPendingJoinedWork() and re-stages the same continuation. Nothing has changed (no graph input, nothing pending), so the while condition still holds and the loop spins synchronously. The joined load can never settle, and the page hangs at 100% CPU.

Repro (plain collections, no custom options): a 30-row items collection left-joined to owners, where(eq(owner.active, true)), orderBy(rank desc), limit(5). items.loadSubset resolves pages after setTimeout and answers limit-less tie loads synchronously. owners.loadSubset resolves after setTimeout. The test below hangs on 0.15.2.

Fix: stop draining when a consumed continuation re-stages itself. The joined work's settlement already resumes it through the joined-filter gate.

const continuation = this.stagedContinuation
this.consumeStagedContinuation()
if (this.stagedContinuation === continuation) break

With it, the repro settles with the full 5-row window, and the full @tanstack/db suite passes. Happy to open a PR.

Repro test (tests/query/joined-filter-sync-tie.test.ts) 
import { expect, it } from 'vitest'
import { createCollection } from '../../src/collection/index.js'
import { BTreeIndex } from '../../src/index.js'
import { createLiveQueryCollection } from '../../src/query/live-query-collection.js'
import { eq } from '../../src/query/builder/functions.js'
import { compileSingleRowExpression } from '../../src/query/compiler/evaluators.js'
import type { LoadSubsetOptions } from '../../src/types.js'

type Item = { id: string; rank: number; ownerId: string }
type Owner = { id: string; active: boolean }

it(`settles a joined-filter window whose tie load answers synchronously`, async () => {
  const items: Array<Item> = Array.from({ length: 30 }, (_, n) => ({
    id: `i${String(n).padStart(2, `0`)}`,
    rank: 100 - n,
    ownerId: `o${n}`,
  }))
  const owners: Array<Owner> = items.map((item, n) => ({
    id: item.ownerId,
    active: n % 3 !== 0,
  }))
  const delivered = new Set<string>()
  const itemCollection = createCollection<Item>({
    id: `loop-items`,
    getKey: (row) => row.id,
    syncMode: `on-demand`,
    startSync: true,
    autoIndex: `eager`,
    defaultIndexType: BTreeIndex,
    sync: {
      sync: ({ begin, write, commit, markReady }) => {
        markReady()
        return {
          loadSubset: (options: LoadSubsetOptions) => {
            const where = options.where
              ? compileSingleRowExpression(options.where)
              : undefined
            const from = options.cursor
              ? compileSingleRowExpression(options.cursor.whereFrom)
              : undefined
            const offset = from ? 0 : (options.offset ?? 0)
            const rows = items
              .filter((row) => (where ? where(row) === true : true))
              .filter((row) => (from ? from(row) === true : true))
              .sort((a, b) => b.rank - a.rank)
              .slice(
                offset,
                options.limit === undefined
                  ? undefined
                  : offset + options.limit,
              )
            const answer = () => {
              begin()
              for (const row of rows) {
                if (delivered.has(row.id)) continue
                delivered.add(row.id)
                write({ type: `insert`, value: { ...row } })
              }
              return commit()
            }
            // A page goes over the wire; its boundary ties are rows it holds.
            if (options.limit === undefined) return answer()
            return new Promise<void>((resolve) =>
              setTimeout(() => {
                const receipt = answer()
                void (receipt === true ? resolve() : receipt.then(resolve))
              }, 1),
            )
          },
        }
      },
    },
  })
  const ownerCollection = createCollection<Owner>({
    id: `loop-owners`,
    getKey: (row) => row.id,
    syncMode: `on-demand`,
    startSync: true,
    autoIndex: `eager`,
    defaultIndexType: BTreeIndex,
    sync: {
      sync: ({ begin, write, commit, markReady }) => {
        markReady()
        return {
          loadSubset: (options: LoadSubsetOptions) =>
            new Promise<void>((resolve) =>
              setTimeout(() => {
                const where = options.where
                  ? compileSingleRowExpression(options.where)
                  : undefined
                begin()
                for (const row of owners)
                  if (!where || where(row) === true)
                    write({ type: `insert`, value: { ...row } })
                const receipt = commit()
                void (receipt === true ? resolve() : receipt.then(resolve))
              }, 1),
            ),
        }
      },
    },
  })
  const live = createLiveQueryCollection({
    query: (q) =>
      q
        .from({ item: itemCollection })
        .leftJoin({ owner: ownerCollection }, ({ item, owner }) =>
          eq(item.ownerId, owner.id),
        )
        .where(({ owner }) => eq(owner.active, true))
        .orderBy(({ item }) => item.rank, `desc`)
        .limit(5)
        .select(({ item }) => ({ id: item.id })),
  })
  await live.preload()
  await new Promise((resolve) => setTimeout(resolve, 30))
  expect(live.size).toBe(5)
  await live.cleanup()
})
Dominant language
TypeScript
Stars
4k
Forks
277
Avg merge
17h 33m
Merged PRs (30d)
227

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from TanStack/db

All issues in TanStack/db

Similar issues

More TypeScript issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.