@rotorsoft/act 0.8.0 → 0.10.0

package/dist/index.js

@@ -564,9 +564,6 @@ process.once("unhandledRejection", async (arg) => {
   await disposeAndExit("ERROR");
 });
 
-// src/act-builder.ts
-import { ZodObject as ZodObject2 } from "zod";
-
 // src/act.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
@@ -807,7 +804,6 @@ var Act = class {
       action2,
       target,
       payload,
-      // @ts-expect-error type lost
       reactingTo,
       skipValidation
     );
@@ -935,7 +931,7 @@ var Act = class {
     for (const payload of payloads) {
       const { event, handler, options } = payload;
       try {
-        await handler(event, stream);
+        await handler(event, stream, this);
         at = event.id;
         handled++;
       } catch (error) {
@@ -1064,7 +1060,6 @@ var Act = class {
                 retry: 0,
                 lagging: lagging2
               },
-              // @ts-expect-error indexed by key
               payloads
             });
           });
@@ -1281,7 +1276,8 @@ var Act = class {
   }
 };
 
-// src/act-builder.ts
+// src/merge.ts
+import { ZodObject as ZodObject2 } from "zod";
 function baseTypeName(zodType) {
   let t = zodType;
   while (typeof t.unwrap === "function") {
@@ -1311,80 +1307,216 @@ function mergeSchemas(existing, incoming, stateName) {
 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 (events[name]) throw new Error(`Duplicate event "${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: { ...existing.patch, ...state2.patch },
+      on: { ...existing.on, ...state2.on },
+      given: { ...existing.given, ...state2.given },
+      snap: 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()
+      };
+    }
+  }
+}
 var _this_ = ({ stream }) => ({
   source: stream,
   target: stream
 });
 var _void_ = () => void 0;
+
+// src/projection-builder.ts
+function isProjection(x) {
+  return x != null && x._tag === "Projection";
+}
+function projection(target, events = {}) {
+  const defaultResolver = target ? { target } : void 0;
+  const builder = {
+    on: (entry) => {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const event = keys[0];
+      const schema = entry[event];
+      if (!(event in events)) {
+        events[event] = {
+          schema,
+          reactions: /* @__PURE__ */ new Map()
+        };
+      }
+      return {
+        do: (handler) => {
+          const reaction = {
+            handler,
+            resolver: defaultResolver ?? _this_,
+            options: {
+              blockOnError: true,
+              maxRetries: 3
+            }
+          };
+          const register = events[event];
+          const name = handler.name || `${event}_${register.reactions.size}`;
+          register.reactions.set(name, reaction);
+          const nextBuilder = projection(
+            target,
+            events
+          );
+          return {
+            ...nextBuilder,
+            to(resolver) {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: typeof resolver === "string" ? { target: resolver } : resolver
+              });
+              return nextBuilder;
+            },
+            void() {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: _void_
+              });
+              return nextBuilder;
+            }
+          };
+        }
+      };
+    },
+    build: () => ({
+      _tag: "Projection",
+      events
+    }),
+    events
+  };
+  return builder;
+}
+
+// src/slice-builder.ts
+function isSlice(x) {
+  return x != null && x._tag === "Slice";
+}
+function slice(states = /* @__PURE__ */ new Map(), actions = {}, events = {}) {
+  const builder = {
+    with: (state2) => {
+      registerState(state2, states, actions, events);
+      return slice(states, actions, events);
+    },
+    on: (event) => ({
+      do: (handler, options) => {
+        const reaction = {
+          handler,
+          resolver: _this_,
+          options: {
+            blockOnError: options?.blockOnError ?? true,
+            maxRetries: options?.maxRetries ?? 3
+          }
+        };
+        const name = handler.name || `${String(event)}_${events[event].reactions.size}`;
+        events[event].reactions.set(name, reaction);
+        return {
+          ...builder,
+          to(resolver) {
+            events[event].reactions.set(name, {
+              ...reaction,
+              resolver: typeof resolver === "string" ? { target: resolver } : resolver
+            });
+            return builder;
+          },
+          void() {
+            events[event].reactions.set(name, {
+              ...reaction,
+              resolver: _void_
+            });
+            return builder;
+          }
+        };
+      }
+    }),
+    build: () => ({
+      _tag: "Slice",
+      states,
+      events
+    }),
+    events
+  };
+  return builder;
+}
+
+// src/act-builder.ts
 function act(states = /* @__PURE__ */ new Map(), registry = {
   actions: {},
   events: {}
 }) {
   const builder = {
-    /**
-     * Adds a state to the builder. When a state with the same name is already
-     * registered, merges the new partial's actions, events, patches, and handlers
-     * into the existing state (errors on duplicate action/event names).
-     *
-     * @template SX The type of state
-     * @template EX The type of events
-     * @template AX The type of actions
-     * @param state The state to add
-     * @returns The builder
-     */
-    with: (state2) => {
-      if (states.has(state2.name)) {
-        const existing = states.get(state2.name);
-        for (const name of Object.keys(state2.actions)) {
-          if (registry.actions[name])
-            throw new Error(`Duplicate action "${name}"`);
-        }
-        for (const name of Object.keys(state2.events)) {
-          if (registry.events[name])
-            throw new Error(`Duplicate event "${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: { ...existing.patch, ...state2.patch },
-          on: { ...existing.on, ...state2.on },
-          given: { ...existing.given, ...state2.given },
-          snap: state2.snap || existing.snap
-        };
-        states.set(state2.name, merged);
-        for (const name of Object.keys(merged.actions)) {
-          registry.actions[name] = merged;
-        }
-        for (const name of Object.keys(state2.events)) {
-          registry.events[name] = {
-            schema: state2.events[name],
-            reactions: /* @__PURE__ */ new Map()
-          };
+    with: ((input) => {
+      if (isProjection(input)) {
+        for (const eventName of Object.keys(input.events)) {
+          const projRegister = input.events[eventName];
+          const existing = registry.events[eventName];
+          if (!existing) {
+            registry.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);
+            }
+          }
         }
-      } else {
-        states.set(state2.name, state2);
-        for (const name of Object.keys(state2.actions)) {
-          if (registry.actions[name])
-            throw new Error(`Duplicate action "${name}"`);
-          registry.actions[name] = state2;
+        return act(states, registry);
+      }
+      if (isSlice(input)) {
+        for (const s of input.states.values()) {
+          registerState(s, states, registry.actions, registry.events);
         }
-        for (const name of Object.keys(state2.events)) {
-          if (registry.events[name])
-            throw new Error(`Duplicate event "${name}"`);
-          registry.events[name] = {
-            schema: state2.events[name],
-            reactions: /* @__PURE__ */ new Map()
-          };
+        for (const eventName of Object.keys(input.events)) {
+          const sliceRegister = input.events[eventName];
+          for (const [name, reaction] of sliceRegister.reactions) {
+            registry.events[eventName].reactions.set(name, reaction);
+          }
         }
+        return act(states, registry);
       }
-      return act(
-        states,
-        registry
-      );
-    },
+      registerState(input, states, registry.actions, registry.events);
+      return act(states, registry);
+    }),
     /**
      * Adds a reaction to an event.
      *
@@ -1402,18 +1534,19 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
             maxRetries: options?.maxRetries ?? 3
           }
         };
-        registry.events[event].reactions.set(handler.name, reaction);
+        const name = handler.name || `${String(event)}_${registry.events[event].reactions.size}`;
+        registry.events[event].reactions.set(name, reaction);
         return {
           ...builder,
           to(resolver) {
-            registry.events[event].reactions.set(handler.name, {
+            registry.events[event].reactions.set(name, {
               ...reaction,
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
           },
           void() {
-            registry.events[event].reactions.set(handler.name, {
+            registry.events[event].reactions.set(name, {
               ...reaction,
               resolver: _void_
             });
@@ -1454,7 +1587,11 @@ function state(name, state2) {
 }
 function action_builder(state2) {
   return {
-    on(action2, schema) {
+    on(entry) {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const action2 = keys[0];
+      const schema = entry[action2];
       if (action2 in state2.actions)
         throw new Error(`Duplicate action "${action2}"`);
       const actions = { ...state2.actions, [action2]: schema };
@@ -1507,10 +1644,14 @@ export {
   dispose,
   disposeAndExit,
   extend,
+  isProjection,
+  isSlice,
   logger,
   patch,
   port,
+  projection,
   sleep,
+  slice,
   state,
   store,
   validate