ci: apply automated fixes

Author: autofix-ci[bot]

packages/db/src/query/compiler/index.ts

@@ -1,9 +1,4 @@
-import {
-  distinct,
-  filter,
-  join as joinOperator,
-  map,
-} from '@tanstack/db-ivm'
+import { distinct, filter, join as joinOperator, map } from '@tanstack/db-ivm'
 import { optimizeQuery } from '../optimizer.js'
 import {
   CollectionInputNotFoundError,
@@ -203,9 +198,7 @@ export function compileQuery(
     )
 
     // Inner join: only children whose correlation key exists in parent keys pass through
-    const joined = childRekeyed.pipe(
-      joinOperator(parentKeyStream, `inner`),
-    )
+    const joined = childRekeyed.pipe(joinOperator(parentKeyStream, `inner`))
 
     // Extract: [correlationValue, [[childKey, childRow], null]] → [childKey, childRow]
     // Tag the row with __correlationKey for output routing
@@ -323,7 +316,9 @@ export function compileQuery(
         fieldName: subquery.fieldName,
         correlationField: subquery.correlationField,
         childCorrelationField: subquery.childCorrelationField,
-        hasOrderBy: !!(subquery.query.orderBy && subquery.query.orderBy.length > 0),
+        hasOrderBy: !!(
+          subquery.query.orderBy && subquery.query.orderBy.length > 0
+        ),
         childCompilationResult: childResult,
       })
 
@@ -438,7 +433,8 @@ export function compileQuery(
     // When in includes mode with limit/offset, use grouped ordering so that
     // the limit is applied per parent (per correlation key), not globally.
     const includesGroupKeyFn =
-      parentKeyStream && (query.limit !== undefined || query.offset !== undefined)
+      parentKeyStream &&
+      (query.limit !== undefined || query.offset !== undefined)
         ? (_key: unknown, row: unknown) =>
             (row as any)?.[mainSource]?.__correlationKey
         : undefined
@@ -479,8 +475,7 @@ export function compileQuery(
       sourceWhereClauses,
       aliasToCollectionId,
       aliasRemapping,
-      includes:
-        includesResults.length > 0 ? includesResults : undefined,
+      includes: includesResults.length > 0 ? includesResults : undefined,
     }
     cache.set(rawQuery, compilationResult)
 
@@ -516,8 +511,7 @@ export function compileQuery(
     sourceWhereClauses,
     aliasToCollectionId,
     aliasRemapping,
-    includes:
-      includesResults.length > 0 ? includesResults : undefined,
+    includes: includesResults.length > 0 ? includesResults : undefined,
   }
   cache.set(rawQuery, compilationResult)
 

packages/db/src/query/compiler/order-by.ts

@@ -1,4 +1,7 @@
-import { groupedOrderByWithFractionalIndex, orderByWithFractionalIndex } from '@tanstack/db-ivm'
+import {
+  groupedOrderByWithFractionalIndex,
+  orderByWithFractionalIndex,
+} from '@tanstack/db-ivm'
 import { defaultComparator, makeComparator } from '../../utils/comparison.js'
 import { PropRef, followRef } from '../ir.js'
 import { ensureIndexForField } from '../../indexes/auto-index.js'
@@ -306,17 +309,15 @@ export function processOrderBy(
         setWindowFn: (
           windowFn: (options: { offset?: number; limit?: number }) => void,
         ) => {
-          setWindowFn(
-            (options) => {
-              windowFn(options)
-              if (orderByOptimizationInfo) {
-                orderByOptimizationInfo.offset =
-                  options.offset ?? orderByOptimizationInfo.offset
-                orderByOptimizationInfo.limit =
-                  options.limit ?? orderByOptimizationInfo.limit
-              }
-            },
-          )
+          setWindowFn((options) => {
+            windowFn(options)
+            if (orderByOptimizationInfo) {
+              orderByOptimizationInfo.offset =
+                options.offset ?? orderByOptimizationInfo.offset
+              orderByOptimizationInfo.limit =
+                options.limit ?? orderByOptimizationInfo.limit
+            }
+          })
         },
       }),
     )

packages/db/src/query/live/collection-config-builder.ts

@@ -731,7 +731,10 @@ export class CollectionConfigBuilder<
     )
 
     // Set up includes output routing and child collection lifecycle
-    const includesState = this.setupIncludesOutput(this.includesCache, syncState)
+    const includesState = this.setupIncludesOutput(
+      this.includesCache,
+      syncState,
+    )
 
     // Flush pending changes and reset the accumulator.
     // Called at the end of each graph run to commit all accumulated changes.
@@ -829,10 +832,7 @@ export class CollectionConfigBuilder<
           const messages = data.getInner()
           syncState.messagesCount += messages.length
 
-          for (const [
-            [childKey, tupleData],
-            multiplicity,
-          ] of messages) {
+          for (const [[childKey, tupleData], multiplicity] of messages) {
             const [childResult, _orderByIndex, correlationKey] =
               tupleData as unknown as [any, string | undefined, unknown]
 
@@ -1346,7 +1346,14 @@ function createChildCollectionEntry(
     startSync: true,
   })
 
-  return { collection, get syncMethods() { return syncMethods }, resultKeys, orderByIndices }
+  return {
+    collection,
+    get syncMethods() {
+      return syncMethods
+    },
+    resultKeys,
+    orderByIndices,
+  }
 }
 
 /**
@@ -1396,10 +1403,7 @@ function flushIncludesState(
 
     // Flush child changes: route to correct child Collections
     if (state.pendingChildChanges.size > 0) {
-      for (const [
-        correlationKey,
-        childChanges,
-      ] of state.pendingChildChanges) {
+      for (const [correlationKey, childChanges] of state.pendingChildChanges) {
         // Ensure child Collection exists for this correlation key
         let entry = state.childRegistry.get(correlationKey)
         if (!entry) {
@@ -1509,7 +1513,7 @@ function attachChildCollectionToParent(
 
     if (value === correlationKey) {
       // Set the child Collection on this parent row
-      ;(item)[fieldName] = childCollection
+      item[fieldName] = childCollection
     }
   }
 }

packages/db/tests/query/includes.test.ts

@@ -113,19 +113,17 @@ describe(`includes subqueries`, () => {
 
   function buildIncludesQuery() {
     return createLiveQueryCollection((q) =>
-      q
-        .from({ p: projects })
-        .select(({ p }) => ({
-          id: p.id,
-          name: p.name,
-          issues: q
-            .from({ i: issues })
-            .where(({ i }) => eq(i.projectId, p.id))
-            .select(({ i }) => ({
-              id: i.id,
-              title: i.title,
-            })),
-        })),
+      q.from({ p: projects }).select(({ p }) => ({
+        id: p.id,
+        name: p.name,
+        issues: q
+          .from({ i: issues })
+          .where(({ i }) => eq(i.projectId, p.id))
+          .select(({ i }) => ({
+            id: i.id,
+            title: i.title,
+          })),
+      })),
     )
   }
 
@@ -155,8 +153,7 @@ describe(`includes subqueries`, () => {
         },
       ])
     })
-
-})
+  })
 
   describe(`reactivity`, () => {
     it(`adding a child updates the parent's child collection`, async () => {
@@ -299,20 +296,18 @@ describe(`includes subqueries`, () => {
   describe(`ordered child queries`, () => {
     it(`child collection respects orderBy on the child query`, async () => {
       const collection = createLiveQueryCollection((q) =>
-        q
-          .from({ p: projects })
-          .select(({ p }) => ({
-            id: p.id,
-            name: p.name,
-            issues: q
-              .from({ i: issues })
-              .where(({ i }) => eq(i.projectId, p.id))
-              .orderBy(({ i }) => i.title, `desc`)
-              .select(({ i }) => ({
-                id: i.id,
-                title: i.title,
-              })),
-          })),
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .orderBy(({ i }) => i.title, `desc`)
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+            })),
+        })),
       )
 
       await collection.preload()
@@ -338,20 +333,18 @@ describe(`includes subqueries`, () => {
 
     it(`newly inserted children appear in the correct order`, async () => {
       const collection = createLiveQueryCollection((q) =>
-        q
-          .from({ p: projects })
-          .select(({ p }) => ({
-            id: p.id,
-            name: p.name,
-            issues: q
-              .from({ i: issues })
-              .where(({ i }) => eq(i.projectId, p.id))
-              .orderBy(({ i }) => i.title, `asc`)
-              .select(({ i }) => ({
-                id: i.id,
-                title: i.title,
-              })),
-          })),
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .orderBy(({ i }) => i.title, `asc`)
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+            })),
+        })),
       )
 
       await collection.preload()
@@ -382,21 +375,19 @@ describe(`includes subqueries`, () => {
   describe(`ordered child queries with limit`, () => {
     it(`limits child collection to N items per parent`, async () => {
       const collection = createLiveQueryCollection((q) =>
-        q
-          .from({ p: projects })
-          .select(({ p }) => ({
-            id: p.id,
-            name: p.name,
-            issues: q
-              .from({ i: issues })
-              .where(({ i }) => eq(i.projectId, p.id))
-              .orderBy(({ i }) => i.title, `asc`)
-              .limit(1)
-              .select(({ i }) => ({
-                id: i.id,
-                title: i.title,
-              })),
-          })),
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .orderBy(({ i }) => i.title, `asc`)
+            .limit(1)
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+            })),
+        })),
       )
 
       await collection.preload()
@@ -420,31 +411,27 @@ describe(`includes subqueries`, () => {
 
     it(`inserting a child that displaces an existing one respects the limit`, async () => {
       const collection = createLiveQueryCollection((q) =>
-        q
-          .from({ p: projects })
-          .select(({ p }) => ({
-            id: p.id,
-            name: p.name,
-            issues: q
-              .from({ i: issues })
-              .where(({ i }) => eq(i.projectId, p.id))
-              .orderBy(({ i }) => i.title, `asc`)
-              .limit(1)
-              .select(({ i }) => ({
-                id: i.id,
-                title: i.title,
-              })),
-          })),
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .orderBy(({ i }) => i.title, `asc`)
+            .limit(1)
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+            })),
+        })),
       )
 
       await collection.preload()
 
       // Alpha should have exactly 1 issue (limit 1): "Bug in Alpha"
       const alphaIssues = [...(collection.get(1) as any).issues.toArray]
       expect(alphaIssues).toHaveLength(1)
-      expect(alphaIssues).toEqual([
-        { id: 10, title: `Bug in Alpha` },
-      ])
+      expect(alphaIssues).toEqual([{ id: 10, title: `Bug in Alpha` }])
 
       // Insert an issue that comes before "Bug" alphabetically
       issues.utils.begin()
@@ -469,26 +456,24 @@ describe(`includes subqueries`, () => {
   describe(`nested includes`, () => {
     it(`supports two levels of includes`, async () => {
       const collection = createLiveQueryCollection((q) =>
-        q
-          .from({ p: projects })
-          .select(({ p }) => ({
-            id: p.id,
-            name: p.name,
-            issues: q
-              .from({ i: issues })
-              .where(({ i }) => eq(i.projectId, p.id))
-              .select(({ i }) => ({
-                id: i.id,
-                title: i.title,
-                comments: q
-                  .from({ c: comments })
-                  .where(({ c }) => eq(c.issueId, i.id))
-                  .select(({ c }) => ({
-                    id: c.id,
-                    body: c.body,
-                  })),
-              })),
-          })),
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+              comments: q
+                .from({ c: comments })
+                .where(({ c }) => eq(c.issueId, i.id))
+                .select(({ c }) => ({
+                  id: c.id,
+                  body: c.body,
+                })),
+            })),
+        })),
       )
 
       await collection.preload()