@reventlessdev/reventless-infra 3.0.0-alpha.81

package/src/components/AutomationSlice.res

@@ -0,0 +1,48 @@
+/**
+Deploy-time outputs produced when an `AutomationSlice` is provisioned.
+
+- `resources` — the underlying infrastructure (e.g. SQS subscription)
+- `queryDb` — the DynamoDB table for the TODO list
+*/
+type outputs = {
+  resources: array<Adapter.resource>,
+  queryDb: QueryDb.outputs,
+}
+
+/**
+Runtime operations exposed by an `AutomationSlice` component.
+
+- `enqueueEvent` — push events into the slice's projection queue
+- `processPending` — manually trigger Phase 2 (useful in tests and for heartbeat)
+*/
+type operations = {
+  enqueueEvent: EventCollector.enqueueEvent,
+  processPending: unit => promise<unit>,
+}
+
+/**
+Module type produced by `Platform.AutomationSlice.Make(Spec)`.
+
+@example
+```rescript
+module ShipOrderSlice = Platform.AutomationSlice.Make(ShipOrder)
+let slice = ShipOrderSlice.make(~dcbEventLog=log, ~publishJsons=publishJsonsOutput)
+```
+*/
+type t
+
+module type T = {
+  module Spec: Reventless.AutomationSlice.Spec
+  module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+  /** Names of all sources this slice consumes (deduplicated). Used by
+      `Plugin_Builder` for the source-name fail-fast assembly check. */
+  let sourceNames: array<string>
+  let make: (
+    ~allEventTopics: EventTopic.allOutputs,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~context: Reventless.AutomationSlice.context,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/AutomationSlice.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/CommandGenerator.res

@@ -0,0 +1,8 @@
+/**
+ * Deploy-time outputs produced when a `CommandGenerator` is provisioned.
+ *
+ * The command generator is an internal component that translates raw JSON
+ * command messages from the command topic into typed domain commands and
+ * dispatches them to the aggregate handler.
+ */
+type outputs = {resources: array<Adapter.resource>}

package/src/components/CommandGenerator.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/CommandTopic.res

@@ -0,0 +1,70 @@
+/**
+Module type for an aggregate's command topic specification.
+
+`CommandTopic.T` is used by the framework to identify the command channel
+(e.g. an SQS FIFO queue) and validate that published commands match the
+aggregate's command schema.
+*/
+module type T = {
+  module Id: Reventless.Id.T
+
+  /** Logical name of the aggregate or component owning this command topic. */
+  let name: string
+
+  /** The command type published to this topic. Must carry `@schema` for serialization. */
+  @schema
+  type command
+}
+
+/**
+Deploy-time outputs produced when a `CommandTopic` is provisioned.
+Contains the underlying queue / messaging infrastructure resources.
+*/
+type outputs = {resources: array<Adapter.resource>}
+
+/** A dictionary of command topic outputs keyed by aggregate name. */
+type allOutputs = dict<outputs>
+
+/**
+Publishes an array of serialized command envelopes to this command topic.
+
+Commands are batched for efficiency. Each `Message.commandJson` carries
+the aggregate ID, metadata, raw JSON payload, and optional delivery delay.
+
+@example
+```rescript
+await ops.publishJsons([{id: "cat-1", meta, commandJson: json}])
+```
+*/
+type publishJsons = array<Reventless.Message.commandJson> => promise<unit>
+
+/**
+Publishes a stream of serialized command envelopes as an `Effect.t`.
+Use this for high-throughput or streaming command pipelines.
+*/
+type publishJsonsStream = Stream.t<Reventless.Message.commandJson, string, unit> => Effect.t<unit, string, unit>
+
+/**
+A command together with an idempotency reference string.
+
+Used by the extension point runtime to track which commands have already
+been processed and avoid duplicate dispatch.
+*/
+type topicItem<'command> = {
+  command: 'command,
+  reference: string,
+}
+
+/**
+A handler that processes a stream of typed topic items and returns an Effect
+producing per-item results.
+
+`commandsHandler<JSON.t>` is the JSON-level variant used for routing;
+`commandsHandler<Reventless.Message.command'<Id.t, command>>` is the decoded variant
+used by aggregate and slice callbacks.
+*/
+type commandsHandler<'command> = Stream.t<topicItem<'command>, string, unit> => Effect.t<
+  array<result<string, string>>,
+  string,
+  unit,
+>

package/src/components/CommandTopic.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/Component.js

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+let ComponentMjs = require("./Component.mjs").default;
+
+let _outputsStore = new WeakMap();
+
+let _operationsStore = new WeakMap();
+
+function outputs(self) {
+  return _outputsStore.get(self);
+}
+
+function wrappedOutputs(component) {
+  return component.apply(outputs);
+}
+
+function setOperations(self, ops) {
+  _operationsStore.set(self, ops);
+}
+
+function operations(self) {
+  return _operationsStore.get(self);
+}
+
+function make(prim0, prim1, prim2, prim3) {
+  return new ComponentMjs(prim0, prim1, prim2, prim3);
+}
+
+function registerOutputs(self, outputs) {
+  return self.registerOutputs(outputs);
+}
+
+function setOutputs(self, outputs) {
+  _outputsStore.set(self, outputs);
+  return self.registerOutputs({});
+}
+
+function toPulumiResource(prim) {
+  return prim;
+}
+
+function fromPulumiResource(prim) {
+  return prim;
+}
+
+exports.registerOutputs = registerOutputs;
+exports.setOutputs = setOutputs;
+exports.outputs = outputs;
+exports.wrappedOutputs = wrappedOutputs;
+exports.setOperations = setOperations;
+exports.operations = operations;
+exports.toPulumiResource = toPulumiResource;
+exports.fromPulumiResource = fromPulumiResource;
+exports.make = make;
+/* _outputsStore Not a pure module */

package/src/components/Component.mjs

@@ -0,0 +1,10 @@
+import * as pulumi from "@pulumi/pulumi";
+
+class Component extends pulumi.ComponentResource {
+  constructor(componentType, name, construct, opts, param1, param2, param3) {
+    super("reventless:" + componentType, name, {}, opts);
+    construct(this, name, param1, param2, param3);
+  };
+}
+
+export default Component;

package/src/components/Component.res

@@ -0,0 +1,90 @@
+/**
+A Reventless component — a typed wrapper around a Pulumi `ComponentResource`.
+
+Type parameters:
+- `'component` — the concrete component module type (e.g. `Aggregate.T`)
+- `'outputs` — the deploy-time outputs record (infrastructure references)
+- `'operations` — the runtime operations record (async functions for Lambda handlers)
+
+Components are created at deploy time by a `Make` functor and carry two payloads:
+- `outputs` — immediately available infrastructure references (queue ARNs, table names…)
+- `operations` — an `Output.t`-wrapped set of async functions injected at runtime
+*/
+type t<'component, 'outputs, 'operations>
+
+// Side-channel storage for outputs and operations.
+// Using WeakMaps keyed by the component instance prevents Pulumi from
+// serializing internal data (sury schemas, Spec modules) as ComponentResource
+// properties in `pulumi stack output`.
+type weakMap
+@new external _makeWeakMap: unit => weakMap = "WeakMap"
+@send external _get: (weakMap, t<'c, 'o, 'p>) => 'v = "get"
+@send external _set: (weakMap, t<'c, 'o, 'p>, 'v) => unit = "set"
+
+let _outputsStore = _makeWeakMap()
+let _operationsStore = _makeWeakMap()
+
+/** Access the deploy-time outputs record for this component. */
+let outputs = (self: t<'component, 'outputs, 'operations>): 'outputs =>
+  _outputsStore->_get(self)
+
+/**
+Access the deploy-time outputs wrapped in an `Output.t` (resolved asynchronously).
+Useful when you need to chain outputs into another `Output.apply`.
+*/
+let wrappedOutputs = component => component->Pulumi.Output.apply(component => component->outputs)
+
+let setOperations = (
+  self: t<'component, 'outputs, 'operations>,
+  ops: Pulumi.Output.t<'operations>,
+): unit => _operationsStore->_set(self, ops)
+
+/**
+Access the runtime operations for this component.
+
+Returns an `Output.t` that resolves to the runtime operations record once the
+underlying infrastructure values are known. Use `TestRunner.resolve` in tests.
+*/
+let operations = (self: t<'component, 'outputs, 'operations>): Pulumi.Output.t<'operations> =>
+  _operationsStore->_get(self)
+
+/** Cast to a plain Pulumi resource (e.g. to pass to `~opts` as a parent). */
+external toPulumiResource: t<'component, 'outputs, 'operations> => Pulumi.Resource.t = "%identity"
+external fromPulumiResource: Pulumi.Resource.t => t<'component, 'outputs, 'operations> = "%identity"
+
+type constructed
+
+/**
+Create a new Reventless component backed by a Pulumi `ComponentResource`.
+
+- `componentType` — Pulumi type token (e.g. `"reventless:index:Aggregate"`)
+- `name` — unique Pulumi resource name
+- `construct` — a callback that builds child resources; called by the Pulumi runtime
+- `opts` — optional Pulumi resource options (parent, provider, etc.)
+*/
+@module("./Component.mjs") @new
+external make: (
+  ~componentType: string,
+  ~name: string,
+  ~construct: 'construct,
+  ~opts: option<Pulumi.ComponentResource.options>,
+) => t<'component, 'outputs, 'operations> = "default"
+
+@send
+external _registerOutputs: (t<'component, 'outputs, 'operations>, 'a) => constructed =
+  "registerOutputs"
+
+/** Register the component's outputs with Pulumi to mark it as constructed. */
+let registerOutputs = (self, outputs) => self->_registerOutputs(outputs)
+
+/**
+Set the component's outputs and mark the component as constructed.
+
+Outputs are stored in a WeakMap (not on the ComponentResource instance) to prevent
+Pulumi from serializing internal data in `pulumi stack output`. Cross-stack data
+is exported explicitly via `Pulumi.export`.
+*/
+let setOutputs = (self, outputs) => {
+  _outputsStore->_set(self, outputs)
+  self->_registerOutputs(JSON.Encode.object(Dict.make()))
+}

package/src/components/Component.res.mjs

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import ComponentMjs from "./Component.mjs";
+
+let _outputsStore = new WeakMap();
+
+let _operationsStore = new WeakMap();
+
+function outputs(self) {
+  return _outputsStore.get(self);
+}
+
+function wrappedOutputs(component) {
+  return component.apply(outputs);
+}
+
+function setOperations(self, ops) {
+  _operationsStore.set(self, ops);
+}
+
+function operations(self) {
+  return _operationsStore.get(self);
+}
+
+function make(prim0, prim1, prim2, prim3) {
+  return new ComponentMjs(prim0, prim1, prim2, prim3);
+}
+
+function registerOutputs(self, outputs) {
+  return self.registerOutputs(outputs);
+}
+
+function setOutputs(self, outputs) {
+  _outputsStore.set(self, outputs);
+  return self.registerOutputs({});
+}
+
+function toPulumiResource(prim) {
+  return prim;
+}
+
+function fromPulumiResource(prim) {
+  return prim;
+}
+
+export {
+  registerOutputs,
+  setOutputs,
+  outputs,
+  wrappedOutputs,
+  setOperations,
+  operations,
+  toPulumiResource,
+  fromPulumiResource,
+  make,
+}
+/* _outputsStore Not a pure module */

package/src/components/Component.resi

@@ -0,0 +1,21 @@
+type t<'component, 'outputs, 'operations>
+
+type constructed
+let registerOutputs: (t<'component, 'outputs, 'operations>, 'outputs) => constructed
+let setOutputs: (t<'component, 'outputs, 'operations>, 'outputs) => constructed
+let outputs: t<'component, 'outputs, 'operations> => 'outputs
+let wrappedOutputs: Pulumi.Output.t<t<'component, 'outputs, 'operations>> => Pulumi.Output.t<
+  'outputs,
+>
+let setOperations: (t<'component, 'outputs, 'operations>, Pulumi.Output.t<'operations>) => unit
+let operations: t<'component, 'outputs, 'operations> => Pulumi.Output.t<'operations>
+
+let toPulumiResource: t<'component, 'outputs, 'operations> => Pulumi.Resource.t
+let fromPulumiResource: Pulumi.Resource.t => t<'component, 'outputs, 'operations>
+
+let make: (
+  ~componentType: string,
+  ~name: string,
+  ~construct: 'construct,
+  ~opts: option<Pulumi.ComponentResource.options>,
+) => t<'component, 'outputs, 'operations>

package/src/components/Counter.res

@@ -0,0 +1,81 @@
+/**
+A single counter increment item.
+
+- `counterId` — which counter to increment
+- `reference` — idempotency key (e.g. the triggering event's message ID)
+- `inc` — how much to increment by (usually 1)
+*/
+type countItem = {
+  counterId: Reventless.Counter.counterId,
+  reference: Reventless.Counter.reference,
+  inc: int,
+}
+
+/**
+A counter threshold target with an idempotency reference.
+
+Used by `addToCounterTarget` to register that a target has been claimed by
+a specific `reference`, preventing duplicate threshold triggers.
+*/
+type counterTargetRef = {
+  counterId: Reventless.Counter.counterId,
+  target: int,
+  targetRef: Reventless.Counter.reference,
+}
+
+/**
+Deploy-time outputs produced when a `Counter` component is provisioned.
+
+- `referencesDb` — tracks which references have already been counted (dedup)
+- `countsDb` — stores the current count per `counterId`
+*/
+type outputs = {referencesDb: QueryDb.outputs, countsDb: QueryDb.outputs}
+
+/** Increments one or more counters. Each item is applied idempotently via its `reference`. */
+type count = array<countItem> => promise<unit>
+
+/**
+Registers a threshold target, claiming it with a `targetRef`.
+When the count reaches `target`, the event mapping's `AddToCounterTarget` action fires.
+*/
+type addToCounterTarget = counterTargetRef => promise<unit>
+
+/**
+Runtime operations exposed by a `Counter` component.
+Available inside event mapping `map` functions via the injected `operations` record.
+*/
+type operations = {count: count, addToCounterTarget: addToCounterTarget}
+
+/**
+Processes a stream of raw event JSON values to extract and apply counter increments.
+Used internally by the counter's Lambda handler.
+*/
+type jsonEventsHandler = Stream.t<JSON.t, string, unit> => Effect.t<unit, string, unit>
+
+/**
+Module type for a `Counter` component.
+
+The `Counter` component maintains named reference-counted thresholds.
+When a count crosses a configured threshold, the associated event mapping
+fires a command to the target aggregate.
+*/
+module type T = {
+  type component
+  let make: (
+    ~name: string,
+    ~jsonEventsHandler: jsonEventsHandler,
+    ~ttl: int=?,
+    /** ESM specifier of the counter target's spec module. Used by bundling
+        adapters that load callbacks via `import()`; other adapters ignore it. */
+    ~specModulePath: string=?,
+    /** ESM specifier of the counter target's mappings module. Used by bundling
+        adapters that load callbacks via `import()`; other adapters ignore it. */
+    ~mappingsModulePath: string=?,
+    /** Publish-channel address of the aggregate this counter dispatches commands
+        to. Used by bundling adapters; other adapters ignore it. */
+    ~publishChannelId: Pulumi.Output.t<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+}

package/src/components/Counter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/DcbEventLog.res

@@ -0,0 +1,115 @@
+/**
+Deploy-time outputs produced when a `DcbEventLog` is provisioned.
+
+- `resources` — the underlying storage infrastructure (e.g. DynamoDB table)
+- `eventTopic` — the SNS topic for downstream subscribers (state view slices)
+*/
+type outputs = {resources: array<Adapter.resource>, eventTopic: EventTopic.outputs}
+
+/**
+A raw event ready to be stored in the DCB log.
+Produced by slice callbacks after encoding with their eventSchema.
+
+`meta` is the envelope metadata for this event (causation, correlation, tracing).
+Slice callbacks derive it from the triggering message's context.
+*/
+type rawEvent = {
+  eventType: string,
+  data: JSON.t,
+  tags: array<Reventless.DcbTag.tag>,
+  meta: Reventless.Message.meta,
+}
+
+/**
+A raw event read from the DCB log at a known position.
+Consumed by slice callbacks for decoding with their consumedEventSchema.
+
+`meta` is the envelope metadata that was written at append time.
+`recordedAt` is the storage timestamp, set by the storage adapter at append.
+*/
+type rawSequencedEvent = {
+  position: Reventless.DcbTag.sequencePosition,
+  eventType: string,
+  data: JSON.t,
+  tags: array<Reventless.DcbTag.tag>,
+  meta: Reventless.Message.meta,
+  recordedAt: string,
+}
+
+/**
+The result of a DCB `read` operation.
+
+- `events` — the matching events in sequence order
+- `headPosition` — the sequence position of the last event read (use as the
+  `after` cursor in a subsequent `appendCondition` to detect conflicts)
+*/
+type readResult = {
+  events: array<rawSequencedEvent>,
+  headPosition?: Reventless.DcbTag.sequencePosition,
+}
+
+/**
+Reads events from the DCB log matching the given query.
+
+- `~query` — content-based filter (event types + tags)
+- `~after` — optional cursor; only events after this position are returned
+*/
+type read = (
+  ~query: Reventless.DcbTag.query,
+  ~after: Reventless.DcbTag.sequencePosition=?,
+) => promise<readResult>
+
+/**
+Appends raw events to the DCB log with optional optimistic-concurrency checking.
+
+Returns `Ok(position)` on success or `Error(reason)` if the append condition
+was violated (i.e. the log was modified since `condition.after`).
+*/
+type append = (
+  array<rawEvent>,
+  ~condition: Reventless.DcbTag.appendCondition=?,
+) => promise<result<Reventless.DcbTag.sequencePosition, string>>
+
+/**
+Streams events from the DCB log matching the given query.
+Use for large result sets that should not be loaded into memory at once.
+*/
+type readStream = (
+  ~query: Reventless.DcbTag.query,
+  ~after: Reventless.DcbTag.sequencePosition=?,
+  /** Opt into strongly-consistent single-tag reads. Defaults to eventually
+      consistent: a stale read can only cause a rejected append (then a retry),
+      never a wrong write, because the append fence is always evaluated strongly.
+      The slice callback sets this on retries (eventual-first, strong-on-retry). */
+  ~strongConsistency: bool=?,
+) => Stream.t<rawSequencedEvent, string, unit>
+
+/**
+Appends a stream of raw events to the DCB log as an `Effect.t`.
+Use for high-throughput batch imports.
+*/
+type appendStream = (
+  Stream.t<rawEvent, string, unit>,
+  ~condition: Reventless.DcbTag.appendCondition=?,
+) => Effect.t<result<Reventless.DcbTag.sequencePosition, string>, string, unit>
+
+/**
+Runtime operations exposed by a `DcbEventLog` component.
+Works with raw events — encode/decode is handled by each slice's callback.
+
+Obtained via `Component.operations(dcbEventLog)`. Available inside Lambda handlers.
+*/
+type operations = {
+  read: read,
+  append: append,
+  readStream: readStream,
+  appendStream: appendStream,
+}
+
+type t
+type component = Component.t<t, outputs, operations>
+
+module type T = {
+  type component = component
+  let make: (~name: string, ~indexes: array<string>=?, ~opts: Pulumi.ComponentResource.options=?) => component
+}

package/src/components/DcbEventLog.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/EventCollector.res

@@ -0,0 +1,19 @@
+/**
+ * Enqueues an event for processing by a downstream component (e.g. a read model).
+ *
+ * - `delay` — delivery delay in seconds (0 for immediate delivery)
+ * - `id` — the aggregate ID string the event belongs to
+ * - `message` — the serialized event payload (JSON string)
+ *
+ * This function is exposed by read model `operations` so that the aggregate
+ * runtime can push events without knowing the read model's infrastructure details.
+ */
+type enqueueEvent = (/* ~delay: */ int, /* ~id: */ string, /* ~message: */ string) => promise<unit>
+
+/**
+ * Deploy-time outputs produced when an `EventCollector` is provisioned.
+ *
+ * An `EventCollector` is the inbound queue of a read model — events are collected
+ * here and then processed in order by the read model's projection function.
+ */
+type outputs = {name: string, resources: array<Adapter.resource>}

package/src/components/EventCollector.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/EventLog.res

@@ -0,0 +1,24 @@
+/**
+Module type for an aggregate's event log specification.
+
+`EventLog.T` is used by the framework to configure the event storage backend
+(e.g. a DynamoDB table) and the associated event topic for downstream subscribers.
+*/
+module type T = {
+  module Id: Reventless.Id.T
+
+  /** Logical name of the aggregate / event stream (used as a table-name prefix). */
+  let name: string
+
+  /** The event type stored in this log. Must carry `@schema` for serialization. */
+  @schema
+  type event
+}
+
+/**
+Deploy-time outputs produced when an `EventLog` is provisioned.
+
+- `resources` — the underlying infrastructure resources (e.g. DynamoDB table)
+- `eventTopic` — the event topic outputs for downstream subscribers
+*/
+type outputs = {resources: array<Adapter.resource>, eventTopic: EventTopic.outputs}

package/src/components/EventLog.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/EventMapper.res

@@ -0,0 +1,37 @@
+/**
+Deploy-time outputs produced when an `EventMapper` is provisioned.
+
+An `EventMapper` subscribes to an aggregate's event topic and routes events
+to one or more target aggregate command topics, optionally via a `Counter`.
+*/
+type outputs = {
+  name: string,
+  eventCollector: Pulumi.Output.t<EventCollector.outputs>,
+  counter?: Counter.outputs,
+}
+
+/**
+A collection of `EventMapping.T` modules that route events from one aggregate
+to commands on one or more target aggregates.
+
+Pass a `Mappings` module to `Platform.Aggregate.Make` as the third argument.
+Use `NoEventMappings.Make(TargetSpec)` when no routing is needed.
+
+@example
+```rescript
+// CatalogPlugin.res
+module CategoryMappings: Mappings with module Target := CategoriesReadModel = {
+  module CategoryMappings = Mappings.Make(CategoriesReadModel)
+  module type Mapping = CategoryMappings.Mapping
+  let mappings = CategoriesProjections.mappings
+}
+```
+*/
+module type Mappings = {
+  module Target: Reventless.EventMapping.Target
+  module type Mapping = Reventless.EventMapping.T with module Target := Target
+  let moduleUrl: string
+  let mappings: array<module(Mapping)>
+  /** Optional counter component for threshold-based command triggers. */
+  let counter: option<module(Counter.T)>
+}

package/src/components/EventMapper.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */