@relaybus/mongodb 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,754 @@
+import { ConfigurationError, createUuidV7, EventValidationError } from '@relaybus/core';
+
+// src/mongo-event-store.ts
+
+// src/claim-scan.ts
+var ClaimScan = class {
+  #keys = /* @__PURE__ */ new Map();
+  /** Why the delivery must wait according to what this scan already knows, if it does. */
+  verdict(orderingId, sequence) {
+    const known = this.#keys.get(orderingId);
+    if (known?.openSequence !== void 0 && sequence > known.openSequence) {
+      return "open-predecessor";
+    }
+    return known?.leaseHeld === true ? "live-lease" : void 0;
+  }
+  /** Records an unfinished delivery of the key with this sequence. */
+  noteOpen(orderingId, sequence) {
+    const known = this.#know(orderingId);
+    known.openSequence = Math.min(known.openSequence ?? sequence, sequence);
+  }
+  /** Records that this scan leased the delivery, which is now unfinished and holds a live lease. */
+  noteClaimed(orderingId, sequence) {
+    this.noteOpen(orderingId, sequence);
+    this.#know(orderingId).leaseHeld = true;
+  }
+  /** Records that a live lease of the key blocks every delivery of it. */
+  noteLeaseHeld(orderingId) {
+    this.#know(orderingId).leaseHeld = true;
+  }
+  /** Remembers a delivery that waited behind an unfinished predecessor. */
+  noteWaiting(orderingId, delivery) {
+    if (delivery.status === "pending") {
+      this.#know(orderingId).waiting.push(delivery._id);
+    }
+  }
+  /**
+   * Ids of the waiting deliveries of every key that accumulated at least
+   * `minimum` of them. Shorter queues stay in the claim index: moving them out
+   * and back would cost more than skipping them.
+   */
+  waitingBacklogs(minimum) {
+    return [...this.#keys.values()].filter((known) => known.waiting.length >= minimum).flatMap((known) => known.waiting);
+  }
+  #know(orderingId) {
+    let known = this.#keys.get(orderingId);
+    if (known === void 0) {
+      known = { openSequence: void 0, leaseHeld: false, waiting: [] };
+      this.#keys.set(orderingId, known);
+    }
+    return known;
+  }
+};
+function orderingIdentity(handler, key) {
+  return `${handler}\0${key}`;
+}
+function toEventDocument(event, sequence) {
+  const payloadJson = serializeWellFormed(event.payload, "payload");
+  const headersJson = serializeWellFormed(event.headers, "headers");
+  return {
+    _id: event.id,
+    type: event.type,
+    source: event.source,
+    key: event.key,
+    sequence,
+    ...payloadJson === void 0 ? {} : { payload: JSON.parse(payloadJson) },
+    headers: JSON.parse(headersJson),
+    correlationId: event.correlationId,
+    causationId: event.causationId,
+    occurredAt: event.occurredAt,
+    revision: 0
+  };
+}
+var LONE_SURROGATE_ESCAPE = /(?<!\\)(?:\\\\)*\\ud[89a-f][0-9a-f]{2}/i;
+function serializeWellFormed(value, field) {
+  const json = JSON.stringify(value);
+  if (json !== void 0 && LONE_SURROGATE_ESCAPE.test(json)) {
+    throw new EventValidationError(`The event ${field} contains a lone UTF-16 surrogate`, [
+      {
+        message: "A lone surrogate cannot be stored as UTF-8 and would be replaced by U+FFFD. Remove it or encode the text first (for example with String.prototype.toWellFormed)",
+        path: [field]
+      }
+    ]);
+  }
+  return json;
+}
+function toEnvelope(document) {
+  return {
+    id: document._id,
+    type: document.type,
+    source: document.source,
+    key: document.key,
+    payload: document.payload,
+    headers: document.headers,
+    correlationId: document.correlationId,
+    causationId: document.causationId,
+    occurredAt: document.occurredAt
+  };
+}
+function toDeliveryDocument(delivery, event, ordering, now) {
+  return {
+    _id: delivery.id,
+    eventId: event.id,
+    eventType: event.type,
+    handler: delivery.handler,
+    ...ordering.key === null || ordering.sequence === null ? {} : { key: ordering.key, sequence: ordering.sequence },
+    status: "pending",
+    lane: "ready",
+    attempts: 0,
+    availableAt: delivery.availableAt,
+    dueAt: delivery.availableAt,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function toDeliveryRecord(document, event) {
+  return {
+    id: document._id,
+    handler: document.handler,
+    status: document.status,
+    attempts: document.attempts,
+    availableAt: document.availableAt,
+    leaseOwner: document.leaseOwner ?? null,
+    leaseExpiresAt: document.leaseExpiresAt ?? null,
+    lastError: document.lastError === void 0 ? null : toErrorInfo(document.lastError),
+    createdAt: document.createdAt,
+    updatedAt: document.updatedAt,
+    completedAt: document.completedAt ?? null,
+    event
+  };
+}
+function toErrorInfo(error) {
+  return error.stack === void 0 ? { name: error.name, message: error.message } : { name: error.name, message: error.message, stack: error.stack };
+}
+var ILLEGAL_OPERATION = 20;
+function isTransactionsUnsupportedError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === ILLEGAL_OPERATION && "message" in error && typeof error.message === "string" && error.message.includes("replica set member or mongos");
+}
+function createTransactionsUnsupportedError(cause) {
+  return new ConfigurationError(
+    "MongoEventStore needs multi-document transactions, which MongoDB only offers on a replica set or a sharded cluster. Run a single-node replica set for development (mongod --replSet rs0, then rs.initiate())",
+    { cause }
+  );
+}
+var COLLECTION_PREFIX_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,39}$/;
+var DATABASE_NAME_PATTERN = /^[A-Za-z0-9_-]{1,63}$/;
+function assertCollectionPrefix(prefix) {
+  if (!COLLECTION_PREFIX_PATTERN.test(prefix)) {
+    throw new ConfigurationError(
+      `collectionPrefix '${prefix}' must be 1-40 characters of letters, digits or '_', starting with a letter or '_'`
+    );
+  }
+}
+function assertDatabaseName(name) {
+  if (!DATABASE_NAME_PATTERN.test(name)) {
+    throw new ConfigurationError(
+      `database '${name}' must be 1-63 characters of letters, digits, '_' or '-'`
+    );
+  }
+}
+
+// src/mongo-event-store.ts
+var DEFAULT_TRANSACTION_OPTIONS = {
+  readConcern: { level: "snapshot" },
+  writeConcern: { w: "majority" },
+  readPreference: "primary"
+};
+var NAMESPACE_EXISTS = 48;
+var DEFAULT_PURGE_BATCH_SIZE = 500;
+var DEFAULT_LIST_LIMIT = 100;
+var MINIMUM_CANDIDATE_BATCH_SIZE = 32;
+var PARK_BACKLOG_THRESHOLD = 32;
+var PARK_UPDATE_CHUNK_SIZE = 1e3;
+var LEASE_FIELDS = { leaseOwner: "", leaseToken: "", leaseExpiresAt: "" };
+var FINISHED_FIELDS = { dueAt: "", lane: "" };
+var MongoEventStore = class {
+  #client;
+  #database;
+  #events;
+  #deliveries;
+  #keySequences;
+  #transactionOptions;
+  #purgeBatchSize;
+  #generateIdentifier;
+  constructor(options) {
+    const prefix = options.collectionPrefix ?? "relaybus_";
+    assertCollectionPrefix(prefix);
+    if (options.database !== void 0) {
+      assertDatabaseName(options.database);
+    }
+    const purgeBatchSize = options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE;
+    if (!Number.isInteger(purgeBatchSize) || purgeBatchSize < 1) {
+      throw new ConfigurationError(
+        `purgeBatchSize must be a positive integer, received ${String(purgeBatchSize)}`
+      );
+    }
+    this.#client = options.client;
+    const database = options.client.db(options.database);
+    this.#database = database;
+    const collectionOptions = {
+      readPreference: "primary",
+      writeConcern: { w: "majority" }
+    };
+    this.#events = database.collection(`${prefix}events`, collectionOptions);
+    this.#deliveries = database.collection(`${prefix}deliveries`, collectionOptions);
+    this.#keySequences = database.collection(`${prefix}key_sequences`, collectionOptions);
+    this.#transactionOptions = options.transactionOptions ?? DEFAULT_TRANSACTION_OPTIONS;
+    this.#purgeBatchSize = purgeBatchSize;
+    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
+  }
+  /**
+   * Verifies the deployment supports transactions and creates the indexes.
+   * Safe to run repeatedly and from several processes.
+   *
+   * @throws ConfigurationError when the server is a standalone mongod.
+   */
+  async setup() {
+    const hello = await this.#client.db("admin").command({ hello: 1 });
+    const supportsTransactions = typeof hello["setName"] === "string" || hello["msg"] === "isdbgrid";
+    if (!supportsTransactions) {
+      throw createTransactionsUnsupportedError(void 0);
+    }
+    for (const collection of [this.#events, this.#deliveries, this.#keySequences]) {
+      await this.#createCollectionIfMissing(collection.collectionName);
+    }
+    await this.#deliveries.createIndexes([
+      // Idempotent appends and lookups by event.
+      { key: { eventId: 1, handler: 1 }, name: "event_handler", unique: true },
+      // Claim: due work of a handler in due order. Holds ready deliveries only.
+      {
+        key: { handler: 1, dueAt: 1, _id: 1 },
+        name: "claim",
+        partialFilterExpression: { lane: "ready" }
+      },
+      // Ordering: unfinished predecessors of a keyed delivery, parked or not.
+      {
+        key: { handler: 1, key: 1, sequence: 1 },
+        name: "ordering",
+        partialFilterExpression: { dueAt: { $exists: true }, sequence: { $exists: true } }
+      },
+      // Parked deliveries: the lowest parked delivery of each key, to move it back once it is next.
+      {
+        key: { handler: 1, key: 1, sequence: 1 },
+        name: "parked",
+        partialFilterExpression: { lane: "parked" }
+      },
+      // Live leases: a keyed delivery may not start while another of its key is running.
+      {
+        key: { handler: 1, key: 1, dueAt: 1 },
+        name: "running",
+        partialFilterExpression: { status: "processing", key: { $exists: true } }
+      },
+      // Statistics: oldest due delivery across handlers.
+      { key: { dueAt: 1 }, name: "due", partialFilterExpression: { dueAt: { $exists: true } } },
+      // Purge of completed deliveries.
+      {
+        key: { completedAt: 1 },
+        name: "completed",
+        partialFilterExpression: { completedAt: { $exists: true } }
+      },
+      // Listing and status counts.
+      { key: { status: 1, createdAt: 1 }, name: "status_created" },
+      // Purge of dead deliveries.
+      { key: { status: 1, updatedAt: 1 }, name: "status_updated" },
+      { key: { handler: 1, createdAt: 1 }, name: "handler_created" },
+      { key: { eventType: 1, createdAt: 1 }, name: "type_created" }
+    ]);
+  }
+  async #createCollectionIfMissing(name) {
+    try {
+      await this.#database.createCollection(name);
+    } catch (error) {
+      if (!(typeof error === "object" && error !== null && "code" in error && error.code === NAMESPACE_EXISTS)) {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Runs `work` in a transaction on a new session and commits when it resolves.
+   *
+   * `work` can run more than once. The driver restarts the whole callback after
+   * a transient failure such as a write conflict, and re-sends only the commit
+   * after an unknown commit result. A restart is safe for everything written
+   * through the session, because the aborted attempt left nothing behind. It is
+   * not safe for side effects outside the session (HTTP calls, other databases),
+   * so keep those out of `work`; relaybus handlers are already at-least-once.
+   *
+   * @throws ConfigurationError when the deployment does not support transactions.
+   */
+  async transaction(work) {
+    try {
+      return await this.#client.withSession(async (session) => {
+        let result;
+        await session.withTransaction(async () => {
+          result = await work(session);
+        }, this.#transactionOptions);
+        return result;
+      });
+    } catch (error) {
+      if (isTransactionsUnsupportedError(error)) {
+        throw createTransactionsUnsupportedError(error);
+      }
+      throw error;
+    }
+  }
+  async append(session, entries, now) {
+    assertInTransaction(session, "append");
+    const eventIds = [...new Set(entries.map((entry) => entry.event.id))];
+    const storedEvents = new Map(
+      (await this.#events.find({ _id: { $in: eventIds } }, { session, projection: { key: 1, sequence: 1 } }).toArray()).map((stored) => [stored._id, stored])
+    );
+    const storedDeliveryKeys = new Set(
+      (await this.#deliveries.find({ eventId: { $in: eventIds } }, { session, projection: { eventId: 1, handler: 1 } }).toArray()).map((stored) => deliveryPairKey(stored.eventId, stored.handler))
+    );
+    const appendedEventIds = [];
+    const duplicateEventIds = [];
+    const newEvents = [];
+    const newDeliveries = [];
+    const touchedEventIds = /* @__PURE__ */ new Set();
+    const orderingByEventId = /* @__PURE__ */ new Map();
+    for (const [eventId, stored] of storedEvents) {
+      orderingByEventId.set(eventId, { key: stored.key, sequence: stored.sequence });
+    }
+    for (const { event, deliveries } of entries) {
+      let ordering = orderingByEventId.get(event.id);
+      if (ordering === void 0) {
+        const sequence = event.key === null ? null : await this.#nextSequence(event.key, session);
+        ordering = { key: event.key, sequence };
+        orderingByEventId.set(event.id, ordering);
+        newEvents.push(toEventDocument(event, sequence));
+        appendedEventIds.push(event.id);
+      } else {
+        duplicateEventIds.push(event.id);
+      }
+      for (const delivery of deliveries) {
+        const pairKey = deliveryPairKey(event.id, delivery.handler);
+        if (storedDeliveryKeys.has(pairKey)) {
+          continue;
+        }
+        storedDeliveryKeys.add(pairKey);
+        newDeliveries.push(toDeliveryDocument(delivery, event, ordering, now));
+        if (storedEvents.has(event.id)) {
+          touchedEventIds.add(event.id);
+        }
+      }
+    }
+    if (newEvents.length > 0) {
+      await this.#events.bulkWrite(
+        newEvents.map((document) => ({
+          updateOne: {
+            filter: { _id: document._id },
+            update: { $setOnInsert: document },
+            upsert: true
+          }
+        })),
+        { session, ordered: true }
+      );
+    }
+    if (touchedEventIds.size > 0) {
+      await this.#events.updateMany(
+        { _id: { $in: [...touchedEventIds] } },
+        { $inc: { revision: 1 } },
+        { session }
+      );
+    }
+    if (newDeliveries.length > 0) {
+      await this.#deliveries.bulkWrite(
+        newDeliveries.map((document) => ({
+          updateOne: {
+            filter: { eventId: document.eventId, handler: document.handler },
+            update: { $setOnInsert: document },
+            upsert: true
+          }
+        })),
+        { session, ordered: true }
+      );
+    }
+    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount: newDeliveries.length };
+  }
+  async claim(request) {
+    if (request.handlers.length === 0 || request.limit <= 0) {
+      return [];
+    }
+    await this.#unparkNextDeliveries(request.handlers);
+    const claimed = [];
+    const scan = new ClaimScan();
+    const candidates = this.#deliveries.find(
+      { handler: { $in: [...request.handlers] }, dueAt: { $lte: request.now }, lane: "ready" },
+      {
+        sort: { dueAt: 1, _id: 1 },
+        batchSize: Math.max(request.limit * 2, MINIMUM_CANDIDATE_BATCH_SIZE)
+      }
+    );
+    try {
+      for await (const candidate of candidates) {
+        const leased = await this.#claimCandidate(candidate, request, scan);
+        if (leased !== void 0) {
+          claimed.push(leased);
+          if (claimed.length >= request.limit) {
+            break;
+          }
+        }
+      }
+    } finally {
+      await candidates.close();
+    }
+    await this.#parkDeliveries(scan.waitingBacklogs(PARK_BACKLOG_THRESHOLD));
+    return this.#toClaimedDeliveries(claimed, request.leaseExpiresAt);
+  }
+  async extendLease(lease, leaseExpiresAt, now) {
+    return this.#updateLeased(lease, void 0, {
+      $set: { leaseExpiresAt, dueAt: leaseExpiresAt, updatedAt: now }
+    });
+  }
+  async complete(lease, now, session) {
+    if (session !== void 0) {
+      assertInTransaction(session, "complete");
+    }
+    return this.#updateLeased(lease, session, {
+      $set: { status: "completed", completedAt: now, updatedAt: now },
+      $unset: { ...LEASE_FIELDS, ...FINISHED_FIELDS }
+    });
+  }
+  async reschedule(lease, availableAt, error, now) {
+    return this.#updateLeased(lease, void 0, {
+      $set: {
+        status: "pending",
+        availableAt,
+        dueAt: availableAt,
+        lastError: toErrorInfo(error),
+        updatedAt: now
+      },
+      $unset: LEASE_FIELDS
+    });
+  }
+  async release(lease, now) {
+    return this.#updateLeased(lease, void 0, {
+      $set: { status: "pending", availableAt: now, dueAt: now, updatedAt: now },
+      $inc: { attempts: -1 },
+      $unset: LEASE_FIELDS
+    });
+  }
+  async bury(lease, error, now) {
+    return this.#updateLeased(lease, void 0, {
+      $set: { status: "dead", lastError: toErrorInfo(error), updatedAt: now },
+      $unset: { ...LEASE_FIELDS, ...FINISHED_FIELDS }
+    });
+  }
+  async listDeliveries(query) {
+    const filter = {
+      ...query.status === void 0 ? {} : { status: String(query.status) },
+      ...query.handler === void 0 ? {} : { handler: String(query.handler) },
+      ...query.eventType === void 0 ? {} : { eventType: String(query.eventType) },
+      ...query.eventId === void 0 ? {} : { eventId: String(query.eventId) }
+    };
+    const documents = await this.#deliveries.find(filter, { sort: { createdAt: 1, _id: 1 }, limit: query.limit ?? DEFAULT_LIST_LIMIT }).toArray();
+    const events = await this.#readEnvelopes(documents.map((document) => document.eventId));
+    return documents.map((document) => toDeliveryRecord(document, events.get(document.eventId)));
+  }
+  async requeue(deliveryIds, now) {
+    const result = await this.#deliveries.updateMany(
+      { _id: { $in: deliveryIds.map(String) }, status: "dead" },
+      {
+        $set: {
+          status: "pending",
+          lane: "ready",
+          attempts: 0,
+          availableAt: now,
+          dueAt: now,
+          updatedAt: now
+        }
+      }
+    );
+    return result.modifiedCount;
+  }
+  async purge(request) {
+    const filters = [];
+    if (request.completedBefore !== void 0) {
+      filters.push({ status: "completed", completedAt: { $lt: request.completedBefore } });
+    }
+    if (request.deadBefore !== void 0) {
+      filters.push({ status: "dead", updatedAt: { $lt: request.deadBefore } });
+    }
+    let deletedDeliveries = 0;
+    let deletedEvents = 0;
+    for (const filter of filters) {
+      const result = await this.#purgeMatching(filter);
+      deletedDeliveries += result.deletedDeliveries;
+      deletedEvents += result.deletedEvents;
+    }
+    return { deletedDeliveries, deletedEvents };
+  }
+  async statistics(now) {
+    const statuses = ["pending", "processing", "completed", "dead"];
+    const [pending, processing, completed, dead] = await Promise.all(
+      statuses.map((status) => this.#deliveries.countDocuments({ status }))
+    );
+    const oldestDue = await this.#deliveries.findOne(
+      { dueAt: { $lte: now } },
+      { sort: { dueAt: 1 }, projection: { dueAt: 1 } }
+    );
+    return {
+      pending,
+      processing,
+      completed,
+      dead,
+      oldestDueAt: oldestDue?.dueAt ?? null
+    };
+  }
+  /** Atomically increments the counter of `key`; conflicting appends of the key serialize here. */
+  async #nextSequence(key, session) {
+    const counter = await this.#keySequences.findOneAndUpdate(
+      { _id: key },
+      { $inc: { value: 1 } },
+      { upsert: true, returnDocument: "after", session }
+    );
+    return counter.value;
+  }
+  async #claimCandidate(candidate, request, scan) {
+    const { key, sequence } = candidate;
+    if (key === void 0) {
+      return this.#lease(candidate, request);
+    }
+    const orderingId = orderingIdentity(candidate.handler, key);
+    const known = scan.verdict(orderingId, sequence);
+    if (known === "open-predecessor") {
+      scan.noteWaiting(orderingId, candidate);
+      return void 0;
+    }
+    if (known === "live-lease") {
+      return void 0;
+    }
+    const predecessor = await this.#findUnfinishedPredecessor(candidate.handler, key, sequence);
+    if (predecessor !== void 0) {
+      scan.noteOpen(orderingId, predecessor);
+      scan.noteWaiting(orderingId, candidate);
+      return void 0;
+    }
+    if (await this.#hasLiveLease(candidate.handler, key, request.now)) {
+      scan.noteLeaseHeld(orderingId);
+      return void 0;
+    }
+    const leased = await this.#lease(candidate, request);
+    if (leased === void 0) {
+      return void 0;
+    }
+    const lateBlocker = await this.#findUnfinishedPredecessor(candidate.handler, key, sequence);
+    if (lateBlocker !== void 0) {
+      await this.#restore(candidate, leased);
+      scan.noteOpen(orderingId, lateBlocker);
+      return void 0;
+    }
+    scan.noteClaimed(orderingId, sequence);
+    return leased;
+  }
+  /**
+   * Takes the delivery with one conditional update that pins the exact state
+   * that was selected, so a competing claimer, a finished lease, a reschedule
+   * or a parking since then makes it match nothing.
+   */
+  async #lease(candidate, request) {
+    const leased = await this.#deliveries.findOneAndUpdate(
+      {
+        _id: candidate._id,
+        status: candidate.status,
+        lane: "ready",
+        attempts: candidate.attempts,
+        dueAt: candidate.dueAt
+      },
+      {
+        $set: {
+          status: "processing",
+          leaseOwner: request.leaseOwner,
+          leaseToken: this.#generateIdentifier(),
+          leaseExpiresAt: request.leaseExpiresAt,
+          dueAt: request.leaseExpiresAt,
+          updatedAt: request.now
+        },
+        $inc: { attempts: 1 }
+      },
+      { returnDocument: "after" }
+    );
+    return leased ?? void 0;
+  }
+  /** Puts a delivery that was leased a moment ago back exactly as it was selected. */
+  async #restore(selected, leased) {
+    const state = {
+      status: selected.status,
+      attempts: selected.attempts,
+      dueAt: selected.dueAt,
+      updatedAt: selected.updatedAt
+    };
+    await this.#deliveries.updateOne(
+      { _id: leased._id, status: "processing", leaseToken: leased.leaseToken },
+      selected.status === "processing" ? {
+        $set: {
+          ...state,
+          leaseOwner: selected.leaseOwner,
+          leaseToken: selected.leaseToken,
+          leaseExpiresAt: selected.leaseExpiresAt
+        }
+      } : { $set: state, $unset: LEASE_FIELDS }
+    );
+  }
+  /** Sequence of the lowest unfinished delivery of the handler and key before `sequence`, if any. */
+  async #findUnfinishedPredecessor(handler, key, sequence) {
+    const predecessor = await this.#deliveries.findOne(
+      { handler, key, sequence: { $lt: sequence }, dueAt: { $exists: true } },
+      { sort: { sequence: 1 }, projection: { sequence: 1 } }
+    );
+    return predecessor?.sequence;
+  }
+  /** Whether some delivery of the handler and key runs under a lease that has not expired. */
+  async #hasLiveLease(handler, key, now) {
+    const running = await this.#deliveries.findOne(
+      { handler, key, status: "processing", dueAt: { $gt: now } },
+      { projection: { _id: 1 } }
+    );
+    return running !== null;
+  }
+  /**
+   * Parks pending deliveries that waited behind an unfinished predecessor, which
+   * removes them from the claim index until their turn. Parking is a hint, not a
+   * guarantee: a predecessor that finishes meanwhile is found by the next
+   * {@link MongoEventStore.claim}, which moves the lowest parked delivery back.
+   */
+  async #parkDeliveries(deliveryIds) {
+    for (let offset = 0; offset < deliveryIds.length; offset += PARK_UPDATE_CHUNK_SIZE) {
+      await this.#deliveries.updateMany(
+        {
+          _id: { $in: deliveryIds.slice(offset, offset + PARK_UPDATE_CHUNK_SIZE) },
+          status: "pending",
+          lane: "ready"
+        },
+        { $set: { lane: "parked" } }
+      );
+    }
+  }
+  /**
+   * Moves the lowest parked delivery of every parked key of `handlers` back into
+   * the claim index when nothing unfinished precedes it. Level-triggered on
+   * purpose: it looks at the current state only, so a crash anywhere, or a
+   * predecessor finishing while its followers were being parked, can delay a key
+   * until the next claim but never strand it.
+   */
+  async #unparkNextDeliveries(handlers) {
+    const anyParked = await this.#deliveries.findOne(
+      { handler: { $in: [...handlers] }, lane: "parked" },
+      // The sort lets the planner pick the small partial index over the handler's whole history.
+      { sort: { handler: 1, key: 1, sequence: 1 }, projection: { _id: 1 } }
+    );
+    if (anyParked === null) {
+      return;
+    }
+    for (const handler of new Set(handlers)) {
+      let afterKey;
+      for (; ; ) {
+        const lowest = await this.#deliveries.findOne(
+          {
+            handler,
+            lane: "parked",
+            ...afterKey === void 0 ? {} : { key: { $gt: afterKey } }
+          },
+          { sort: { key: 1, sequence: 1 }, projection: { key: 1, sequence: 1 } }
+        );
+        if (lowest === null) {
+          break;
+        }
+        afterKey = lowest.key;
+        if (await this.#findUnfinishedPredecessor(handler, afterKey, lowest.sequence) === void 0) {
+          await this.#deliveries.updateOne(
+            { _id: lowest._id, lane: "parked" },
+            { $set: { lane: "ready" } }
+          );
+        }
+      }
+    }
+  }
+  async #toClaimedDeliveries(leased, leaseExpiresAt) {
+    const events = await this.#readEnvelopes(leased.map((document) => document.eventId));
+    return leased.map((document) => ({
+      deliveryId: document._id,
+      leaseToken: document.leaseToken,
+      handler: document.handler,
+      attempt: document.attempts,
+      leaseExpiresAt,
+      event: events.get(document.eventId)
+    }));
+  }
+  async #readEnvelopes(eventIds) {
+    const documents = await this.#events.find({ _id: { $in: [...new Set(eventIds)] } }).toArray();
+    return new Map(documents.map((document) => [document._id, toEnvelope(document)]));
+  }
+  async #updateLeased(lease, session, update) {
+    const result = await this.#deliveries.updateOne(
+      { _id: lease.deliveryId, status: "processing", leaseToken: lease.leaseToken },
+      update,
+      session === void 0 ? {} : { session }
+    );
+    return result.matchedCount === 1;
+  }
+  /**
+   * Deletes batches of matching deliveries together with the events no delivery
+   * references any more, each batch in one transaction, so a crash can never
+   * leave an event without deliveries behind. An append adding a delivery to the
+   * same event writes the event document, so the two conflict and one restarts
+   * instead of leaving a delivery without event. A delivery requeued since the
+   * batch was read conflicts with its deletion and is read again.
+   */
+  async #purgeMatching(filter) {
+    let deletedDeliveries = 0;
+    let deletedEvents = 0;
+    for (; ; ) {
+      const step = await this.transaction(async (session) => {
+        const batch = await this.#deliveries.find(filter, { session, projection: { eventId: 1 }, limit: this.#purgeBatchSize }).toArray();
+        const eventIds = [...new Set(batch.map((document) => document.eventId))];
+        const deliveries = await this.#deliveries.deleteMany(
+          { _id: { $in: batch.map((document) => document._id) } },
+          { session }
+        );
+        const stillReferenced = new Set(
+          (await this.#deliveries.find({ eventId: { $in: eventIds } }, { session, projection: { eventId: 1 } }).toArray()).map((document) => document.eventId)
+        );
+        const events = await this.#events.deleteMany(
+          { _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) } },
+          { session }
+        );
+        return {
+          batchSize: batch.length,
+          deletedDeliveries: deliveries.deletedCount,
+          deletedEvents: events.deletedCount
+        };
+      });
+      deletedDeliveries += step.deletedDeliveries;
+      deletedEvents += step.deletedEvents;
+      if (step.batchSize < this.#purgeBatchSize) {
+        return { deletedDeliveries, deletedEvents };
+      }
+    }
+  }
+};
+function deliveryPairKey(eventId, handler) {
+  return `${eventId}\0${handler}`;
+}
+function assertInTransaction(session, operation) {
+  if (!session.inTransaction()) {
+    throw new ConfigurationError(
+      `MongoEventStore.${operation} needs a ClientSession inside a started transaction (session.withTransaction or startTransaction). Without one, MongoDB commits each write immediately and the write is no longer atomic with yours`
+    );
+  }
+}
+
+export { MongoEventStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map