Function createSubqueryTests

packages/db/tests/query/subquery.test.ts:77–283

(autoIndex: `off` | `eager`)

}

function createSubqueryTests(autoIndex: `off` | `eager`): void {
  describe(`with autoIndex ${autoIndex}`, () => {
    describe(`basic subqueries in FROM clause`, () => {
      let issuesCollection: ReturnType<typeof createIssuesCollection>

      beforeEach(() => {
        issuesCollection = createIssuesCollection(autoIndex)
      })

      test(`should create live query with simple subquery in FROM clause`, () => {
        const liveCollection = createLiveQueryCollection({
          startSync: true,
          query: (q) => {
            const projectIssues = q
              .from({ issue: issuesCollection })
              .where(({ issue }) => eq(issue.projectId, 1))

            return q
              .from({ filteredIssue: projectIssues })
              .select(({ filteredIssue }) => ({
                id: filteredIssue.id,
                title: filteredIssue.title,
                status: filteredIssue.status,
              }))
          },
        })

        const results = liveCollection.toArray
        expect(results).toHaveLength(4) // Issues 1, 2, 3, 5 are from project 1

        expect(results.map((r) => r.id).sort()).toEqual([1, 2, 3, 5])
        expect(results.map((r) => r.title)).toEqual(
          expect.arrayContaining([`Bug 1`, `Bug 2`, `Feature 1`, `Feature 2`]),
        )
      })

      test(`should create live query with subquery using query function syntax`, async () => {
        const liveCollection = createLiveQueryCollection((q) => {
          const openIssues = q
            .from({ issue: issuesCollection })
            .where(({ issue }) => eq(issue.status, `open`))

          return q.from({ openIssue: openIssues }).select(({ openIssue }) => ({
            id: openIssue.id,
            title: openIssue.title,
            projectId: openIssue.projectId,
          }))
        })
        await liveCollection.preload()

        const results = liveCollection.toArray
        expect(results).toHaveLength(2) // Issues 1 and 4 are open

        expect(results.map((r) => r.id).sort()).toEqual([1, 4])
        expect(
          results.every(
            (r) => sampleIssues.find((i) => i.id === r.id)?.status === `open`,
          ),