@rotorsoft/act 1.5.2 → 1.7.0

package/dist/index.js

@@ -873,6 +873,29 @@ var subscribe = (streams) => store().subscribe(streams);
 
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
+
+// src/internal/backoff.ts
+function computeBackoffDelay(retry, opts) {
+  if (!opts || opts.baseMs <= 0) return 0;
+  const r = Math.max(0, retry);
+  let delay;
+  switch (opts.strategy) {
+    case "fixed":
+      delay = opts.baseMs;
+      break;
+    case "linear":
+      delay = opts.baseMs * (r + 1);
+      break;
+    case "exponential":
+      delay = opts.baseMs * 2 ** r;
+      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
+      break;
+  }
+  if (opts.jitter) delay = delay * (0.5 + Math.random());
+  return Math.max(0, Math.floor(delay));
+}
+
+// src/internal/event-sourcing.ts
 var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   try {
@@ -912,13 +935,30 @@ function is_valid(event) {
   return true;
 }
 async function scan(source, opts = {}, callback) {
-  const { drop_snapshots = false, on_progress } = opts;
+  const {
+    drop_snapshots = false,
+    drop_closed_streams = false,
+    on_progress,
+    event_migrations,
+    stream_rename
+  } = opts;
   const limit = opts.batch_size ?? DEFAULT_BATCH;
   const id_map = /* @__PURE__ */ new Map();
   let kept = 0;
   let dropped_snaps = 0;
+  let dropped_closed = 0;
+  let migrated_count = 0;
   let processed = 0;
   let at;
+  const closed_streams = /* @__PURE__ */ new Set();
+  if (drop_closed_streams) {
+    await source.query(
+      (e) => {
+        if (e.name === TOMBSTONE_EVENT) closed_streams.add(e.stream);
+      },
+      { names: [TOMBSTONE_EVENT] }
+    );
+  }
   let max_id;
   const probed = await source.query(
     (e) => {
@@ -942,12 +982,35 @@ async function scan(source, opts = {}, callback) {
           dropped_snaps++;
           return;
         }
+        if (closed_streams.has(event.stream) && event.name !== TOMBSTONE_EVENT) {
+          dropped_closed++;
+          return;
+        }
+        let migrated = event;
+        const migration = event_migrations?.[event.name];
+        if (migration) {
+          const old_data = migration.from_schema.parse(event.data);
+          const new_data = migration.migrate(old_data);
+          migration.to_schema.parse(new_data);
+          migrated = {
+            ...event,
+            name: migration.to,
+            // biome-ignore lint/suspicious/noExplicitAny: migration target shape is caller-defined
+            data: new_data
+          };
+          migrated_count++;
+        }
+        if (stream_rename) {
+          const renamed = stream_rename(migrated.stream);
+          if (renamed !== migrated.stream)
+            migrated = { ...migrated, stream: renamed };
+        }
         if (!callback) {
           kept++;
           return;
         }
-        let remapped = event;
-        const caused_by = event.meta.causation.event?.id;
+        let remapped = migrated;
+        const caused_by = migrated.meta.causation.event?.id;
         if (caused_by !== void 0) {
           const new_caused_by = id_map.get(caused_by);
           if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
@@ -974,10 +1037,10 @@ async function scan(source, opts = {}, callback) {
   }
   return {
     kept,
+    migrated: migrated_count,
     dropped: {
-      closed_streams: 0,
-      snapshots: dropped_snaps,
-      empty_streams: 0
+      closed_streams: dropped_closed,
+      snapshots: dropped_snaps
     }
   };
 }
@@ -1040,113 +1103,126 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
   const validated = 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;
-  if (me.given) {
-    const invariants = me.given[action2] || [];
-    invariants.forEach(({ valid, description }) => {
-      if (!valid(snapshot.state, actor))
-        throw new InvariantError(
-          action2,
-          validated,
-          target,
-          snapshot,
-          description
-        );
-    });
-  }
-  const result = me.on[action2](validated, snapshot, target);
-  if (!result) return [snapshot];
-  if (Array.isArray(result) && result.length === 0) {
-    return [snapshot];
-  }
-  const tuples = Array.isArray(result[0]) ? result : [result];
-  const deprecated = me._deprecated;
-  if (deprecated && deprecated.size > 0) {
-    const me_ = me;
-    const warned = me_._warned ?? (me_._warned = /* @__PURE__ */ new Set());
-    for (const [name] of tuples) {
-      const evt = name;
-      if (deprecated.has(evt) && !warned.has(evt)) {
-        warned.add(evt);
-        log().warn(
-          `Action "${String(action2)}" emitted deprecated event "${evt}". A newer version exists in the registry \u2014 update the action's .emit() to target the current version. (warned once per process)`
+  const opts = me.options?.[action2];
+  const maxRetries = opts?.maxRetries ?? 0;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      const snapshot = await load(me, stream);
+      if (snapshot.event?.name === TOMBSTONE_EVENT)
+        throw new StreamClosedError(stream);
+      const expected = expectedVersion ?? snapshot.event?.version;
+      if (me.given) {
+        const invariants = me.given[action2] || [];
+        invariants.forEach(({ valid, description }) => {
+          if (!valid(snapshot.state, actor))
+            throw new InvariantError(
+              action2,
+              validated,
+              target,
+              snapshot,
+              description
+            );
+        });
+      }
+      const result = me.on[action2](validated, snapshot, target);
+      if (!result) return [snapshot];
+      if (Array.isArray(result) && result.length === 0) {
+        return [snapshot];
+      }
+      const tuples = Array.isArray(result[0]) ? result : [result];
+      const deprecated = me._deprecated;
+      if (deprecated && deprecated.size > 0) {
+        const me_ = me;
+        const warned = me_._warned ?? (me_._warned = /* @__PURE__ */ new Set());
+        for (const [name] of tuples) {
+          const evt = name;
+          if (deprecated.has(evt) && !warned.has(evt)) {
+            warned.add(evt);
+            log().warn(
+              `Action "${String(action2)}" emitted deprecated event "${evt}". A newer version exists in the registry \u2014 update the action's .emit() to target the current version. (warned once per process)`
+            );
+          }
+        }
+      }
+      const emitted = tuples.map(([name, data]) => ({
+        name,
+        data: skipValidation ? data : validate(name, data, me.events[name])
+      }));
+      const meta = {
+        correlation: reactingTo?.meta.correlation || correlator({
+          action: action2,
+          state: me.name,
+          stream,
+          actor: target.actor
+        }),
+        causation: {
+          action: {
+            name: action2,
+            ...target
+            // payload intentionally omitted: it can be large or contain PII,
+            // and callers correlate via the correlation id when they need it.
+          },
+          event: reactingTo ? {
+            id: reactingTo.id,
+            name: reactingTo.name,
+            stream: reactingTo.stream
+          } : void 0
+        }
+      };
+      let committed;
+      try {
+        committed = await store().commit(
+          stream,
+          emitted,
+          meta,
+          // Reactions skip optimistic concurrency: they always append against the
+          // current head. Stream leasing already serializes concurrent reactions,
+          // and forcing version checks here would turn ordinary catch-up into
+          // spurious retries.
+          reactingTo ? void 0 : expected
         );
+      } catch (error) {
+        if (error instanceof ConcurrencyError) {
+          await cache().invalidate(stream);
+        }
+        throw error;
+      }
+      let { state: state2, patches } = snapshot;
+      const snapshots = committed.map((event) => {
+        const p = me.patch[event.name](event, state2);
+        state2 = patch(state2, p);
+        patches++;
+        return {
+          event,
+          state: state2,
+          version: event.version,
+          patches,
+          snaps: snapshot.snaps,
+          patch: p,
+          cache_hit: snapshot.cache_hit,
+          replayed: snapshot.replayed
+        };
+      });
+      const last = snapshots.at(-1);
+      const snapped = me.snap?.(last);
+      cache().set(stream, {
+        state: last.state,
+        version: last.event.version,
+        event_id: last.event.id,
+        patches: snapped ? 0 : last.patches,
+        snaps: snapped ? last.snaps + 1 : last.snaps
+      }).catch((err) => log().error(err));
+      if (snapped) void snap(last);
+      return snapshots;
+    } catch (error) {
+      if (!(error instanceof ConcurrencyError)) throw error;
+      if (attempt >= maxRetries) throw error;
+      if (opts?.backoff) {
+        const delayMs = computeBackoffDelay(attempt, opts.backoff);
+        if (delayMs > 0) await sleep(delayMs);
       }
     }
   }
-  const emitted = tuples.map(([name, data]) => ({
-    name,
-    data: skipValidation ? data : validate(name, data, me.events[name])
-  }));
-  const meta = {
-    correlation: reactingTo?.meta.correlation || correlator({
-      action: action2,
-      state: me.name,
-      stream,
-      actor: target.actor
-    }),
-    causation: {
-      action: {
-        name: action2,
-        ...target
-        // payload intentionally omitted: it can be large or contain PII,
-        // and callers correlate via the correlation id when they need it.
-      },
-      event: reactingTo ? {
-        id: reactingTo.id,
-        name: reactingTo.name,
-        stream: reactingTo.stream
-      } : void 0
-    }
-  };
-  let committed;
-  try {
-    committed = await store().commit(
-      stream,
-      emitted,
-      meta,
-      // Reactions skip optimistic concurrency: they always append against the
-      // current head. Stream leasing already serializes concurrent reactions,
-      // and forcing version checks here would turn ordinary catch-up into
-      // spurious retries.
-      reactingTo ? void 0 : expected
-    );
-  } catch (error) {
-    if (error instanceof ConcurrencyError) {
-      await cache().invalidate(stream);
-    }
-    throw error;
-  }
-  let { state: state2, patches } = snapshot;
-  const snapshots = committed.map((event) => {
-    const p = me.patch[event.name](event, state2);
-    state2 = patch(state2, p);
-    patches++;
-    return {
-      event,
-      state: state2,
-      version: event.version,
-      patches,
-      snaps: snapshot.snaps,
-      patch: p,
-      cache_hit: snapshot.cache_hit,
-      replayed: snapshot.replayed
-    };
-  });
-  const last = snapshots.at(-1);
-  const snapped = me.snap?.(last);
-  cache().set(stream, {
-    state: last.state,
-    version: last.event.version,
-    event_id: last.event.id,
-    patches: snapped ? 0 : last.patches,
-    snaps: snapped ? last.snaps + 1 : last.snaps
-  }).catch((err) => log().error(err));
-  if (snapped) void snap(last);
-  return snapshots;
 }
 
 // src/internal/tracing.ts
@@ -1680,27 +1756,6 @@ var _this_ = ({ stream }) => ({
   target: stream
 });
 
-// src/internal/backoff.ts
-function computeBackoffDelay(retry, opts) {
-  if (!opts || opts.baseMs <= 0) return 0;
-  const r = Math.max(0, retry);
-  let delay;
-  switch (opts.strategy) {
-    case "fixed":
-      delay = opts.baseMs;
-      break;
-    case "linear":
-      delay = opts.baseMs * (r + 1);
-      break;
-    case "exponential":
-      delay = opts.baseMs * 2 ** r;
-      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
-      break;
-  }
-  if (opts.jitter) delay = delay * (0.5 + Math.random());
-  return Math.max(0, Math.floor(delay));
-}
-
 // src/internal/reactions.ts
 function finalize(lease, handled, at, error, options, logger, failed_at) {
   if (!error) return { lease, handled, acked_at: at };
@@ -2692,13 +2747,15 @@ var Act = class {
         return s;
       })();
       let kept = 0;
-      let dropped = { closed_streams: 0, snapshots: 0, empty_streams: 0 };
+      let migrated = 0;
+      let dropped = { closed_streams: 0, snapshots: 0 };
       await target.restore(async (callback) => {
         const partial = await scan(source, opts, callback);
         kept = partial.kept;
+        migrated = partial.migrated;
         dropped = partial.dropped;
       });
-      return { kept, dropped, duration_ms: Date.now() - started };
+      return { kept, migrated, dropped, duration_ms: Date.now() - started };
     });
   }
   /**
@@ -3230,7 +3287,7 @@ function state(entry) {
 function action_builder(state2) {
   const internal = state2;
   const builder = {
-    on(entry) {
+    on(entry, options) {
       const keys = Object.keys(entry);
       if (keys.length !== 1) throw new Error(".on() requires exactly one key");
       const action2 = keys[0];
@@ -3238,6 +3295,10 @@ function action_builder(state2) {
       if (action2 in internal.actions)
         throw new Error(`Duplicate action "${action2}"`);
       internal.actions[action2] = schema;
+      if (options) {
+        internal.options ??= {};
+        internal.options[action2] = options;
+      }
       function given(rules) {
         internal.given ??= {};
         internal.given[action2] = rules;