@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/CommandTopic/CommandTopic_Builder.res

@@ -0,0 +1,146 @@
+module Make = (Spec: ReventlessInfra.CommandTopic.T, Channel: CommandTopic_Adapter.Channel): (
+  CommandTopic.T with module Spec = Spec and type callbackEvent = Channel.callbackEvent
+) => {
+  module Spec = Spec
+  type callbackEvent = Channel.callbackEvent
+
+  type commandsHandler = CommandTopic.commandsHandler<Message.command'<Spec.Id.t, Spec.command>>
+
+  type publish = CommandTopic.publish<Spec.Id.t, Spec.command>
+
+  type operations = {
+    publish: publish,
+    publishJsons: CommandTopic.publishJsons,
+    publishJsonsStream: CommandTopic.publishJsonsStream,
+    publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>,
+  }
+  type component = Component.t<CommandTopic.t, CommandTopic.outputs, operations>
+
+  // Helper to extract type name from JSON command using TAG field.
+  // Handles both direct command JSON (TAG at top level) and full message
+  // body from publishJsons (TAG nested inside "command" field).
+  let extractTypeNameFromJson = json => {
+    switch json {
+    | JSON.Object(dict) =>
+      switch dict->Dict.get("TAG") {
+      | Some(JSON.String(tag)) => tag
+      | _ =>
+        // TAG is nested inside "command" when message comes via publishJsons → bus
+        switch dict->Dict.get("command") {
+        | Some(JSON.Object(cmdDict)) =>
+          switch cmdDict->Dict.get("TAG") {
+          | Some(JSON.String(tag)) => tag
+          | _ => ""
+          }
+        | _ => ""
+        }
+      }
+    | _ => ""
+    }
+  }
+
+  // Filtering handler that routes commands to registered handlers via global registry.
+  // Defined at module level so it can be referenced by makeFilteringHandler.
+  let filteringHandler: CommandTopic.jsonCommandsHandler = stream =>
+    stream
+    ->Stream.mapEffect(item => {
+      let {ReventlessInfra.CommandTopic.reference: reference, command: json} = item
+      let typeName = extractTypeNameFromJson(json)
+      let handlers = CommandTopic.getHandlers(typeName)
+      Effect.promise(async () => {
+        let allResults: array<result<string, string>> = []
+        let _ =
+          await handlers
+          ->Array.map(async handlerEntry => {
+            let {CommandTopic.handler: handler} = handlerEntry
+            try {
+              let results =
+                await handler(
+                  Stream.fromIterable([{ReventlessInfra.CommandTopic.reference, command: json}]),
+                )->Effect.runPromise
+              allResults->Array.pushMany(results)
+            } catch {
+            | _ => () // Skip if handler fails
+            }
+          })
+          ->Promise.all
+        allResults
+      })
+    })
+    ->Stream.runCollect
+    ->Effect.map(Array.flat)
+
+  let construct = (self, name) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let name = name->ComponentType.name(CommandTopic.componentType)
+
+    let channel = Channel.make(~name, ~opts)
+    self->CommandTopic_Adapter.setChannel(channel)
+
+    self->Component.setOperations(
+      (channel.publishJsons, channel.publishJsonsStream, channel.publishJsonsAndWait)
+      ->Pulumi.Output.all3
+      ->Pulumi.Output.apply(((publishJsons, publishJsonsStream, publishJsonsAndWait)) => {
+        module Ops = {
+          let publishJsons = publishJsons
+        }
+        module Operations = CommandTopic_Operations.Make(Spec, Ops)
+
+        {
+          publish: Operations.publish,
+          publishJsons: Operations.publishJsons,
+          publishJsonsStream: publishJsonsStream,
+          publishJsonsAndWait,
+        }
+      }),
+    )
+
+    let outputs: CommandTopic.outputs = {
+      resources: channel.resources,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let connect = (~runtime, ~resources, commandTopic) => {
+    let commandTopicResource = commandTopic->Component.toPulumiResource
+    let name =
+      commandTopicResource.name
+      ->Option.getOr("Unnamed")
+      ->ComponentType.name(CommandTopic.componentType)
+    let opts = {Pulumi.ComponentResource.parent: commandTopicResource}
+    let channel = commandTopic->CommandTopic_Adapter.channel
+
+    let _connectResources = channel.connect(~name, ~channel, ~runtime, ~resources, ~opts)
+  }
+
+  let registerHandler = (~commandTopic as _, ~schema, ~handler, ~typeNames) => {
+    // Delegate to global registry
+    CommandTopic.registerHandler(~schema, ~handler, ~typeNames)
+  }
+
+  let makeHandler = (~commandTopic, ~commandsHandler: commandsHandler) => {
+    let channel = commandTopic->CommandTopic_Adapter.channel
+    module CallbackOps = {
+      module Spec = Spec
+      let commandsHandler = commandsHandler
+    }
+    module Callback = CommandTopic_Callback.Make(Spec, CallbackOps)
+
+    channel.handleChannelEvent(Callback.handleJsonCommands)
+  }
+
+  // Returns the filtering handler output for runtime connection.
+  // This is the entry point for the shared DCB command topic Lambda.
+  let makeFilteringHandler = commandTopic => {
+    let channel = commandTopic->CommandTopic_Adapter.channel
+    channel.handleChannelEvent(filteringHandler)
+  }
+
+  let make = (~name, ~opts=?): component =>
+    Component.make(
+      ~componentType=CommandTopic.componentType->ComponentType.toString,
+      ~name,
+      ~construct,
+      ~opts,
+    )
+}

package/src/components/CommandTopic/CommandTopic_Builder.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.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 Component$ReventlessCore from "../Component.res.mjs";
+import * as CommandTopic$ReventlessCore from "./CommandTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as CommandTopic_Callback$ReventlessCore from "./CommandTopic_Callback.res.mjs";
+import * as CommandTopic_Operations$ReventlessCore from "./CommandTopic_Operations.res.mjs";
+
+function Make(Spec) {
+  return Channel => {
+    let extractTypeNameFromJson = json => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return "";
+      }
+      let match = json["TAG"];
+      if (typeof match === "string") {
+        return match;
+      }
+      let match$1 = json["command"];
+      if (match$1 === undefined) {
+        return "";
+      }
+      if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+        return "";
+      }
+      let match$2 = match$1["TAG"];
+      if (typeof match$2 === "string") {
+        return match$2;
+      } else {
+        return "";
+      }
+    };
+    let filteringHandler = stream => Effect.map(Stream.runCollect(Stream$1.mapEffect(stream, item => {
+      let reference = item.reference;
+      let json = item.command;
+      let typeName = extractTypeNameFromJson(json);
+      let handlers = CommandTopic$ReventlessCore.getHandlers(typeName);
+      return Effect.promise(async () => {
+        let allResults = [];
+        await Promise.all(handlers.map(async handlerEntry => {
+          try {
+            let results = await Effect.runPromise(handlerEntry.handler(Stream$1.fromIterable([{
+                command: json,
+                reference: reference
+              }])));
+            allResults.push(...results);
+            return;
+          } catch (exn) {
+            return;
+          }
+        }));
+        return allResults;
+      });
+    })), prim => prim.flat());
+    let construct = (self, name) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(self);
+      let opts = {
+        parent: opts_parent
+      };
+      let name$1 = ComponentType$ReventlessCore.name(name, CommandTopic$ReventlessCore.componentType);
+      let channel = Channel.make(name$1, opts);
+      self.channel = channel;
+      Component$ReventlessCore.setOperations(self, Pulumi.all([
+        channel.publishJsons,
+        channel.publishJsonsStream,
+        channel.publishJsonsAndWait
+      ]).apply(param => {
+        let Ops = {
+          publishJsons: param[0]
+        };
+        let Operations = CommandTopic_Operations$ReventlessCore.Make(Spec)(Ops);
+        return {
+          publish: Operations.publish,
+          publishJsons: Operations.publishJsons,
+          publishJsonsStream: param[1],
+          publishJsonsAndWait: param[2]
+        };
+      }));
+      let outputs = {
+        resources: channel.resources
+      };
+      return Component$ReventlessCore.setOutputs(self, outputs);
+    };
+    let connect = (runtime, resources, commandTopic) => {
+      let commandTopicResource = Component$ReventlessCore.toPulumiResource(commandTopic);
+      let name = ComponentType$ReventlessCore.name(Stdlib_Option.getOr(commandTopicResource.__name, "Unnamed"), CommandTopic$ReventlessCore.componentType);
+      let opts_parent = commandTopicResource;
+      let opts = {
+        parent: opts_parent
+      };
+      let channel = commandTopic.channel;
+      channel.connect(name, channel, runtime, resources, opts);
+    };
+    let registerHandler = (param, schema, handler, typeNames) => CommandTopic$ReventlessCore.registerHandler(schema, handler, typeNames);
+    let makeHandler = (commandTopic, commandsHandler) => {
+      let channel = commandTopic.channel;
+      let Callback = CommandTopic_Callback$ReventlessCore.Make(Spec)({
+        Spec: Spec,
+        commandsHandler: commandsHandler
+      });
+      return channel.handleChannelEvent(Callback.handleJsonCommands);
+    };
+    let makeFilteringHandler = commandTopic => {
+      let channel = commandTopic.channel;
+      return channel.handleChannelEvent(filteringHandler);
+    };
+    let make = (name, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(CommandTopic$ReventlessCore.componentType), name, construct, opts);
+    return {
+      Spec: Spec,
+      connect: connect,
+      registerHandler: registerHandler,
+      makeHandler: makeHandler,
+      makeFilteringHandler: makeFilteringHandler,
+      make: make
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/components/CommandTopic/CommandTopic_Callback.res

@@ -0,0 +1,38 @@
+module type Ops = {
+  module Spec: ReventlessInfra.CommandTopic.T
+  let commandsHandler: CommandTopic.commandsHandler<Message.command'<Spec.Id.t, Spec.command>>
+}
+
+module type T = {
+  let handleJsonCommands: CommandTopic.jsonCommandsHandler
+}
+
+module Make = (Spec: ReventlessInfra.CommandTopic.T, Ops: Ops with module Spec = Spec): T => {
+  let comp = `CommandTopic(${Spec.name})`
+
+  let handleJsonCommands: CommandTopic.jsonCommandsHandler = stream =>
+    stream
+    ->Stream.mapEffect(({ReventlessInfra.CommandTopic.reference: reference, command: json}) =>
+      Effect.sync(() =>
+        switch json->Message.decodeCommand'(Spec.Id.schema, Spec.commandSchema) {
+        | command' => Some({ReventlessInfra.CommandTopic.reference, command: command'})
+        | exception err =>
+          let commandStr = json->JSON.stringify
+          let errMsg =
+            err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+          EffectLogger.logError(
+            ~comp,
+            `decode failed: ${commandStr} err=${errMsg}`,
+          )->Effect.runSync
+          None
+        }
+      )
+    )
+    ->Stream.flatMap(opt =>
+      switch opt {
+      | Some(v) => Stream.fromIterable([v])
+      | None => Stream.empty
+      }
+    )
+    ->Ops.commandsHandler
+}

package/src/components/CommandTopic/CommandTopic_Callback.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Stream from "effect/Stream";
+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";
+
+function Make(Spec) {
+  return Ops => {
+    let comp = `CommandTopic(` + Spec.name + `)`;
+    let handleJsonCommands = stream => Ops.commandsHandler(Stream.flatMap(Stream.mapEffect(stream, param => {
+      let reference = param.reference;
+      let json = param.command;
+      return Effect.sync(() => {
+        let command$p;
+        try {
+          command$p = Message$ReventlessCore.decodeCommand$p(json, Spec.Id.schema, Spec.commandSchema);
+        } catch (raw_err) {
+          let err = Primitive_exceptions.internalToException(raw_err);
+          let commandStr = JSON.stringify(json);
+          let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+          Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, `decode failed: ` + commandStr + ` err=` + errMsg));
+          return;
+        }
+        return {
+          command: command$p,
+          reference: reference
+        };
+      });
+    }), opt => {
+      if (opt !== undefined) {
+        return Stream.fromIterable([opt]);
+      } else {
+        return Stream.empty;
+      }
+    }));
+    return {
+      handleJsonCommands: handleJsonCommands
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/components/CommandTopic/CommandTopic_Helpers.res

@@ -0,0 +1,176 @@
+// Re-export from spec so ReventlessCore.CommandTopic.topicItem === ReventlessInfra.CommandTopic.topicItem
+type topicItem<'command> = ReventlessInfra.CommandTopic.topicItem<'command>
+
+type jsonCommandsHandler = ReventlessInfra.CommandTopic.commandsHandler<JSON.t>
+
+/**
+Carries entity identity and event count from a successful synchronous command dispatch.
+Populated by `StateChangeSlice_Callback.handleSingleCommand` and `Aggregate_Callback.replayProcessAppend`
+during inline `publishJsonsAndWait` execution and read by `runInlineAndCollect` to build
+`CommandTopic.Accepted` outcomes.
+*/
+type acceptedResult = {entityId?: string, eventCount: int}
+
+/**
+Carries an encoded domain rejection from `Behavior.decide` back to a synchronous producer.
+`errorCode` is the variant tag of `Spec.errorSchema` (e.g. `"AlreadyExists"`); `errorDetail`
+is the JSON-stringified error payload (or empty string for payload-less variants).
+*/
+type rejectedResult = {errorCode: string, errorDetail: string}
+
+// Side-channel for publishJsonsAndWait result propagation.
+// Set by runInlineAndCollect before invoking the handler; cleared after.
+// Callback implementations call reportAccepted during inline dispatch.
+let acceptedResultChannel: ref<option<(string, acceptedResult) => unit>> = ref(None)
+
+// Sibling side-channel for domain rejections — populated by callbacks when
+// `Behavior.decide` returns `Error`. Read by runInlineAndCollect to build
+// `Rejected` outcomes that carry the real error code and detail.
+let rejectedResultChannel: ref<option<(string, rejectedResult) => unit>> = ref(None)
+
+let reportAccepted = (reference: string, result: acceptedResult) =>
+  acceptedResultChannel.contents->Option.forEach(cb => cb(reference, result))
+
+let reportRejected = (reference: string, result: rejectedResult) =>
+  rejectedResultChannel.contents->Option.forEach(cb => cb(reference, result))
+
+// Placed here (rather than CommandTopic.res) so runInlineAndCollect can use commandOutcome
+// without importing Adapter.res → @pulumi/pulumi. Re-exported by CommandTopic via include.
+type commandOutcome =
+  | Accepted({msgId: string, entityId?: string, eventCount: int})
+  | Rejected({msgId: string, errorCode: string, errorDetail: option<string>})
+  | Pending({msgId: string})
+
+// Serialise a commandOutcome to the JSON shape the CommandResult GraphQL union
+// expects — every variant carries an explicit `__typename` so AppSync (and any
+// other spec-compliant GraphQL server) can resolve the abstract type at
+// runtime. Shared between in-memory (graphql-yoga resolvers) and the AWS
+// Lambda direct-invocation entry point so both surfaces stay byte-compatible.
+let commandOutcomeToJson = (outcome: commandOutcome): JSON.t =>
+  switch outcome {
+  | Accepted({msgId, eventCount} as accepted) =>
+    JSON.Object(
+      Dict.fromArray([
+        ("__typename", JSON.String("CommandAccepted")),
+        ("msgId", JSON.String(msgId)),
+        ("entityId", accepted.entityId->Option.map(id => JSON.String(id))->Option.getOr(JSON.Null)),
+        ("eventCount", JSON.Number(eventCount->Int.toFloat)),
+      ]),
+    )
+  | Rejected({msgId, errorCode, errorDetail}) =>
+    JSON.Object(
+      Dict.fromArray([
+        ("__typename", JSON.String("CommandRejected")),
+        ("msgId", JSON.String(msgId)),
+        ("errorCode", JSON.String(errorCode)),
+        ("errorDetail", errorDetail->Option.map(s => JSON.String(s))->Option.getOr(JSON.Null)),
+      ]),
+    )
+  | Pending({msgId}) =>
+    JSON.Object(
+      Dict.fromArray([
+        ("__typename", JSON.String("CommandPending")),
+        ("msgId", JSON.String(msgId)),
+      ]),
+    )
+  }
+
+type publishJsonsAndWait = array<Reventless.Message.commandJson> => promise<array<commandOutcome>>
+
+// Encode the full message body expected by CommandTopic_Callback: {id, meta, command}.
+// Shared by LocalCommandTopicChannel and CommandTopicChannel_SQS_Sync.
+let encodeCommandJson = (cmdJson: Reventless.Message.commandJson): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", JSON.Encode.string(cmdJson.id)),
+      ("meta", cmdJson.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
+      ("command", cmdJson.commandJson),
+    ]),
+  )
+
+// Runs handleCmds inline, manages the acceptedResultChannel side-channel, and maps
+// results to commandOutcome. Shared by LocalCommandTopicChannel and CommandTopicChannel_SQS_Sync.
+let runInlineAndCollect = async (
+  jsons: array<Reventless.Message.commandJson>,
+  handleCmds: jsonCommandsHandler,
+) => {
+  let items = jsons->Array.map((cmdJson: Reventless.Message.commandJson) => {
+    let reference = cmdJson.meta.msgId
+    let item: topicItem<JSON.t> = {command: encodeCommandJson(cmdJson), reference}
+    item
+  })
+  let acceptedResults: dict<acceptedResult> = Dict.make()
+  let rejectedResults: dict<rejectedResult> = Dict.make()
+  acceptedResultChannel.contents = Some(
+    (reference, result) => acceptedResults->Dict.set(reference, result),
+  )
+  rejectedResultChannel.contents = Some(
+    (reference, result) => rejectedResults->Dict.set(reference, result),
+  )
+  let results = await handleCmds(Stream.fromIterable(items))->Effect.runPromise
+  acceptedResultChannel.contents = None
+  rejectedResultChannel.contents = None
+  jsons->Array.mapWithIndex((cmdJson, i) => {
+    let msgId = cmdJson.meta.msgId
+    // Domain rejection from Behavior.decide takes precedence over both Accepted
+    // and the synthesized "Conflict" — it carries the most informative error.
+    switch rejectedResults->Dict.get(msgId) {
+    | Some({errorCode, errorDetail}) =>
+      let detail = errorDetail == "" ? None : Some(errorDetail)
+      Rejected({msgId, errorCode, errorDetail: detail})
+    | None =>
+      switch results->Array.get(i) {
+      | Some(Error(msg)) =>
+        Rejected({msgId, errorCode: "Conflict", errorDetail: Some(msg)})
+      | _ =>
+        let ar = acceptedResults->Dict.get(msgId)->Option.getOr({eventCount: 0})
+        switch ar.entityId {
+        | Some(entityId) => Accepted({msgId, entityId, eventCount: ar.eventCount})
+        | None => Accepted({msgId, eventCount: ar.eventCount})
+        }
+      }
+    }
+  })
+}
+
+// Convenience helper for test code that needs to call a stream handler with an array
+// (for use in packages that don't have rescript-effect as a direct dependency)
+let callHandlerWithArray: (
+  jsonCommandsHandler,
+  array<topicItem<JSON.t>>,
+) => promise<array<result<string, string>>> = (handler, items) =>
+  handler(Stream.fromIterable(items))->Effect.runPromise
+
+// Helper to extract type names from a schema (for variant types). Used to
+// register every command constructor so the StateChangeSlice command-topic
+// dispatcher can route incoming JSON payloads to the right handler — payload-
+// less variants must be addressable too, so this calls extractAllVariantNames
+// (the inclusive version) rather than extractVariantNames (DCB-event filter).
+let extractTypeNamesFromSchema = (schema: S.t<unknown>): array<string> =>
+  Reventless.DcbTag.extractAllVariantNames(schema)
+
+// Global registry for schema-based filtering
+// Keyed by command type name (e.g., "CreateItem", "UpdateItem")
+type handlerEntry = {
+  schema: S.t<unknown>,
+  handler: jsonCommandsHandler,
+}
+type registry = Dict.t<array<handlerEntry>>
+let globalRegistry: registry = Dict.make()
+
+// Register a handler with the global registry
+// This is called by StateChangeSlice to register its command handler
+let registerHandler = (
+  ~schema: S.t<unknown>,
+  ~handler: jsonCommandsHandler,
+  ~typeNames: array<string>,
+) => {
+  typeNames->Array.forEach(typeName => {
+    let existing = globalRegistry->Dict.get(typeName)->Option.getOr([])
+    globalRegistry->Dict.set(typeName, existing->Array.concat([{schema, handler}]))
+  })
+}
+
+// Get handlers for a specific command type name
+let getHandlers = (typeName: string): array<handlerEntry> =>
+  globalRegistry->Dict.get(typeName)->Option.getOr([])