@tanstack/db 0.5.7 → 0.5.9

package/src/query/builder/types.ts

@@ -371,11 +371,11 @@ export type RefsForContext<TContext extends Context> = {
   > extends true
     ? IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is both non-exact optional and non-exact nullable (e.g., string | null | undefined)
-        // Extract the non-undefined and non-null part and place undefined outside
-        Ref<NonNullable<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined and non-null part and place undefined outside
+          Ref<NonNullable<TContext[`schema`][K]>> | undefined
       : // T is optional (T | undefined) but not exactly undefined, and not nullable
-        // Extract the non-undefined part and place undefined outside
-        Ref<NonUndefined<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined part and place undefined outside
+          Ref<NonUndefined<TContext[`schema`][K]>> | undefined
     : IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is nullable (T | null) but not exactly null, and not optional
         // Extract the non-null part and place null outside
@@ -612,7 +612,7 @@ export type ApplyJoinOptionalityToMergedSchema<
   // Apply optionality to new schema based on join type
   [K in keyof TNewSchema]: TJoinType extends `left` | `full`
     ? // New table becomes optional for left and full joins
-      TNewSchema[K] | undefined
+        TNewSchema[K] | undefined
     : // New table is required for inner and right joins
       TNewSchema[K]
 }

package/src/query/predicate-utils.ts

@@ -802,6 +802,33 @@ export function isPredicateSubset(
   subset: LoadSubsetOptions,
   superset: LoadSubsetOptions
 ): boolean {
+  // When the superset has a limit, we can only determine subset relationship
+  // if the where clauses are equal (not just subset relationship).
+  //
+  // This is because a limited query only loads a portion of the matching rows.
+  // A more restrictive where clause might require rows outside that portion.
+  //
+  // Example: superset = {where: undefined, limit: 10, orderBy: desc}
+  //          subset = {where: LIKE 'search%', limit: 10, orderBy: desc}
+  // The top 10 items matching 'search%' might include items outside the overall top 10.
+  //
+  // However, if the where clauses are equal, then the subset relationship can
+  // be determined by orderBy and limit alone:
+  // Example: superset = {where: status='active', limit: 10, orderBy: desc}
+  //          subset = {where: status='active', limit: 5, orderBy: desc}
+  // The top 5 active items ARE contained in the top 10 active items.
+  if (superset.limit !== undefined) {
+    // For limited supersets, where clauses must be equal
+    if (!areWhereClausesEqual(subset.where, superset.where)) {
+      return false
+    }
+    return (
+      isOrderBySubset(subset.orderBy, superset.orderBy) &&
+      isLimitSubset(subset.limit, superset.limit)
+    )
+  }
+
+  // For unlimited supersets, use the normal subset logic
   return (
     isWhereSubset(subset.where, superset.where) &&
     isOrderBySubset(subset.orderBy, superset.orderBy) &&
@@ -809,6 +836,23 @@ export function isPredicateSubset(
   )
 }
 
+/**
+ * Check if two where clauses are structurally equal.
+ * Used for limited query subset checks where subset relationship isn't sufficient.
+ */
+function areWhereClausesEqual(
+  a: BasicExpression<boolean> | undefined,
+  b: BasicExpression<boolean> | undefined
+): boolean {
+  if (a === undefined && b === undefined) {
+    return true
+  }
+  if (a === undefined || b === undefined) {
+    return false
+  }
+  return areExpressionsEqual(a, b)
+}
+
 // ============================================================================
 // Helper functions
 // ============================================================================

package/src/types.ts

@@ -13,9 +13,9 @@ export interface CollectionLike<
   T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
 > extends Pick<
-    Collection<T, TKey>,
-    `get` | `has` | `entries` | `indexes` | `id` | `compareOptions`
-  > {}
+  Collection<T, TKey>,
+  `get` | `has` | `entries` | `indexes` | `id` | `compareOptions`
+> {}
 
 /**
  * StringSortOpts - Options for string sorting behavior
@@ -727,8 +727,10 @@ export interface SubscribeChangesOptions {
   whereExpression?: BasicExpression<boolean>
 }
 
-export interface SubscribeChangesSnapshotOptions
-  extends Omit<SubscribeChangesOptions, `includeInitialState`> {
+export interface SubscribeChangesSnapshotOptions extends Omit<
+  SubscribeChangesOptions,
+  `includeInitialState`
+> {
   orderBy?: OrderBy
   limit?: number
 }