@rotorsoft/act 0.28.0 → 0.29.0

package/dist/index.js

@@ -140,7 +140,8 @@ var InMemoryCache = class {
 var Errors = {
   ValidationError: "ERR_VALIDATION",
   InvariantError: "ERR_INVARIANT",
-  ConcurrencyError: "ERR_CONCURRENCY"
+  ConcurrencyError: "ERR_CONCURRENCY",
+  StreamClosedError: "ERR_STREAM_CLOSED"
 };
 var ValidationError = class extends Error {
   constructor(target, payload, details) {
@@ -162,6 +163,13 @@ var InvariantError = class extends Error {
     this.name = Errors.InvariantError;
   }
 };
+var StreamClosedError = class extends Error {
+  constructor(stream) {
+    super(`Stream "${stream}" is closed (tombstoned)`);
+    this.stream = stream;
+    this.name = Errors.StreamClosedError;
+  }
+};
 var ConcurrencyError = class extends Error {
   constructor(stream, lastVersion, events, expectedVersion) {
     super(
@@ -595,6 +603,41 @@ var InMemoryStore = class {
     }
     return count;
   }
+  /**
+   * Atomically truncates streams and seeds each with a snapshot or tombstone.
+   * @param targets - Streams to truncate with optional snapshot state and meta.
+   * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.
+   */
+  async truncate(targets) {
+    await sleep();
+    const deletedCounts = /* @__PURE__ */ new Map();
+    const streamSet = new Set(targets.map((t) => t.stream));
+    for (const e of this._events) {
+      if (streamSet.has(e.stream)) {
+        deletedCounts.set(e.stream, (deletedCounts.get(e.stream) ?? 0) + 1);
+      }
+    }
+    this._events = this._events.filter((e) => !streamSet.has(e.stream));
+    const result = /* @__PURE__ */ new Map();
+    for (const { stream, snapshot, meta } of targets) {
+      this._streams.delete(stream);
+      const event = {
+        id: this._events.length,
+        stream,
+        version: 0,
+        created: /* @__PURE__ */ new Date(),
+        name: snapshot !== void 0 ? SNAP_EVENT : TOMBSTONE_EVENT,
+        data: snapshot ?? {},
+        meta: meta ?? { correlation: "", causation: {} }
+      };
+      this._events.push(event);
+      result.set(stream, {
+        deleted: deletedCounts.get(stream) ?? 0,
+        committed: event
+      });
+    }
+    return result;
+  }
 };
 
 // src/ports.ts
@@ -641,6 +684,7 @@ function dispose(disposer) {
   return disposeAndExit;
 }
 var SNAP_EVENT = "__snapshot__";
+var TOMBSTONE_EVENT = "__tombstone__";
 function build_tracer(logLevel2) {
   if (logLevel2 === "trace") {
     const logger4 = log();
@@ -781,6 +825,8 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   if (!stream) throw new Error("Missing target stream");
   payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
   const snapshot = await load(me, stream);
+  if (snapshot.event?.name === TOMBSTONE_EVENT)
+    throw new StreamClosedError(stream);
   const expected = expectedVersion ?? snapshot.event?.version;
   logger2.trace(
     payload,
@@ -1559,6 +1605,170 @@ var Act = class {
       this._settle_timer = void 0;
     }
   }
+  /**
+   * Close the books — guard, archive, truncate, and optionally restart streams.
+   *
+   * Safely removes historical events from the operational store:
+   *
+   * 1. **Correlate** — discover pending reaction targets
+   * 2. **Safety check** — skip streams with pending reactions (skipped when no reactive events)
+   * 3. **Guard** — commit `__tombstone__` with `expectedVersion` to block concurrent writes
+   * 4. **Load state** — for streams in `snapshots`, load final state while guarded (no races)
+   * 5. **Archive** — user callback per stream (abort-all on failure, streams are guarded)
+   * 6. **Truncate + seed** — atomic: delete all events, insert `__snapshot__` or `__tombstone__`
+   * 7. **Cache** — invalidate (tombstoned) or warm (restarted)
+   * 8. **Emit "closed"** — lifecycle event with results
+   *
+   * @param targets - Per-stream close options (stream, restart?, archive?)
+   * @returns `{ truncated: TruncateResult, skipped: string[] }`
+   *
+   * @example Archive and close
+   * ```typescript
+   * await app.close([
+   *   { stream: "order-123", archive: async () => { await archiveToS3("order-123"); } },
+   *   { stream: "order-456" },
+   * ]);
+   * ```
+   *
+   * @example Close with restart (state loaded automatically after guard)
+   * ```typescript
+   * await app.close([
+   *   { stream: "counter-1", restart: true },
+   *   { stream: "counter-2" },  // tombstoned
+   * ]);
+   * ```
+   */
+  async close(targets) {
+    if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
+    const targetMap = new Map(targets.map((t) => [t.stream, t]));
+    const streams = [...targetMap.keys()];
+    await this.correlate({ limit: 1e3 });
+    const streamInfo = /* @__PURE__ */ new Map();
+    await Promise.all(
+      streams.map(async (s) => {
+        let maxId = -1;
+        let version = -1;
+        await store().query(
+          (e) => {
+            if (e.name !== TOMBSTONE_EVENT) {
+              maxId = e.id;
+              version = e.version;
+            }
+          },
+          { stream: s, stream_exact: true, backward: true, limit: 1 }
+        );
+        if (maxId >= 0) streamInfo.set(s, { maxId, version });
+      })
+    );
+    const skipped = [];
+    let safe;
+    if (this._reactive_events.size === 0) {
+      safe = [...streamInfo.keys()];
+    } else {
+      const pendingSet = /* @__PURE__ */ new Set();
+      const leases = await store().claim(1e3, 1e3, randomUUID2(), 1);
+      if (leases.length) await store().ack(leases);
+      for (const lease of leases) {
+        const sourceRe = lease.source ? RegExp(lease.source) : void 0;
+        for (const [stream, info] of streamInfo) {
+          if ((!sourceRe || sourceRe.test(stream)) && lease.at < info.maxId) {
+            pendingSet.add(stream);
+          }
+        }
+      }
+      safe = [];
+      for (const [stream] of streamInfo) {
+        if (pendingSet.has(stream)) {
+          skipped.push(stream);
+        } else {
+          safe.push(stream);
+        }
+      }
+    }
+    if (!safe.length) {
+      const result2 = { truncated: /* @__PURE__ */ new Map(), skipped };
+      this.emit("closed", result2);
+      return result2;
+    }
+    const correlation = randomUUID2();
+    const guarded = [];
+    const guardEvents = /* @__PURE__ */ new Map();
+    await Promise.all(
+      safe.map(async (stream) => {
+        try {
+          const info = streamInfo.get(stream);
+          const [committed] = await store().commit(
+            stream,
+            [{ name: TOMBSTONE_EVENT, data: {} }],
+            { correlation, causation: {} },
+            info.version
+          );
+          guarded.push(stream);
+          guardEvents.set(stream, { id: committed.id, stream });
+        } catch {
+          skipped.push(stream);
+        }
+      })
+    );
+    if (!guarded.length) {
+      const result2 = { truncated: /* @__PURE__ */ new Map(), skipped };
+      this.emit("closed", result2);
+      return result2;
+    }
+    const mergedState = [...this._states.values()][0];
+    const seedStates = /* @__PURE__ */ new Map();
+    if (mergedState) {
+      await Promise.all(
+        guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
+          const snap2 = await load(mergedState, stream);
+          seedStates.set(stream, snap2.state);
+        })
+      );
+    }
+    for (const stream of guarded) {
+      const archiveFn = targetMap.get(stream)?.archive;
+      if (archiveFn) await archiveFn();
+    }
+    const truncTargets = guarded.map((stream) => {
+      const snapshot = seedStates.get(stream);
+      const guard = guardEvents.get(stream);
+      return {
+        stream,
+        snapshot,
+        meta: {
+          correlation,
+          causation: {
+            event: {
+              id: guard.id,
+              name: TOMBSTONE_EVENT,
+              stream: guard.stream
+            }
+          }
+        }
+      };
+    });
+    const truncated = await store().truncate(truncTargets);
+    await Promise.all(
+      guarded.map(async (stream) => {
+        const entry = truncated.get(stream);
+        const state2 = seedStates.get(stream);
+        if (state2 && entry) {
+          await cache().set(stream, {
+            state: state2,
+            version: entry.committed.version,
+            event_id: entry.committed.id,
+            patches: 0,
+            snaps: 1
+          });
+        } else {
+          await cache().invalidate(stream);
+        }
+      })
+    );
+    const result = { truncated, skipped };
+    this.emit("closed", result);
+    return result;
+  }
   /**
    * Debounced, non-blocking correlate→drain cycle.
    *
@@ -2104,6 +2314,8 @@ export {
   PackageSchema,
   QuerySchema,
   SNAP_EVENT,
+  StreamClosedError,
+  TOMBSTONE_EVENT,
   TargetSchema,
   ValidationError,
   ZodEmpty,