@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res

@@ -0,0 +1,181 @@
+// OutboundTranslationSlice builder — creates the TODO list QueryDb, EventCollector,
+// and wires the event handler (Phase 1 + Phase 2) plus exposes translatePending.
+//
+// Follows the AutomationSlice_Builder pattern for adapter injection.
+
+let log = Logger.fromEnv()
+
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  QueryDbResolvers: QueryDb_Adapter.Resolvers
+    with type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+  Api: {
+    let api: unit => QueryDbStorage.api
+    let apiRole: unit => QueryDbStorage.role
+  },
+) => {
+  let finish = EventCollectorRuntimeBuilder.finish
+  module Make = (
+    Spec: Reventless.OutboundTranslationSlice.Spec,
+    Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+  ): OutboundTranslationSlice.T => {
+    module Spec = Spec
+    module Translation = Translation
+    type component = OutboundTranslationSlice.component
+
+    module Callback = OutboundTranslationSlice_Callback.Make(Spec, Translation)
+
+    let queryDbName = Spec.name ++ "Todo"
+
+    // QueryDb for TODO list — stores todoRow keyed by string ID
+    module TodoQueryDbSpec = {
+      module Id = Reventless.Id.String
+      let name = queryDbName
+      let moduleUrl: string = %raw(`import.meta.url`)
+      type state = OutboundTranslationSlice_Callback.todoRow
+      let stateSchema = OutboundTranslationSlice_Callback.todoRowSchema
+      let config = Reventless.ReadModel.config()
+      let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>> = None
+      let authorization: Reventless.Authorization.permission = AllowAuthenticated
+      let visibility: Reventless.Visibility.t = Public
+    }
+
+    module SpecificQueryDb = QueryDb_Builder.Make(TodoQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+    module SpecificEventCollector = EventCollector_Builder.Make(
+      RuntimeEnvironment,
+      EventCollectorChannel,
+    )
+
+    let decoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
+
+    let syncToQueryDb = async (queryDbOps: SpecificQueryDb.operations) => {
+      let items = Callback.todoItems->Dict.toArray
+      let _ = await items->Array.reduce(Promise.resolve(), async (prev, (id, row)) => {
+        let _ = await prev
+        let _ = await queryDbOps.save(
+          id->Reventless.Id.String.makeFromString,
+          row,
+          QueryDb.Overwrite,
+          None,
+        )
+      })
+    }
+
+    let construct = (~dcbEventLog: DcbEventLog.component, ~publishJsons, self, _name) => {
+      let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+
+      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+
+      let dcbEventTopicOutputs: EventTopic.outputs = (dcbEventLog->Component.outputs).eventTopic
+      let allEventTopics = Dict.fromArray([(Spec.name, dcbEventTopicOutputs)])
+
+      // Resolve publishJsons so it's available for Phase 2
+      let publishJsonsRef: ref<option<ReventlessInfra.CommandTopic.publishJsons>> = ref(None)
+      let _ = publishJsons->Pulumi.Output.apply(pj => {
+        publishJsonsRef := Some(pj)
+      })
+
+      let eventCollector =
+        queryDb
+        ->Component.operations
+        ->Pulumi.Output.apply(queryDbOps => {
+          let ec = SpecificEventCollector.make(~name=Spec.name, ~eventTopics=allEventTopics, ~opts)
+
+          let jsonEventsHandler: EventCollector.jsonEventsHandler = stream =>
+            stream
+            ->Stream.mapEffect(json =>
+              Effect.sync(
+                () => {
+                  let (eventType, dataDict) = json->Message.splitMessage
+                  switch decoder.decode(~eventType, ~data=dataDict) {
+                  | Some(event) => [event]
+                  | None => []
+                  }
+                },
+              )
+            )
+            ->Stream.flatMap(events => Stream.fromIterable(events))
+            ->Stream.runCollect
+            ->Effect.flatMap(eventsArr =>
+              Effect.promise(
+                async () => {
+                  // Phase 1: collect outbound items
+                  Callback.phase1(eventsArr)
+                  // Sync the post-phase-1 TODO state so consumers awaiting the
+                  // originating publishEvent observe Pending rows immediately.
+                  await syncToQueryDb(queryDbOps)
+                  // Phase 2 must NOT be awaited here. If a translation publishes
+                  // an inbound command whose downstream events fan back to this
+                  // same topic, awaiting would self-deadlock the bus — same
+                  // shape as AutomationSlice. Detach it; errors are logged.
+                  switch publishJsonsRef.contents {
+                  | Some(pj) =>
+                    let _ =
+                      Callback.phase2(pj)
+                      ->Promise.then(() => syncToQueryDb(queryDbOps))
+                      ->Promise.catch(exn => {
+                        let errMsg =
+                          exn
+                          ->JsExn.fromException
+                          ->Option.flatMap(JsExn.message)
+                          ->Option.getOr("unknown")
+                        EffectLogger.logError(
+                          ~comp=`OutboundTranslationSlice(${Spec.name})`,
+                          `detached phase 2 error: ${errMsg}`,
+                        )->Effect.runSync
+                        Promise.resolve()
+                      })
+                  | None =>
+                    log.error(
+                      ~comp=`OutboundTranslationSlice(${Spec.name})`,
+                      `publishJsons not yet resolved`,
+                    )
+                  }
+                },
+              )
+            )
+
+          let handler = SpecificEventCollector.makeHandler(~eventCollector=ec, ~jsonEventsHandler)
+          let resources = (queryDb->Component.outputs).resources
+          ec->EventCollectorRuntimeBuilder.forEventCollector(
+            ~handler,
+            ~eventTopics=allEventTopics,
+            ~resources,
+          )
+          ec
+        })
+
+      self->Component.setOperations(
+        (eventCollector->Pulumi.Output.flatMap(ec => ec->Component.operations), publishJsons)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((ecOps, publishJsonsFn)) => {
+          let ops: OutboundTranslationSlice.operations = {
+            enqueueEvent: ecOps.enqueueEvent,
+            translatePending: async () => await Callback.phase2(publishJsonsFn),
+          }
+          ops
+        }),
+      )
+
+      let outputs: OutboundTranslationSlice.outputs = {
+        resources: dcbEventTopicOutputs.resources,
+        queryDb: queryDb->Component.outputs,
+      }
+      self->Component.setOutputs(outputs)
+    }
+
+    let make = (~dcbEventLog, ~publishJsons, ~opts=?): OutboundTranslationSlice.component =>
+      Component.make(
+        ~componentType=OutboundTranslationSlice.componentType->ComponentType.toString,
+        ~name=Spec.name,
+        ~construct=construct(~dcbEventLog, ~publishJsons, ...),
+        ~opts,
+      )
+  }
+}

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res.mjs

@@ -0,0 +1,137 @@
+// 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 Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.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 OutboundTranslationSlice$ReventlessCore from "./OutboundTranslationSlice.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "./OutboundTranslationSlice_Callback.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function Make(RuntimeEnvironment) {
+  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
+    let Make = Spec => (Translation => {
+      let Callback = OutboundTranslationSlice_Callback$ReventlessCore.Make(Spec)(Translation);
+      let queryDbName = Spec.name + "Todo";
+      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: OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema,
+        config: config,
+        subIdConfig: undefined,
+        authorization: "AllowAuthenticated",
+        visibility: "Public"
+      })(QueryDbStorage)(QueryDbResolvers);
+      let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+      let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+      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 = (dcbEventLog, publishJsons, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(OutboundTranslationSlice$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);
+        let dcbEventTopicOutputs = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
+        let allEventTopics = Object.fromEntries([[
+            Spec.name,
+            dcbEventTopicOutputs
+          ]]);
+        let publishJsonsRef = {
+          contents: undefined
+        };
+        publishJsons.apply(pj => {
+          publishJsonsRef.contents = pj;
+        });
+        let eventCollector = Component$ReventlessCore.operations(queryDb).apply(queryDbOps => {
+          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, opts);
+          let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
+            let match = Message$ReventlessCore.splitMessage(json);
+            let event = decoder.decode(match[0], match[1]);
+            if (event !== undefined) {
+              return [Primitive_option.valFromOption(event)];
+            } else {
+              return [];
+            }
+          })), events => Stream$1.fromIterable(events))), eventsArr => Effect.promise(async () => {
+            Callback.phase1(eventsArr);
+            await syncToQueryDb(queryDbOps);
+            let pj = publishJsonsRef.contents;
+            if (pj !== undefined) {
+              Stdlib_Promise.$$catch(Callback.phase2(pj).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(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
+                return Promise.resolve();
+              });
+              return;
+            } else {
+              return log.error(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `publishJsons not yet resolved`);
+            }
+          }));
+          let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
+          let resources = Component$ReventlessCore.outputs(queryDb).resources;
+          EventCollectorRuntimeBuilder.forEventCollector(handler, allEventTopics, 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,
+            translatePending: async () => await Callback.phase2(publishJsonsFn)
+          };
+        }));
+        let outputs_resources = dcbEventTopicOutputs.resources;
+        let outputs_queryDb = Component$ReventlessCore.outputs(queryDb);
+        let outputs = {
+          resources: outputs_resources,
+          queryDb: outputs_queryDb
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+      return {
+        Spec: Spec,
+        Translation: Translation,
+        queryDbName: queryDbName,
+        make: make
+      };
+    });
+    return {
+      finish: EventCollectorRuntimeBuilder.finish,
+      Make: Make
+    };
+  }))));
+}
+
+export {
+  log,
+  Make,
+}
+/* log Not a pure module */

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -0,0 +1,173 @@
+S.enableJson()
+// OutboundTranslationSlice callback — implements the tracked external call pattern.
+//
+// Phase 1 (collect): updates the in-memory TODO list from events (no resolve)
+// Phase 2 (translate): calls Translation.translate for each pending item individually
+
+@schema
+type todoStatus =
+  | Pending
+  | Processing
+  | Completed
+  | Failed
+
+@schema
+type todoRow = {
+  item: JSON.t,
+  status: todoStatus,
+  createdAt: string,
+  processedAt?: string,
+  completedAt?: string,
+  retryCount: int,
+  lastError?: string,
+}
+
+module type T = {
+  module Spec: Reventless.OutboundTranslationSlice.Spec
+  module Translation: Reventless.OutboundTranslationSlice.Translation 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 events (collect only, no resolve). */
+  let phase1: array<Spec.consumedEvent> => unit
+
+  /** Phase 2: translate all pending items, optionally publishing commands via publishJsons. */
+  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+}
+
+module Make = (
+  Spec: Reventless.OutboundTranslationSlice.Spec,
+  Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+): (T with module Spec = Spec and module Translation := Translation) => {
+  module Spec = Spec
+  module Translation = Translation
+
+  let todoItems: Dict.t<todoRow> = Dict.make()
+
+  let now = () => Date.make()->Date.toISOString
+
+  // Root meta for messages emitted by this OutboundTranslationSlice. Source-event
+  // meta is not threaded from phase1 → phase2 today, so causation across the
+  // translation hop is not preserved. If sources later carry meta into todoItems,
+  // switch to Message.deriveMeta.
+  let makeMeta = (): Reventless.Message.meta =>
+    Message.generateMeta(~service=`OutboundTranslationSlice:${Spec.name}`)
+
+  let phase1 = (events: array<Spec.consumedEvent>) => {
+    events->Array.forEach(event => {
+      // Collect new outbound items
+      Translation.collect(event)->Array.forEach(((id, item)) => {
+        switch todoItems->Dict.get(id) {
+        | Some(_) => () // Already exists -- skip (idempotent)
+        | None =>
+          let row: todoRow = {
+            item: item->S.reverseConvertToJsonOrThrow(Spec.outboundItemSchema),
+            status: Pending,
+            createdAt: now(),
+            retryCount: 0,
+          }
+          todoItems->Dict.set(id, row)
+        }
+      })
+    })
+  }
+
+  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)
+      )
+
+    // Process each item individually -- each translate call is independent
+    let _ = await pending->Array.reduce(Promise.resolve(), async (prev, (id, row)) => {
+      let _ = await prev
+
+      let item = try row.item->S.parseJsonOrThrow(Spec.outboundItemSchema)->Some catch {
+      | exn =>
+        let errMsg =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`OutboundTranslationSlice(${Spec.name})`,
+          `failed to decode outboundItem: ${errMsg}`,
+        )->Effect.runSync
+        None
+      }
+
+      switch item {
+      | None => ()
+      | Some(item) =>
+        todoItems->Dict.set(id, {...row, status: Processing, processedAt: now()})
+
+        let result = try await Translation.translate(id, item) catch {
+        | exn =>
+          let msg =
+            exn
+            ->JsExn.fromException
+            ->Option.flatMap(JsExn.message)
+            ->Option.getOr("unknown error")
+          Error(msg)
+        }
+
+        switch result {
+        | Ok(Some((targetId, cmd))) =>
+          // Encode command and publish
+          let commandJson = try cmd
+          ->S.reverseConvertToJsonOrThrow(Spec.inboundCommandSchema)
+          ->Some catch {
+          | exn =>
+            let errMsg =
+              exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+            EffectLogger.logError(
+              ~comp=`OutboundTranslationSlice(${Spec.name})`,
+              `failed to encode inbound command: ${errMsg}`,
+            )->Effect.runSync
+            None
+          }
+
+          switch commandJson {
+          | Some(commandJson) =>
+            try {
+              let msg: Reventless.Message.commandJson = {
+                id: targetId,
+                meta: makeMeta(),
+                commandJson,
+              }
+              await publishJsons([msg])
+              todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
+            } catch {
+            | exn =>
+              let errMsg =
+                exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+              EffectLogger.logError(
+                ~comp=`OutboundTranslationSlice(${Spec.name})`,
+                `failed to publish command: ${errMsg}`,
+              )->Effect.runSync
+              todoItems->Dict.set(
+                id,
+                {...row, status: Failed, retryCount: row.retryCount + 1},
+              )
+            }
+          | None =>
+            todoItems->Dict.set(
+              id,
+              {...row, status: Failed, retryCount: row.retryCount + 1},
+            )
+          }
+
+        | Ok(None) =>
+          // Fire-and-forget: no command to publish
+          todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
+
+        | Error(msg) =>
+          todoItems->Dict.set(
+            id,
+            {...row, status: Failed, retryCount: row.retryCount + 1, lastError: msg},
+          )
+        }
+      }
+    })
+  }
+}

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -0,0 +1,173 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.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 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 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),
+  lastError: s.m(S.option(S.string))
+}));
+
+function Make(Spec) {
+  return Translation => {
+    let todoItems = {};
+    let makeMeta = () => Message$ReventlessCore.generateMeta(`OutboundTranslationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let phase1 = events => {
+      events.forEach(event => {
+        Translation.collect(event).forEach(param => {
+          let id = param[0];
+          let match = todoItems[id];
+          if (match !== undefined) {
+            return;
+          }
+          let row_item = S.reverseConvertToJsonOrThrow(param[1], Spec.outboundItemSchema);
+          let row_createdAt = new Date().toISOString();
+          let row = {
+            item: row_item,
+            status: "Pending",
+            createdAt: row_createdAt,
+            retryCount: 0
+          };
+          todoItems[id] = row;
+        });
+      });
+    };
+    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;
+        }
+      });
+      await Stdlib_Array.reduce(pending, Promise.resolve(), async (prev, param) => {
+        let row = param[1];
+        let id = param[0];
+        await prev;
+        let item;
+        try {
+          item = Primitive_option.some(S.parseJsonOrThrow(row.item, Spec.outboundItemSchema));
+        } 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(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to decode outboundItem: ` + errMsg));
+          item = undefined;
+        }
+        if (item === undefined) {
+          return;
+        }
+        let newrecord = {...row};
+        newrecord.processedAt = new Date().toISOString();
+        newrecord.status = "Processing";
+        todoItems[id] = newrecord;
+        let result;
+        try {
+          result = await Translation.translate(id, Primitive_option.valFromOption(item));
+        } catch (raw_exn$1) {
+          let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+          let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown error");
+          result = {
+            TAG: "Error",
+            _0: msg
+          };
+        }
+        if (result.TAG === "Ok") {
+          let match = result._0;
+          if (match !== undefined) {
+            let commandJson;
+            try {
+              commandJson = S.reverseConvertToJsonOrThrow(match[1], Spec.inboundCommandSchema);
+            } catch (raw_exn$2) {
+              let exn$2 = Primitive_exceptions.internalToException(raw_exn$2);
+              let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$2), Stdlib_JsExn.message), "unknown");
+              Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to encode inbound command: ` + errMsg$1));
+              commandJson = undefined;
+            }
+            if (commandJson !== undefined) {
+              try {
+                let msg_id = match[0];
+                let msg_meta = makeMeta();
+                let msg$1 = {
+                  id: msg_id,
+                  meta: msg_meta,
+                  commandJson: commandJson
+                };
+                await publishJsons([msg$1]);
+                let newrecord$1 = {...row};
+                newrecord$1.completedAt = new Date().toISOString();
+                newrecord$1.status = "Completed";
+                todoItems[id] = newrecord$1;
+                return;
+              } catch (raw_exn$3) {
+                let exn$3 = Primitive_exceptions.internalToException(raw_exn$3);
+                let errMsg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$3), Stdlib_JsExn.message), "unknown");
+                Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to publish command: ` + errMsg$2));
+                let newrecord$2 = {...row};
+                newrecord$2.retryCount = row.retryCount + 1 | 0;
+                newrecord$2.status = "Failed";
+                todoItems[id] = newrecord$2;
+                return;
+              }
+            } else {
+              let newrecord$3 = {...row};
+              newrecord$3.retryCount = row.retryCount + 1 | 0;
+              newrecord$3.status = "Failed";
+              todoItems[id] = newrecord$3;
+              return;
+            }
+          } else {
+            let newrecord$4 = {...row};
+            newrecord$4.completedAt = new Date().toISOString();
+            newrecord$4.status = "Completed";
+            todoItems[id] = newrecord$4;
+            return;
+          }
+        } else {
+          let newrecord$5 = {...row};
+          newrecord$5.lastError = result._0;
+          newrecord$5.retryCount = row.retryCount + 1 | 0;
+          newrecord$5.status = "Failed";
+          todoItems[id] = newrecord$5;
+          return;
+        }
+      });
+    };
+    return {
+      Spec: Spec,
+      todoItems: todoItems,
+      phase1: phase1,
+      phase2: phase2
+    };
+  };
+}
+
+export {
+  todoStatusSchema,
+  todoRowSchema,
+  Make,
+}
+/*  Not a pure module */