Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

OfflineExecutor.dispose() never settles pendingTransactionPromises

Abierto Apto para principiantes
  • ¿Algo no está bien?
#2,254 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
2/5
Tiempo estimado
1-3 horas
Aptitud para principiantes
78/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
node.js, typescript
Área
backend, databases

Línea de trabajo

Empieza por packages/offline-transactions/src/OfflineExecutor.ts, especialmente por waitForTransactionCompletion, resolveTransaction/rejectTransaction y dispose(), tal como se enlazan en el issue. Sigue cómo se corresponden los deferreds pendientes con las transacciones y revisa las pruebas de disposal y de transacciones del paquete. Reproduce la secuencia de commit offline, disposal y replay del issue; se considera terminado cuando la transacción original alcanza un estado resuelto y su isPersisted.promise deja de quedar bloqueada.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

  • I've validated the bug against the latest version of DB packages

Describe the bug
OfflineExecutor keeps a pendingTransactionPromises map of deferreds, created by waitForTransactionCompletion and settled by resolveTransaction / rejectTransaction. dispose() pauses the executor and tears down the collection refresh hooks, the online listener, leadership, and the online detector, but it never touches the map. Every deferred in it is abandoned, so a transaction committed on a disposed executor never leaves persisting, and its isPersisted.promise never settles.

To Reproduce

  1. npm i @tanstack/[email protected] @tanstack/db and save the script below as repro.mjs. It runs in plain Node: in-memory storage stands in for IndexedDB and is shared by both executors, and connectivity and leader election are stubbed.
  2. Start an executor offline and commit a transaction. It persists to the outbox, and the mutation fn does not run.
  3. Call dispose() on that executor and start a successor on the same storage, online.
  4. The successor replays the row, runs the mutation fn once, and empties the outbox.
  5. See that the original transaction still reads persisting and its isPersisted.promise is unsettled (node repro.mjs --dispose). The control run without the dispose resolves (node repro.mjs).
repro.mjs 
import { createCollection, localOnlyCollectionOptions } from "@tanstack/db";
import { startOfflineExecutor } from "@tanstack/offline-transactions";

const withDispose = process.argv.includes("--dispose");

// Shared in-memory storage, standing in for IndexedDB across both executors.
const store = new Map();
const storage = {
  get: async (k) => store.get(k) ?? null,
  set: async (k, v) => void store.set(k, v),
  delete: async (k) => void store.delete(k),
  keys: async () => [...store.keys()],
  clear: async () => void store.clear(),
};

// Always-leader election: no Web Locks in Node.
const leaderElection = {
  requestLeadership: async () => true,
  releaseLeadership: () => {},
  isLeader: () => true,
  onLeadershipChange: () => () => {},
};

// Manually toggled connectivity.
function makeDetector(initiallyOnline) {
  let online = initiallyOnline;
  const listeners = new Set();
  return {
    subscribe: (cb) => (listeners.add(cb), () => listeners.delete(cb)),
    notifyOnline: () => listeners.forEach((cb) => cb()),
    isOnline: () => online,
    dispose: () => listeners.clear(),
    goOnline() {
      online = true;
      listeners.forEach((cb) => cb());
    },
  };
}

const todos = createCollection(
  localOnlyCollectionOptions({ id: "todos", getKey: (t) => t.id }),
);

const calls = [];
const mutationFns = {
  syncTodos: async ({ transaction }) => {
    calls.push(transaction.id);
  },
};

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const settledWithin = (promise, ms) =>
  Promise.race([
    promise.then(
      () => "resolved",
      (e) => `rejected: ${e?.message}`,
    ),
    sleep(ms).then(() => "STILL PENDING"),
  ]);

// 1. Start offline and commit a transaction; it persists to the outbox.
const detector1 = makeDetector(false);
const executor1 = startOfflineExecutor({
  collections: { todos },
  mutationFns,
  storage,
  leaderElection,
  onlineDetector: detector1,
});
await executor1.waitForInit();

const tx = executor1.createOfflineTransaction({ mutationFnName: "syncTodos" });
// autoCommit defaults to true, so mutate() commits.
const transaction = tx.mutate(() => todos.insert({ id: "1", text: "hello" }));
const isPersisted = transaction.isPersisted.promise;
await sleep(100);
console.log("outbox rows after offline commit:", store.size);
console.log("mutationFn calls while offline:", calls.length);

let completer;
if (withDispose) {
  // 2. Dispose (the recreate pattern) and start a successor on the same storage.
  executor1.dispose();
  const detector2 = makeDetector(true);
  completer = startOfflineExecutor({
    collections: { todos },
    mutationFns,
    storage,
    leaderElection,
    onlineDetector: detector2,
  });
  await completer.waitForInit();
} else {
  // Control: no dispose, just come back online on the same executor.
  detector1.goOnline();
  completer = executor1;
}

// 3. Let the outbox drain.
await sleep(500);
console.log("mutationFn calls after replay:", calls.length);
console.log("outbox rows after replay:", store.size);
console.log("pending count on completing executor:", completer.getPendingCount());

// 4. The promises the first executor handed out.
console.log("transaction.state:", transaction.state);
console.log("isPersisted.promise:", await settledWithin(isPersisted, 2000));
process.exit(0);

Output:

== node repro.mjs  (control: no dispose)
outbox rows after offline commit: 1
mutationFn calls while offline: 0
mutationFn calls after replay: 1
outbox rows after replay: 0
pending count on completing executor: 0
transaction.state: completed
isPersisted.promise: resolved

== node repro.mjs --dispose
outbox rows after offline commit: 1
mutationFn calls while offline: 0
mutationFn calls after replay: 1
outbox rows after replay: 0
pending count on completing executor: 0
transaction.state: persisting
isPersisted.promise: STILL PENDING

Expected behavior
dispose() settles every deferred in pendingTransactionPromises, so no caller is left awaiting a transaction from a disposed executor. Either of these would work:

  • Reject each deferred with a disposal error the caller can treat as retriable.
  • Expose the pending ids so a successor executor can re-bridge them, and resolve them when it completes the replayed transaction.

Screenshots
N/A. The repro's console output is above.

Desktop (please complete the following information):

  • OS: Linux (kernel 6.18)
  • Browser: N/A. Reproduced in Node v24.22.1. The executor code path is environment-independent.
  • Version: @tanstack/offline-transactions 1.1.4, @tanstack/db 0.15.2. dispose() is unchanged on main at d2935d0.

Smartphone (please complete the following information):

  • N/A

Additional context
I first hit this on 1.0.42 in an app whose outbox recreates its executor whenever a new collection registers. I work around it with a completion ledger that carries isPersisted settlement across the recreate, but an upstream fix would let me delete this workaround.

Lenguaje dominante
TypeScript
Estrellas
4k
Forks
277
Merge medio
17 h 40 min
PR fusionados (30 d)
223

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de TanStack/db

Todos los issues de TanStack/db

Issues similares

Más issues de TypeScript

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.