@tanstack/db 0.4.15 → 0.4.16

package/dist/cjs/strategies/queueStrategy.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const asyncQueuer = require("@tanstack/pacer/async-queuer");
+function queueStrategy(options) {
+  const queuer = new asyncQueuer.AsyncQueuer({
+    concurrency: 1,
+    // Process one at a time to ensure serialization
+    wait: options?.wait,
+    maxSize: options?.maxSize,
+    addItemsTo: options?.addItemsTo ?? `back`,
+    // Default FIFO: add to back
+    getItemsFrom: options?.getItemsFrom ?? `front`,
+    // Default FIFO: get from front
+    started: true
+    // Start processing immediately
+  });
+  return {
+    _type: `queue`,
+    options,
+    execute: (fn) => {
+      queuer.addItem(async () => {
+        const transaction = fn();
+        await transaction.isPersisted.promise;
+      });
+    },
+    cleanup: () => {
+      queuer.stop();
+      queuer.clear();
+    }
+  };
+}
+exports.queueStrategy = queueStrategy;
+//# sourceMappingURL=queueStrategy.cjs.map

package/dist/cjs/strategies/queueStrategy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queueStrategy.cjs","sources":["../../../src/strategies/queueStrategy.ts"],"sourcesContent":["import { AsyncQueuer } from \"@tanstack/pacer/async-queuer\"\nimport type { QueueStrategy, QueueStrategyOptions } from \"./types\"\nimport type { Transaction } from \"../transactions\"\n\n/**\n * Creates a queue strategy that processes all mutations in order with proper serialization.\n *\n * Unlike other strategies that may drop executions, queue ensures every\n * mutation is processed sequentially. Each transaction commit completes before\n * the next one starts. Useful when data consistency is critical and\n * every operation must complete in order.\n *\n * @param options - Configuration for queue behavior (FIFO/LIFO, timing, size limits)\n * @returns A queue strategy instance\n *\n * @example\n * ```ts\n * // FIFO queue - process in order received\n * const mutate = usePacedMutations({\n *   mutationFn: async ({ transaction }) => {\n *     await api.save(transaction.mutations)\n *   },\n *   strategy: queueStrategy({\n *     wait: 200,\n *     addItemsTo: 'back',\n *     getItemsFrom: 'front'\n *   })\n * })\n * ```\n *\n * @example\n * ```ts\n * // LIFO queue - process most recent first\n * const mutate = usePacedMutations({\n *   mutationFn: async ({ transaction }) => {\n *     await api.save(transaction.mutations)\n *   },\n *   strategy: queueStrategy({\n *     wait: 200,\n *     addItemsTo: 'back',\n *     getItemsFrom: 'back'\n *   })\n * })\n * ```\n */\nexport function queueStrategy(options?: QueueStrategyOptions): QueueStrategy {\n  const queuer = new AsyncQueuer<void>({\n    concurrency: 1, // Process one at a time to ensure serialization\n    wait: options?.wait,\n    maxSize: options?.maxSize,\n    addItemsTo: options?.addItemsTo ?? `back`, // Default FIFO: add to back\n    getItemsFrom: options?.getItemsFrom ?? `front`, // Default FIFO: get from front\n    started: true, // Start processing immediately\n  })\n\n  return {\n    _type: `queue`,\n    options,\n    execute: <T extends object = Record<string, unknown>>(\n      fn: () => Transaction<T>\n    ) => {\n      // Wrap the callback in an async function that waits for persistence\n      queuer.addItem(async () => {\n        const transaction = fn()\n        // Wait for the transaction to be persisted before processing next item\n        // Note: fn() already calls commit(), we just wait for it to complete\n        await transaction.isPersisted.promise\n      })\n    },\n    cleanup: () => {\n      queuer.stop()\n      queuer.clear()\n    },\n  }\n}\n"],"names":["AsyncQueuer"],"mappings":";;;AA6CO,SAAS,cAAc,SAA+C;AAC3E,QAAM,SAAS,IAAIA,wBAAkB;AAAA,IACnC,aAAa;AAAA;AAAA,IACb,MAAM,SAAS;AAAA,IACf,SAAS,SAAS;AAAA,IAClB,YAAY,SAAS,cAAc;AAAA;AAAA,IACnC,cAAc,SAAS,gBAAgB;AAAA;AAAA,IACvC,SAAS;AAAA;AAAA,EAAA,CACV;AAED,SAAO;AAAA,IACL,OAAO;AAAA,IACP;AAAA,IACA,SAAS,CACP,OACG;AAEH,aAAO,QAAQ,YAAY;AACzB,cAAM,cAAc,GAAA;AAGpB,cAAM,YAAY,YAAY;AAAA,MAChC,CAAC;AAAA,IACH;AAAA,IACA,SAAS,MAAM;AACb,aAAO,KAAA;AACP,aAAO,MAAA;AAAA,IACT;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/strategies/queueStrategy.d.cts

@@ -0,0 +1,43 @@
+import { QueueStrategy, QueueStrategyOptions } from './types.cjs';
+/**
+ * Creates a queue strategy that processes all mutations in order with proper serialization.
+ *
+ * Unlike other strategies that may drop executions, queue ensures every
+ * mutation is processed sequentially. Each transaction commit completes before
+ * the next one starts. Useful when data consistency is critical and
+ * every operation must complete in order.
+ *
+ * @param options - Configuration for queue behavior (FIFO/LIFO, timing, size limits)
+ * @returns A queue strategy instance
+ *
+ * @example
+ * ```ts
+ * // FIFO queue - process in order received
+ * const mutate = usePacedMutations({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'front'
+ *   })
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // LIFO queue - process most recent first
+ * const mutate = usePacedMutations({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'back'
+ *   })
+ * })
+ * ```
+ */
+export declare function queueStrategy(options?: QueueStrategyOptions): QueueStrategy;

package/dist/cjs/strategies/throttleStrategy.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const throttler = require("@tanstack/pacer/throttler");
+function throttleStrategy(options) {
+  const throttler$1 = new throttler.Throttler(
+    (callback) => callback(),
+    options
+  );
+  return {
+    _type: `throttle`,
+    options,
+    execute: (fn) => {
+      throttler$1.maybeExecute(fn);
+    },
+    cleanup: () => {
+      throttler$1.cancel();
+    }
+  };
+}
+exports.throttleStrategy = throttleStrategy;
+//# sourceMappingURL=throttleStrategy.cjs.map

package/dist/cjs/strategies/throttleStrategy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttleStrategy.cjs","sources":["../../../src/strategies/throttleStrategy.ts"],"sourcesContent":["import { Throttler } from \"@tanstack/pacer/throttler\"\nimport type { ThrottleStrategy, ThrottleStrategyOptions } from \"./types\"\nimport type { Transaction } from \"../transactions\"\n\n/**\n * Creates a throttle strategy that ensures transactions are evenly spaced\n * over time.\n *\n * Provides smooth, controlled execution patterns ideal for UI updates like\n * sliders, progress bars, or scroll handlers where you want consistent\n * execution timing.\n *\n * @param options - Configuration for throttle behavior\n * @returns A throttle strategy instance\n *\n * @example\n * ```ts\n * // Throttle slider updates to every 200ms\n * const mutate = useSerializedTransaction({\n *   mutationFn: async ({ transaction }) => {\n *     await api.updateVolume(transaction.mutations)\n *   },\n *   strategy: throttleStrategy({ wait: 200 })\n * })\n * ```\n *\n * @example\n * ```ts\n * // Throttle with leading and trailing execution\n * const mutate = useSerializedTransaction({\n *   mutationFn: async ({ transaction }) => {\n *     await api.save(transaction.mutations)\n *   },\n *   strategy: throttleStrategy({\n *     wait: 500,\n *     leading: true,\n *     trailing: true\n *   })\n * })\n * ```\n */\nexport function throttleStrategy(\n  options: ThrottleStrategyOptions\n): ThrottleStrategy {\n  const throttler = new Throttler(\n    (callback: () => Transaction) => callback(),\n    options\n  )\n\n  return {\n    _type: `throttle`,\n    options,\n    execute: <T extends object = Record<string, unknown>>(\n      fn: () => Transaction<T>\n    ) => {\n      throttler.maybeExecute(fn as () => Transaction)\n    },\n    cleanup: () => {\n      throttler.cancel()\n    },\n  }\n}\n"],"names":["throttler","Throttler"],"mappings":";;;AAyCO,SAAS,iBACd,SACkB;AAClB,QAAMA,cAAY,IAAIC,UAAAA;AAAAA,IACpB,CAAC,aAAgC,SAAA;AAAA,IACjC;AAAA,EAAA;AAGF,SAAO;AAAA,IACL,OAAO;AAAA,IACP;AAAA,IACA,SAAS,CACP,OACG;AACHD,kBAAU,aAAa,EAAuB;AAAA,IAChD;AAAA,IACA,SAAS,MAAM;AACbA,kBAAU,OAAA;AAAA,IACZ;AAAA,EAAA;AAEJ;;"}

package/dist/cjs/strategies/throttleStrategy.d.cts

@@ -0,0 +1,39 @@
+import { ThrottleStrategy, ThrottleStrategyOptions } from './types.cjs';
+/**
+ * Creates a throttle strategy that ensures transactions are evenly spaced
+ * over time.
+ *
+ * Provides smooth, controlled execution patterns ideal for UI updates like
+ * sliders, progress bars, or scroll handlers where you want consistent
+ * execution timing.
+ *
+ * @param options - Configuration for throttle behavior
+ * @returns A throttle strategy instance
+ *
+ * @example
+ * ```ts
+ * // Throttle slider updates to every 200ms
+ * const mutate = useSerializedTransaction({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.updateVolume(transaction.mutations)
+ *   },
+ *   strategy: throttleStrategy({ wait: 200 })
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Throttle with leading and trailing execution
+ * const mutate = useSerializedTransaction({
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: throttleStrategy({
+ *     wait: 500,
+ *     leading: true,
+ *     trailing: true
+ *   })
+ * })
+ * ```
+ */
+export declare function throttleStrategy(options: ThrottleStrategyOptions): ThrottleStrategy;

package/dist/cjs/strategies/types.d.cts

@@ -0,0 +1,103 @@
+import { Transaction } from '../transactions.cjs';
+/**
+ * Base strategy interface that all strategy implementations must conform to
+ */
+export interface BaseStrategy<TName extends string = string> {
+    /** Type discriminator for strategy identification */
+    _type: TName;
+    /**
+     * Execute a function according to the strategy's timing rules
+     * @param fn - The function to execute
+     * @returns The result of the function execution (if applicable)
+     */
+    execute: <T extends object = Record<string, unknown>>(fn: () => Transaction<T>) => void | Promise<void>;
+    /**
+     * Clean up any resources held by the strategy
+     * Should be called when the strategy is no longer needed
+     */
+    cleanup: () => void;
+}
+/**
+ * Options for debounce strategy
+ * Delays execution until after a period of inactivity
+ */
+export interface DebounceStrategyOptions {
+    /** Wait time in milliseconds before execution */
+    wait: number;
+    /** Execute immediately on the first call */
+    leading?: boolean;
+    /** Execute after the wait period on the last call */
+    trailing?: boolean;
+}
+/**
+ * Debounce strategy that delays execution until activity stops
+ */
+export interface DebounceStrategy extends BaseStrategy<`debounce`> {
+    options: DebounceStrategyOptions;
+}
+/**
+ * Options for queue strategy
+ * Processes all executions in order (FIFO/LIFO)
+ */
+export interface QueueStrategyOptions {
+    /** Wait time between processing queue items (milliseconds) */
+    wait?: number;
+    /** Maximum queue size (items are dropped if exceeded) */
+    maxSize?: number;
+    /** Where to add new items in the queue */
+    addItemsTo?: `front` | `back`;
+    /** Where to get items from when processing */
+    getItemsFrom?: `front` | `back`;
+}
+/**
+ * Queue strategy that processes all executions in order
+ * FIFO: { addItemsTo: 'back', getItemsFrom: 'front' }
+ * LIFO: { addItemsTo: 'back', getItemsFrom: 'back' }
+ */
+export interface QueueStrategy extends BaseStrategy<`queue`> {
+    options?: QueueStrategyOptions;
+}
+/**
+ * Options for throttle strategy
+ * Ensures executions are evenly spaced over time
+ */
+export interface ThrottleStrategyOptions {
+    /** Minimum wait time between executions (milliseconds) */
+    wait: number;
+    /** Execute immediately on the first call */
+    leading?: boolean;
+    /** Execute on the last call after wait period */
+    trailing?: boolean;
+}
+/**
+ * Throttle strategy that spaces executions evenly over time
+ */
+export interface ThrottleStrategy extends BaseStrategy<`throttle`> {
+    options: ThrottleStrategyOptions;
+}
+/**
+ * Options for batch strategy
+ * Groups multiple executions together
+ */
+export interface BatchStrategyOptions {
+    /** Maximum items per batch */
+    maxSize?: number;
+    /** Maximum wait time before processing batch (milliseconds) */
+    wait?: number;
+    /** Custom logic to determine when to execute batch */
+    getShouldExecute?: (items: Array<any>) => boolean;
+}
+/**
+ * Batch strategy that groups multiple executions together
+ */
+export interface BatchStrategy extends BaseStrategy<`batch`> {
+    options?: BatchStrategyOptions;
+}
+/**
+ * Union type of all available strategies
+ */
+export type Strategy = DebounceStrategy | QueueStrategy | ThrottleStrategy | BatchStrategy;
+/**
+ * Extract the options type from a strategy
+ */
+export type StrategyOptions<T extends Strategy> = T extends DebounceStrategy ? DebounceStrategyOptions : T extends QueueStrategy ? QueueStrategyOptions : T extends ThrottleStrategy ? ThrottleStrategyOptions : T extends BatchStrategy ? BatchStrategyOptions : never;

package/dist/esm/index.d.ts

@@ -9,6 +9,8 @@ export * from './optimistic-action.js';
 export * from './local-only.js';
 export * from './local-storage.js';
 export * from './errors.js';
+export * from './paced-mutations.js';
+export * from './strategies/index.js';
 export * from './indexes/base-index.js';
 export * from './indexes/btree-index.js';
 export * from './indexes/lazy-index.js';

package/dist/esm/index.js

@@ -7,6 +7,7 @@ import { createOptimisticAction } from "./optimistic-action.js";
 import { localOnlyCollectionOptions } from "./local-only.js";
 import { localStorageCollectionOptions } from "./local-storage.js";
 import { AggregateFunctionNotInSelectError, AggregateNotSupportedError, CannotCombineEmptyExpressionListError, CollectionConfigurationError, CollectionInErrorStateError, CollectionInputNotFoundError, CollectionIsInErrorStateError, CollectionOperationError, CollectionRequiresConfigError, CollectionRequiresSyncConfigError, CollectionStateError, DeleteKeyNotFoundError, DistinctRequiresSelectError, DuplicateKeyError, DuplicateKeySyncError, EmptyReferencePathError, GroupByError, HavingRequiresGroupByError, InvalidCollectionStatusTransitionError, InvalidJoinCondition, InvalidJoinConditionLeftSourceError, InvalidJoinConditionRightSourceError, InvalidJoinConditionSameSourceError, InvalidJoinConditionSourceMismatchError, InvalidSchemaError, InvalidSourceError, InvalidStorageDataFormatError, InvalidStorageObjectFormatError, JoinCollectionNotFoundError, JoinConditionMustBeEqualityError, JoinError, KeyUpdateNotAllowedError, LimitOffsetRequireOrderByError, LocalStorageCollectionError, MissingAliasInputsError, MissingDeleteHandlerError, MissingHandlerError, MissingInsertHandlerError, MissingMutationFunctionError, MissingUpdateArgumentError, MissingUpdateHandlerError, NegativeActiveSubscribersError, NoKeysPassedToDeleteError, NoKeysPassedToUpdateError, NoPendingSyncTransactionCommitError, NoPendingSyncTransactionWriteError, NonAggregateExpressionNotInGroupByError, NonRetriableError, OnlyOneSourceAllowedError, QueryBuilderError, QueryCompilationError, QueryMustHaveFromClauseError, QueryOptimizerError, SchemaMustBeSynchronousError, SchemaValidationError, SerializationError, SetWindowRequiresOrderByError, StorageError, StorageKeyRequiredError, SubQueryMustHaveFromClauseError, SubscriptionNotFoundError, SyncCleanupError, SyncTransactionAlreadyCommittedError, SyncTransactionAlreadyCommittedWriteError, TanStackDBError, TransactionAlreadyCompletedRollbackError, TransactionError, TransactionNotPendingCommitError, TransactionNotPendingMutateError, UndefinedKeyError, UnknownExpressionTypeError, UnknownFunctionError, UnknownHavingExpressionTypeError, UnsupportedAggregateFunctionError, UnsupportedFromTypeError, UnsupportedJoinSourceTypeError, UnsupportedJoinTypeError, UpdateKeyNotFoundError, WhereClauseConversionError } from "./errors.js";
+import { createPacedMutations } from "./paced-mutations.js";
 import { BaseIndex, IndexOperation } from "./indexes/base-index.js";
 import { BTreeIndex } from "./indexes/btree-index.js";
 import { IndexProxy, LazyIndexWrapper } from "./indexes/lazy-index.js";
@@ -14,6 +15,9 @@ import { BaseQueryBuilder, Query } from "./query/builder/index.js";
 import { add, and, avg, coalesce, concat, count, eq, gt, gte, ilike, inArray, isNull, isUndefined, length, like, lower, lt, lte, max, min, not, or, sum, upper } from "./query/builder/functions.js";
 import { compileQuery } from "./query/compiler/index.js";
 import { createLiveQueryCollection, liveQueryCollectionOptions } from "./query/live-query-collection.js";
+import { debounceStrategy } from "./strategies/debounceStrategy.js";
+import { queueStrategy } from "./strategies/queueStrategy.js";
+import { throttleStrategy } from "./strategies/throttleStrategy.js";
 export {
   AggregateFunctionNotInSelectError,
   AggregateNotSupportedError,
@@ -116,7 +120,9 @@ export {
   createCollection,
   createLiveQueryCollection,
   createOptimisticAction,
+  createPacedMutations,
   createTransaction,
+  debounceStrategy,
   eq,
   getActiveTransaction,
   gt,
@@ -137,7 +143,9 @@ export {
   min,
   not,
   or,
+  queueStrategy,
   sum,
+  throttleStrategy,
   upper,
   withArrayChangeTracking,
   withChangeTracking

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/indexes/auto-index.js

@@ -17,14 +17,23 @@ function ensureIndexForField(fieldName, fieldPath, collection, compareOptions =
     return;
   }
   try {
-    collection.createIndex((row) => row[fieldName], {
-      name: `auto_${fieldName}`,
-      indexType: BTreeIndex,
-      options: compareFn ? { compareFn, compareOptions } : {}
-    });
+    collection.createIndex(
+      (row) => {
+        let current = row;
+        for (const part of fieldPath) {
+          current = current[part];
+        }
+        return current;
+      },
+      {
+        name: `auto:${fieldPath.join(`.`)}`,
+        indexType: BTreeIndex,
+        options: compareFn ? { compareFn, compareOptions } : {}
+      }
+    );
   } catch (error) {
     console.warn(
-      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field "${fieldName}":`,
+      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field path "${fieldPath.join(`.`)}":`,
       error
     );
   }
@@ -60,10 +69,10 @@ function extractIndexableExpressions(expression) {
     }
     const fieldRef = func.args[0];
     const fieldPath = fieldRef.path;
-    if (fieldPath.length !== 1) {
+    if (fieldPath.length === 0) {
       return;
     }
-    const fieldName = fieldPath[0];
+    const fieldName = fieldPath.join(`_`);
     results.push({ fieldName, fieldPath });
   }
   extractFromExpression(expression);

package/dist/esm/indexes/auto-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"auto-index.js","sources":["../../../src/indexes/auto-index.ts"],"sourcesContent":["import { DEFAULT_COMPARE_OPTIONS } from \"../utils\"\nimport { BTreeIndex } from \"./btree-index\"\nimport type { CompareOptions } from \"../query/builder/types\"\nimport type { BasicExpression } from \"../query/ir\"\nimport type { CollectionImpl } from \"../collection/index.js\"\n\nexport interface AutoIndexConfig {\n  autoIndex?: `off` | `eager`\n}\n\nfunction shouldAutoIndex(collection: CollectionImpl<any, any, any, any, any>) {\n  // Only proceed if auto-indexing is enabled\n  if (collection.config.autoIndex !== `eager`) {\n    return false\n  }\n\n  return true\n}\n\nexport function ensureIndexForField<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  fieldName: string,\n  fieldPath: Array<string>,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n  compareOptions: CompareOptions = DEFAULT_COMPARE_OPTIONS,\n  compareFn?: (a: any, b: any) => number\n) {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Check if we already have an index for this field\n  const existingIndex = Array.from(collection.indexes.values()).find(\n    (index) =>\n      index.matchesField(fieldPath) &&\n      index.matchesCompareOptions(compareOptions)\n  )\n\n  if (existingIndex) {\n    return // Index already exists\n  }\n\n  // Create a new index for this field using the collection's createIndex method\n  try {\n    collection.createIndex((row) => (row as any)[fieldName], {\n      name: `auto_${fieldName}`,\n      indexType: BTreeIndex,\n      options: compareFn ? { compareFn, compareOptions } : {},\n    })\n  } catch (error) {\n    console.warn(\n      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field \"${fieldName}\":`,\n      error\n    )\n  }\n}\n\n/**\n * Analyzes a where expression and creates indexes for all simple operations on single fields\n */\nexport function ensureIndexForExpression<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  expression: BasicExpression,\n  collection: CollectionImpl<T, TKey, any, any, any>\n): void {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Extract all indexable expressions and create indexes for them\n  const indexableExpressions = extractIndexableExpressions(expression)\n\n  for (const { fieldName, fieldPath } of indexableExpressions) {\n    ensureIndexForField(fieldName, fieldPath, collection)\n  }\n}\n\n/**\n * Extracts all indexable expressions from a where expression\n */\nfunction extractIndexableExpressions(\n  expression: BasicExpression\n): Array<{ fieldName: string; fieldPath: Array<string> }> {\n  const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []\n\n  function extractFromExpression(expr: BasicExpression): void {\n    if (expr.type !== `func`) {\n      return\n    }\n\n    const func = expr as any\n\n    // Handle 'and' expressions by recursively processing all arguments\n    if (func.name === `and`) {\n      for (const arg of func.args) {\n        extractFromExpression(arg)\n      }\n      return\n    }\n\n    // Check if this is a supported operation\n    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]\n    if (!supportedOperations.includes(func.name)) {\n      return\n    }\n\n    // Check if the first argument is a property reference (single field)\n    if (func.args.length < 1 || func.args[0].type !== `ref`) {\n      return\n    }\n\n    const fieldRef = func.args[0]\n    const fieldPath = fieldRef.path\n\n    // Skip if it's not a simple field (e.g., nested properties or array access)\n    if (fieldPath.length !== 1) {\n      return\n    }\n\n    const fieldName = fieldPath[0]\n    results.push({ fieldName, fieldPath })\n  }\n\n  extractFromExpression(expression)\n  return results\n}\n"],"names":[],"mappings":";;AAUA,SAAS,gBAAgB,YAAqD;AAE5E,MAAI,WAAW,OAAO,cAAc,SAAS;AAC3C,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,SAAS,oBAId,WACA,WACA,YACA,iBAAiC,yBACjC,WACA;AACA,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,gBAAgB,MAAM,KAAK,WAAW,QAAQ,OAAA,CAAQ,EAAE;AAAA,IAC5D,CAAC,UACC,MAAM,aAAa,SAAS,KAC5B,MAAM,sBAAsB,cAAc;AAAA,EAAA;AAG9C,MAAI,eAAe;AACjB;AAAA,EACF;AAGA,MAAI;AACF,eAAW,YAAY,CAAC,QAAS,IAAY,SAAS,GAAG;AAAA,MACvD,MAAM,QAAQ,SAAS;AAAA,MACvB,WAAW;AAAA,MACX,SAAS,YAAY,EAAE,WAAW,eAAA,IAAmB,CAAA;AAAA,IAAC,CACvD;AAAA,EACH,SAAS,OAAO;AACd,YAAQ;AAAA,MACN,GAAG,WAAW,KAAK,IAAI,WAAW,EAAE,OAAO,EAAE,0CAA0C,SAAS;AAAA,MAChG;AAAA,IAAA;AAAA,EAEJ;AACF;AAKO,SAAS,yBAId,YACA,YACM;AACN,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,uBAAuB,4BAA4B,UAAU;AAEnE,aAAW,EAAE,WAAW,UAAA,KAAe,sBAAsB;AAC3D,wBAAoB,WAAW,WAAW,UAAU;AAAA,EACtD;AACF;AAKA,SAAS,4BACP,YACwD;AACxD,QAAM,UAAkE,CAAA;AAExE,WAAS,sBAAsB,MAA6B;AAC1D,QAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,IACF;AAEA,UAAM,OAAO;AAGb,QAAI,KAAK,SAAS,OAAO;AACvB,iBAAW,OAAO,KAAK,MAAM;AAC3B,8BAAsB,GAAG;AAAA,MAC3B;AACA;AAAA,IACF;AAGA,UAAM,sBAAsB,CAAC,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AACjE,QAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,GAAG;AAC5C;AAAA,IACF;AAGA,QAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE,SAAS,OAAO;AACvD;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,KAAK,CAAC;AAC5B,UAAM,YAAY,SAAS;AAG3B,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAEA,UAAM,YAAY,UAAU,CAAC;AAC7B,YAAQ,KAAK,EAAE,WAAW,UAAA,CAAW;AAAA,EACvC;AAEA,wBAAsB,UAAU;AAChC,SAAO;AACT;"}
+{"version":3,"file":"auto-index.js","sources":["../../../src/indexes/auto-index.ts"],"sourcesContent":["import { DEFAULT_COMPARE_OPTIONS } from \"../utils\"\nimport { BTreeIndex } from \"./btree-index\"\nimport type { CompareOptions } from \"../query/builder/types\"\nimport type { BasicExpression } from \"../query/ir\"\nimport type { CollectionImpl } from \"../collection/index.js\"\n\nexport interface AutoIndexConfig {\n  autoIndex?: `off` | `eager`\n}\n\nfunction shouldAutoIndex(collection: CollectionImpl<any, any, any, any, any>) {\n  // Only proceed if auto-indexing is enabled\n  if (collection.config.autoIndex !== `eager`) {\n    return false\n  }\n\n  return true\n}\n\nexport function ensureIndexForField<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  fieldName: string,\n  fieldPath: Array<string>,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n  compareOptions: CompareOptions = DEFAULT_COMPARE_OPTIONS,\n  compareFn?: (a: any, b: any) => number\n) {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Check if we already have an index for this field\n  const existingIndex = Array.from(collection.indexes.values()).find(\n    (index) =>\n      index.matchesField(fieldPath) &&\n      index.matchesCompareOptions(compareOptions)\n  )\n\n  if (existingIndex) {\n    return // Index already exists\n  }\n\n  // Create a new index for this field using the collection's createIndex method\n  try {\n    // Use the proxy-based approach to create the proper accessor for nested paths\n    collection.createIndex(\n      (row) => {\n        // Navigate through the field path\n        let current: any = row\n        for (const part of fieldPath) {\n          current = current[part]\n        }\n        return current\n      },\n      {\n        name: `auto:${fieldPath.join(`.`)}`,\n        indexType: BTreeIndex,\n        options: compareFn ? { compareFn, compareOptions } : {},\n      }\n    )\n  } catch (error) {\n    console.warn(\n      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field path \"${fieldPath.join(`.`)}\":`,\n      error\n    )\n  }\n}\n\n/**\n * Analyzes a where expression and creates indexes for all simple operations on single fields\n */\nexport function ensureIndexForExpression<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  expression: BasicExpression,\n  collection: CollectionImpl<T, TKey, any, any, any>\n): void {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Extract all indexable expressions and create indexes for them\n  const indexableExpressions = extractIndexableExpressions(expression)\n\n  for (const { fieldName, fieldPath } of indexableExpressions) {\n    ensureIndexForField(fieldName, fieldPath, collection)\n  }\n}\n\n/**\n * Extracts all indexable expressions from a where expression\n */\nfunction extractIndexableExpressions(\n  expression: BasicExpression\n): Array<{ fieldName: string; fieldPath: Array<string> }> {\n  const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []\n\n  function extractFromExpression(expr: BasicExpression): void {\n    if (expr.type !== `func`) {\n      return\n    }\n\n    const func = expr as any\n\n    // Handle 'and' expressions by recursively processing all arguments\n    if (func.name === `and`) {\n      for (const arg of func.args) {\n        extractFromExpression(arg)\n      }\n      return\n    }\n\n    // Check if this is a supported operation\n    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]\n    if (!supportedOperations.includes(func.name)) {\n      return\n    }\n\n    // Check if the first argument is a property reference\n    if (func.args.length < 1 || func.args[0].type !== `ref`) {\n      return\n    }\n\n    const fieldRef = func.args[0]\n    const fieldPath = fieldRef.path\n\n    // Skip if the path is empty\n    if (fieldPath.length === 0) {\n      return\n    }\n\n    // For nested paths, use the full path joined with underscores as the field name\n    // For simple paths, use the first (and only) element\n    const fieldName = fieldPath.join(`_`)\n    results.push({ fieldName, fieldPath })\n  }\n\n  extractFromExpression(expression)\n  return results\n}\n"],"names":[],"mappings":";;AAUA,SAAS,gBAAgB,YAAqD;AAE5E,MAAI,WAAW,OAAO,cAAc,SAAS;AAC3C,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,SAAS,oBAId,WACA,WACA,YACA,iBAAiC,yBACjC,WACA;AACA,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,gBAAgB,MAAM,KAAK,WAAW,QAAQ,OAAA,CAAQ,EAAE;AAAA,IAC5D,CAAC,UACC,MAAM,aAAa,SAAS,KAC5B,MAAM,sBAAsB,cAAc;AAAA,EAAA;AAG9C,MAAI,eAAe;AACjB;AAAA,EACF;AAGA,MAAI;AAEF,eAAW;AAAA,MACT,CAAC,QAAQ;AAEP,YAAI,UAAe;AACnB,mBAAW,QAAQ,WAAW;AAC5B,oBAAU,QAAQ,IAAI;AAAA,QACxB;AACA,eAAO;AAAA,MACT;AAAA,MACA;AAAA,QACE,MAAM,QAAQ,UAAU,KAAK,GAAG,CAAC;AAAA,QACjC,WAAW;AAAA,QACX,SAAS,YAAY,EAAE,WAAW,eAAA,IAAmB,CAAA;AAAA,MAAC;AAAA,IACxD;AAAA,EAEJ,SAAS,OAAO;AACd,YAAQ;AAAA,MACN,GAAG,WAAW,KAAK,IAAI,WAAW,EAAE,OAAO,EAAE,+CAA+C,UAAU,KAAK,GAAG,CAAC;AAAA,MAC/G;AAAA,IAAA;AAAA,EAEJ;AACF;AAKO,SAAS,yBAId,YACA,YACM;AACN,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,uBAAuB,4BAA4B,UAAU;AAEnE,aAAW,EAAE,WAAW,UAAA,KAAe,sBAAsB;AAC3D,wBAAoB,WAAW,WAAW,UAAU;AAAA,EACtD;AACF;AAKA,SAAS,4BACP,YACwD;AACxD,QAAM,UAAkE,CAAA;AAExE,WAAS,sBAAsB,MAA6B;AAC1D,QAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,IACF;AAEA,UAAM,OAAO;AAGb,QAAI,KAAK,SAAS,OAAO;AACvB,iBAAW,OAAO,KAAK,MAAM;AAC3B,8BAAsB,GAAG;AAAA,MAC3B;AACA;AAAA,IACF;AAGA,UAAM,sBAAsB,CAAC,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AACjE,QAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,GAAG;AAC5C;AAAA,IACF;AAGA,QAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE,SAAS,OAAO;AACvD;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,KAAK,CAAC;AAC5B,UAAM,YAAY,SAAS;AAG3B,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAIA,UAAM,YAAY,UAAU,KAAK,GAAG;AACpC,YAAQ,KAAK,EAAE,WAAW,UAAA,CAAW;AAAA,EACvC;AAEA,wBAAsB,UAAU;AAChC,SAAO;AACT;"}

package/dist/esm/paced-mutations.d.ts

@@ -0,0 +1,81 @@
+import { MutationFn, Transaction } from './types.js';
+import { Strategy } from './strategies/types.js';
+/**
+ * Configuration for creating a paced mutations manager
+ */
+export interface PacedMutationsConfig<TVariables = unknown, T extends object = Record<string, unknown>> {
+    /**
+     * Callback to apply optimistic updates immediately.
+     * Receives the variables passed to the mutate function.
+     */
+    onMutate: (variables: TVariables) => void;
+    /**
+     * Function to execute the mutation on the server.
+     * Receives the transaction parameters containing all merged mutations.
+     */
+    mutationFn: MutationFn<T>;
+    /**
+     * Strategy for controlling mutation execution timing
+     * Examples: debounceStrategy, queueStrategy, throttleStrategy
+     */
+    strategy: Strategy;
+    /**
+     * Custom metadata to associate with transactions
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Creates a paced mutations manager with pluggable timing strategies.
+ *
+ * This function provides a way to control when and how optimistic mutations
+ * are persisted to the backend, using strategies like debouncing, queuing,
+ * or throttling. The optimistic updates are applied immediately via `onMutate`,
+ * and the actual persistence is controlled by the strategy.
+ *
+ * The returned function accepts variables of type TVariables and returns a
+ * Transaction object that can be awaited to know when persistence completes
+ * or to handle errors.
+ *
+ * @param config - Configuration including onMutate, mutationFn and strategy
+ * @returns A function that accepts variables and returns a Transaction
+ *
+ * @example
+ * ```ts
+ * // Debounced mutations for auto-save
+ * const updateTodo = createPacedMutations<string>({
+ *   onMutate: (text) => {
+ *     // Apply optimistic update immediately
+ *     collection.update(id, draft => { draft.text = text })
+ *   },
+ *   mutationFn: async (text, { transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: debounceStrategy({ wait: 500 })
+ * })
+ *
+ * // Call with variables, returns a transaction
+ * const tx = updateTodo('New text')
+ *
+ * // Await persistence or handle errors
+ * await tx.isPersisted.promise
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Queue strategy for sequential processing
+ * const addTodo = createPacedMutations<{ text: string }>({
+ *   onMutate: ({ text }) => {
+ *     collection.insert({ id: uuid(), text, completed: false })
+ *   },
+ *   mutationFn: async ({ text }, { transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: queueStrategy({
+ *     wait: 200,
+ *     addItemsTo: 'back',
+ *     getItemsFrom: 'front'
+ *   })
+ * })
+ * ```
+ */
+export declare function createPacedMutations<TVariables = unknown, T extends object = Record<string, unknown>>(config: PacedMutationsConfig<TVariables, T>): (variables: TVariables) => Transaction<T>;

package/dist/esm/paced-mutations.js

@@ -0,0 +1,52 @@
+import { createTransaction } from "./transactions.js";
+function createPacedMutations(config) {
+  const { onMutate, mutationFn, strategy, ...transactionConfig } = config;
+  let activeTransaction = null;
+  const commitCallback = () => {
+    if (!activeTransaction) {
+      throw new Error(
+        `Strategy callback called but no active transaction exists. This indicates a bug in the strategy implementation.`
+      );
+    }
+    if (activeTransaction.state !== `pending`) {
+      throw new Error(
+        `Strategy callback called but active transaction is in state "${activeTransaction.state}". Expected "pending".`
+      );
+    }
+    const txToCommit = activeTransaction;
+    activeTransaction = null;
+    txToCommit.commit().catch(() => {
+    });
+    return txToCommit;
+  };
+  function mutate(variables) {
+    if (!activeTransaction || activeTransaction.state !== `pending`) {
+      activeTransaction = createTransaction({
+        ...transactionConfig,
+        mutationFn,
+        autoCommit: false
+      });
+    }
+    activeTransaction.mutate(() => {
+      onMutate(variables);
+    });
+    const txToReturn = activeTransaction;
+    if (strategy._type === `queue`) {
+      const capturedTx = activeTransaction;
+      activeTransaction = null;
+      strategy.execute(() => {
+        capturedTx.commit().catch(() => {
+        });
+        return capturedTx;
+      });
+    } else {
+      strategy.execute(commitCallback);
+    }
+    return txToReturn;
+  }
+  return mutate;
+}
+export {
+  createPacedMutations
+};
+//# sourceMappingURL=paced-mutations.js.map

package/dist/esm/paced-mutations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paced-mutations.js","sources":["../../src/paced-mutations.ts"],"sourcesContent":["import { createTransaction } from \"./transactions\"\nimport type { MutationFn, Transaction } from \"./types\"\nimport type { Strategy } from \"./strategies/types\"\n\n/**\n * Configuration for creating a paced mutations manager\n */\nexport interface PacedMutationsConfig<\n  TVariables = unknown,\n  T extends object = Record<string, unknown>,\n> {\n  /**\n   * Callback to apply optimistic updates immediately.\n   * Receives the variables passed to the mutate function.\n   */\n  onMutate: (variables: TVariables) => void\n  /**\n   * Function to execute the mutation on the server.\n   * Receives the transaction parameters containing all merged mutations.\n   */\n  mutationFn: MutationFn<T>\n  /**\n   * Strategy for controlling mutation execution timing\n   * Examples: debounceStrategy, queueStrategy, throttleStrategy\n   */\n  strategy: Strategy\n  /**\n   * Custom metadata to associate with transactions\n   */\n  metadata?: Record<string, unknown>\n}\n\n/**\n * Creates a paced mutations manager with pluggable timing strategies.\n *\n * This function provides a way to control when and how optimistic mutations\n * are persisted to the backend, using strategies like debouncing, queuing,\n * or throttling. The optimistic updates are applied immediately via `onMutate`,\n * and the actual persistence is controlled by the strategy.\n *\n * The returned function accepts variables of type TVariables and returns a\n * Transaction object that can be awaited to know when persistence completes\n * or to handle errors.\n *\n * @param config - Configuration including onMutate, mutationFn and strategy\n * @returns A function that accepts variables and returns a Transaction\n *\n * @example\n * ```ts\n * // Debounced mutations for auto-save\n * const updateTodo = createPacedMutations<string>({\n *   onMutate: (text) => {\n *     // Apply optimistic update immediately\n *     collection.update(id, draft => { draft.text = text })\n *   },\n *   mutationFn: async (text, { transaction }) => {\n *     await api.save(transaction.mutations)\n *   },\n *   strategy: debounceStrategy({ wait: 500 })\n * })\n *\n * // Call with variables, returns a transaction\n * const tx = updateTodo('New text')\n *\n * // Await persistence or handle errors\n * await tx.isPersisted.promise\n * ```\n *\n * @example\n * ```ts\n * // Queue strategy for sequential processing\n * const addTodo = createPacedMutations<{ text: string }>({\n *   onMutate: ({ text }) => {\n *     collection.insert({ id: uuid(), text, completed: false })\n *   },\n *   mutationFn: async ({ text }, { transaction }) => {\n *     await api.save(transaction.mutations)\n *   },\n *   strategy: queueStrategy({\n *     wait: 200,\n *     addItemsTo: 'back',\n *     getItemsFrom: 'front'\n *   })\n * })\n * ```\n */\nexport function createPacedMutations<\n  TVariables = unknown,\n  T extends object = Record<string, unknown>,\n>(\n  config: PacedMutationsConfig<TVariables, T>\n): (variables: TVariables) => Transaction<T> {\n  const { onMutate, mutationFn, strategy, ...transactionConfig } = config\n\n  // The currently active transaction (pending, not yet persisting)\n  let activeTransaction: Transaction<T> | null = null\n\n  // Commit callback that the strategy will call when it's time to persist\n  const commitCallback = () => {\n    if (!activeTransaction) {\n      throw new Error(\n        `Strategy callback called but no active transaction exists. This indicates a bug in the strategy implementation.`\n      )\n    }\n\n    if (activeTransaction.state !== `pending`) {\n      throw new Error(\n        `Strategy callback called but active transaction is in state \"${activeTransaction.state}\". Expected \"pending\".`\n      )\n    }\n\n    const txToCommit = activeTransaction\n\n    // Clear active transaction reference before committing\n    activeTransaction = null\n\n    // Commit the transaction\n    txToCommit.commit().catch(() => {\n      // Errors are handled via transaction.isPersisted.promise\n      // This catch prevents unhandled promise rejections\n    })\n\n    return txToCommit\n  }\n\n  /**\n   * Executes a mutation with the given variables. Creates a new transaction if none is active,\n   * or adds to the existing active transaction. The strategy controls when\n   * the transaction is actually committed.\n   */\n  function mutate(variables: TVariables): Transaction<T> {\n    // Create a new transaction if we don't have an active one\n    if (!activeTransaction || activeTransaction.state !== `pending`) {\n      activeTransaction = createTransaction<T>({\n        ...transactionConfig,\n        mutationFn,\n        autoCommit: false,\n      })\n    }\n\n    // Execute onMutate with variables to apply optimistic updates\n    activeTransaction.mutate(() => {\n      onMutate(variables)\n    })\n\n    // Save reference before calling strategy.execute\n    const txToReturn = activeTransaction\n\n    // For queue strategy, pass a function that commits the captured transaction\n    // This prevents the error when commitCallback tries to access the cleared activeTransaction\n    if (strategy._type === `queue`) {\n      const capturedTx = activeTransaction\n      activeTransaction = null // Clear so next mutation creates a new transaction\n      strategy.execute(() => {\n        capturedTx.commit().catch(() => {\n          // Errors are handled via transaction.isPersisted.promise\n        })\n        return capturedTx\n      })\n    } else {\n      // For debounce/throttle, use commitCallback which manages activeTransaction\n      strategy.execute(commitCallback)\n    }\n\n    return txToReturn\n  }\n\n  return mutate\n}\n"],"names":[],"mappings":";AAsFO,SAAS,qBAId,QAC2C;AAC3C,QAAM,EAAE,UAAU,YAAY,UAAU,GAAG,sBAAsB;AAGjE,MAAI,oBAA2C;AAG/C,QAAM,iBAAiB,MAAM;AAC3B,QAAI,CAAC,mBAAmB;AACtB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAEA,QAAI,kBAAkB,UAAU,WAAW;AACzC,YAAM,IAAI;AAAA,QACR,gEAAgE,kBAAkB,KAAK;AAAA,MAAA;AAAA,IAE3F;AAEA,UAAM,aAAa;AAGnB,wBAAoB;AAGpB,eAAW,SAAS,MAAM,MAAM;AAAA,IAGhC,CAAC;AAED,WAAO;AAAA,EACT;AAOA,WAAS,OAAO,WAAuC;AAErD,QAAI,CAAC,qBAAqB,kBAAkB,UAAU,WAAW;AAC/D,0BAAoB,kBAAqB;AAAA,QACvC,GAAG;AAAA,QACH;AAAA,QACA,YAAY;AAAA,MAAA,CACb;AAAA,IACH;AAGA,sBAAkB,OAAO,MAAM;AAC7B,eAAS,SAAS;AAAA,IACpB,CAAC;AAGD,UAAM,aAAa;AAInB,QAAI,SAAS,UAAU,SAAS;AAC9B,YAAM,aAAa;AACnB,0BAAoB;AACpB,eAAS,QAAQ,MAAM;AACrB,mBAAW,SAAS,MAAM,MAAM;AAAA,QAEhC,CAAC;AACD,eAAO;AAAA,MACT,CAAC;AAAA,IACH,OAAO;AAEL,eAAS,QAAQ,cAAc;AAAA,IACjC;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;"}

package/dist/esm/query/optimizer.js

@@ -73,6 +73,14 @@ function applySingleLevelOptimization(query) {
     return query;
   }
   if (!query.join || query.join.length === 0) {
+    if (query.where.length > 1) {
+      const splitWhereClauses2 = splitAndClauses(query.where);
+      const combinedWhere = combineWithAnd(splitWhereClauses2);
+      return {
+        ...query,
+        where: [combinedWhere]
+      };
+    }
     return query;
   }
   const nonResidualWhereClauses = query.where.filter(
@@ -232,6 +240,13 @@ function applyOptimizations(query, groupedClauses) {
       remainingWhereClauses.push(createResidualWhere(clause));
     }
   }
+  const finalWhere = remainingWhereClauses.length > 1 ? [
+    combineWithAnd(
+      remainingWhereClauses.flatMap(
+        (clause) => splitAndClausesRecursive(getWhereExpression(clause))
+      )
+    )
+  ] : remainingWhereClauses;
   const optimizedQuery = {
     // Copy all non-optimized fields as-is
     select: query.select,
@@ -247,8 +262,8 @@ function applyOptimizations(query, groupedClauses) {
     // Use the optimized FROM and JOIN clauses
     from: optimizedFrom,
     join: optimizedJoins,
-    // Only include WHERE clauses that weren't successfully optimized
-    where: remainingWhereClauses.length > 0 ? remainingWhereClauses : []
+    // Include combined WHERE clauses
+    where: finalWhere.length > 0 ? finalWhere : []
   };
   return optimizedQuery;
 }