@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.262

package/src/components/DcbEventLog/DcbEventLog.res

@@ -14,9 +14,9 @@ type appendStream = ReventlessInfra.DcbEventLog.appendStream
 type operations = ReventlessInfra.DcbEventLog.operations
 type component = ReventlessInfra.DcbEventLog.component
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.DcbEventLog.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.DcbEventLog.resolvedOutputs,
+> =>
   (
     outputs.resources->Adapter.resourcesToInterop,
     outputs.eventTopic.resources->Adapter.resourcesToInterop,
@@ -24,7 +24,7 @@ let toResolvedOutputs = (
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((resources, eventTopicResources)) => {
     let resolved: ReventlessInterop.DcbEventLog.resolvedOutputs = {
-      resources: resources,
+      resources,
       eventTopic: {resources: eventTopicResources},
     }
     resolved

package/src/components/DcbEventLog/DcbEventLog_Builder.res

@@ -2,7 +2,6 @@ module Make = (
   Storage: DcbEventLog_Adapter.Storage,
   EventTopicPublisher: EventTopic_Adapter.Publisher,
 ): DcbEventLog.T => {
-
   // DcbEventLog uses a generic JSON event topic (no typed event schema needed)
   module EventTopicSpec = {
     module Id = Reventless.Id.String

package/src/components/DcbEventLog/DcbEventLog_Operations.res

@@ -35,12 +35,13 @@ module Make = (Ops: Ops): T => {
     | None => Message.generateMeta(~service=serviceName)
     }
 
-    let rawEventsJson = rawEvents->Array.map(rawEvent =>
-      Message.combineMessage(
-        rawEvent.eventType,
-        rawEvent.data->JSON.Decode.object->Option.getOr(Dict.make()),
+    let rawEventsJson =
+      rawEvents->Array.map(rawEvent =>
+        Message.combineMessage(
+          rawEvent.eventType,
+          rawEvent.data->JSON.Decode.object->Option.getOr(Dict.make()),
+        )
       )
-    )
 
     // Run beforePublish hook — if it throws, log the error and publish original events.
     let finalRawEventsJson = switch EventPublish_Callback.beforePublishHook.contents {
@@ -75,13 +76,15 @@ module Make = (Ops: Ops): T => {
     let recordedAt = Message.nowAsISOString()
     let _ = await Array.zip(rawEvents, finalRawEventsJson)
     ->Array.map(async ((rawEvent, eventJson)) => {
-      let entityId =
-        rawEvent.tags->Array.get(0)->Option.map(t => t.value)->Option.getOr(name)
+      let entityId = rawEvent.tags->Array.get(0)->Option.map(t => t.value)->Option.getOr(name)
       let eventJson' = Message.composeEventJson'(entityId, rawEvent.meta, ~recordedAt, eventJson)
       try await Ops.publishJson(serviceName, rawEvent.meta, eventJson') catch {
       | JsExn(err) =>
         let errMsg = err->JsExn.message->Option.getOr("unknown")
-        EffectLogger.logError(~comp=`DcbEventLog(${name})`, `EventTopic.publish Error: ${errMsg}`)->Effect.runSync
+        EffectLogger.logError(
+          ~comp=`DcbEventLog(${name})`,
+          `EventTopic.publish Error: ${errMsg}`,
+        )->Effect.runSync
       }
     })
     ->Promise.all
@@ -114,10 +117,7 @@ module Make = (Ops: Ops): T => {
     }
   }
 
-  let append: DcbEventLog.append = async (
-    rawEvents,
-    ~condition=?,
-  ) => {
+  let append: DcbEventLog.append = async (rawEvents, ~condition=?) => {
     // Normalise `meta.service` to the DcbEventLog's serviceName on every event
     // before BOTH storage append and SNS publish. EventCollector dispatch (via
     // Plugin_Callback.handleJsonEvents) keys on `meta.service`, and the catalog
@@ -140,10 +140,7 @@ module Make = (Ops: Ops): T => {
     }
   }
 
-  let read: DcbEventLog.read = async (
-    ~query,
-    ~after=?,
-  ) => {
+  let read: DcbEventLog.read = async (~query, ~after=?) => {
     let rawResult = await Ops.storage.read(~query, ~after?)
     // Adapter rawSequencedEvent is structurally identical to infra rawSequencedEvent
     let events: array<DcbEventLog.rawSequencedEvent> = rawResult.events->Obj.magic
@@ -155,14 +152,16 @@ module Make = (Ops: Ops): T => {
   }
 
   let readStream: DcbEventLog.readStream = (~query, ~after=?, ~strongConsistency=?) =>
-    Ops.storage.readStream(~query, ~after?, ~strongConsistency?)->Stream.map(raw => (raw->Obj.magic: DcbEventLog.rawSequencedEvent))
+    Ops.storage.readStream(~query, ~after?, ~strongConsistency?)->Stream.map((
+      raw
+    ): DcbEventLog.rawSequencedEvent => raw->Obj.magic)
 
   // Streaming append — collects the stream into an array, then makes a single
   // storage.append call to preserve atomicity of the condition check.
   // Does not publish to EventTopic (use case: migration / bulk seeding).
   let appendStream: DcbEventLog.appendStream = (stream, ~condition=?) =>
     stream
-    ->Stream.map(rawEvent => (rawEvent->Obj.magic: DcbEventLog_Adapter.rawStoredEvent))
+    ->Stream.map((rawEvent): DcbEventLog_Adapter.rawStoredEvent => rawEvent->Obj.magic)
     ->Stream.runCollect
     ->Effect.flatMap(rawEvents => Effect.promise(() => Ops.storage.append(rawEvents, ~condition?)))
 }

package/src/components/EventCollector/EventCollector_Builder.res

@@ -15,7 +15,8 @@ let makeStreamHandler = (
     )
     ->jsonEventsHandler
 
-  let channel: EventCollector_Adapter.channel<_, _, _> = eventCollector->EventCollector_Adapter.channel
+  let channel: EventCollector_Adapter.channel<_, _, _> =
+    eventCollector->EventCollector_Adapter.channel
   channel.handleChannelEvent(jsonHandler)
 }
 

package/src/components/EventLog/EventLog.res

@@ -33,7 +33,11 @@ type replay<'id, 'event> = 'id => promise<array<'event>>
 // `fromSeq` starts the replay at that sequence number (inclusive; default 0) —
 // the delta read after seeding from a snapshot at seqNr = fromSeq.
 type replayStream<'id, 'event> = ('id, ~fromSeq: int=?) => Stream.t<'event, string, unit>
-type appendStream<'id, 'event> = (int, 'id, Stream.t<'event, string, unit>) => Effect.t<unit, string, unit>
+type appendStream<'id, 'event> = (
+  int,
+  'id,
+  Stream.t<'event, string, unit>,
+) => Effect.t<unit, string, unit>
 // Keep-one semantics: `writeSnapshot` overwrites the single snapshot per
 // aggregate; recovery from a corrupt snapshot is full replay, not older
 // snapshots. Failures are plain strings — a snapshot op failure must never

package/src/components/EventLog/EventLog_Operations.res

@@ -134,8 +134,9 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
     // result (no Cause stringification / substring matching).
     let storageEffect =
       Effect.tryPromise(
-        ~catch=(err: unknown) =>
-          EventLog.StorageFailure(Util.Error.messageFromUnknown(err, "storage error")),
+        ~catch=(err: unknown) => EventLog.StorageFailure(
+          Util.Error.messageFromUnknown(err, "storage error"),
+        ),
         () => Ops.storage.append(sequenceNr, idStr, eventsJson),
       )
       ->Effect.flatMap(result =>
@@ -149,12 +150,16 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
       ->Effect.catchAll(e => Effect.succeed(Error(e)))
     switch await storageEffect->Effect.runPromise {
     | Ok() =>
-      (await publishToEventTopic(id, events', eventsJson))->Result.mapError(msg => EventLog.StorageFailure(
-        msg,
-      ))
+      (
+        await publishToEventTopic(id, events', eventsJson)
+      )->Result.mapError(msg => EventLog.StorageFailure(msg))
     | Error(EventLog.Conflict) => Error(EventLog.Conflict)
     | Error(StorageFailure(msg)) =>
-      Error(EventLog.StorageFailure(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${msg}`))
+      Error(
+        EventLog.StorageFailure(
+          `EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${msg}`,
+        ),
+      )
     }
   }
 
@@ -190,8 +195,7 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
   // Lazy streaming replay — wraps decodeEvent in Effect.sync so thrown exceptions
   // surface through the stream's error channel rather than as unhandled exceptions.
   let replayStream = (id, ~fromSeq=?) =>
-    Ops.storage.replayStream(id->Spec.Id.toString, ~fromSeq=?fromSeq)
-    ->Stream.mapEffect(json =>
+    Ops.storage.replayStream(id->Spec.Id.toString, ~fromSeq?)->Stream.mapEffect(json =>
       Effect.sync(() => decodeEvent(id->Spec.Id.toString, json))
     )
 

package/src/components/EventMapper/EventMapper.res

@@ -20,9 +20,9 @@ module type T = {
   ) => component
 }
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.EventMapper.resolvedOutputs> => {
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.EventMapper.resolvedOutputs,
+> => {
   let eventCollectorOutput =
     outputs.eventCollector->Pulumi.Output.flatMap((ec: ReventlessEventCollector.outputs) =>
       ec.resources
@@ -30,7 +30,7 @@ let toResolvedOutputs = (
       ->Pulumi.Output.apply(resources => {
         let resolved: ReventlessInterop.EventCollector.resolvedOutputs = {
           name: ec.name,
-          resources: resources,
+          resources,
         }
         resolved
       })
@@ -42,12 +42,10 @@ let toResolvedOutputs = (
       counter.countsDb.resources->Adapter.resourcesToInterop,
     )
     ->Pulumi.Output.all2
-    ->Pulumi.Output.apply(((referencesDbResources, countsDbResources)) =>
-      Some({
-        ReventlessInterop.Counter.referencesDb: {resources: referencesDbResources},
-        countsDb: {resources: countsDbResources},
-      })
-    )
+    ->Pulumi.Output.apply(((referencesDbResources, countsDbResources)) => Some({
+      ReventlessInterop.Counter.referencesDb: {resources: referencesDbResources},
+      countsDb: {resources: countsDbResources},
+    }))
   | None => Pulumi.Output.make(None)
   }
   (eventCollectorOutput, counterOutput)

package/src/components/EventMapper/EventMapper_Builder.res

@@ -38,7 +38,10 @@ module Make = (
             count: async _items =>
               log.warn(~comp="EventMapper", "No counter deployed, but trying to use count"),
             addToCounterTarget: async _target =>
-              log.warn(~comp="EventMapper", "No counter deployed, but trying to use addToCounterTarget"),
+              log.warn(
+                ~comp="EventMapper",
+                "No counter deployed, but trying to use addToCounterTarget",
+              ),
           }
           ops
         }),

package/src/components/EventMapper/EventMapper_Callback.res

@@ -22,10 +22,11 @@ module MakeCounterHandler = (
   // Used to pre-filter incoming envelopes by TAG before attempting decode —
   // sibling variants on the same source aggregate that this mapping does not
   // declare are silently skipped instead of producing decode-failure noise.
-  let mappingsWithTags = Mappings.mappings->Array.map((module(M: Mappings.Mapping)) => (
-    module(M: Mappings.Mapping),
-    Reventless.DcbTag.extractAllVariantNames(M.Source.eventSchema),
-  ))
+  let mappingsWithTags =
+    Mappings.mappings->Array.map((module(M: Mappings.Mapping)) => (
+      module(M: Mappings.Mapping),
+      Reventless.DcbTag.extractAllVariantNames(M.Source.eventSchema),
+    ))
 
   // Looks up the event mapping for a given event JSON by matching the source service name
   // from the event's meta against the registered Mapping modules.
@@ -44,12 +45,18 @@ module MakeCounterHandler = (
           )
         switch entry {
         | None =>
-          EffectLogger.logInfo(~comp="EventMapper", `map: No mapping ${source} -> ${target} found`)->Effect.runSync
+          EffectLogger.logInfo(
+            ~comp="EventMapper",
+            `map: No mapping ${source} -> ${target} found`,
+          )->Effect.runSync
           None
         | Some((mapping, acceptedTags)) =>
           module Mapping = unpack(mapping)
           let source = Mapping.Source.name
-          EffectLogger.logInfo(~comp="EventMapper", `map: found mapping ${source} -> ${target}`)->Effect.runSync
+          EffectLogger.logInfo(
+            ~comp="EventMapper",
+            `map: found mapping ${source} -> ${target}`,
+          )->Effect.runSync
           Some((eventObj', eventMeta, mapping, acceptedTags))
         }
       | None =>
@@ -224,8 +231,9 @@ module MakeCounterHandler = (
         }
       )
       ->Effect.flatMap(((publisherEntries, _)) =>
-        Effect.promise(() => publisherEntries)
-        ->Effect.flatMap(entries => Effect.promise(() => Ops.publishJsons(entries)))
+        Effect.promise(() => publisherEntries)->Effect.flatMap(
+          entries => Effect.promise(() => Ops.publishJsons(entries)),
+        )
       )
     )
 }
@@ -271,8 +279,10 @@ module MakeEventCollectorHandler = (Ops: EventCollectorOps): EventCollectorHandl
   //   3. Publishes generated commands to the target aggregate
   let handleJsonEvents: EventCollector.jsonEventsHandler = stream =>
     stream->Stream.runForEach(eventJson' =>
-      Effect.promise(() => Ops.commonEventsHandler([eventJson']))
-      ->Effect.flatMap(((publisherEntries, counterActions)) => {
+      Effect.promise(() => Ops.commonEventsHandler([eventJson']))->Effect.flatMap(((
+        publisherEntries,
+        counterActions,
+      )) => {
         let (countActions, addToCounterTargetActions) = counterActions->Array.partition(
           x =>
             switch x {
@@ -294,29 +304,34 @@ module MakeEventCollectorHandler = (Ops: EventCollectorOps): EventCollectorHandl
             ->Int.toString}`,
         )
         ->Effect.flatMap(_ => doCount(countItems))
-        ->Effect.flatMap(_ =>
-          EffectLogger.logInfo(
-            ~comp="EventMapper",
-            `eventCollectorEventsHandler: addToCounterTargetActions: ${addToCounterTargetActions
-              ->JSON.stringifyAny
-              ->Option.getOr("[]")}`,
-          )
-        )
-        ->Effect.flatMap(_ =>
-          Effect.all(
-            addToCounterTargetActions->Array.filterMap(x =>
-              switch x {
-              | AddToCounterTarget(counterTarget) =>
-                Some(Effect.promise(() => Ops.addToCounterTarget(counterTarget)))
-              | _ => None
-              }
+        ->Effect.flatMap(
+          _ =>
+            EffectLogger.logInfo(
+              ~comp="EventMapper",
+              `eventCollectorEventsHandler: addToCounterTargetActions: ${addToCounterTargetActions
+                ->JSON.stringifyAny
+                ->Option.getOr("[]")}`,
             ),
-            {"concurrency": "unbounded"},
-          )->Effect.map(_ => ())
         )
-        ->Effect.flatMap(_ =>
-          Effect.promise(() => publisherEntries)
-          ->Effect.flatMap(entries => Effect.promise(() => Ops.publishJsons(entries)))
+        ->Effect.flatMap(
+          _ =>
+            Effect.all(
+              addToCounterTargetActions->Array.filterMap(
+                x =>
+                  switch x {
+                  | AddToCounterTarget(counterTarget) =>
+                    Some(Effect.promise(() => Ops.addToCounterTarget(counterTarget)))
+                  | _ => None
+                  },
+              ),
+              {"concurrency": "unbounded"},
+            )->Effect.map(_ => ()),
+        )
+        ->Effect.flatMap(
+          _ =>
+            Effect.promise(() => publisherEntries)->Effect.flatMap(
+              entries => Effect.promise(() => Ops.publishJsons(entries)),
+            ),
         )
       })
     )

package/src/components/EventTopic/EventTopic.res

@@ -32,9 +32,9 @@ module type T = {
   ) => component
 }
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.EventTopic.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.EventTopic.resolvedOutputs,
+> =>
   outputs.resources
   ->Adapter.resourcesToInterop
   ->Pulumi.Output.apply(resources => {

package/src/components/EventTopic/EventTopic_Builder.res

@@ -35,7 +35,7 @@ module Make = (Spec: ReventlessInfra.EventTopic.T, Publisher: EventTopic_Adapter
         {
           publishJson,
           publish: Operations.publish,
-          publishJsonStream: publishJsonStream,
+          publishJsonStream,
         }
       }),
     )

package/src/components/Extension/Extension.res

@@ -4,7 +4,10 @@ type outputs = ReventlessInfra.Extension.outputs
 type t
 
 type jsonEventsHandler = (JSON.t, Reventless.Plugin.pluginDefinition) => promise<unit>
-type operations = {incomingJsonEventsHandler: jsonEventsHandler, outgoingJsonEventsHandler: jsonEventsHandler}
+type operations = {
+  incomingJsonEventsHandler: jsonEventsHandler,
+  outgoingJsonEventsHandler: jsonEventsHandler,
+}
 type component = Component.t<t, outputs, operations>
 
 module type T = {

package/src/components/Extension/Extension_Operations.res

@@ -67,7 +67,9 @@ module Make = (
   let publishAggregateCommand = async (aggregateName, cmdJson: Message.commandJson) => {
     EffectLogger.logInfo(
       ~comp,
-      `EP→${aggregateName}: ${cmdJson.commandJson->Message.variantNameOfJson->LogFormat.bold}(${cmdJson.id})`,
+      `EP→${aggregateName}: ${cmdJson.commandJson
+        ->Message.variantNameOfJson
+        ->LogFormat.bold}(${cmdJson.id})`,
     )->Effect.runSync
     let pub = Ops.publishToAggregates->Dict.get(aggregateName)->Option.getOrThrow
     try await pub([cmdJson]) catch {
@@ -152,7 +154,10 @@ module Make = (
     }
 
   let incomingJsonEventsHandler = async (eventJson', pluginDef) => {
-    EffectLogger.logInfo(~comp=comp, `incoming EP event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    EffectLogger.logInfo(
+      ~comp,
+      `incoming EP event: ${LogFormat.eventSummary(eventJson')}`,
+    )->Effect.runSync
     switch eventJson'->Message.decodeEvent'(
       Reventless.Id.StringPure.schema,
       MappingSpec.eventSchema,
@@ -193,7 +198,10 @@ module Make = (
   }
 
   let outgoingJsonEventsHandler = (eventJson', pluginDef) => {
-    EffectLogger.logInfo(~comp=comp, `outgoing delegate event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    EffectLogger.logInfo(
+      ~comp,
+      `outgoing delegate event: ${LogFormat.eventSummary(eventJson')}`,
+    )->Effect.runSync
     let commandActions = mapOutgoingEvent(eventJson', pluginDef)
     commandActions
     ->Array.map(applyOutgoingCommandAction)

package/src/components/ExtensionPoint/ExtensionPoint.res

@@ -33,9 +33,9 @@ module type Mappings = {
   let mappings: array<module(Mapping)>
 }
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.ExtensionPoint.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.ExtensionPoint.resolvedOutputs,
+> =>
   (
     outputs.commandTopic->Pulumi.Output.flatMap(CommandTopic.toResolvedOutputs),
     outputs.eventTopic->Pulumi.Output.flatMap(EventTopic.toResolvedOutputs),

package/src/components/ExtensionPoint/ExtensionPoint_Builder.res

@@ -89,13 +89,12 @@ module Make = (
         // first command-topic resource's `id`. The in-memory ExtensionPoint
         // runtime builder ignores this dict, so including every aggregate
         // (not just mapping targets) and the empty fallback are both harmless.
-        let publishToAggregatesQueueUrls =
-          aggregateResources->Dict.mapValues(resources =>
-            switch resources->Array.get(0) {
-            | Some(r: ReventlessInfra.Adapter.resource) => r.id
-            | None => Pulumi.Output.make("")
-            }
-          )
+        let publishToAggregatesQueueUrls = aggregateResources->Dict.mapValues(resources =>
+          switch resources->Array.get(0) {
+          | Some(r: ReventlessInfra.Adapter.resource) => r.id
+          | None => Pulumi.Output.make("")
+          }
+        )
 
         commandTopic->ExtensionPointRuntimeBuilder.forCommandTopic(
           ~handler,
@@ -138,9 +137,9 @@ module Make = (
       ->Pulumi.Output.unzip3
 
     self->Component.setOperations(
-      outgoingJsonEventsHandler->Pulumi.Output.apply(outgoingJsonEventsHandler =>
-        ({outgoingJsonEventsHandler: outgoingJsonEventsHandler}: ExtensionPoint.operations)
-      ),
+      outgoingJsonEventsHandler->Pulumi.Output.apply((
+        outgoingJsonEventsHandler
+      ): ExtensionPoint.operations => {outgoingJsonEventsHandler: outgoingJsonEventsHandler}),
     )
 
     let epOutputs: ExtensionPoint.outputs = {

package/src/components/ExtensionPoint/ExtensionPoint_Callback.res

@@ -70,8 +70,7 @@ module Make = (
           let _ = result()
           Ok(reference)
         },
-      )
-      ->Effect.catchAll(((errorResult, errMsg)) =>
+      )->Effect.catchAll(((errorResult, errMsg)) =>
         EffectLogger.logError(~comp="ExtensionPoint", errMsg)->Effect.map(_ => errorResult)
       )
     | AbstractHandleDirective(reference, handler) =>
@@ -102,9 +101,6 @@ module Make = (
           Spec.resourceNaming,
           Spec.commandTopicResources,
         )
-      Effect.all(
-        commandActions->Array.map(applyCommandAction),
-        {"concurrency": "unbounded"},
-      )
+      Effect.all(commandActions->Array.map(applyCommandAction), {"concurrency": "unbounded"})
     })
 }

package/src/components/ExtensionPoint/ExtensionPoint_Operations.res

@@ -77,8 +77,7 @@ module Make = (
 
     try await Ops.publishToEventTopic(id, meta, finalEventJson) catch {
     | err =>
-      let errMsg =
-        err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      let errMsg = err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
       EffectLogger.logError(
         ~comp=`ExtensionPoint(${MappingSpec.name})`,
         `Error on publishToEventTopic command: ${errMsg}`,
@@ -113,7 +112,10 @@ module Make = (
   let applyEventAction = async action =>
     switch action {
     | ReventlessInfra.ExtensionPointMapping.AbstractPublishEvent(id, meta, eventJson) =>
-      EffectLogger.logInfo(~comp=`ExtensionPoint(${MappingSpec.name})`, `applying event: ${LogFormat.eventSummary(eventJson)}`)->Effect.runSync
+      EffectLogger.logInfo(
+        ~comp=`ExtensionPoint(${MappingSpec.name})`,
+        `applying event: ${LogFormat.eventSummary(eventJson)}`,
+      )->Effect.runSync
       await publishWithHooks(id, meta, eventJson)
     | ReventlessInfra.ExtensionPointMapping.AbstractPublishEventAsync(promise) =>
       let (id, meta, eventJson) = await promise
@@ -123,12 +125,18 @@ module Make = (
       | err =>
         let errMsg =
           err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
-        EffectLogger.logError(~comp=`ExtensionPoint(${MappingSpec.name})`, `Error on handling directive: ${errMsg}`)->Effect.runSync
+        EffectLogger.logError(
+          ~comp=`ExtensionPoint(${MappingSpec.name})`,
+          `Error on handling directive: ${errMsg}`,
+        )->Effect.runSync
       }
     }
 
   let outgoingJsonEventsHandler = async (eventJson', _pluginDef) => {
-    EffectLogger.logInfo(~comp=`ExtensionPoint(${MappingSpec.name})`, `outgoing event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    EffectLogger.logInfo(
+      ~comp=`ExtensionPoint(${MappingSpec.name})`,
+      `outgoing event: ${LogFormat.eventSummary(eventJson')}`,
+    )->Effect.runSync
     let eventActions = mapOutgoingEvent(
       eventJson',
       Mappings.mappings,

package/src/components/Heartbeat/Heartbeat_Callback.res

@@ -23,9 +23,9 @@ module Make = (Spec: Spec) => {
           msgId,
           correlationId: msgId,
         },
-        commandJson: PluginExtensionPointSpec.Heartbeat(
-          Spec.timeout,
-        )->Message.encode(PluginExtensionPointSpec.commandSchema),
+        commandJson: PluginExtensionPointSpec.Heartbeat(Spec.timeout)->Message.encode(
+          PluginExtensionPointSpec.commandSchema,
+        ),
       },
     ])
   }

package/src/components/InboundTranslationSlice/InboundTranslationSlice.res

@@ -7,9 +7,9 @@ type acceptedResult = ReventlessInfra.InboundTranslationSlice.acceptedResult
 type rejectedResult = ReventlessInfra.InboundTranslationSlice.rejectedResult
 type component = Component.t<t, outputs, operations>
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.InboundTranslationSlice.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.InboundTranslationSlice.resolvedOutputs,
+> =>
   (
     outputs.resources->Adapter.resourcesToInterop,
     outputs.queryDb.resources->Adapter.resourcesToInterop,
@@ -17,7 +17,7 @@ let toResolvedOutputs = (
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((resources, queryDbResources)) => {
     let resolved: ReventlessInterop.InboundTranslationSlice.resolvedOutputs = {
-      resources: resources,
+      resources,
       queryDb: {resources: queryDbResources},
     }
     resolved

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res

@@ -39,7 +39,11 @@ module Make = (
       let visibility: Reventless.Visibility.t = Public
     }
 
-    module SpecificQueryDb = QueryDb_Builder.Make(AuditQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+    module SpecificQueryDb = QueryDb_Builder.Make(
+      AuditQueryDbSpec,
+      QueryDbStorage,
+      QueryDbResolvers,
+    )
 
     // Persist just this request's audit row, taking it out of the in-memory log
     // as it goes — see `takeAuditRow` for why draining the whole dict is wrong.
@@ -78,10 +82,7 @@ module Make = (
           let ops: InboundTranslationSlice.operations = {
             receive: async inputJson => {
               let result = await Callback.receive(publishJsonsFn, inputJson)
-              await syncToQueryDb(
-                queryDbOps,
-                result->InboundTranslationSlice_Callback.requestIdOf,
-              )
+              await syncToQueryDb(queryDbOps, result->InboundTranslationSlice_Callback.requestIdOf)
               result
             },
           }
@@ -99,11 +100,7 @@ module Make = (
     // InboundTranslationSlice publishes commands + syncs its QueryDb inline; it
     // provisions no per-slice runtime environment, so the runtime hint is accepted
     // (for composition-surface parity) and discarded.
-    let make = (
-      ~publishJsons,
-      ~runtime as _=?,
-      ~opts=?,
-    ): InboundTranslationSlice.component =>
+    let make = (~publishJsons, ~runtime as _=?, ~opts=?): InboundTranslationSlice.component =>
       Component.make(
         ~componentType=InboundTranslationSlice.componentType->ComponentType.toString,
         ~name=Spec.name,

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice.res

@@ -5,9 +5,9 @@ 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> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.OutboundTranslationSlice.resolvedOutputs,
+> =>
   (
     outputs.resources->Adapter.resourcesToInterop,
     outputs.queryDb.resources->Adapter.resourcesToInterop,
@@ -15,7 +15,7 @@ let toResolvedOutputs = (
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((resources, queryDbResources)) => {
     let resolved: ReventlessInterop.OutboundTranslationSlice.resolvedOutputs = {
-      resources: resources,
+      resources,
       queryDb: {resources: queryDbResources},
     }
     resolved