@reventlessdev/reventless-aws 3.0.0-alpha.344 → 3.0.0-alpha.345

package/src/adapter/QueryDb/QueryDbStorage_DynamoDb.res

@@ -10,14 +10,8 @@ let globalSecondaryIndexes = (indexes: array<Reventless.ReadModel.indexConfig>)
     let {index, projectionType} = indexConfig
     let (projectionType, includes) = switch projectionType {
     | Reventless.ReadModel.ALL as _projection => (PulumiAws.DynamoDb.Table.ALL, None)
-    | Reventless.ReadModel.KEYS_ONLY as _projection => (
-        PulumiAws.DynamoDb.Table.KEYS_ONLY,
-        None,
-      )
-    | Reventless.ReadModel.INCLUDE(includes) => (
-        PulumiAws.DynamoDb.Table.INCLUDE,
-        Some(includes),
-      )
+    | Reventless.ReadModel.KEYS_ONLY as _projection => (PulumiAws.DynamoDb.Table.KEYS_ONLY, None)
+    | Reventless.ReadModel.INCLUDE(includes) => (PulumiAws.DynamoDb.Table.INCLUDE, Some(includes))
     }
     {
       name: index,
@@ -34,20 +28,19 @@ let globalSecondaryIndexes = (indexes: array<Reventless.ReadModel.indexConfig>)
 // sorts on `id`, and any index may sort on the table's own sort key. First
 // declaration wins; they agree on the type because both name the same column.
 let attributes = (sortField, indexes: array<Reventless.ReadModel.indexConfig>) => {
-  let all =
-    [
-      [{name: "id", type_: "S"}],
-      sortField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
-      indexes
-      ->Array.map((indexConfig: Reventless.ReadModel.indexConfig) => {
-        let {index, type_} = indexConfig
-        [
-          [{name: indexConfig.idField->Option.getOr(index), type_}],
-          indexConfig.subIdField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
-        ]->Array.flat
-      })
-      ->Array.flat,
-    ]->Array.flat
+  let all = [
+    [{name: "id", type_: "S"}],
+    sortField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
+    indexes
+    ->Array.map((indexConfig: Reventless.ReadModel.indexConfig) => {
+      let {index, type_} = indexConfig
+      [
+        [{name: indexConfig.idField->Option.getOr(index), type_}],
+        indexConfig.subIdField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
+      ]->Array.flat
+    })
+    ->Array.flat,
+  ]->Array.flat
   let seen = Set.make()
   all->Array.filter(({name}) =>
     if seen->Set.has(name) {
@@ -111,9 +104,15 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
   ~ttl=?,
   ~api,
   ~apiRole,
-  ~owner, ~opts,
+  ~owner,
+  ~opts,
 ) => {
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.QueryDb.componentType, ~role=QueryDb, ~owner?)
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.QueryDb.componentType,
+    ~role=QueryDb,
+    ~owner?,
+  )
   let table = Util_DynamoDb.makeTable(
     name,
     ~attributes=attributes(subIdField, indexes),

package/src/adapter/QueryDb/QueryDbStorage_DynamoDbStream.res

@@ -14,10 +14,16 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
   ~ttl=?,
   ~api,
   ~apiRole,
-  ~owner, ~opts,
+  ~owner,
+  ~opts,
 ) => {
   streamRegistry->Set.add(name)
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.QueryDb.componentType, ~role=QueryDb, ~owner?)
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.QueryDb.componentType,
+    ~role=QueryDb,
+    ~owner?,
+  )
   let table = Util_DynamoDbStream.makeTable(
     name,
     ~attributes=attributes(subIdField, indexes),

package/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res

@@ -14,21 +14,16 @@ let loadStream = table =>
       expressionAttributeValues: [(":id", id->JSON.Encode.string)]->Dict.fromArray,
     }
     Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
-      Effect.tryPromise(
-        ~catch=DynamoDb_Error.classify,
-        () => {
-          let params = switch cursor {
-          | None => baseParams
-          | Some(key) => {...baseParams, exclusiveStartKey: key}
-          }
-          QueryCommand.send(params->QueryCommand.make)
-        },
-      )
+      Effect.tryPromise(~catch=DynamoDb_Error.classify, () => {
+        let params = switch cursor {
+        | None => baseParams
+        | Some(key) => {...baseParams, exclusiveStartKey: key}
+        }
+        QueryCommand.send(params->QueryCommand.make)
+      })
       ->Effect.retry(DynamoDb_Error.retrySchedule)
       ->Effect.catchAll(err =>
-        Effect.fail(
-          ReventlessInfra.QueryDb.NotLoadedFromStorage(DynamoDb_Error.message(err)),
-        )
+        Effect.fail(ReventlessInfra.QueryDb.NotLoadedFromStorage(DynamoDb_Error.message(err)))
       )
       ->Effect.map(result => (
         result.items
@@ -51,8 +46,7 @@ let load = table =>
       ReventlessCore.EffectLogger.logError(
         ~comp=__MODULE__,
         `load: Couldn't load state for ${id} from ${tableName}: ${msg}`,
-      )
-      ->Effect.map(_ => Error(err))
+      )->Effect.map(_ => Error(err))
     })
     ->Effect.runPromise
 
@@ -63,18 +57,20 @@ let save = table =>
 
     let effect = switch saveMode {
     | Init =>
-      table->putIfNotExistsWithRetries(~idKey=table.hashKey, ~sortKey=?table.rangeKey, id, json)
+      table
+      ->putIfNotExistsWithRetries(~idKey=table.hashKey, ~sortKey=?table.rangeKey, id, json)
       ->Effect.flatMap(result =>
         switch result {
         | Ok() =>
-          ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, `save: saved Init state to ${tableName}: id=${id}`)
-          ->Effect.map(_ => Ok())
+          ReventlessCore.EffectLogger.logInfo(
+            ~comp=__MODULE__,
+            `save: saved Init state to ${tableName}: id=${id}`,
+          )->Effect.map(_ => Ok())
         | Error(errorMsg) =>
           ReventlessCore.EffectLogger.logError(
             ~comp=__MODULE__,
             `save: Couldn't save Init state to ${tableName}, id=${id}: ${errorMsg}`,
-          )
-          ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
+          )->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
         }
       )
     | Any
@@ -84,14 +80,15 @@ let save = table =>
       ->Effect.flatMap(result =>
         switch result {
         | Ok() =>
-          ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, `save: saved state to ${tableName}: id=${id}`)
-          ->Effect.map(_ => Ok())
+          ReventlessCore.EffectLogger.logInfo(
+            ~comp=__MODULE__,
+            `save: saved state to ${tableName}: id=${id}`,
+          )->Effect.map(_ => Ok())
         | Error(errorMsg) =>
           ReventlessCore.EffectLogger.logError(
             ~comp=__MODULE__,
             `save: Couldn't save state to ${tableName}, id=${id}: ${errorMsg}`,
-          )
-          ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
+          )->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
         }
       )
     }
@@ -111,38 +108,34 @@ let writeMultiple = (writeRequests, op, ids, table) => {
   let size = writeRequests->Array.length
   let batches = (size->Int.toFloat /. BatchWriteCommand.maxBatchSize->Int.toFloat)->Math.Int.ceil
 
-  let logSplitEffect =
-    if batches > 1 {
-      ReventlessCore.EffectLogger.logInfo(
-        ~comp=__MODULE__,
-        `writeBatch: splitting up batch of size ${size->Int.toString} into ${batches->Int.toString} batches`,
-      )
-    } else {
-      Effect.succeed()
-    }
-
-  let batchEffects =
-    Array.fromInitializer(~length=batches, batchNr =>
-      writeRequests
-      ->sliceBatch(batchNr)
-      ->toTable(tableName)
-      ->batchWriteWithRetries
-      ->Effect.map(result => {
-        let batchIds = ids->sliceBatch(batchNr)
-        let batchCount = batchIds->Array.length->Int.toString
-        let batchIdsStr = batchIds->Array.joinUnsafe(", ")
-        switch result {
-        | Ok() => None
-        | Error(error) =>
-          Some(`Batch ${batchNr->Int.toString}: ${batchCount} ids:${batchIdsStr}: ${error}`)
-        }
-      })
+  let logSplitEffect = if batches > 1 {
+    ReventlessCore.EffectLogger.logInfo(
+      ~comp=__MODULE__,
+      `writeBatch: splitting up batch of size ${size->Int.toString} into ${batches->Int.toString} batches`,
     )
+  } else {
+    Effect.succeed()
+  }
 
-  logSplitEffect
-  ->Effect.flatMap(_ =>
-    Effect.all(batchEffects, {"concurrency": "unbounded"})
+  let batchEffects = Array.fromInitializer(~length=batches, batchNr =>
+    writeRequests
+    ->sliceBatch(batchNr)
+    ->toTable(tableName)
+    ->batchWriteWithRetries
+    ->Effect.map(result => {
+      let batchIds = ids->sliceBatch(batchNr)
+      let batchCount = batchIds->Array.length->Int.toString
+      let batchIdsStr = batchIds->Array.joinUnsafe(", ")
+      switch result {
+      | Ok() => None
+      | Error(error) =>
+        Some(`Batch ${batchNr->Int.toString}: ${batchCount} ids:${batchIdsStr}: ${error}`)
+      }
+    })
   )
+
+  logSplitEffect
+  ->Effect.flatMap(_ => Effect.all(batchEffects, {"concurrency": "unbounded"}))
   ->Effect.map(results => results->Array.filterMap(x => x))
   ->Effect.flatMap(errors =>
     switch errors {
@@ -150,20 +143,21 @@ let writeMultiple = (writeRequests, op, ids, table) => {
       ReventlessCore.EffectLogger.logInfo(
         ~comp=__MODULE__,
         `writeBatch: ${op} ${count} states: ${tableName}, ids:${allIdsStr}`,
-      )
-      ->Effect.map(_ => Ok())
+      )->Effect.map(_ => Ok())
     | errors =>
       let errorsStr = errors->Array.joinUnsafe("; ")
       let errorMsg = `writeBatch: Couldn't save states to ${tableName}: ${errorsStr}`
-      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)
-      ->Effect.map(_ => Error(ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg)))
+      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)->Effect.map(_ => Error(
+        ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg),
+      ))
     }
   )
   ->Effect.catchAll(err => {
     let msg = DynamoDb_Error.message(err)
     let errorMsg = `writeBatch: Couldn't save states to ${tableName}, ${count} ids:${allIdsStr}: ${msg}`
-    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)
-    ->Effect.map(_ => Error(ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg)))
+    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)->Effect.map(_ => Error(
+      ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg),
+    ))
   })
   ->Effect.runPromise
 }
@@ -199,8 +193,9 @@ let count = table =>
             key: [("id", id->JSON.Encode.string)]->Dict.fromArray,
             updateExpression: "ADD #fieldName :inc",
             expressionAttributeNames: [("#fieldName", fieldName)]->Dict.fromArray,
-            expressionAttributeValues: [(":inc", inc->Int.toFloat->JSON.Encode.float)]
-            ->Dict.fromArray,
+            expressionAttributeValues: [
+              (":inc", inc->Int.toFloat->JSON.Encode.float),
+            ]->Dict.fromArray,
             returnValues: #UPDATED_NEW,
           })->UpdateCommand.send,
       )
@@ -212,15 +207,16 @@ let count = table =>
         ReventlessCore.EffectLogger.logError(
           ~comp=__MODULE__,
           `count: Invalid updateOutput in count on ${tableName}`,
-        )
-        ->Effect.map(_ =>
-          Error(ReventlessInfra.QueryDb.NotCountedOnStorage("Invalid updateOutput in count"))
-        )
+        )->Effect.map(_ => Error(
+          ReventlessInfra.QueryDb.NotCountedOnStorage("Invalid updateOutput in count"),
+        ))
       }
     )
     ->Effect.catchAll(errorMsg =>
-      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `count: Couldn't count on ${tableName}: ${errorMsg}`)
-      ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotCountedOnStorage(errorMsg)))
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        `count: Couldn't count on ${tableName}: ${errorMsg}`,
+      )->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotCountedOnStorage(errorMsg)))
     )
     ->Effect.runPromise
   }
@@ -235,15 +231,17 @@ let delete = table =>
       | Ok() =>
         ReventlessCore.EffectLogger.logInfo(
           ~comp=__MODULE__,
-          `delete: deleted state from ${tableName}: id=${id}, sort=${sort->JSON.stringifyAny->Option.getOr("None")}`,
-        )
-        ->Effect.map(_ => Ok())
+          `delete: deleted state from ${tableName}: id=${id}, sort=${sort
+            ->JSON.stringifyAny
+            ->Option.getOr("None")}`,
+        )->Effect.map(_ => Ok())
       | Error(errorMsg) =>
         ReventlessCore.EffectLogger.logError(
           ~comp=__MODULE__,
-          `delete: Couldn't delete state from ${tableName}, id=${id}, sort=${sort->JSON.stringifyAny->Option.getOr("None")}: ${errorMsg}`,
-        )
-        ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotDeletedFromStorage(errorMsg)))
+          `delete: Couldn't delete state from ${tableName}, id=${id}, sort=${sort
+            ->JSON.stringifyAny
+            ->Option.getOr("None")}: ${errorMsg}`,
+        )->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotDeletedFromStorage(errorMsg)))
       }
     )
     ->Effect.runPromise

package/src/adapter/QueryDb/QueryDbStorage_Postgres.res

@@ -24,7 +24,8 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
   ~ttl as _=?,
   ~api as _,
   ~apiRole as _,
-  ~owner as _, ~opts as _,
+  ~owner as _,
+  ~opts as _,
 ) => {
   let operations = switch QueryDbBackend.get() {
   | Some({connectionConfig}) =>
@@ -33,7 +34,9 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
     )
   | None =>
     // Selectable only routes here when a selection is set; guard defensively.
-    JsError.throwWithMessage("QueryDbStorage_Postgres.make called without a QueryDbBackend selection")
+    JsError.throwWithMessage(
+      "QueryDbStorage_Postgres.make called without a QueryDbBackend selection",
+    )
   }
   {
     ReventlessCore.QueryDb_Adapter.resources: [],

package/src/adapter/QueryDb/QueryInterceptor_Provisioning.res

@@ -28,7 +28,6 @@
     compose: that path bundles registered runtime extensions into the archive and
     writes `RUNTIME_EXTENSIONS`, so an extension registering its interceptor in
     `onColdStart` reaches this runtime without a second registration. */
-
 open PulumiAws
 
 // Memoised on the api handle itself — see the module docstring for why identity
@@ -46,9 +45,7 @@ let nameFor = () => {
   let owner = ReventlessCore.ResourceAttribution.current.contents.plugin->Option.getOr("Platform")
   let used = namesUsed->Dict.get(owner)->Option.getOr(0)
   namesUsed->Dict.set(owner, used + 1)
-  used == 0
-    ? owner ++ "QueryInterceptor"
-    : owner ++ "QueryInterceptor" ++ (used + 1)->Int.toString
+  used == 0 ? owner ++ "QueryInterceptor" : owner ++ "QueryInterceptor" ++ (used + 1)->Int.toString
 }
 
 let buildInterceptor = (~api: Types.AppSync.api, ~opts) => {

package/src/adapter/QueryEngine/QueryEngine_DynamoDb.res

@@ -109,7 +109,10 @@ let queryByTableName = (
     ->Effect.map(items => items->Array.map(js => js->JSON.stringify->JSON.parseOrThrow))
     ->Effect.catchAll(err => {
       let msg = DynamoDb_Error.message(err)
-      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, "queryByTableName: " ++ msg)->Effect.map(_ => [])
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        "queryByTableName: " ++ msg,
+      )->Effect.map(_ => [])
     })
   )
   ->Effect.runPromise
@@ -145,7 +148,10 @@ let scanByTableName = (~tableName, ~filterConfigs, ~limit) => {
     ->Effect.map(items => items->Array.map(js => js->JSON.stringify->JSON.parseOrThrow))
     ->Effect.catchAll(err => {
       let msg = DynamoDb_Error.message(err)
-      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, "scanByTableName: " ++ msg)->Effect.map(_ => [])
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        "scanByTableName: " ++ msg,
+      )->Effect.map(_ => [])
     })
   )
   ->Effect.runPromise

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro.res

@@ -75,44 +75,30 @@ let forCommandGenerator: ReventlessCore.Runtime.forComponent<
   ReventlessCore.CommandGenerator.effectEventHandler<context>,
   runtimeParts,
   ReventlessCore.CommandGenerator.component,
-> = (
-  ~handler as _,
-  ~connect,
-  ~memorySize=1024,
-  ~timeout=30,
-  commandGenerator,
-) => {
+> = (~handler as _, ~connect, ~memorySize=1024, ~timeout=30, commandGenerator) => {
   let resource = commandGenerator->ReventlessCore.Component.toPulumiResource
   switch resource.parent {
   | Some(aggregateResource) =>
     let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
     let spec = getStoredSpec(aggregateName, aggregateResource)
-    storedSpecs->Dict.set(aggregateName, {
-      ...spec,
-      commandGeneratorConnects: spec.commandGeneratorConnects->Array.concat([connect]),
-      commandGeneratorMemorySize: Math.Int.max(spec.commandGeneratorMemorySize, memorySize),
-      commandGeneratorTimeout: Math.Int.max(spec.commandGeneratorTimeout, timeout),
-    })
+    storedSpecs->Dict.set(
+      aggregateName,
+      {
+        ...spec,
+        commandGeneratorConnects: spec.commandGeneratorConnects->Array.concat([connect]),
+        commandGeneratorMemorySize: Math.Int.max(spec.commandGeneratorMemorySize, memorySize),
+        commandGeneratorTimeout: Math.Int.max(spec.commandGeneratorTimeout, timeout),
+      },
+    )
   | None => ()
   }
 }
 
 let forCommandTopic: ReventlessCore.Runtime.forComponent<
-  ReventlessCore.Runtime.effectHandler<
-    CommandTopicChannel.callbackEvent,
-    context,
-    unit,
-    string,
-  >,
+  ReventlessCore.Runtime.effectHandler<CommandTopicChannel.callbackEvent, context, unit, string>,
   runtimeParts,
   ReventlessCore.CommandTopic.component<'op>,
-> = (
-  ~handler as _,
-  ~connect,
-  ~memorySize=1024,
-  ~timeout=30,
-  commandTopic,
-) => {
+> = (~handler as _, ~connect, ~memorySize=1024, ~timeout=30, commandTopic) => {
   let commandTopicResource = commandTopic->ReventlessCore.Component.toPulumiResource
   switch commandTopicResource.parent {
   | Some(aggregateResource) =>
@@ -122,50 +108,42 @@ let forCommandTopic: ReventlessCore.Runtime.forComponent<
     let queue = channelParts.queue
 
     let spec = getStoredSpec(aggregateName, aggregateResource)
-    storedSpecs->Dict.set(aggregateName, {
-      ...spec,
-      queueUrl: queue.id,
-      queueArn: queue.arn,
-      commandTopicConnects: spec.commandTopicConnects->Array.concat([connect]),
-      commandTopicMemorySize: Math.Int.max(spec.commandTopicMemorySize, memorySize),
-      commandTopicTimeout: Math.Int.max(spec.commandTopicTimeout, timeout),
-    })
+    storedSpecs->Dict.set(
+      aggregateName,
+      {
+        ...spec,
+        queueUrl: queue.id,
+        queueArn: queue.arn,
+        commandTopicConnects: spec.commandTopicConnects->Array.concat([connect]),
+        commandTopicMemorySize: Math.Int.max(spec.commandTopicMemorySize, memorySize),
+        commandTopicTimeout: Math.Int.max(spec.commandTopicTimeout, timeout),
+      },
+    )
   | None =>
     let name = commandTopicResource.name->Option.getOr("Unnamed")
-    JsError.throwWithMessage(
-      `forCommandTopic(micro): commandTopic ${name} has no Aggregate parent`,
-    )
+    JsError.throwWithMessage(`forCommandTopic(micro): commandTopic ${name} has no Aggregate parent`)
   }
 }
 
 let forEventCollector: ReventlessCore.Runtime.forEventCollector<
-  ReventlessCore.Runtime.effectHandler<
-    EventCollectorChannel.callbackEvent,
-    context,
-    unit,
-    string,
-  >,
+  ReventlessCore.Runtime.effectHandler<EventCollectorChannel.callbackEvent, context, unit, string>,
   ReventlessCore.EventCollector.component,
-> = (
-  ~handler as _,
-  ~eventTopics,
-  ~resources,
-  ~memorySize=2048,
-  ~timeout=180,
-  eventCollector,
-) => {
+> = (~handler as _, ~eventTopics, ~resources, ~memorySize=2048, ~timeout=180, eventCollector) => {
   let eventCollectorResource = eventCollector->ReventlessCore.Component.toPulumiResource
   let channel = eventCollector->ReventlessCore.EventCollector_Adapter.channel
   switch eventCollectorResource.parent->Option.flatMap(parent => parent.parent) {
   | Some(aggregateResource) =>
     let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
     let spec = getStoredSpec(aggregateName, aggregateResource)
-    storedSpecs->Dict.set(aggregateName, {
-      ...spec,
-      eventCollectorChannelSpec: Some({channel, eventTopics, resources}),
-      eventCollectorMemorySize: Math.Int.max(spec.eventCollectorMemorySize, memorySize),
-      eventCollectorTimeout: Math.Int.max(spec.eventCollectorTimeout, timeout),
-    })
+    storedSpecs->Dict.set(
+      aggregateName,
+      {
+        ...spec,
+        eventCollectorChannelSpec: Some({channel, eventTopics, resources}),
+        eventCollectorMemorySize: Math.Int.max(spec.eventCollectorMemorySize, memorySize),
+        eventCollectorTimeout: Math.Int.max(spec.eventCollectorTimeout, timeout),
+      },
+    )
   | None =>
     let name = eventCollectorResource.name->Option.getOr("Unnamed")
     JsError.throwWithMessage(
@@ -198,13 +176,11 @@ let finish = () =>
           packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
           packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
 
-          let specModule =
-            info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
-          let behaviorModule =
-            info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
+          let specModule = info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+          let behaviorModule = info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
 
           // --- CommandTopic Lambda ---
-// `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
+          // `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
           // deploy-time structure, and the Lambda-name fallback yields nothing for a
           // shared or per-aggregate command handler. Resolve it here; the shell still
           // derives `comp` itself from the spec name.
@@ -212,15 +188,24 @@ let finish = () =>
             ~comp=`AggregateRuntime(${spec.aggregateName})`,
           )
           let cmdTopicHandlerConfigOutput =
-            Pulumi.Output.all3((info.eventLogTableName, spec.queueUrl, spec.queueArn))
-            ->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
+            Pulumi.Output.all3((
+              info.eventLogTableName,
+              spec.queueUrl,
+              spec.queueArn,
+            ))->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
               `{"handlers":[{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pluginFragment}}]}`
             )
 
           let cmdTopicEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
-          cmdTopicEnvVars->Dict.set("HANDLER_CONFIG", cmdTopicHandlerConfigOutput->Pulumi.Output.asInput)
+          cmdTopicEnvVars->Dict.set(
+            "HANDLER_CONFIG",
+            cmdTopicHandlerConfigOutput->Pulumi.Output.asInput,
+          )
 
-          let {code: cmdTopicCode, sourceCodeHash: cmdTopicSourceCodeHash} = Util_Bundle.buildCodeArchive(
+          let {
+            code: cmdTopicCode,
+            sourceCodeHash: cmdTopicSourceCodeHash,
+          } = Util_Bundle.buildCodeArchive(
             ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs",
             ~packageDirs,
           )
@@ -242,7 +227,7 @@ let finish = () =>
 
           // --- CommandGenerator Lambda ---
           if spec.commandGeneratorConnects->Array.length > 0 {
-// `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
+            // `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
             // deploy-time structure, and the Lambda-name fallback yields nothing for a
             // shared or per-aggregate command handler. Resolve it here; the shell still
             // derives `comp` itself from the spec name.
@@ -250,15 +235,24 @@ let finish = () =>
               ~comp=`AggregateRuntime(${spec.aggregateName})`,
             )
             let cmdGenHandlerConfigOutput =
-              Pulumi.Output.all3((info.eventLogTableName, spec.queueUrl, spec.queueArn))
-              ->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
+              Pulumi.Output.all3((
+                info.eventLogTableName,
+                spec.queueUrl,
+                spec.queueArn,
+              ))->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
                 `{"handlers":[{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pluginFragment}}]}`
               )
 
             let cmdGenEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
-            cmdGenEnvVars->Dict.set("HANDLER_CONFIG", cmdGenHandlerConfigOutput->Pulumi.Output.asInput)
+            cmdGenEnvVars->Dict.set(
+              "HANDLER_CONFIG",
+              cmdGenHandlerConfigOutput->Pulumi.Output.asInput,
+            )
 
-            let {code: cmdGenCode, sourceCodeHash: cmdGenSourceCodeHash} = Util_Bundle.buildCodeArchive(
+            let {
+              code: cmdGenCode,
+              sourceCodeHash: cmdGenSourceCodeHash,
+            } = Util_Bundle.buildCodeArchive(
               ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs",
               ~packageDirs,
             )
@@ -276,9 +270,7 @@ let finish = () =>
               ~opts=aggregateOpts,
             )
 
-            spec.commandGeneratorConnects->Array.forEach(connect =>
-              connect(~runtime=cmdGenRuntime)
-            )
+            spec.commandGeneratorConnects->Array.forEach(connect => connect(~runtime=cmdGenRuntime))
           }
 
           // --- EventMapper Lambda ---
@@ -286,14 +278,11 @@ let finish = () =>
           | (Some(channelSpec), Some(mappingsModulePath)) =>
             let evtMapperEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
 
-            let targetSpecModule =
-              info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
-            let mappingsModuleJson =
-              mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let targetSpecModule = info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let mappingsModuleJson = mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
 
             let handlerConfigJson =
-              spec.queueUrl
-              ->Pulumi.Output.apply(queueUrl =>
+              spec.queueUrl->Pulumi.Output.apply(queueUrl =>
                 `{"targetSpecModule":${targetSpecModule},"mappingsModule":${mappingsModuleJson},"queueUrl":"${queueUrl}"}`
               )
             evtMapperEnvVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
@@ -304,7 +293,10 @@ let finish = () =>
             evtMapperPackageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
             evtMapperPackageDirs->Dict.set(mappingsPkg, Util_Bundle.resolvePackageRoot(mappingsPkg))
 
-            let {code: evtMapperCode, sourceCodeHash: evtMapperSourceCodeHash} = Util_Bundle.buildCodeArchive(
+            let {
+              code: evtMapperCode,
+              sourceCodeHash: evtMapperSourceCodeHash,
+            } = Util_Bundle.buildCodeArchive(
               ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/EventMapperEntryPoint.mjs",
               ~packageDirs=evtMapperPackageDirs,
             )