@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res

@@ -0,0 +1,98 @@
+// InboundTranslationSlice builder — creates the audit log QueryDb and wires
+// the receive function that translates external input into domain commands.
+//
+// Simpler than OutboundTranslationSlice — no EventCollector needed.
+// Triggered externally via operations.receive rather than by event subscription.
+
+module Make = (
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  QueryDbResolvers: QueryDb_Adapter.Resolvers
+    with type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role,
+  Api: {
+    let api: unit => QueryDbStorage.api
+    let apiRole: unit => QueryDbStorage.role
+  },
+) => {
+  module Make = (
+    Spec: Reventless.InboundTranslationSlice.Spec,
+    Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+  ): InboundTranslationSlice.T => {
+    module Spec = Spec
+    module Translation = Translation
+    type component = InboundTranslationSlice.component
+
+    module Callback = InboundTranslationSlice_Callback.Make(Spec, Translation)
+
+    let queryDbName = Spec.name ++ "Audit"
+
+    // QueryDb for audit log — stores auditRow keyed by request ID
+    module AuditQueryDbSpec = {
+      module Id = Reventless.Id.String
+      let name = queryDbName
+      let moduleUrl: string = %raw(`import.meta.url`)
+      type state = InboundTranslationSlice_Callback.auditRow
+      let stateSchema = InboundTranslationSlice_Callback.auditRowSchema
+      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(AuditQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+
+    let syncToQueryDb = async (queryDbOps: SpecificQueryDb.operations) => {
+      let items = Callback.auditLog->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 = (~publishJsons, self, _name) => {
+      let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+
+      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+
+      // Resolve publishJsons so it's available for receive
+      let publishJsonsRef: ref<option<ReventlessInfra.CommandTopic.publishJsons>> = ref(None)
+      let _ = publishJsons->Pulumi.Output.apply(pj => {
+        publishJsonsRef := Some(pj)
+      })
+
+      self->Component.setOperations(
+        (queryDb->Component.operations, publishJsons)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn)) => {
+          let ops: InboundTranslationSlice.operations = {
+            receive: async inputJson => {
+              let result = await Callback.receive(publishJsonsFn, inputJson)
+              await syncToQueryDb(queryDbOps)
+              result
+            },
+          }
+          ops
+        }),
+      )
+
+      let outputs: InboundTranslationSlice.outputs = {
+        resources: [],
+        queryDb: queryDb->Component.outputs,
+      }
+      self->Component.setOutputs(outputs)
+    }
+
+    let make = (~publishJsons, ~opts=?): InboundTranslationSlice.component =>
+      Component.make(
+        ~componentType=InboundTranslationSlice.componentType->ComponentType.toString,
+        ~name=Spec.name,
+        ~construct=construct(~publishJsons, ...),
+        ~opts,
+      )
+  }
+}

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res.mjs

@@ -0,0 +1,87 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
+import * as InboundTranslationSlice$ReventlessCore from "./InboundTranslationSlice.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "./InboundTranslationSlice_Callback.res.mjs";
+
+function Make(QueryDbStorage) {
+  return QueryDbResolvers => (Api => {
+    let Make = Spec => (Translation => {
+      let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make(Spec)(Translation);
+      let queryDbName = Spec.name + "Audit";
+      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: InboundTranslationSlice_Callback$ReventlessCore.auditRowSchema,
+        config: config,
+        subIdConfig: undefined,
+        authorization: "AllowAuthenticated",
+        visibility: "Public"
+      })(QueryDbStorage)(QueryDbResolvers);
+      let syncToQueryDb = async queryDbOps => {
+        let items = Object.entries(Callback.auditLog);
+        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 = (publishJsons, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(InboundTranslationSlice$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 publishJsonsRef = {
+          contents: undefined
+        };
+        publishJsons.apply(pj => {
+          publishJsonsRef.contents = pj;
+        });
+        Component$ReventlessCore.setOperations(extra, Pulumi.all([
+          Component$ReventlessCore.operations(queryDb),
+          publishJsons
+        ]).apply(param => {
+          let publishJsonsFn = param[1];
+          let queryDbOps = param[0];
+          return {
+            receive: async inputJson => {
+              let result = await Callback.receive(publishJsonsFn, inputJson);
+              await syncToQueryDb(queryDbOps);
+              return result;
+            }
+          };
+        }));
+        let outputs_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 {
+      Make: Make
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Id-Reventless Not a pure module */

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res

@@ -0,0 +1,191 @@
+S.enableJson()
+// InboundTranslationSlice callback — receives external input and translates to commands.
+//
+// Maintains an audit log QueryDb and delegates translation to Translation.translate.
+
+@schema
+type auditStatus =
+  | Success
+  | Failure
+
+@schema
+type auditRow = {
+  input: string,
+  status: auditStatus,
+  targetIds?: array<string>,
+  commandCount?: int,
+  error?: string,
+  receivedAt: string,
+}
+
+module type T = {
+  module Spec: Reventless.InboundTranslationSlice.Spec
+  module Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec
+
+  /** The audit log -- maps request ID to audit row. */
+  let auditLog: Dict.t<auditRow>
+
+  /** Receive external input, translate it, and publish commands. */
+  let receive: (
+    ReventlessInfra.CommandTopic.publishJsons,
+    JSON.t,
+  ) => promise<result<array<string>, string>>
+}
+
+module Make = (
+  Spec: Reventless.InboundTranslationSlice.Spec,
+  Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+): (T with module Spec = Spec and module Translation := Translation) => {
+  module Spec = Spec
+  module Translation = Translation
+
+  let auditLog: Dict.t<auditRow> = Dict.make()
+
+  let now = () => Date.make()->Date.toISOString
+
+  // InboundTranslationSlice ingests external (non-Reventless) messages — there's
+  // no upstream Reventless meta to derive from, so emitted commands are roots
+  // of a fresh correlation chain. `traceparent` populated from an inbound HTTP
+  // header would need to be threaded in here by the API/ingress adapter.
+  let makeMeta = (): Reventless.Message.meta =>
+    Message.generateMeta(~service=`InboundTranslationSlice:${Spec.name}`)
+
+  let receive = async (
+    publishJsons: ReventlessInfra.CommandTopic.publishJsons,
+    inputJson: JSON.t,
+  ) => {
+    let requestId = Uuid.v4()
+
+    // Parse the external input
+    let input = try inputJson->S.parseOrThrow(Spec.externalInputSchema)->Ok catch {
+    | exn =>
+      let msg =
+        exn
+        ->JsExn.fromException
+        ->Option.flatMap(JsExn.message)
+        ->Option.getOr("invalid input")
+      Error(msg)
+    }
+
+    switch input {
+    | Error(msg) =>
+      auditLog->Dict.set(
+        requestId,
+        {
+          input: inputJson->JSON.stringify,
+          status: Failure,
+          error: msg,
+          receivedAt: now(),
+        },
+      )
+      Error(msg)
+
+    | Ok(input) =>
+      switch Translation.translate(input) {
+      | Ok(pairs) =>
+        if pairs->Array.length === 0 {
+          auditLog->Dict.set(
+            requestId,
+            {
+              input: inputJson->JSON.stringify,
+              status: Success,
+              targetIds: [],
+              commandCount: 0,
+              receivedAt: now(),
+            },
+          )
+          Ok([])
+        } else {
+          // Encode all commands; abort on first encoding failure
+          let msgs = ref([])
+          let encodeError = ref(None)
+          pairs->Array.forEach(pair => {
+            let (targetId, cmd) = pair
+            if encodeError.contents->Option.isNone {
+              try {
+                let commandJson = cmd->JSON.stringifyAny->Option.getOrThrow->JSON.parseOrThrow
+                let msg: Reventless.Message.commandJson = {
+                  id: targetId,
+                  meta: makeMeta(),
+                  commandJson,
+                }
+                msgs.contents = msgs.contents->Array.concat([msg])
+              } catch {
+              | exn =>
+                let errMsg =
+                  exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+                EffectLogger.logError(
+                  ~comp=`InboundTranslationSlice(${Spec.name})`,
+                  `failed to encode command: ${errMsg}`,
+                )->Effect.runSync
+                encodeError := Some("failed to encode command")
+              }
+            }
+          })
+
+          switch encodeError.contents {
+          | Some(msg) =>
+            auditLog->Dict.set(
+              requestId,
+              {
+                input: inputJson->JSON.stringify,
+                status: Failure,
+                error: msg,
+                receivedAt: now(),
+              },
+            )
+            Error(msg)
+          | None =>
+            try {
+              await publishJsons(msgs.contents)
+              let targetIds = pairs->Array.map(pair => {
+                let (targetId, _) = pair
+                targetId
+              })
+              auditLog->Dict.set(
+                requestId,
+                {
+                  input: inputJson->JSON.stringify,
+                  status: Success,
+                  targetIds,
+                  commandCount: pairs->Array.length,
+                  receivedAt: now(),
+                },
+              )
+              Ok(targetIds)
+            } catch {
+            | exn =>
+              let msg =
+                exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("publish failed")
+              auditLog->Dict.set(
+                requestId,
+                {
+                  input: inputJson->JSON.stringify,
+                  status: Failure,
+                  error: msg,
+                  receivedAt: now(),
+                },
+              )
+              Error(msg)
+            }
+          }
+        }
+
+      | Error(msg) =>
+        auditLog->Dict.set(
+          requestId,
+          {
+            input: inputJson->JSON.stringify,
+            status: Failure,
+            error: msg,
+            receivedAt: now(),
+          },
+        )
+        Error(msg)
+      }
+    }
+  }
+}

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs

@@ -0,0 +1,175 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Uuid from "uuid";
+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_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 auditStatusSchema = S.union([
+  S.literal("Success"),
+  S.literal("Failure")
+]);
+
+let auditRowSchema = S.schema(s => ({
+  input: s.m(S.string),
+  status: s.m(auditStatusSchema),
+  targetIds: s.m(S.option(S.array(S.string))),
+  commandCount: s.m(S.option(S.int)),
+  error: s.m(S.option(S.string)),
+  receivedAt: s.m(S.string)
+}));
+
+function Make(Spec) {
+  return Translation => {
+    let auditLog = {};
+    let makeMeta = () => Message$ReventlessCore.generateMeta(`InboundTranslationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let receive = async (publishJsons, inputJson) => {
+      let requestId = Uuid.v4();
+      let input;
+      try {
+        input = {
+          TAG: "Ok",
+          _0: S.parseOrThrow(inputJson, Spec.externalInputSchema)
+        };
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "invalid input");
+        input = {
+          TAG: "Error",
+          _0: msg
+        };
+      }
+      if (input.TAG === "Ok") {
+        let pairs = Translation.translate(input._0);
+        if (pairs.TAG === "Ok") {
+          let pairs$1 = pairs._0;
+          if (pairs$1.length === 0) {
+            auditLog[requestId] = {
+              input: JSON.stringify(inputJson),
+              status: "Success",
+              targetIds: [],
+              commandCount: 0,
+              receivedAt: new Date().toISOString()
+            };
+            return {
+              TAG: "Ok",
+              _0: []
+            };
+          }
+          let msgs = {
+            contents: []
+          };
+          let encodeError = {
+            contents: undefined
+          };
+          pairs$1.forEach(pair => {
+            if (!Stdlib_Option.isNone(encodeError.contents)) {
+              return;
+            }
+            try {
+              let commandJson = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(pair[1]), undefined));
+              let msg_id = pair[0];
+              let msg_meta = makeMeta();
+              let msg = {
+                id: msg_id,
+                meta: msg_meta,
+                commandJson: commandJson
+              };
+              msgs.contents = msgs.contents.concat([msg]);
+              return;
+            } 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(`InboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to encode command: ` + errMsg));
+              encodeError.contents = "failed to encode command";
+              return;
+            }
+          });
+          let msg$1 = encodeError.contents;
+          if (msg$1 !== undefined) {
+            auditLog[requestId] = {
+              input: JSON.stringify(inputJson),
+              status: "Failure",
+              error: msg$1,
+              receivedAt: new Date().toISOString()
+            };
+            return {
+              TAG: "Error",
+              _0: msg$1
+            };
+          }
+          try {
+            await publishJsons(msgs.contents);
+            let targetIds = pairs$1.map(pair => pair[0]);
+            auditLog[requestId] = {
+              input: JSON.stringify(inputJson),
+              status: "Success",
+              targetIds: targetIds,
+              commandCount: pairs$1.length,
+              receivedAt: new Date().toISOString()
+            };
+            return {
+              TAG: "Ok",
+              _0: targetIds
+            };
+          } catch (raw_exn$1) {
+            let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+            let msg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "publish failed");
+            auditLog[requestId] = {
+              input: JSON.stringify(inputJson),
+              status: "Failure",
+              error: msg$2,
+              receivedAt: new Date().toISOString()
+            };
+            return {
+              TAG: "Error",
+              _0: msg$2
+            };
+          }
+        } else {
+          let msg$3 = pairs._0;
+          auditLog[requestId] = {
+            input: JSON.stringify(inputJson),
+            status: "Failure",
+            error: msg$3,
+            receivedAt: new Date().toISOString()
+          };
+          return {
+            TAG: "Error",
+            _0: msg$3
+          };
+        }
+      } else {
+        let msg$4 = input._0;
+        auditLog[requestId] = {
+          input: JSON.stringify(inputJson),
+          status: "Failure",
+          error: msg$4,
+          receivedAt: new Date().toISOString()
+        };
+        return {
+          TAG: "Error",
+          _0: msg$4
+        };
+      }
+    };
+    return {
+      Spec: Spec,
+      auditLog: auditLog,
+      receive: receive
+    };
+  };
+}
+
+export {
+  auditStatusSchema,
+  auditRowSchema,
+  Make,
+}
+/*  Not a pure module */

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice.res

@@ -0,0 +1,35 @@
+let componentType = ComponentType.OutboundTranslationSlice
+
+type t = ReventlessInfra.OutboundTranslationSlice.t
+type outputs = ReventlessInfra.OutboundTranslationSlice.outputs
+type operations = ReventlessInfra.OutboundTranslationSlice.operations
+type component = Component.t<t, outputs, operations>
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.OutboundTranslationSlice.resolvedOutputs> =>
+  (
+    outputs.resources->Adapter.resourcesToInterop,
+    outputs.queryDb.resources->Adapter.resourcesToInterop,
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((resources, queryDbResources)) => {
+    let resolved: ReventlessInterop.OutboundTranslationSlice.resolvedOutputs = {
+      resources: resources,
+      queryDb: {resources: queryDbResources},
+    }
+    resolved
+  })
+
+module type T = {
+  module Spec: Reventless.OutboundTranslationSlice.Spec
+  module Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

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

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Pulumi.all([
+    Adapter$ReventlessCore.resourcesToInterop(outputs.resources),
+    Adapter$ReventlessCore.resourcesToInterop(outputs.queryDb.resources)
+  ]).apply(param => ({
+    resources: param[0],
+    queryDb: {
+      resources: param[1]
+    }
+  }));
+}
+
+let componentType = "OutboundTranslationSlice";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */