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

package/src/components/Api/MCP_SchemaGenerator.res

@@ -28,8 +28,7 @@ let buildDescriptionSuffix = (
   ~entry: ReventlessInfra.Api.mutationSchemaEntry,
 ): string => {
   let viewsSuffix = switch entry.linkedViews {
-  | Some(views) if views->Array.length > 0 =>
-    ` Affects views: ${views->Array.join(", ")}.`
+  | Some(views) if views->Array.length > 0 => ` Affects views: ${views->Array.join(", ")}.`
   | _ => ""
   }
   let consistencySuffix = switch entry.consistencyRead {
@@ -41,10 +40,9 @@ let buildDescriptionSuffix = (
 
 /** Generate MCP tool definitions from mutation entries.
     Each command variant becomes a separate tool. */
-let generateTools = (
-  ~pluginName: string,
-  ~mutationEntries: array<mutationSchemaEntry>,
-): array<mcpToolDefinition> => {
+let generateTools = (~pluginName: string, ~mutationEntries: array<mutationSchemaEntry>): array<
+  mcpToolDefinition,
+> => {
   let tools: array<mcpToolDefinition> = []
 
   mutationEntries->Array.forEach(entry => {
@@ -87,8 +85,7 @@ let generateTools = (
                 obj->Dict.set("required", JSON.Encode.array(arr))
               | None => ()
               }
-            | None =>
-              obj->Dict.set("required", JSON.Encode.array([JSON.Encode.string("id")]))
+            | None => obj->Dict.set("required", JSON.Encode.array([JSON.Encode.string("id")]))
             }
             JSON.Encode.object(obj)
           | None => inputSchema
@@ -124,10 +121,9 @@ let generateTools = (
 
 /** Generate MCP resource definitions from query entries.
     Each query entry becomes one or two resources (single + list). */
-let generateResources = (
-  ~pluginName: string,
-  ~queryEntries: array<querySchemaEntry>,
-): array<mcpResourceDefinition> => {
+let generateResources = (~pluginName: string, ~queryEntries: array<querySchemaEntry>): array<
+  mcpResourceDefinition,
+> => {
   let resources: array<mcpResourceDefinition> = []
 
   queryEntries->Array.forEach(entry => {

package/src/components/Api/OwnerScopeDiagnostics.res

@@ -43,8 +43,7 @@ let warnIfNoElevatedGroups = (~comp: string, ~view: string, ~ownerField: option<
         `${view}: "${field}" is declared @owner, but no elevated groups are configured. ` ++
         "Every caller — administrators included — will see only their own rows. " ++
         "Call OwnerScope.setElevatedGroups([...]) before components are built, or set " ++
-        "REVENTLESS_ELEVATED_GROUPS — the environment is what reaches a deployment's " ++
-        "separate function runtimes, which a call in the deploy program does not.",
+        "REVENTLESS_ELEVATED_GROUPS — the environment is what reaches a deployment's " ++ "separate function runtimes, which a call in the deploy program does not.",
       )
     }
   | _ => ()

package/src/components/Api/QueryDbListQuery.res

@@ -66,10 +66,14 @@ let buildConnection = (
   ~cursorValueOf: JSON.t => string,
 ): JSON.t => {
   let edges =
-    pageItems->Array.map(item => Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))}))
+    pageItems->Array.map(item =>
+      Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))})
+    )
   let startCursor = pageItems->Array.get(0)->Option.map(item => encodeCursor(cursorValueOf(item)))
   let endCursor =
-    pageItems->Array.get(pageItems->Array.length - 1)->Option.map(item => encodeCursor(cursorValueOf(item)))
+    pageItems
+    ->Array.get(pageItems->Array.length - 1)
+    ->Option.map(item => encodeCursor(cursorValueOf(item)))
   Obj.magic({
     "edges": edges,
     "pageInfo": {
@@ -130,7 +134,7 @@ let run = (
   let perFieldChecks: array<JSON.t => bool> = capability.filterFields->Array.flatMap(f => {
     let checks: array<JSON.t => bool> = []
     switch filterDict->Dict.get(f.name ++ "Eq") {
-    | Some(v) when v != JSON.Encode.null =>
+    | Some(v) if v != JSON.Encode.null =>
       let expected = switch v->JSON.Decode.string {
       | Some(s) => s
       | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr("")
@@ -142,16 +146,18 @@ let run = (
     }
     if f.range {
       switch filterDict->Dict.get(f.name ++ "From") {
-      | Some(v) when v != JSON.Encode.null =>
+      | Some(v) if v != JSON.Encode.null =>
         let from =
           v
           ->JSON.Decode.string
           ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
-        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v >= from))
+        checks->Array.push(item =>
+          getFieldString(item, f.name)->Option.mapOr(false, v => v >= from)
+        )
       | _ => ()
       }
       switch filterDict->Dict.get(f.name ++ "To") {
-      | Some(v) when v != JSON.Encode.null =>
+      | Some(v) if v != JSON.Encode.null =>
         let to_ =
           v
           ->JSON.Decode.string
@@ -207,6 +213,7 @@ let run = (
           item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(scope.field)),
         )
       )
+
     | None => true
     }
     passSearch && passPrefix && passIds && passPerField && passOwner && passRetired

package/src/components/Api/SchemaType.res

@@ -1,44 +1,44 @@
 type rec schemaType =
   | ScalarString
   | ScalarNumber
-  | /** A number the schema says is whole. sury carries the fact on the number's
+  /** A number the schema says is whole. sury carries the fact on the number's
         `format`, and it was being dropped here — so every `int` in the domain
         reached the SDL as `Float` and JSON Schema as `"number"`, and a quantity
         was a field a client could legally send `2.5` in. */
-  ScalarInt
+  | ScalarInt
   | ScalarBoolean
   | ScalarBigInt
   | EntityId
   | DateTime
-  | /** A calendar day, with no instant in it. A shape of its own rather than a
+  /** A calendar day, with no instant in it. A shape of its own rather than a
         plain string so `format: "date"` reaches the JSON Schema — but, unlike
         `DateTime`, it is not excluded from the generic semantic wrapper below,
         so it carries `x-reventless-semantic` as well. `DateTime`'s exclusion
         exists because its bare-`format` output predates the marker and is a
         published contract; a new semantic has no such history. */
-  CalendarDate
+  | CalendarDate
   | Nullable(schemaType)
   | ArrayOf(schemaType)
   | ObjectRef(string, dict<schemaType>)
   | Enum(string, array<string>)
-  | /** A field whose type carries a semantic the IR has no dedicated shape for.
+  /** A field whose type carries a semantic the IR has no dedicated shape for.
         Wraps the shape the value actually has, so every consumer that only cares
         about shape unwraps and is otherwise unaffected. `DateTime` and `EntityId`
         are *not* expressed this way: they long predate the generic marker and
         their JSON Schema `format` output is a published contract. */
-  Semantic(Reventless.Semantic.t, schemaType)
-  | /** A field whose type declares the value it opens with. Wraps the shape the
+  | Semantic(Reventless.Semantic.t, schemaType)
+  /** A field whose type declares the value it opens with. Wraps the shape the
         value has, as `Semantic` does, so a consumer that cares only about shape
         unwraps: a default changes where a form starts, never what the field is. */
-  Defaulted(JSON.t, schemaType)
-  | /** A variant used as a field: the union's name, and one arm per constructor
+  | Defaulted(JSON.t, schemaType)
+  /** A variant used as a field: the union's name, and one arm per constructor
         keyed by the `TAG` sury discriminates on. Each arm is the `ObjectRef` its
         member type is emitted from, so the arm's own name travels with it and
         every consumer that can already render an object renders an arm.
 
         Only a *named* union reaches this case — see `Reventless.TaggedUnion`,
         which owns the name and the arm rules both. */
-  TaggedUnion(string, array<(string, schemaType)>)
+  | TaggedUnion(string, array<(string, schemaType)>)
   | Unknown
 
 let isTagged = Reventless.DcbTag.isTagged
@@ -96,7 +96,11 @@ let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown
   }
 }
 
-and withoutDefault = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
+and withoutDefault = (
+  ~parentName: string,
+  ~fieldName: string,
+  schema: S.t<unknown>,
+): schemaType => {
   // Semantics the IR already has a dedicated shape for keep it: `dateTime` and
   // `reference` are read below via `isDateTime` / `getTarget`, both of which now
   // consult the generic marker, and their `format` output is a published
@@ -150,9 +154,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
         | _ => ScalarString
         }
       }
-      let itemType = (isIdsFieldName(fieldName) || isIdFieldName(fieldName)) && itemType == ScalarString
-        ? EntityId
-        : itemType
+      let itemType =
+        (isIdsFieldName(fieldName) || isIdFieldName(fieldName)) && itemType == ScalarString
+          ? EntityId
+          : itemType
       ArrayOf(itemType)
     | Object({properties}) =>
       let nestedName =
@@ -164,7 +169,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
       ->Dict.toArray
       ->Array.forEach(((propName, propSchema)) => {
         if propName !== "TAG" {
-          fields->Dict.set(propName, fromSury(~parentName=nestedName, ~fieldName=propName, propSchema))
+          fields->Dict.set(
+            propName,
+            fromSury(~parentName=nestedName, ~fieldName=propName, propSchema),
+          )
         }
       })
       if fields->Dict.keysToArray->Array.length == 0 {
@@ -181,13 +189,7 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
       )
       let isOptional = nonNullVariants->Array.length < anyOf->Array.length
       if nonNullVariants->Array.length == 1 {
-        Nullable(
-          fromSury(
-            ~parentName,
-            ~fieldName,
-            nonNullVariants->Array.getUnsafe(0),
-          ),
-        )
+        Nullable(fromSury(~parentName, ~fieldName, nonNullVariants->Array.getUnsafe(0)))
       } else {
         let constValues = nonNullVariants->Array.filterMap(v =>
           switch v {
@@ -195,7 +197,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
           | _ => None
           }
         )
-        if constValues->Array.length == nonNullVariants->Array.length && constValues->Array.length > 0 {
+        if (
+          constValues->Array.length == nonNullVariants->Array.length &&
+            constValues->Array.length > 0
+        ) {
           let enumName =
             parentName ++
             fieldName->String.charAt(0)->String.toUpperCase ++

package/src/components/Api/SuryToJsonSchema.res

@@ -13,10 +13,10 @@ let jsonObject = (entries: array<(string, JSON.t)>): JSON.t =>
 // An absent plugin means "the declaring plugin's own", which the key's absence
 // says exactly. Writing an empty string instead would make "mine" and "unnamed"
 // indistinguishable to every reader.
-let withOptionalPlugin = (
-  entries: array<(string, JSON.t)>,
-  plugin: option<string>,
-): array<(string, JSON.t)> =>
+let withOptionalPlugin = (entries: array<(string, JSON.t)>, plugin: option<string>): array<(
+  string,
+  JSON.t,
+)> =>
   switch plugin {
   | Some(p) => entries->Array.concat([("plugin", JSON.Encode.string(p))])
   | None => entries
@@ -47,8 +47,7 @@ let mergeAnnotations = (
     }
     switch spec.indexes->Array.find(((field, _)) => field === fieldName) {
     | Some((_, indexName)) =>
-      let value =
-        indexName === "" ? JSON.Encode.bool(true) : JSON.Encode.string(indexName)
+      let value = indexName === "" ? JSON.Encode.bool(true) : JSON.Encode.string(indexName)
       obj->Dict.set("x-reventless-index", value)
     | None => ()
     }
@@ -141,10 +140,9 @@ let mergeAnnotations = (
       // the keys above follow: false is what every record said before the opt-in
       // existed, and writing it would put a key on every retirement to say
       // nothing changed.
-      let entries =
-        r.namedWhenRetired
-          ? Array.concat(entries, [("namedWhenRetired", JSON.Encode.bool(true))])
-          : entries
+      let entries = r.namedWhenRetired
+        ? Array.concat(entries, [("namedWhenRetired", JSON.Encode.bool(true))])
+        : entries
       obj->Dict.set("x-reventless-retired", JSON.Encode.object(Dict.fromArray(entries)))
     | _ => ()
     }
@@ -428,6 +426,7 @@ and objectRefToJsonSchema = (
     | None => withAnnotations
     }
     props->Dict.set(fieldName, withAnnotations)
+
     // Optional two ways, because neither source answers alone. `optional` is
     // read off the sury schema and is the only thing that can speak for a
     // reference or a tagged field, which classify as `EntityId` before their

package/src/components/AutomationSlice/AutomationSlice.res

@@ -5,9 +5,9 @@ type outputs = ReventlessInfra.AutomationSlice.outputs
 type operations = ReventlessInfra.AutomationSlice.operations
 type component = Component.t<t, outputs, operations>
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.AutomationSlice.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.AutomationSlice.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.AutomationSlice.resolvedOutputs = {
-      resources: resources,
+      resources,
       queryDb: {resources: queryDbResources},
     }
     resolved

package/src/components/AutomationSlice/AutomationSlice_Builder.res

@@ -110,8 +110,7 @@ module Make = (
             `AutomationSlice "${Spec.name}" has a Mapping with sourceName "${sourceName}", ` ++
             `but no EventTopic with that key exists in allEventTopics. ` ++
             `Available source names: [${availableNames}]. ` ++
-            `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB ` ++
-            `source name (typically "<pluginName>DcbEventLog").`,
+            `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB ` ++ `source name (typically "<pluginName>DcbEventLog").`,
           )
         }
       )
@@ -159,18 +158,20 @@ module Make = (
                   let _ =
                     Callback.phase2(publishJsonsFn)
                     ->Promise.then(() => syncToQueryDb(queryDbOps))
-                    ->Promise.catch(exn => {
-                      let errMsg =
-                        exn
-                        ->JsExn.fromException
-                        ->Option.flatMap(JsExn.message)
-                        ->Option.getOr("unknown")
-                      EffectLogger.logError(
-                        ~comp=`AutomationSlice(${Spec.name})`,
-                        `detached phase 2 error: ${errMsg}`,
-                      )->Effect.runSync
-                      Promise.resolve()
-                    })
+                    ->Promise.catch(
+                      exn => {
+                        let errMsg =
+                          exn
+                          ->JsExn.fromException
+                          ->Option.flatMap(JsExn.message)
+                          ->Option.getOr("unknown")
+                        EffectLogger.logError(
+                          ~comp=`AutomationSlice(${Spec.name})`,
+                          `detached phase 2 error: ${errMsg}`,
+                        )->Effect.runSync
+                        Promise.resolve()
+                      },
+                    )
                 },
               )
             )

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -172,9 +172,9 @@ module Make = (
     handle: (JSON.t, ~sourceId: string, Reventless.AutomationSlice.context) => unit,
   }
 
-  let dispatches: array<dispatch> = Automation.mappings->Array.map((
-    module(M: Automation.Mapping),
-  ) => {
+  let dispatches: array<
+    dispatch,
+  > = Automation.mappings->Array.map((module(M: Automation.Mapping)) => {
     let decoder = Reventless.DcbDecode.makeDecoder(M.sourceEventSchema)
     let handle = (json: JSON.t, ~sourceId: string, ctx: Reventless.AutomationSlice.context) => {
       let (eventType, dataDict) = json->Message.splitMessage

package/src/components/Builder_Helpers.res

@@ -30,14 +30,9 @@ let createAggregatesWithoutEventMappers = (
       ~opts,
     )
     let aggOutputs = SpecificAggregate.outputs(aggregate)
-    addEventMapperFns->Dict.set(
-      SpecificAggregate.Spec.name,
-      aggOutputs.addEventMapper,
-    )
+    addEventMapperFns->Dict.set(SpecificAggregate.Spec.name, aggOutputs.addEventMapper)
     let resources =
-      aggOutputs.commandTopic->Pulumi.Output.apply(commandTopic =>
-        commandTopic.resources
-      )
+      aggOutputs.commandTopic->Pulumi.Output.apply(commandTopic => commandTopic.resources)
     aggregateResources->Dict.set(SpecificAggregate.Spec.name, resources)
     let publishJsons =
       SpecificAggregate.operations(aggregate)->Pulumi.Output.apply(({publishJsons}) => publishJsons)
@@ -54,10 +49,7 @@ let createAggregatesWithoutEventMappers = (
   ->Array.map(aggregate => {(aggregate.name, aggregate)})
   ->Dict.fromArray
 
-
-let finishAggregates = (
-  aggregatesOutputs: dict<Aggregate.outputs>,
-) => {
+let finishAggregates = (aggregatesOutputs: dict<Aggregate.outputs>) => {
   let allOutputs = aggregatesOutputs->Dict.valuesToArray
 
   // Wait for ALL commandTopicOutputs (not just those with event mappers)
@@ -89,10 +81,7 @@ let finishAggregates = (
     )
 }
 
-let addEventMappers = (
-  allEventTopics,
-  queryEngine,
-) => {
+let addEventMappers = (allEventTopics, queryEngine) => {
   let aggregatesOutputs =
     addEventMapperFns->Dict.mapValues(addEventMapperFn =>
       addEventMapperFn(allEventTopics, queryEngine)
@@ -126,9 +115,7 @@ let finishTasks = () =>
     let _ =
       taskSideEffectGates
       ->Pulumi.Output.all
-      ->Pulumi.Output.apply(_ =>
-        taskSideEffectFinishFns->Array.forEach(finishFn => finishFn())
-      )
+      ->Pulumi.Output.apply(_ => taskSideEffectFinishFns->Array.forEach(finishFn => finishFn()))
   }
 
 let readModelNamesForSourceName = Dict.make()
@@ -154,8 +141,7 @@ let extractReadModelsOutputs = readModels =>
   ->Dict.fromArray
 
 let createReadModels = (
-  type a,
-  type r,
+  type a r,
   readModels: array<module(ReventlessInfra.ReadModel.T with type api = a and type role = r)>,
   ~api: a,
   ~apiRole: r,
@@ -163,7 +149,9 @@ let createReadModels = (
   allEventTopics,
   opts,
 ) => {
-  let readModels = readModels->Array.map((module(SpecificReadModel: ReventlessInfra.ReadModel.T with type api = a and type role = r)) => {
+  let readModels = readModels->Array.map((
+    module(SpecificReadModel: ReventlessInfra.ReadModel.T with type api = a and type role = r),
+  ) => {
     let readModel = SpecificReadModel.make(
       ~api,
       ~apiRole,
@@ -222,8 +210,9 @@ let createExtensionPoints = (
   ~opts,
 ) => {
   let triples =
-    extensionPoints
-    ->Array.map((module(SpecificExtensionPoint: ReventlessInfra.ExtensionPoint.T)) => {
+    extensionPoints->Array.map((
+      module(SpecificExtensionPoint: ReventlessInfra.ExtensionPoint.T),
+    ) => {
       let extensionPoint = SpecificExtensionPoint.make(
         ~aggregateResources,
         ~publishToAggregates,

package/src/components/CommandGenerator/CommandGenerator.res

@@ -27,7 +27,12 @@ external asEvent: 'a => event = "%identity"
 let metaInfo = event => (event->asEvent).meta->Option.map(({info}) => info)
 
 type commandGenerator = payload => Effect.t<CommandTopic.commandOutcome, unit, unit>
-type effectEventHandler<'context> = Runtime.effectHandler<payload, 'context, CommandTopic.commandOutcome, unit>
+type effectEventHandler<'context> = Runtime.effectHandler<
+  payload,
+  'context,
+  CommandTopic.commandOutcome,
+  unit,
+>
 
 type publishJsons = CommandTopic.publishJsons
 

package/src/components/CommandGenerator/CommandGenerator_Builder.res

@@ -1,25 +1,29 @@
-module Make = (
-  Spec: Reventless.Aggregate.Spec,
-  Resolvers: CommandGenerator_Adapter.Resolvers,
-): (
+module Make = (Spec: Reventless.Aggregate.Spec, Resolvers: CommandGenerator_Adapter.Resolvers): (
   CommandGenerator.T with type runtimeParts := Resolvers.runtimeParts and type api := Resolvers.api
 ) => {
   let construct = (self, _name) => {
-    let resources = Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name)->Option.getOr([])->Array.map(field => {
-      let r: ReventlessInfra.Adapter.resource = {
-        id: ""->Pulumi.Output.make,
-        resourceInfo: ReventlessInfra.Adapter.ApiResolver({typeName: "Mutation", fieldName: field})->Pulumi.Output.make,
-        name: ""->Pulumi.Output.make,
-        urn: ""->Pulumi.Output.make,
-        service: ""->Pulumi.Output.make,
-        role: "commandGenerator"->Pulumi.Output.make,
-        region: ""->Pulumi.Output.make,
-        resourceType: ""->Pulumi.Output.make,
-        configuration: Dict.make()->Pulumi.Output.make,
-        tags: Dict.make()->Pulumi.Output.make,
-      }
-      r
-    })
+    let resources =
+      Plugin_Helpers.aggregateMutationFieldsRegistry
+      ->Dict.get(Spec.name)
+      ->Option.getOr([])
+      ->Array.map(field => {
+        let r: ReventlessInfra.Adapter.resource = {
+          id: ""->Pulumi.Output.make,
+          resourceInfo: ReventlessInfra.Adapter.ApiResolver({
+            typeName: "Mutation",
+            fieldName: field,
+          })->Pulumi.Output.make,
+          name: ""->Pulumi.Output.make,
+          urn: ""->Pulumi.Output.make,
+          service: ""->Pulumi.Output.make,
+          role: "commandGenerator"->Pulumi.Output.make,
+          region: ""->Pulumi.Output.make,
+          resourceType: ""->Pulumi.Output.make,
+          configuration: Dict.make()->Pulumi.Output.make,
+          tags: Dict.make()->Pulumi.Output.make,
+        }
+        r
+      })
     let outputs: CommandGenerator.outputs = {resources: resources}
     let _ = self->Component.setOutputs(outputs)
   }
@@ -32,7 +36,8 @@ module Make = (
       ->ComponentType.name(CommandGenerator.componentType)
     let opts = {Pulumi.ComponentResource.parent: commandGeneratorResource}
 
-    let fields = Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name)->Option.getOr([])
+    let fields =
+      Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name)->Option.getOr([])
 
     let resolvers = Resolvers.make(
       ~name,
@@ -48,7 +53,10 @@ module Make = (
     let _ = commandGenerator->Component.setOutputs(cgOutputs)
   }
 
-  let makeHandler = (~publishJsons, ~publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>) => {
+  let makeHandler = (
+    ~publishJsons,
+    ~publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>,
+  ) => {
     module Callback = CommandGenerator_Callback.Make(
       {
         let publishJsons = publishJsons

package/src/components/CommandGenerator/CommandGenerator_Callback.res

@@ -168,9 +168,7 @@ let makeGenerateCommand = (
         | Some(idValue) => idValue
         | None =>
           try {
-            let derived = Reventless.DcbTag.derivePartitionTag([
-              (serviceName, "", commandSchema),
-            ])
+            let derived = Reventless.DcbTag.derivePartitionTag([(serviceName, "", commandSchema)])
             switch derived {
             | Simple(pt) =>
               let tags = Reventless.DcbTag.extractTagsFromJson(commandSchema, commandJson)
@@ -221,22 +219,23 @@ let makeGenerateCommand = (
           | Allow =>
             switch publishJsonsAndWait {
             | Some(publishAndWait) =>
-              Effect.promise(() => publishAndWait([{id, meta, commandJson}]))
-              ->Effect.map(outcomes => {
-                // For aggregates, entityId comes from the envelope id.
-                // DCB slices populate entityId via the side-channel; don't override it.
-                switch outcomes->Array.getUnsafe(0) {
-                | CommandTopic.Accepted(payload) when payload.entityId->Option.isNone =>
-                  CommandTopic.Accepted({...payload, entityId: id})
-                | outcome => outcome
-                }
-              })
+              Effect.promise(() => publishAndWait([{id, meta, commandJson}]))->Effect.map(
+                outcomes => {
+                  // For aggregates, entityId comes from the envelope id.
+                  // DCB slices populate entityId via the side-channel; don't override it.
+                  switch outcomes->Array.getUnsafe(0) {
+                  | CommandTopic.Accepted(payload) if payload.entityId->Option.isNone =>
+                    CommandTopic.Accepted({...payload, entityId: id})
+                  | outcome => outcome
+                  }
+                },
+              )
             | None =>
-              Effect.promise(() => publishJsons([{id, meta, commandJson}]))
-              ->Effect.map(_ => CommandTopic.Pending({msgId: meta.msgId}))
+              Effect.promise(() => publishJsons([{id, meta, commandJson}]))->Effect.map(
+                _ => CommandTopic.Pending({msgId: meta.msgId}),
+              )
             }
-          | Deny(msg) =>
-            JsError.throwWithMessage(msg)
+          | Deny(msg) => JsError.throwWithMessage(msg)
           }
         )
       | exception err =>
@@ -265,10 +264,7 @@ let makeGenerateCommand = (
     })
 }
 
-module Make = (
-  Spec: Spec,
-  AggregateSpec: Reventless.Aggregate.Spec,
-): T => {
+module Make = (Spec: Spec, AggregateSpec: Reventless.Aggregate.Spec): T => {
   let generateCommand = makeGenerateCommand(
     ~publishJsons=Spec.publishJsons,
     ~publishJsonsAndWait=?Spec.publishJsonsAndWait,

package/src/components/CommandTopic/CommandTopic.res

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

package/src/components/CommandTopic/CommandTopic_Builder.res

@@ -49,21 +49,21 @@ module Make = (Spec: ReventlessInfra.CommandTopic.T, Channel: CommandTopic_Adapt
       let handlers = CommandTopic.getHandlers(typeName)
       Effect.promise(async () => {
         let allResults: array<result<string, string>> = []
-        let _ =
-          await handlers
-          ->Array.map(async handlerEntry => {
+        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
+              let results = await handler(
+                Stream.fromIterable([{ReventlessInfra.CommandTopic.reference, command: json}]),
+              )->Effect.runPromise
               allResults->Array.pushMany(results)
             } catch {
             | _ => () // Skip if handler fails
             }
-          })
-          ->Promise.all
+          },
+        )
+        ->Promise.all
         allResults
       })
     })
@@ -89,7 +89,7 @@ module Make = (Spec: ReventlessInfra.CommandTopic.T, Channel: CommandTopic_Adapt
         {
           publish: Operations.publish,
           publishJsons: Operations.publishJsons,
-          publishJsonsStream: publishJsonsStream,
+          publishJsonsStream,
           publishJsonsAndWait,
         }
       }),

package/src/components/CommandTopic/CommandTopic_Callback.res

@@ -19,10 +19,7 @@ module Make = (Spec: ReventlessInfra.CommandTopic.T, Ops: Ops with module Spec =
         | exception err =>
           let commandStr = json->JSON.stringify
           let errMsg = err->Reventless.Util_Sury.exnMessage
-          EffectLogger.logError(
-            ~comp,
-            `decode failed: ${commandStr} err=${errMsg}`,
-          )->Effect.runSync
+          EffectLogger.logError(~comp, `decode failed: ${commandStr} err=${errMsg}`)->Effect.runSync
           None
         }
       )