@rotorsoft/act 0.32.1 → 0.32.2

package/dist/index.js

@@ -672,6 +672,136 @@ process.once("unhandledRejection", async (arg) => {
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
 
+// src/internal/merge.ts
+import { ZodObject } from "zod";
+function baseTypeName(zodType) {
+  let t = zodType;
+  while (typeof t.unwrap === "function") {
+    t = t.unwrap();
+  }
+  return t.constructor.name;
+}
+function mergeSchemas(existing, incoming, stateName) {
+  if (existing instanceof ZodObject && incoming instanceof ZodObject) {
+    const existingShape = existing.shape;
+    const incomingShape = incoming.shape;
+    for (const key of Object.keys(incomingShape)) {
+      if (key in existingShape) {
+        const existingBase = baseTypeName(existingShape[key]);
+        const incomingBase = baseTypeName(incomingShape[key]);
+        if (existingBase !== incomingBase) {
+          throw new Error(
+            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
+          );
+        }
+      }
+    }
+    return existing.extend(incomingShape);
+  }
+  return existing;
+}
+function mergeInits(existing, incoming) {
+  return () => ({ ...existing(), ...incoming() });
+}
+function registerState(state2, states, actions, events) {
+  const existing = states.get(state2.name);
+  if (existing) {
+    mergeIntoExisting(state2, existing, states, actions, events);
+  } else {
+    registerNewState(state2, states, actions, events);
+  }
+}
+function registerNewState(state2, states, actions, events) {
+  states.set(state2.name, state2);
+  for (const name of Object.keys(state2.actions)) {
+    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
+    actions[name] = state2;
+  }
+  for (const name of Object.keys(state2.events)) {
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
+    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
+  }
+}
+function mergeIntoExisting(state2, existing, states, actions, events) {
+  for (const name of Object.keys(state2.actions)) {
+    if (existing.actions[name] === state2.actions[name]) continue;
+    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
+  }
+  for (const name of Object.keys(state2.events)) {
+    if (existing.events[name] === state2.events[name]) continue;
+    if (existing.events[name]) continue;
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
+  }
+  const mergedPatch = mergePatches(existing.patch, state2.patch, state2.name);
+  const merged = {
+    ...existing,
+    state: mergeSchemas(existing.state, state2.state, state2.name),
+    init: mergeInits(existing.init, state2.init),
+    events: { ...existing.events, ...state2.events },
+    actions: { ...existing.actions, ...state2.actions },
+    patch: mergedPatch,
+    on: { ...existing.on, ...state2.on },
+    given: { ...existing.given, ...state2.given },
+    snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
+      throw new Error(
+        `Duplicate snap strategy for state "${state2.name}"`
+      );
+    })() : state2.snap || existing.snap
+  };
+  states.set(state2.name, merged);
+  for (const name of Object.keys(merged.actions)) {
+    actions[name] = merged;
+  }
+  for (const name of Object.keys(state2.events)) {
+    if (events[name]) continue;
+    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
+  }
+}
+function mergePatches(existing, incoming, stateName) {
+  const merged = { ...existing };
+  for (const name of Object.keys(incoming)) {
+    const existingP = existing[name];
+    const incomingP = incoming[name];
+    if (!existingP) {
+      merged[name] = incomingP;
+      continue;
+    }
+    const existingIsDefault = existingP._passthrough;
+    const incomingIsDefault = incomingP._passthrough;
+    if (!existingIsDefault && !incomingIsDefault && existingP !== incomingP) {
+      throw new Error(
+        `Duplicate custom patch for event "${name}" in state "${stateName}"`
+      );
+    }
+    if (existingIsDefault && !incomingIsDefault) {
+      merged[name] = incomingP;
+    }
+  }
+  return merged;
+}
+function mergeProjection(proj, events) {
+  for (const eventName of Object.keys(proj.events)) {
+    const projRegister = proj.events[eventName];
+    const existing = events[eventName];
+    if (!existing) {
+      events[eventName] = {
+        schema: projRegister.schema,
+        reactions: new Map(projRegister.reactions)
+      };
+    } else {
+      for (const [name, reaction] of projRegister.reactions) {
+        let key = name;
+        while (existing.reactions.has(key)) key = `${key}_p`;
+        existing.reactions.set(key, reaction);
+      }
+    }
+  }
+}
+var _this_ = ({ stream }) => ({
+  source: stream,
+  target: stream
+});
+
 // src/internal/drain.ts
 var claim = (lagging, leading, by, millis) => store().claim(lagging, leading, by, millis);
 async function fetch(leased, eventLimit) {
@@ -694,7 +824,6 @@ var subscribe = (streams) => store().subscribe(streams);
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
 import { randomUUID } from "crypto";
-var logger2 = log();
 async function snap(snapshot) {
   try {
     const { id, stream, name, meta, version } = snapshot.event;
@@ -709,11 +838,11 @@ async function snap(snapshot) {
       // IMPORTANT! - state events are committed right after the snapshot event
     );
   } catch (error) {
-    logger2.error(error);
+    log().error(error);
   }
 }
 async function load(me, stream, callback, asOf) {
-  const timeTravel = asOf && (asOf.before !== void 0 || asOf.created_before !== void 0 || asOf.created_after !== void 0 || asOf.limit !== void 0);
+  const timeTravel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
   const cached = timeTravel ? void 0 : await cache().get(stream);
   let state2 = cached?.state ?? (me.init ? me.init() : {});
   let patches = cached?.patches ?? 0;
@@ -797,7 +926,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       reactingTo ? void 0 : expected
     );
   } catch (error) {
-    if (error.name === "ERR_CONCURRENCY") {
+    if (error instanceof ConcurrencyError) {
       await cache().invalidate(stream);
     }
     throw error;
@@ -811,241 +940,56 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   });
   const last = snapshots.at(-1);
   const snapped = me.snap && me.snap(last);
-  void cache().set(stream, {
+  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/merge.ts
-import { ZodObject } from "zod";
-function baseTypeName(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
-}
-function mergeSchemas(existing, incoming, stateName) {
-  if (existing instanceof ZodObject && incoming instanceof ZodObject) {
-    const existingShape = existing.shape;
-    const incomingShape = incoming.shape;
-    for (const key of Object.keys(incomingShape)) {
-      if (key in existingShape) {
-        const existingBase = baseTypeName(existingShape[key]);
-        const incomingBase = baseTypeName(incomingShape[key]);
-        if (existingBase !== incomingBase) {
-          throw new Error(
-            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
-          );
-        }
-      }
-    }
-    return existing.extend(incomingShape);
-  }
-  return existing;
-}
-function mergeInits(existing, incoming) {
-  return () => ({ ...existing(), ...incoming() });
-}
-function registerState(state2, states, actions, events) {
-  if (states.has(state2.name)) {
-    const existing = states.get(state2.name);
-    for (const name of Object.keys(state2.actions)) {
-      if (existing.actions[name] === state2.actions[name]) continue;
-      if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-    }
-    for (const name of Object.keys(state2.events)) {
-      if (existing.events[name] === state2.events[name]) continue;
-      if (existing.events[name]) continue;
-      if (events[name]) throw new Error(`Duplicate event "${name}"`);
-    }
-    const mergedPatch = { ...existing.patch };
-    for (const name of Object.keys(state2.patch)) {
-      const existingP = existing.patch[name];
-      const incomingP = state2.patch[name];
-      if (!existingP) {
-        mergedPatch[name] = incomingP;
-      } else {
-        const existingIsDefault = existingP._passthrough;
-        const incomingIsDefault = incomingP._passthrough;
-        if (!existingIsDefault && !incomingIsDefault && existingP !== incomingP) {
-          throw new Error(
-            `Duplicate custom patch for event "${name}" in state "${state2.name}"`
-          );
-        }
-        if (existingIsDefault && !incomingIsDefault) {
-          mergedPatch[name] = incomingP;
-        }
-      }
-    }
-    const merged = {
-      ...existing,
-      state: mergeSchemas(existing.state, state2.state, state2.name),
-      init: mergeInits(existing.init, state2.init),
-      events: { ...existing.events, ...state2.events },
-      actions: { ...existing.actions, ...state2.actions },
-      patch: mergedPatch,
-      on: { ...existing.on, ...state2.on },
-      given: { ...existing.given, ...state2.given },
-      snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
-        throw new Error(
-          `Duplicate snap strategy for state "${state2.name}"`
-        );
-      })() : state2.snap || existing.snap
-    };
-    states.set(state2.name, merged);
-    for (const name of Object.keys(merged.actions)) {
-      actions[name] = merged;
-    }
-    for (const name of Object.keys(state2.events)) {
-      if (events[name]) continue;
-      events[name] = {
-        schema: state2.events[name],
-        reactions: /* @__PURE__ */ new Map()
-      };
-    }
-  } else {
-    states.set(state2.name, state2);
-    for (const name of Object.keys(state2.actions)) {
-      if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-      actions[name] = state2;
-    }
-    for (const name of Object.keys(state2.events)) {
-      if (events[name]) throw new Error(`Duplicate event "${name}"`);
-      events[name] = {
-        schema: state2.events[name],
-        reactions: /* @__PURE__ */ new Map()
-      };
-    }
-  }
-}
-function mergeProjection(proj, events) {
-  for (const eventName of Object.keys(proj.events)) {
-    const projRegister = proj.events[eventName];
-    const existing = events[eventName];
-    if (!existing) {
-      events[eventName] = {
-        schema: projRegister.schema,
-        reactions: new Map(projRegister.reactions)
-      };
-    } else {
-      for (const [name, reaction] of projRegister.reactions) {
-        let key = name;
-        while (existing.reactions.has(key)) key = `${key}_p`;
-        existing.reactions.set(key, reaction);
-      }
-    }
-  }
-}
-var _this_ = ({ stream }) => ({
-  source: stream,
-  target: stream
-});
-
 // src/internal/tracing.ts
-var logger3 = log();
-var withSnapTrace = (inner) => async (snapshot) => {
-  logger3.trace(
-    `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
-  );
-  return inner(snapshot);
-};
-var withLoadTrace = (inner) => async (me, stream, callback, asOf) => {
-  logger3.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
-  return inner(me, stream, callback, asOf);
-};
-var withActionTrace = (inner) => async (me, action2, target, payload, reactingTo, skipValidation) => {
-  logger3.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
-  const snapshots = await inner(
-    me,
-    action2,
-    target,
-    payload,
-    reactingTo,
-    skipValidation
-  );
-  const committed = snapshots.filter((s) => s.event);
-  if (committed.length) {
-    logger3.trace(
-      committed.map((s) => s.event.data),
-      `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
-    );
-  }
-  return snapshots;
-};
-function buildEs(level) {
-  if (level !== "trace") {
+var traced = (inner, exit, entry) => (async (...args) => {
+  entry?.(...args);
+  const result = await inner(...args);
+  exit?.(result, ...args);
+  return result;
+});
+function buildEs(logger2) {
+  if (logger2.level !== "trace") {
     return { snap, load, action };
   }
   return {
-    snap: withSnapTrace(snap),
-    load: withLoadTrace(load),
-    action: withActionTrace(action)
+    snap: traced(snap, void 0, (snapshot) => {
+      logger2.trace(
+        `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
+      );
+    }),
+    load: traced(load, void 0, (_me, stream, _cb, asOf) => {
+      logger2.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
+    }),
+    action: traced(
+      action,
+      (snapshots, _me, _action, target) => {
+        const committed = snapshots.filter((s) => s.event);
+        if (committed.length) {
+          logger2.trace(
+            committed.map((s) => s.event.data),
+            `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+          );
+        }
+      },
+      (_me, action2, target, payload) => {
+        logger2.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+      }
+    )
   };
 }
-var withClaimTrace = (inner) => async (lagging, leading, by, millis) => {
-  const leased = await inner(lagging, leading, by, millis);
-  if (leased.length) {
-    const data = Object.fromEntries(
-      leased.map(({ stream, at, retry }) => [stream, { at, retry }])
-    );
-    logger3.trace(data, ">> lease");
-  }
-  return leased;
-};
-var withFetchTrace = (inner) => async (leased, eventLimit) => {
-  const fetched = await inner(leased, eventLimit);
-  const data = Object.fromEntries(
-    fetched.map(({ stream, source, events }) => {
-      const key = source ? `${stream}<-${source}` : stream;
-      const value = Object.fromEntries(
-        events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
-      );
-      return [key, value];
-    })
-  );
-  logger3.trace(data, ">> fetch");
-  return fetched;
-};
-var withAckTrace = (inner) => async (leases) => {
-  const acked = await inner(leases);
-  if (acked.length) {
-    const data = Object.fromEntries(
-      acked.map(({ stream, at, retry }) => [stream, { at, retry }])
-    );
-    logger3.trace(data, ">> ack");
-  }
-  return acked;
-};
-var withBlockTrace = (inner) => async (leases) => {
-  const blocked = await inner(leases);
-  if (blocked.length) {
-    const data = Object.fromEntries(
-      blocked.map(({ stream, at, retry, error }) => [
-        stream,
-        { at, retry, error }
-      ])
-    );
-    logger3.trace(data, ">> block");
-  }
-  return blocked;
-};
-var withSubscribeTrace = (inner) => async (streams) => {
-  const result = await inner(streams);
-  if (result.subscribed) {
-    const data = streams.map(({ stream }) => stream).join(" ");
-    logger3.trace(`>> correlate ${data}`);
-  }
-  return result;
-};
-function buildDrain(level) {
-  if (level !== "trace") {
+function buildDrain(logger2) {
+  if (logger2.level !== "trace") {
     return {
       claim,
       fetch,
@@ -1055,24 +999,62 @@ function buildDrain(level) {
     };
   }
   return {
-    claim: withClaimTrace(claim),
-    fetch: withFetchTrace(fetch),
-    ack: withAckTrace(ack),
-    block: withBlockTrace(block),
-    subscribe: withSubscribeTrace(subscribe)
+    claim: traced(claim, (leased) => {
+      if (leased.length) {
+        const data = Object.fromEntries(
+          leased.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger2.trace(data, ">> lease");
+      }
+    }),
+    fetch: traced(fetch, (fetched) => {
+      const data = Object.fromEntries(
+        fetched.map(({ stream, source, events }) => {
+          const key = source ? `${stream}<-${source}` : stream;
+          const value = Object.fromEntries(
+            events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
+          );
+          return [key, value];
+        })
+      );
+      logger2.trace(data, ">> fetch");
+    }),
+    ack: traced(ack, (acked) => {
+      if (acked.length) {
+        const data = Object.fromEntries(
+          acked.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger2.trace(data, ">> ack");
+      }
+    }),
+    block: traced(block, (blocked) => {
+      if (blocked.length) {
+        const data = Object.fromEntries(
+          blocked.map(({ stream, at, retry, error }) => [
+            stream,
+            { at, retry, error }
+          ])
+        );
+        logger2.trace(data, ">> block");
+      }
+    }),
+    subscribe: traced(subscribe, (result, streams) => {
+      if (result.subscribed) {
+        const data = streams.map(({ stream }) => stream).join(" ");
+        logger2.trace(`>> correlate ${data}`);
+      }
+    })
   };
 }
 
 // src/act.ts
-var logger4 = log();
 var Act = class {
   constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map()) {
     this.registry = registry;
     this._states = _states;
     this._batch_handlers = batchHandlers;
-    const level = log().level;
-    this._es = buildEs(level);
-    this._cd = buildDrain(level);
+    this._es = buildEs(this._logger);
+    this._cd = buildDrain(this._logger);
     const statics = [];
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
@@ -1136,6 +1118,8 @@ var Act = class {
   _es;
   /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
   _cd;
+  /** Logger resolved at construction time (after user port configuration) */
+  _logger = log();
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1357,7 +1341,7 @@ var Act = class {
     if (payloads.length === 0) return { lease, handled: 0, at: lease.at };
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
-    lease.retry > 0 && logger4.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
+    lease.retry > 0 && this._logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
     const doAction = this.do.bind(this);
     const scopedApp = {
       do: doAction,
@@ -1379,9 +1363,11 @@ var Act = class {
         at = event.id;
         handled++;
       } catch (error) {
-        logger4.error(error);
+        this._logger.error(error);
         const block2 = lease.retry >= options.maxRetries && options.blockOnError;
-        block2 && logger4.error(`Blocking ${stream} after ${lease.retry} retries.`);
+        block2 && this._logger.error(
+          `Blocking ${stream} after ${lease.retry} retries.`
+        );
         return {
           lease,
           handled,
@@ -1411,15 +1397,17 @@ var Act = class {
     const stream = lease.stream;
     const events = payloads.map((p) => p.event);
     const at = events.at(-1).id;
-    lease.retry > 0 && logger4.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
+    lease.retry > 0 && this._logger.warn(
+      `Retrying batch ${stream}@${events[0].id} (${lease.retry}).`
+    );
     try {
       await batchHandler(events, stream);
       return { lease, handled: events.length, at };
     } catch (error) {
-      logger4.error(error);
+      this._logger.error(error);
       const { options } = payloads[0];
       const block2 = lease.retry >= options.maxRetries && options.blockOnError;
-      block2 && logger4.error(`Blocking ${stream} after ${lease.retry} retries.`);
+      block2 && this._logger.error(`Blocking ${stream} after ${lease.retry} retries.`);
       return {
         lease,
         handled: 0,
@@ -1545,7 +1533,7 @@ var Act = class {
           this._needs_drain = false;
         return result;
       } catch (error) {
-        logger4.error(error);
+        this._logger.error(error);
       } finally {
         this._drain_locked = false;
       }
@@ -2025,7 +2013,7 @@ var Act = class {
           if (!made_progress) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
-      })().catch((err) => logger4.error(err)).finally(() => {
+      })().catch((err) => this._logger.error(err)).finally(() => {
         this._settling = false;
       });
     }, debounceMs);
@@ -2272,8 +2260,9 @@ function state(entry) {
         emits(events) {
           const defaultPatch = Object.fromEntries(
             Object.keys(events).map((k) => {
-              const fn = ({ data }) => data;
-              fn._passthrough = true;
+              const fn = Object.assign(({ data }) => data, {
+                _passthrough: true
+              });
               return [k, fn];
             })
           );