@rotorsoft/act 0.36.0 → 0.37.0

package/dist/index.js

@@ -1317,6 +1317,43 @@ var DrainController = class {
   }
 };
 
+// src/internal/event-versions.ts
+var VERSION_SUFFIX = /^(.+?)_v(\d+)$/;
+function parse(name) {
+  const m = name.match(VERSION_SUFFIX);
+  if (m) {
+    const v = Number.parseInt(m[2], 10);
+    if (v >= 2) return { base: m[1], version: v };
+  }
+  return { base: name, version: 1 };
+}
+function deprecatedEventNames(names) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const { base, version } = parse(name);
+    const list = groups.get(base);
+    if (list) list.push({ version, name });
+    else groups.set(base, [{ version, name }]);
+  }
+  const deprecated = /* @__PURE__ */ new Set();
+  for (const list of groups.values()) {
+    if (list.length < 2) continue;
+    list.sort((a, b) => b.version - a.version);
+    for (let i = 1; i < list.length; i++) deprecated.add(list[i].name);
+  }
+  return deprecated;
+}
+function currentVersionOf(deprecatedName, allNames) {
+  const target = parse(deprecatedName);
+  let highest;
+  for (const name of allNames) {
+    const { base, version } = parse(name);
+    if (base !== target.base) continue;
+    if (!highest || version > highest.version) highest = { version, name };
+  }
+  return highest && highest.version > target.version ? highest.name : void 0;
+}
+
 // src/internal/merge.ts
 import { ZodObject } from "zod";
 function baseTypeName(zodType) {
@@ -1729,6 +1766,20 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     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])
@@ -2729,6 +2780,38 @@ function act() {
         mergeProjection(proj, registry.events);
         registerBatchHandler(proj, batchHandlers);
       }
+      const deprecationSummary = [];
+      for (const state2 of states.values()) {
+        const eventNames = Object.keys(state2.events);
+        const deprecated = deprecatedEventNames(eventNames);
+        if (deprecated.size === 0) continue;
+        state2._deprecated = deprecated;
+        for (const name of deprecated) {
+          const current = currentVersionOf(name, eventNames);
+          deprecationSummary.push({
+            stateName: state2.name,
+            deprecated: name,
+            current
+          });
+        }
+        for (const [actionName, handler] of Object.entries(state2.on)) {
+          const staticTarget = handler?._staticEmit;
+          if (staticTarget && deprecated.has(staticTarget)) {
+            const current = currentVersionOf(staticTarget, eventNames);
+            throw new Error(
+              `Action "${actionName}" in state "${state2.name}" emits deprecated event "${staticTarget}". A newer version exists: "${current}". Update the .emit() call to target the current version. The reducer (.patch) for "${staticTarget}" stays as-is \u2014 historical events still need it.`
+            );
+          }
+        }
+      }
+      if (deprecationSummary.length > 0) {
+        const list = deprecationSummary.map(
+          (d) => `"${d.deprecated}" (current: "${d.current}", state: "${d.stateName}")`
+        ).join(", ");
+        log().info(
+          `Act registered ${deprecationSummary.length} deprecated event(s): ${list}. These are legacy versions kept for the read path. Consider truncating closed streams via app.close() when feasible to reduce historical event load. See docs/docs/architecture/event-schema-evolution.md.`
+        );
+      }
       return new Act(
         registry,
         states,
@@ -2915,10 +2998,10 @@ function action_builder(state2) {
       function emit(handler) {
         if (typeof handler === "string") {
           const eventName = handler;
-          internal.on[action2] = (payload) => [
-            eventName,
-            payload
-          ];
+          const emitFn = Object.assign((payload) => [eventName, payload], {
+            _staticEmit: eventName
+          });
+          internal.on[action2] = emitFn;
         } else {
           internal.on[action2] = handler;
         }