@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs

@@ -0,0 +1,123 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as AutomationSlice$ReventlessCore from "./AutomationSlice.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventCollector_Builder.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "./AutomationSlice_Callback.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
+    let Make = Spec => (Automation => {
+      let Callback = AutomationSlice_Callback$ReventlessCore.Make(Spec)(Automation);
+      let queryDbName = Spec.name + "Todo";
+      let sourceNames = Belt_SetString.toArray(Belt_SetString.fromArray(Automation.mappings.map(M => M.sourceName)));
+      let moduleUrl = import.meta.url;
+      let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+      let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: queryDbName,
+        moduleUrl: moduleUrl,
+        stateSchema: AutomationSlice_Callback$ReventlessCore.todoRowSchema,
+        config: config,
+        subIdConfig: undefined,
+        authorization: "AllowAuthenticated",
+        visibility: "Public"
+      })(QueryDbStorage)(QueryDbResolvers);
+      let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+      let syncToQueryDb = async queryDbOps => {
+        let items = Object.entries(Callback.todoItems);
+        await Stdlib_Array.reduce(items, Promise.resolve(), async (prev, param) => {
+          await prev;
+          await queryDbOps.save(Id$Reventless.$$String.makeFromString(param[0]), param[1], "Overwrite", undefined);
+        });
+      };
+      let make = (allEventTopics, publishJsons, context, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(AutomationSlice$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, opts);
+        sourceNames.forEach(sourceName => {
+          if (sourceName in allEventTopics) {
+            return;
+          }
+          let availableNames = Object.keys(allEventTopics).toSorted(Primitive_string.compare).join(", ");
+          Stdlib_JsError.throwWithMessage(`AutomationSlice "` + Spec.name + `" has a Mapping with sourceName "` + sourceName + `", but no EventTopic with that key exists in allEventTopics. ` + (`Available source names: [` + availableNames + `]. `) + `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB source name (typically "<pluginName>DcbEventLog").`);
+        });
+        let sourceSet = Belt_SetString.fromArray(sourceNames);
+        let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, sourceSet);
+        let eventCollector = Pulumi.all([
+          Component$ReventlessCore.operations(queryDb),
+          publishJsons
+        ]).apply(param => {
+          let publishJsonsFn = param[1];
+          let queryDbOps = param[0];
+          let ec = SpecificEventCollector.make(Spec.name, eventTopics, opts);
+          let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
+            Callback.phase1(jsons, context);
+            await syncToQueryDb(queryDbOps);
+            Stdlib_Promise.$$catch(Callback.phase2(publishJsonsFn).then(() => syncToQueryDb(queryDbOps)), exn => {
+              let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+              Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
+              return Promise.resolve();
+            });
+          }));
+          let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
+          let resources = Component$ReventlessCore.outputs(queryDb).resources;
+          EventCollectorRuntimeBuilder.forEventCollector(handler, eventTopics, resources, undefined, undefined, ec);
+          return ec;
+        });
+        Component$ReventlessCore.setOperations(extra, Pulumi.all([
+          Output$Pulumi.flatMap(eventCollector, Component$ReventlessCore.operations),
+          publishJsons
+        ]).apply(param => {
+          let publishJsonsFn = param[1];
+          return {
+            enqueueEvent: param[0].enqueueEvent,
+            processPending: async () => await Callback.phase2(publishJsonsFn)
+          };
+        }));
+        let aggregatedResources = Object.values(eventTopics).flatMap(t => t.resources);
+        let outputs_queryDb = Component$ReventlessCore.outputs(queryDb);
+        let outputs = {
+          resources: aggregatedResources,
+          queryDb: outputs_queryDb
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+      return {
+        Spec: Spec,
+        Automation: Automation,
+        queryDbName: queryDbName,
+        sourceNames: sourceNames,
+        make: make
+      };
+    });
+    return {
+      finish: EventCollectorRuntimeBuilder.finish,
+      Make: Make
+    };
+  }))));
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -0,0 +1,212 @@
+S.enableJson()
+// AutomationSlice callback — implements the TODO list pattern with mixed-source
+// dispatch (Plan 04).
+//
+// Phase 1 (collect/resolve): for each event JSON, look up its source by
+// `meta.service`, decode against the matching `Mapping.sourceEventSchema`, and
+// run the mapping's `collect`/`resolve`. Multiple mappings may share a source
+// name; all matching mappings run.
+//
+// Phase 2 (process): walk pending TODO items; for each, call
+// `Automation.process` to construct the command, encode against the command
+// schema (sury enforces `@s.matches` / `@compositePartitionTag` invariants
+// here — failures mark the item Failed for retry), and publish via
+// `publishJsons`. Publish failures revert all `Processing` items to Failed
+// for the next heartbeat sweep.
+
+@schema
+type todoStatus =
+  | Pending
+  | Processing
+  | Completed
+  | Failed
+
+@schema
+type todoRow = {
+  item: JSON.t,
+  status: todoStatus,
+  createdAt: string,
+  processedAt?: string,
+  completedAt?: string,
+  retryCount: int,
+}
+
+module type T = {
+  module Spec: Reventless.AutomationSlice.Spec
+  module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
+
+  /** The in-memory TODO list — maps item ID to row. */
+  let todoItems: Dict.t<todoRow>
+
+  /** Phase 1: update TODO list from a batch of raw event JSONs. Internally
+      decodes per-source via the registered Mappings. */
+  let phase1: (array<JSON.t>, Reventless.AutomationSlice.context) => unit
+
+  /** Phase 2: process all pending items, publishing commands via publishJsons. */
+  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+}
+
+module Make = (
+  Spec: Reventless.AutomationSlice.Spec,
+  Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+): (T with module Spec = Spec and module Automation := Automation) => {
+  module Spec = Spec
+  module Automation = Automation
+
+  let todoItems: Dict.t<todoRow> = Dict.make()
+
+  let now = () => Date.make()->Date.toISOString
+
+  // Root meta for commands emitted by this AutomationSlice. The triggering
+  // event's meta is not currently threaded from phase1 → phase2 (todoItems
+  // only carries `item` data), so causation across the automation hop is
+  // lost — emitted commands are roots of a fresh correlation chain. If we
+  // later thread source meta through todoItems, switch to deriveMeta.
+  let makeMeta = (): Reventless.Message.meta =>
+    Message.generateMeta(~service=`AutomationSlice:${Spec.name}`)
+
+  // Per-source erased dispatch — pre-compile decoders once at module init.
+  type dispatch = {
+    sourceName: string,
+    handle: (JSON.t, Reventless.AutomationSlice.context) => unit,
+  }
+
+  let dispatches: array<dispatch> = Automation.mappings->Array.map((
+    module(M: Automation.Mapping),
+  ) => {
+    let decoder = Reventless.DcbDecode.makeDecoder(M.sourceEventSchema)
+    let handle = (json: JSON.t, ctx: Reventless.AutomationSlice.context) => {
+      let (eventType, dataDict) = json->Message.splitMessage
+      switch decoder.decode(~eventType, ~data=dataDict) {
+      | Some(event) =>
+        // Collect — append new items keyed by ID; first writer wins (idempotent).
+        M.collect(event, ctx)->Array.forEach(((id, item)) => {
+          switch todoItems->Dict.get(id) {
+          | Some(_) => () // Already exists — skip
+          | None =>
+            let row: todoRow = {
+              item: item->S.reverseConvertToJsonOrThrow(Spec.todoItemSchema),
+              status: Pending,
+              createdAt: now(),
+              retryCount: 0,
+            }
+            todoItems->Dict.set(id, row)
+          }
+        })
+        // Resolve — mark a pending item as completed.
+        switch M.resolve(event) {
+        | Some(id) =>
+          todoItems
+          ->Dict.get(id)
+          ->Option.forEach(row => {
+            todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
+          })
+        | None => ()
+        }
+      | None => ()
+      }
+    }
+    {sourceName: M.sourceName, handle}
+  })
+
+  let phase1 = (events: array<JSON.t>, ctx: Reventless.AutomationSlice.context) => {
+    events->Array.forEach(json => {
+      let context = json->Message.decode(Reventless.Message.contextSchema)
+      let sourceName = context.meta.service
+      // Events arrive as `{id, meta, event}` envelopes (see Message.composeEventJson').
+      // Per-mapping decoders work on the inner `event` payload (TAG + fields at
+      // the top level), not the wrapper.
+      let eventPayload = switch json->JSON.Decode.object {
+      | Some(dict) => dict->Dict.get("event")->Option.getOr(json)
+      | None => json
+      }
+      // Multiple mappings can share a sourceName; all matching dispatches run.
+      dispatches->Array.forEach(d => {
+        if d.sourceName == sourceName {
+          d.handle(eventPayload, ctx)
+        }
+      })
+    })
+  }
+
+  let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
+    let pending =
+      todoItems
+      ->Dict.toArray
+      ->Array.filter(((_, row)) =>
+        row.status == Pending || (row.status == Failed && row.retryCount < Spec.maxRetries)
+      )
+
+    let commands = []
+
+    pending->Array.forEach(((id, row)) => {
+      let item = try row.item->S.parseJsonOrThrow(Spec.todoItemSchema)->Some catch {
+      | exn =>
+        let errMsg =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`AutomationSlice(${Spec.name})`,
+          `failed to decode todoItem: ${errMsg}`,
+        )->Effect.runSync
+        None
+      }
+
+      item->Option.forEach(item => {
+        switch Automation.process(id, item) {
+        | Some((targetId, command)) =>
+          todoItems->Dict.set(id, {...row, status: Processing, processedAt: now()})
+          let commandJson = try command
+          ->S.reverseConvertToJsonOrThrow(Spec.commandSchema)
+          ->Some catch {
+          | exn =>
+            let errMsg =
+              exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+            EffectLogger.logError(
+              ~comp=`AutomationSlice(${Spec.name})`,
+              `failed to encode command: ${errMsg}`,
+            )->Effect.runSync
+            todoItems->Dict.set(
+              id,
+              {...row, status: Failed, retryCount: row.retryCount + 1},
+            )
+            None
+          }
+          commandJson->Option.forEach(
+            commandJson => {
+              let msg: Reventless.Message.commandJson = {
+                id: targetId,
+                meta: makeMeta(),
+                commandJson,
+              }
+              let _ = commands->Array.push(msg)
+            },
+          )
+        | None => () // Skip — process returned None
+        }
+      })
+    })
+
+    if commands->Array.length > 0 {
+      try await publishJsons(commands) catch {
+      | exn =>
+        let errMsg =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`AutomationSlice(${Spec.name})`,
+          `failed to publish commands: ${errMsg}`,
+        )->Effect.runSync
+        // Mark items as Failed for retry
+        pending->Array.forEach(((id, row)) => {
+          switch todoItems->Dict.get(id) {
+          | Some(current) if current.status == Processing =>
+            todoItems->Dict.set(
+              id,
+              {...row, status: Failed, retryCount: row.retryCount + 1},
+            )
+          | _ => ()
+          }
+        })
+      }
+    }
+  }
+}

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -0,0 +1,189 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+S.enableJson();
+
+let todoStatusSchema = S.union([
+  S.literal("Pending"),
+  S.literal("Processing"),
+  S.literal("Completed"),
+  S.literal("Failed")
+]);
+
+let todoRowSchema = S.schema(s => ({
+  item: s.m(S.json),
+  status: s.m(todoStatusSchema),
+  createdAt: s.m(S.string),
+  processedAt: s.m(S.option(S.string)),
+  completedAt: s.m(S.option(S.string)),
+  retryCount: s.m(S.int)
+}));
+
+function Make(Spec) {
+  return Automation => {
+    let todoItems = {};
+    let makeMeta = () => Message$ReventlessCore.generateMeta(`AutomationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let dispatches = Automation.mappings.map(M => {
+      let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
+      let handle = (json, ctx) => {
+        let match = Message$ReventlessCore.splitMessage(json);
+        let event = decoder.decode(match[0], match[1]);
+        if (event === undefined) {
+          return;
+        }
+        let event$1 = Primitive_option.valFromOption(event);
+        M.collect(event$1, ctx).forEach(param => {
+          let id = param[0];
+          let match = todoItems[id];
+          if (match !== undefined) {
+            return;
+          }
+          let row_item = S.reverseConvertToJsonOrThrow(param[1], Spec.todoItemSchema);
+          let row_createdAt = new Date().toISOString();
+          let row = {
+            item: row_item,
+            status: "Pending",
+            createdAt: row_createdAt,
+            retryCount: 0
+          };
+          todoItems[id] = row;
+        });
+        let id = M.resolve(event$1);
+        if (id !== undefined) {
+          return Stdlib_Option.forEach(todoItems[id], row => {
+            let newrecord = {...row};
+            newrecord.completedAt = new Date().toISOString();
+            newrecord.status = "Completed";
+            todoItems[id] = newrecord;
+          });
+        }
+      };
+      return {
+        sourceName: M.sourceName,
+        handle: handle
+      };
+    });
+    let phase1 = (events, ctx) => {
+      events.forEach(json => {
+        let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
+        let sourceName = context.meta.service;
+        let dict = Stdlib_JSON.Decode.object(json);
+        let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
+        dispatches.forEach(d => {
+          if (d.sourceName === sourceName) {
+            return d.handle(eventPayload, ctx);
+          }
+        });
+      });
+    };
+    let phase2 = async publishJsons => {
+      let pending = Object.entries(todoItems).filter(param => {
+        let row = param[1];
+        if (row.status === "Pending") {
+          return true;
+        } else if (row.status === "Failed") {
+          return row.retryCount < Spec.maxRetries;
+        } else {
+          return false;
+        }
+      });
+      let commands = [];
+      pending.forEach(param => {
+        let row = param[1];
+        let id = param[0];
+        let item;
+        try {
+          item = Primitive_option.some(S.parseJsonOrThrow(row.item, Spec.todoItemSchema));
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to decode todoItem: ` + errMsg));
+          item = undefined;
+        }
+        Stdlib_Option.forEach(item, item => {
+          let match = Automation.process(id, item);
+          if (match === undefined) {
+            return;
+          }
+          let targetId = match[0];
+          let newrecord = {...row};
+          newrecord.processedAt = new Date().toISOString();
+          newrecord.status = "Processing";
+          todoItems[id] = newrecord;
+          let commandJson;
+          try {
+            commandJson = S.reverseConvertToJsonOrThrow(match[1], Spec.commandSchema);
+          } catch (raw_exn) {
+            let exn = Primitive_exceptions.internalToException(raw_exn);
+            let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+            Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to encode command: ` + errMsg));
+            let newrecord$1 = {...row};
+            newrecord$1.retryCount = row.retryCount + 1 | 0;
+            newrecord$1.status = "Failed";
+            todoItems[id] = newrecord$1;
+            commandJson = undefined;
+          }
+          Stdlib_Option.forEach(commandJson, commandJson => {
+            let msg_meta = makeMeta();
+            let msg = {
+              id: targetId,
+              meta: msg_meta,
+              commandJson: commandJson
+            };
+            commands.push(msg);
+          });
+        });
+      });
+      if (commands.length === 0) {
+        return;
+      }
+      try {
+        return await publishJsons(commands);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish commands: ` + errMsg));
+        pending.forEach(param => {
+          let row = param[1];
+          let id = param[0];
+          let current = todoItems[id];
+          if (current === undefined) {
+            return;
+          }
+          if (current.status !== "Processing") {
+            return;
+          }
+          let newrecord = {...row};
+          newrecord.retryCount = row.retryCount + 1 | 0;
+          newrecord.status = "Failed";
+          todoItems[id] = newrecord;
+        });
+        return;
+      }
+    };
+    return {
+      Spec: Spec,
+      todoItems: todoItems,
+      phase1: phase1,
+      phase2: phase2
+    };
+  };
+}
+
+export {
+  todoStatusSchema,
+  todoRowSchema,
+  Make,
+}
+/*  Not a pure module */