@rotorsoft/act 0.24.0 → 0.25.0

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   CausationEventSchema: () => CausationEventSchema,
   CommittedMetaSchema: () => CommittedMetaSchema,
   ConcurrencyError: () => ConcurrencyError,
+  ConsoleLogger: () => ConsoleLogger,
   Environments: () => Environments,
   Errors: () => Errors,
   EventMetaSchema: () => EventMetaSchema,
@@ -56,7 +57,7 @@ __export(index_exports, {
   dispose: () => dispose,
   disposeAndExit: () => disposeAndExit,
   extend: () => extend,
-  logger: () => logger,
+  log: () => log,
   port: () => port,
   projection: () => projection,
   sleep: () => sleep,
@@ -67,8 +68,107 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/ports.ts
-var import_pino = require("pino");
+// src/adapters/ConsoleLogger.ts
+var LEVEL_VALUES = {
+  fatal: 60,
+  error: 50,
+  warn: 40,
+  info: 30,
+  debug: 20,
+  trace: 10
+};
+var LEVEL_COLORS = {
+  fatal: "\x1B[41m\x1B[37m",
+  // white on red bg
+  error: "\x1B[31m",
+  // red
+  warn: "\x1B[33m",
+  // yellow
+  info: "\x1B[32m",
+  // green
+  debug: "\x1B[36m",
+  // cyan
+  trace: "\x1B[90m"
+  // gray
+};
+var RESET = "\x1B[0m";
+var noop = () => {
+};
+var ConsoleLogger = class _ConsoleLogger {
+  level;
+  _pretty;
+  fatal;
+  error;
+  warn;
+  info;
+  debug;
+  trace;
+  constructor(options = {}) {
+    const {
+      level = "info",
+      pretty = process.env.NODE_ENV !== "production",
+      bindings
+    } = options;
+    this._pretty = pretty;
+    this.level = level;
+    const threshold = LEVEL_VALUES[level] ?? 30;
+    const write = pretty ? this._prettyWrite.bind(this, bindings) : this._jsonWrite.bind(this, bindings);
+    this.fatal = write.bind(this, "fatal", 60);
+    this.error = threshold <= 50 ? write.bind(this, "error", 50) : noop;
+    this.warn = threshold <= 40 ? write.bind(this, "warn", 40) : noop;
+    this.info = threshold <= 30 ? write.bind(this, "info", 30) : noop;
+    this.debug = threshold <= 20 ? write.bind(this, "debug", 20) : noop;
+    this.trace = threshold <= 10 ? write.bind(this, "trace", 10) : noop;
+  }
+  async dispose() {
+  }
+  child(bindings) {
+    return new _ConsoleLogger({
+      level: this.level,
+      pretty: this._pretty,
+      bindings
+    });
+  }
+  _jsonWrite(bindings, level, _num, objOrMsg, msg) {
+    let obj;
+    let message;
+    if (typeof objOrMsg === "string") {
+      message = objOrMsg;
+      obj = {};
+    } else if (objOrMsg !== null && typeof objOrMsg === "object") {
+      message = msg;
+      obj = Object.fromEntries(Object.entries(objOrMsg));
+    } else {
+      message = msg;
+      obj = { value: objOrMsg };
+    }
+    const entry = Object.assign({ level, time: Date.now() }, bindings, obj);
+    if (message) entry.msg = message;
+    process.stdout.write(JSON.stringify(entry) + "\n");
+  }
+  _prettyWrite(bindings, level, _num, objOrMsg, msg) {
+    const color = LEVEL_COLORS[level];
+    const tag = `${color}${level.toUpperCase().padEnd(5)}${RESET}`;
+    const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    let message;
+    let data;
+    if (typeof objOrMsg === "string") {
+      message = objOrMsg;
+    } else {
+      message = msg ?? "";
+      if (objOrMsg !== void 0 && objOrMsg !== null) {
+        try {
+          data = JSON.stringify(objOrMsg);
+        } catch {
+          data = "[unserializable]";
+        }
+      }
+    }
+    const bindStr = bindings && Object.keys(bindings).length ? ` ${JSON.stringify(bindings)}` : "";
+    const parts = [ts, tag, message, data, bindStr].filter(Boolean);
+    process.stdout.write(parts.join(" ") + "\n");
+  }
+};
 
 // src/adapters/InMemoryCache.ts
 var InMemoryCache = class {
@@ -536,28 +636,30 @@ var InMemoryStore = class {
 
 // src/ports.ts
 var ExitCodes = ["ERROR", "EXIT"];
-var logger = (0, import_pino.pino)({
-  transport: config().env !== "production" ? {
-    target: "pino-pretty",
-    options: {
-      ignore: "pid,hostname",
-      singleLine: config().logSingleLine,
-      colorize: true
-    }
-  } : void 0,
-  level: config().logLevel
-});
 var adapters = /* @__PURE__ */ new Map();
 function port(injector) {
   return function(adapter) {
     if (!adapters.has(injector.name)) {
       const injected = injector(adapter);
       adapters.set(injector.name, injected);
-      logger.info(`\u{1F50C} injected ${injector.name}:${injected.constructor.name}`);
+      console.log(`[act] + ${injector.name}:${injected.constructor.name}`);
     }
     return adapters.get(injector.name);
   };
 }
+var log = port(function log2(adapter) {
+  const cfg = config();
+  return adapter || new ConsoleLogger({
+    level: cfg.logLevel,
+    pretty: cfg.env !== "production"
+  });
+});
+var store = port(function store2(adapter) {
+  return adapter || new InMemoryStore();
+});
+var cache = port(function cache2(adapter) {
+  return adapter || new InMemoryCache();
+});
 var disposers = [];
 async function disposeAndExit(code = "EXIT") {
   if (code === "ERROR" && config().env === "production") return;
@@ -565,7 +667,7 @@ async function disposeAndExit(code = "EXIT") {
   await Promise.all(
     [...adapters.values()].reverse().map(async (adapter) => {
       await adapter.dispose();
-      logger.info(`\u{1F50C} disposed ${adapter.constructor.name}`);
+      console.log(`[act] - ${adapter.constructor.name}`);
     })
   );
   adapters.clear();
@@ -576,14 +678,9 @@ function dispose(disposer) {
   return disposeAndExit;
 }
 var SNAP_EVENT = "__snapshot__";
-var store = port(function store2(adapter) {
-  return adapter || new InMemoryStore();
-});
-var cache = port(function cache2(adapter) {
-  return adapter || new InMemoryCache();
-});
 function build_tracer(logLevel2) {
   if (logLevel2 === "trace") {
+    const logger4 = log();
     return {
       fetched: (fetched) => {
         const data = Object.fromEntries(
@@ -595,23 +692,23 @@ function build_tracer(logLevel2) {
             return [key, value];
           })
         );
-        logger.trace(data, "\u26A1\uFE0F fetch");
+        logger4.trace(data, ">> fetch");
       },
       correlated: (streams) => {
         const data = streams.map(({ stream }) => stream).join(" ");
-        logger.trace(`\u26A1\uFE0F correlate ${data}`);
+        logger4.trace(`>> correlate ${data}`);
       },
       leased: (leases) => {
         const data = Object.fromEntries(
           leases.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger.trace(data, "\u26A1\uFE0F lease");
+        logger4.trace(data, ">> lease");
       },
       acked: (leases) => {
         const data = Object.fromEntries(
           leases.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger.trace(data, "\u26A1\uFE0F ack");
+        logger4.trace(data, ">> ack");
       },
       blocked: (leases) => {
         const data = Object.fromEntries(
@@ -620,7 +717,7 @@ function build_tracer(logLevel2) {
             { at, retry, error }
           ])
         );
-        logger.trace(data, "\u26A1\uFE0F block");
+        logger4.trace(data, ">> block");
       }
     };
   } else {
@@ -640,6 +737,7 @@ function build_tracer(logLevel2) {
 }
 
 // src/signals.ts
+var logger = log();
 process.once("SIGINT", async (arg) => {
   logger.info(arg, "SIGINT");
   await disposeAndExit("EXIT");
@@ -664,6 +762,7 @@ var import_events = __toESM(require("events"), 1);
 // src/event-sourcing.ts
 var import_act_patch = require("@rotorsoft/act-patch");
 var import_crypto = require("crypto");
+var logger2 = log();
 async function snap(snapshot) {
   try {
     const { id, stream, name, meta, version } = snapshot.event;
@@ -677,9 +776,9 @@ async function snap(snapshot) {
       version
       // IMPORTANT! - state events are committed right after the snapshot event
     );
-    logger.trace(snapped, "\u{1F7E0} snap");
+    logger2.trace(snapped, "\u{1F7E0} snap");
   } catch (error) {
-    logger.error(error);
+    logger2.error(error);
   }
 }
 async function load(me, stream, callback) {
@@ -703,7 +802,7 @@ async function load(me, stream, callback) {
     },
     { stream, with_snaps: !cached, after: cached?.event_id }
   );
-  logger.trace(
+  logger2.trace(
     state2,
     `\u{1F7E2} load ${stream}${cached && count === 0 ? " (cached)" : ""}`
   );
@@ -715,7 +814,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
   const snapshot = await load(me, stream);
   const expected = expectedVersion || snapshot.event?.version;
-  logger.trace(
+  logger2.trace(
     payload,
     `\u{1F535} ${stream}.${action2}${typeof expected === "number" ? `.${expected}` : ""}`
   );
@@ -758,7 +857,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       } : void 0
     }
   };
-  logger.trace(
+  logger2.trace(
     emitted.map((e) => e.data),
     `\u{1F534} commit ${stream}.${emitted.map((e) => e.name).join(", ")}`
   );
@@ -798,6 +897,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 }
 
 // src/act.ts
+var logger3 = log();
 var tracer = build_tracer(config().logLevel);
 var Act = class {
   constructor(registry, _states = /* @__PURE__ */ new Map()) {
@@ -1078,7 +1178,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 && logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
+    lease.retry > 0 && logger3.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
     for (const payload of payloads) {
       const { event, handler, options } = payload;
       try {
@@ -1086,9 +1186,9 @@ var Act = class {
         at = event.id;
         handled++;
       } catch (error) {
-        logger.error(error);
+        logger3.error(error);
         const block = lease.retry >= options.maxRetries && options.blockOnError;
-        block && logger.error(`Blocking ${stream} after ${lease.retry} retries.`);
+        block && logger3.error(`Blocking ${stream} after ${lease.retry} retries.`);
         return {
           lease,
           handled,
@@ -1232,7 +1332,7 @@ var Act = class {
           this._needs_drain = false;
         return result;
       } catch (error) {
-        logger.error(error);
+        logger3.error(error);
       } finally {
         this._drain_locked = false;
       }
@@ -1505,7 +1605,7 @@ var Act = class {
           if (!lastDrain.acked.length && !lastDrain.blocked.length) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
-      })().catch((err) => logger.error(err)).finally(() => {
+      })().catch((err) => logger3.error(err)).finally(() => {
         this._settling = false;
       });
     }, debounceMs);
@@ -1552,15 +1652,35 @@ function registerState(state2, states, actions, events) {
     }
     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: { ...existing.patch, ...state2.patch },
+      patch: mergedPatch,
       on: { ...existing.on, ...state2.on },
       given: { ...existing.given, ...state2.given },
       snap: state2.snap || existing.snap
@@ -1841,10 +1961,11 @@ function state(entry) {
       return {
         emits(events) {
           const defaultPatch = Object.fromEntries(
-            Object.keys(events).map((k) => [
-              k,
-              ({ data }) => data
-            ])
+            Object.keys(events).map((k) => {
+              const fn = ({ data }) => data;
+              fn._passthrough = true;
+              return [k, fn];
+            })
           );
           const builder = action_builder({
             events,
@@ -1926,6 +2047,7 @@ function action_builder(state2) {
   CausationEventSchema,
   CommittedMetaSchema,
   ConcurrencyError,
+  ConsoleLogger,
   Environments,
   Errors,
   EventMetaSchema,
@@ -1947,7 +2069,7 @@ function action_builder(state2) {
   dispose,
   disposeAndExit,
   extend,
-  logger,
+  log,
   port,
   projection,
   sleep,