address gpt5 review

Author: samwillis

packages/db/src/errors.ts

@@ -350,11 +350,18 @@ export class LimitOffsetRequireOrderByError extends QueryCompilationError {
 }
 
 export class CollectionInputNotFoundError extends QueryCompilationError {
-  constructor(alias: string, collectionId?: string) {
+  constructor(
+    alias: string,
+    collectionId?: string,
+    availableKeys?: Array<string>
+  ) {
     const details = collectionId
       ? `alias "${alias}" (collection "${collectionId}")`
       : `collection "${alias}"`
-    super(`Input for ${details} not found in inputs map`)
+    const availableKeysMsg = availableKeys?.length
+      ? `. Available keys: ${availableKeys.join(`, `)}`
+      : ``
+    super(`Input for ${details} not found in inputs map${availableKeysMsg}`)
   }
 }
 

packages/db/src/query/builder/types.ts

@@ -104,7 +104,7 @@ export type SchemaFromSource<T extends Source> = Prettify<{
  * GetAliases - Extracts all table aliases available in a query context
  *
  * Simple utility type that returns the keys of the schema, representing
- * all table/collection aliases that can be referenced in the current query.
+ * all table/source aliases that can be referenced in the current query.
  */
 export type GetAliases<TContext extends Context> = keyof TContext[`schema`]
 

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

@@ -38,8 +38,8 @@ export interface CompilationResult {
   collectionId: string
   /** The compiled query pipeline */
   pipeline: ResultStream
-  /** Map of collection aliases to their WHERE clauses for index optimization */
-  collectionWhereClauses: Map<string, BasicExpression<boolean>>
+  /** Map of source aliases to their WHERE clauses for index optimization */
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>
   /** Map of alias to underlying collection id used during compilation */
   aliasToCollectionId: Record<string, string>
 }
@@ -70,8 +70,7 @@ export function compileQuery(
   }
 
   // Optimize the query before compilation
-  const { optimizedQuery: query, collectionWhereClauses } =
-    optimizeQuery(rawQuery)
+  const { optimizedQuery: query, sourceWhereClauses } = optimizeQuery(rawQuery)
 
   // Create mapping from optimized query to original for caching
   queryMapping.set(query, rawQuery)
@@ -81,10 +80,11 @@ export function compileQuery(
   const allInputs = { ...inputs }
 
   // Track alias to collection id relationships discovered during compilation so
-  // the live layer can subscribe to every alias the optimiser introduces.
+  // the live layer can subscribe to every alias the optimizer introduces.
   const aliasToCollectionId: Record<string, string> = {}
 
   // Create a map of table aliases to inputs
+  // Note: alias keys take precedence over collection keys for input resolution
   const tables: Record<string, KeyedStream> = {}
 
   // Process the FROM clause to get the main table
@@ -294,7 +294,7 @@ export function compileQuery(
     const compilationResult = {
       collectionId: mainCollectionId,
       pipeline: result,
-      collectionWhereClauses,
+      sourceWhereClauses,
       aliasToCollectionId,
     }
     cache.set(rawQuery, compilationResult)
@@ -323,7 +323,7 @@ export function compileQuery(
   const compilationResult = {
     collectionId: mainCollectionId,
     pipeline: result,
-    collectionWhereClauses,
+    sourceWhereClauses,
     aliasToCollectionId,
   }
   cache.set(rawQuery, compilationResult)
@@ -350,7 +350,11 @@ function processFrom(
     case `collectionRef`: {
       const input = allInputs[from.alias] ?? allInputs[from.collection.id]
       if (!input) {
-        throw new CollectionInputNotFoundError(from.alias, from.collection.id)
+        throw new CollectionInputNotFoundError(
+          from.alias,
+          from.collection.id,
+          Object.keys(allInputs)
+        )
       }
       aliasToCollectionId[from.alias] = from.collection.id
       return { alias: from.alias, input, collectionId: from.collection.id }

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

@@ -264,6 +264,9 @@ function processJoin(
         [key: unknown, [originalKey: string, namespacedRow: NamespacedRow]]
       > = activePipeline.pipe(
         tap((data) => {
+          // For outer joins (LEFT/RIGHT), the driving side determines which alias's
+          // subscription we consult for lazy loading. The main table drives LEFT joins,
+          // joined table drives RIGHT joins.
           const lazyAliasCandidate =
             activeCollection === `main` ? joinedTableAlias : mainTableAlias
           const lazyCollectionSubscription =
@@ -419,7 +422,11 @@ function processJoinSource(
     case `collectionRef`: {
       const input = allInputs[from.alias] ?? allInputs[from.collection.id]
       if (!input) {
-        throw new CollectionInputNotFoundError(from.alias, from.collection.id)
+        throw new CollectionInputNotFoundError(
+          from.alias,
+          from.collection.id,
+          Object.keys(allInputs)
+        )
       }
       aliasToCollectionId[from.alias] = from.collection.id
       return { alias: from.alias, input, collectionId: from.collection.id }

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

@@ -50,11 +50,11 @@ export class CollectionConfigBuilder<
   private graphCache: D2 | undefined
   private inputsCache: Record<string, RootStreamBuilder<unknown>> | undefined
   private pipelineCache: ResultStream | undefined
-  public collectionWhereClausesCache:
+  public sourceWhereClausesCache:
     | Map<string, BasicExpression<boolean>>
     | undefined
 
-  // Map of collection alias to subscription
+  // Map of source alias to subscription
   readonly subscriptions: Record<string, CollectionSubscription> = {}
   // Map of collection IDs to functions that load keys for that lazy collection
   lazyCollectionsCallbacks: Record<string, LazyCollectionCallbacks> = {}
@@ -118,7 +118,7 @@ export class CollectionConfigBuilder<
     if (collection) {
       return collection.id
     }
-    throw new Error(`Unknown collection alias "${alias}"`)
+    throw new Error(`Unknown source alias "${alias}"`)
   }
 
   // The callback function is called after the graph has run.
@@ -209,12 +209,19 @@ export class CollectionConfigBuilder<
       this.graphCache = undefined
       this.inputsCache = undefined
       this.pipelineCache = undefined
-      this.collectionWhereClausesCache = undefined
+      this.sourceWhereClausesCache = undefined
 
       // Reset lazy collection state
       this.lazyCollections.clear()
       this.optimizableOrderByCollections = {}
       this.lazyCollectionsCallbacks = {}
+
+      // Clear subscription references to prevent memory leaks
+      // Note: Individual subscriptions are already unsubscribed via unsubscribeCallbacks
+      Object.keys(this.subscriptions).forEach(
+        (key) => delete this.subscriptions[key]
+      )
+      this.compiledAliasToCollectionId = {}
     }
   }
 
@@ -239,7 +246,7 @@ export class CollectionConfigBuilder<
     )
 
     this.pipelineCache = compilation.pipeline
-    this.collectionWhereClausesCache = compilation.collectionWhereClauses
+    this.sourceWhereClausesCache = compilation.sourceWhereClauses
     this.compiledAliasToCollectionId = compilation.aliasToCollectionId
     // Optimized queries can introduce aliases beyond those declared on the
     // builder. If that happens, provision inputs for the missing aliases and
@@ -266,7 +273,7 @@ export class CollectionConfigBuilder<
       )
 
       this.pipelineCache = compilation.pipeline
-      this.collectionWhereClausesCache = compilation.collectionWhereClauses
+      this.sourceWhereClausesCache = compilation.sourceWhereClauses
       this.compiledAliasToCollectionId = compilation.aliasToCollectionId
     }
   }

packages/db/src/query/live/collection-subscriber.ts

@@ -226,12 +226,12 @@ export class CollectionSubscriber<
   }
 
   private getWhereClauseForAlias(): BasicExpression<boolean> | undefined {
-    const collectionWhereClausesCache =
-      this.collectionConfigBuilder.collectionWhereClausesCache
-    if (!collectionWhereClausesCache) {
+    const sourceWhereClausesCache =
+      this.collectionConfigBuilder.sourceWhereClausesCache
+    if (!sourceWhereClausesCache) {
       return undefined
     }
-    return collectionWhereClausesCache.get(this.alias)
+    return sourceWhereClausesCache.get(this.alias)
   }
 
   private getOrderByInfo(): OrderByOptimizationInfo | undefined {

packages/db/src/query/optimizer.ts

@@ -162,8 +162,8 @@ export interface GroupedWhereClauses {
 export interface OptimizationResult {
   /** The optimized query with WHERE clauses potentially moved to subqueries */
   optimizedQuery: QueryIR
-  /** Map of collection aliases to their extracted WHERE clauses for index optimization */
-  collectionWhereClauses: Map<string, BasicExpression<boolean>>
+  /** Map of source aliases to their extracted WHERE clauses for index optimization */
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>
 }
 
 /**
@@ -184,14 +184,14 @@ export interface OptimizationResult {
  *   where: [eq(u.dept_id, 1), gt(p.views, 100)]
  * }
  *
- * const { optimizedQuery, collectionWhereClauses } = optimizeQuery(originalQuery)
+ * const { optimizedQuery, sourceWhereClauses } = optimizeQuery(originalQuery)
  * // Result: Single-source clauses moved to deepest possible subqueries
- * // collectionWhereClauses: Map { 'u' => eq(u.dept_id, 1), 'p' => gt(p.views, 100) }
+ * // sourceWhereClauses: Map { 'u' => eq(u.dept_id, 1), 'p' => gt(p.views, 100) }
  * ```
  */
 export function optimizeQuery(query: QueryIR): OptimizationResult {
-  // First, extract collection WHERE clauses before optimization
-  const collectionWhereClauses = extractCollectionWhereClauses(query)
+  // First, extract source WHERE clauses before optimization
+  const sourceWhereClauses = extractSourceWhereClauses(query)
 
   // Apply multi-level predicate pushdown with iterative convergence
   let optimized = query
@@ -214,7 +214,7 @@ export function optimizeQuery(query: QueryIR): OptimizationResult {
 
   return {
     optimizedQuery: cleaned,
-    collectionWhereClauses,
+    sourceWhereClauses,
   }
 }
 
@@ -224,16 +224,16 @@ export function optimizeQuery(query: QueryIR): OptimizationResult {
  * to specific collections, but only for simple queries without joins.
  *
  * @param query - The original QueryIR to analyze
- * @returns Map of collection aliases to their WHERE clauses
+ * @returns Map of source aliases to their WHERE clauses
  */
-function extractCollectionWhereClauses(
+function extractSourceWhereClauses(
   query: QueryIR
 ): Map<string, BasicExpression<boolean>> {
-  const collectionWhereClauses = new Map<string, BasicExpression<boolean>>()
+  const sourceWhereClauses = new Map<string, BasicExpression<boolean>>()
 
   // Only analyze queries that have WHERE clauses
   if (!query.where || query.where.length === 0) {
-    return collectionWhereClauses
+    return sourceWhereClauses
   }
 
   // Split all AND clauses at the root level for granular analysis
@@ -254,12 +254,12 @@ function extractCollectionWhereClauses(
     if (isCollectionReference(query, sourceAlias)) {
       // Check if the WHERE clause can be converted to collection-compatible format
       if (isConvertibleToCollectionFilter(whereClause)) {
-        collectionWhereClauses.set(sourceAlias, whereClause)
+        sourceWhereClauses.set(sourceAlias, whereClause)
       }
     }
   }
 
-  return collectionWhereClauses
+  return sourceWhereClauses
 }
 
 /**

packages/db/tests/query/compiler/subqueries.test.ts

@@ -352,6 +352,77 @@ describe(`Query2 Subqueries`, () => {
   })
 
   describe(`Complex composable queries`, () => {
+    it(`exports alias metadata from nested subqueries`, () => {
+      // Create a nested subquery structure to test alias metadata propagation
+      const innerQuery = new Query()
+        .from({ user: usersCollection })
+        .where(({ user }) => eq(user.status, `active`))
+
+      const middleQuery = new Query()
+        .from({ activeUser: innerQuery })
+        .select(({ activeUser }) => ({
+          id: activeUser.id,
+          name: activeUser.name,
+        }))
+
+      const outerQuery = new Query()
+        .from({ issue: issuesCollection })
+        .join({ userInfo: middleQuery }, ({ issue, userInfo }) =>
+          eq(issue.userId, userInfo.id)
+        )
+        .select(({ issue, userInfo }) => ({
+          issueId: issue.id,
+          issueTitle: issue.title,
+          userName: userInfo?.name,
+        }))
+
+      const builtQuery = getQueryIR(outerQuery)
+
+      const usersSubscription = usersCollection.subscribeChanges(() => {})
+      const issuesSubscription = issuesCollection.subscribeChanges(() => {})
+      const subscriptions: Record<string, CollectionSubscription> = {
+        [usersCollection.id]: usersSubscription,
+        [issuesCollection.id]: issuesSubscription,
+      }
+
+      const dummyCallbacks = {
+        loadKeys: (_: any) => {},
+        loadInitialState: () => {},
+      }
+
+      // Compile the query
+      const graph = new D2()
+      const issuesInput = createIssueInput(graph)
+      const usersInput = createUserInput(graph)
+      const lazyCollections = new Set<string>()
+      const compilation = compileQuery(
+        builtQuery,
+        {
+          issues: issuesInput,
+          users: usersInput,
+        },
+        { issues: issuesCollection, users: usersCollection },
+        subscriptions,
+        { issues: dummyCallbacks, users: dummyCallbacks },
+        lazyCollections,
+        {}
+      )
+
+      // Verify that alias metadata includes aliases from the query
+      const aliasToCollectionId = compilation.aliasToCollectionId
+
+      // Should include the main table alias (note: alias is 'issue', not 'issues')
+      expect(aliasToCollectionId.issue).toBe(issuesCollection.id)
+
+      // Should include the user alias from the subquery
+      expect(aliasToCollectionId.user).toBe(usersCollection.id)
+
+      // Verify that the compiler correctly maps aliases to collection IDs
+      expect(Object.keys(aliasToCollectionId)).toHaveLength(2)
+      expect(aliasToCollectionId.issue).toBe(issuesCollection.id)
+      expect(aliasToCollectionId.user).toBe(usersCollection.id)
+    })
+
     it(`executes simple aggregate subquery`, () => {
       // Create a base query that filters issues for project 1
       const baseQuery = new Query()