Upgrade pacer package (#829)

* Upgrade @tanstack/pacer to v0.16.2 and fix AsyncQueuer API usage

The pacer package API changed significantly from v0.1.0 to v0.16.2:
- AsyncQueuer constructor now takes the function as first parameter
- Items are passed to addItem() instead of functions being passed to addItem()
- Updated queueStrategy to use new API pattern

This fixes the build errors in packages/db/src/strategies/queueStrategy.ts

* Improve type safety in queueStrategy by avoiding 'any'

Replace Transaction<any> with Transaction to match the pattern used in
debounceStrategy and throttleStrategy. This maintains type safety while
allowing the queuer to handle transactions with different generic types.

- Changed AsyncQueuer<() => Transaction<any>> to AsyncQueuer<() => Transaction>
- Added type cast in addItem call: fn as () => Transaction
- Consistent with existing strategy implementations

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: KyleAMathews

packages/db/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
     "@tanstack/db-ivm": "workspace:*",
-    "@tanstack/pacer": "^0.1.0"
+    "@tanstack/pacer": "^0.16.2"
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^3.2.4",

packages/db/src/strategies/queueStrategy.ts

@@ -44,28 +44,31 @@ import type { Transaction } from "../transactions"
  * ```
  */
 export function queueStrategy(options?: QueueStrategyOptions): QueueStrategy {
-  const queuer = new AsyncQueuer<void>({
-    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
-  })
+  const queuer = new AsyncQueuer<() => Transaction>(
+    async (fn) => {
+      const transaction = fn()
+      // Wait for the transaction to be persisted before processing next item
+      // Note: fn() already calls commit(), we just wait for it to complete
+      await transaction.isPersisted.promise
+    },
+    {
+      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: <T extends object = Record<string, unknown>>(
       fn: () => Transaction<T>
     ) => {
-      // Wrap the callback in an async function that waits for persistence
-      queuer.addItem(async () => {
-        const transaction = fn()
-        // Wait for the transaction to be persisted before processing next item
-        // Note: fn() already calls commit(), we just wait for it to complete
-        await transaction.isPersisted.promise
-      })
+      // Add the transaction-creating function to the queue
+      queuer.addItem(fn as () => Transaction)
     },
     cleanup: () => {
       queuer.stop()