@relaybus/core 0.3.1 → 0.4.0

package/README.md

@@ -311,7 +311,12 @@ deploy, are still claimed and sent by the new route; the store rows keep their o
 ## Operations
 
 `listDeliveries(query)`, `requeue(ids)`, `statistics()`, `purgeExpired()`,
-`handlers()`, `runOnce()` and `drain()` (tests), `start()` and `stop()`.
+`handlers()`, `runOnce()` and `drain()` (tests), `start()`, `stop()` and `wake()`.
+
+**`wake()` after your own commit.** A publish in relaybus' own transaction wakes the dispatcher right after its
+commit. A publish in your transaction commits at a time the bus cannot see: unless the store reports the commit
+(PostgreSQL with `LISTEN/NOTIFY`), the dispatcher is woken 25, 100 and 250 ms after the latest publish and otherwise
+finds the delivery at its next poll. Call `bus.wake()` right after such a commit to claim at once.
 
 **`stop({ timeout })` is bounded.** The whole shutdown (stop claiming, wait for running
 handlers, hand back leases, close transports and the store) takes at most `timeout`, default

package/dist/index.cjs

@@ -2993,7 +2993,7 @@ var EventPublisher = class {
     context,
     delayMs
   }) {
-    const result = await this.#appendInTransaction(entries, context);
+    const { result, committed } = await this.#appendInTransaction(entries, context);
     const appended = new Set(result.appendedEventIds);
     const published = entries.map((entry) => entry.event).filter((envelope) => appended.has(envelope.id));
     if (published.length > 0) {
@@ -3002,22 +3002,26 @@ var EventPublisher = class {
         deliveries: result.appendedDeliveryCount
       });
       if (delayMs === 0) {
-        this.#parts.scheduleWake();
+        this.#parts.scheduleWake(committed);
       }
     }
   }
+  /** Appends in the caller's transaction, else in one of the store's; `committed` tells which. */
   async #appendInTransaction(entries, { options, scope, now }) {
     const { store, transactionMode, transactionResolver } = this.#parts;
     const transaction = options.transaction ?? scope?.transaction ?? transactionResolver?.();
     if (transaction !== void 0) {
-      return store.append(transaction, entries, now);
+      return { result: await store.append(transaction, entries, now), committed: false };
     }
     if (transactionMode === "required") {
       throw new chunkJ76M7XTS_cjs.TransactionRequiredError(
         "publish found no transaction. Pass { transaction }, publish inside bus.transaction(), configure transactionResolver, or set transactionMode to optional"
       );
     }
-    return store.transaction((ownTransaction) => store.append(ownTransaction, entries, now));
+    const result = await store.transaction(
+      (ownTransaction) => store.append(ownTransaction, entries, now)
+    );
+    return { result, committed: true };
   }
   async #createEnvelope(input) {
     const { event, options, id, scope, now, correlationId } = input;
@@ -3114,7 +3118,7 @@ var EventReceiver = class {
     const status = result.duplicateEventIds.length > 0 ? "duplicate" : "accepted";
     notifier.notify("onReceived", { envelope: normalized, status });
     if (result.appendedDeliveryCount > 0) {
-      scheduleWake();
+      scheduleWake(true);
     }
     return status;
   }
@@ -3204,6 +3208,58 @@ function createInboxAndOutbox(core, hooks) {
   };
 }
 
+// src/bus/publish-wake-ups.ts
+var FIRST_WAKE_MS = 25;
+var SECOND_WAKE_MS = 100;
+var LAST_WAKE_MS = 250;
+var WAKE_DELAYS_MS = [FIRST_WAKE_MS, SECOND_WAKE_MS, LAST_WAKE_MS];
+var PublishWakeUps = class {
+  #dependencies;
+  #lastPublishAt = 0;
+  #cancel;
+  /** When the pending timer fires. */
+  #dueAt = 0;
+  constructor(dependencies) {
+    this.#dependencies = dependencies;
+  }
+  /**
+   * Wakes the dispatcher for a publish: at once when its transaction has `committed` (one of relaybus'
+   * own), else at the wake-ups after it.
+   */
+  afterPublish(committed) {
+    if (committed) {
+      this.#dependencies.wake();
+      return;
+    }
+    this.#lastPublishAt = this.#dependencies.clock.now().getTime();
+    if (this.#cancel === void 0 || this.#dueAt > this.#lastPublishAt + FIRST_WAKE_MS) {
+      this.cancel();
+      this.#cancel = this.#arm(FIRST_WAKE_MS);
+    }
+  }
+  cancel() {
+    this.#cancel?.();
+    this.#cancel = void 0;
+  }
+  #fire() {
+    this.#cancel = void 0;
+    this.#dependencies.wake();
+    const elapsed = this.#dependencies.clock.now().getTime() - this.#lastPublishAt;
+    const next = WAKE_DELAYS_MS.find((delay) => delay > elapsed);
+    if (next !== void 0) {
+      this.#cancel = this.#arm(next - elapsed);
+    }
+  }
+  #arm(delayMs) {
+    this.#dueAt = this.#dependencies.clock.now().getTime() + delayMs;
+    return chunkJ76M7XTS_cjs.schedule(this.#dependencies.clock, {
+      run: () => this.#fire(),
+      delayMs,
+      unref: true
+    });
+  }
+};
+
 // src/transaction-budget.ts
 async function runBudgetedTransaction(store, { clock, timeoutMs, work }) {
   const startedAt = clock.now().getTime();
@@ -3236,20 +3292,24 @@ function createTimeoutError(timeoutMs, cause) {
 
 // src/relay-bus.ts
 var DEFAULT_DRAIN_BATCHES = 1e3;
-var WAKE_DELAY_MS = 25;
 var RelayBus = class {
   #parts;
   #lifecycle;
+  #wakeUps;
   constructor(options) {
     this.#parts = assembleRelayBus(options, {
       reportUnrouted: (envelope) => this.#reportUnrouted(envelope),
-      scheduleWake: () => this.#scheduleWake(),
+      scheduleWake: (committed) => this.#scheduleWake(committed),
       statistics: () => this.statistics()
     });
     this.#lifecycle = new BusLifecycle({
       ...this.#parts,
       closeTransports: (deadline) => this.#closeTransports(deadline)
     });
+    this.#wakeUps = new PublishWakeUps({
+      clock: this.#parts.clock,
+      wake: () => this.#parts.dispatcher.wake()
+    });
   }
   get store() {
     return this.#parts.store;
@@ -3376,6 +3436,7 @@ var RelayBus = class {
     if (!first) {
       return stopping;
     }
+    this.#wakeUps.cancel();
     const result = await stopping;
     if (!result.graceful) {
       this.#parts.logger.warn(
@@ -3409,6 +3470,13 @@ var RelayBus = class {
   listDeliveries(query = {}) {
     return this.#parts.store.listDeliveries(query);
   }
+  /**
+   * Asks the dispatcher to claim now. Call it right after committing your own transaction that published,
+   * when the store cannot report the commit (see Tuning, "Wake-up after your transaction commits").
+   */
+  wake() {
+    this.#parts.dispatcher.wake();
+  }
   /** Moves dead deliveries back to pending with a fresh attempt budget. */
   async requeue(deliveryIds) {
     const moved = await this.#parts.store.requeue(deliveryIds, this.#parts.clock.now());
@@ -3480,15 +3548,11 @@ var RelayBus = class {
     const routes = registrations.filter((registration) => registration.forwardsToTransport).length;
     return { handlers: registrations.length - routes, routes };
   }
-  #scheduleWake() {
+  #scheduleWake(committed) {
     if (this.#lifecycle.state !== "running" || this.#parts.dispatcher.watchesNewDeliveries) {
       return;
     }
-    chunkJ76M7XTS_cjs.schedule(this.#parts.clock, {
-      run: () => this.#parts.dispatcher.wake(),
-      delayMs: WAKE_DELAY_MS,
-      unref: true
-    });
+    this.#wakeUps.afterPublish(committed);
   }
   /** Closes every transport, each at most until the deadline; past it they are asked to force. */
   async #closeTransports(deadline) {