@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_FIFO.res

@@ -0,0 +1,60 @@
+type callbackEvent = PulumiAws.SQS.Queue.event
+type runtimeParts = Util.Lambda.runtimeParts
+type channelParts = Util.SQS.channelParts
+
+let connect = CommandTopicChannel_SQS.connect
+
+let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  Util.SQS.channelParts,
+  Util.Lambda.runtimeParts,
+> = (~name, ~opts=?) => {
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let queue = PulumiAws.SQS.Queue.make(
+    ~name,
+    ~args={
+      PulumiAws.SQS.Queue.fifoQueue: true->Pulumi.Input.make,
+      contentBasedDeduplication: true->Pulumi.Input.make,
+      visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
+      redrivePolicy: Util_DeadLetterQueue.fifoQueue.arn
+      ->Pulumi.Output.apply(dlqArn => {
+        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+      })
+      ->Pulumi.Output.asInput,
+      sqsManagedSseEnabled: false->Pulumi.Input.make,
+      deduplicationScope: MessageGroup,
+      fifoThroughputLimit: PerMessageGroupId,
+      tags,
+    },
+    ~opts?,
+  )
+
+  let resolvedQueueOutput = queue->Util_SQS.toResolvedQueueOutput
+
+  {
+    parts: {queue: queue},
+    resources: [queue->Util_SQS_FIFO.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    publishJsons: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+      resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO, ...)
+    ),
+    publishJsonsStream: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue => {
+      let publishJsons =
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO, ...)
+      stream =>
+        stream
+        ->Stream.grouped(10)
+        ->Stream.runForEach(jsons =>
+          Effect.promise(() => publishJsons(jsons))
+        )
+    }),
+    publishJsonsAndWait: None->Pulumi.Output.make,
+    connect,
+    handleChannelEvent: handleCommands =>
+      resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.handleQueueEvent(handleCommands, ...)
+      ),
+  }
+}

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_FIFO.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as Util_SQS$ReventlessAws from "../../util/Util_SQS.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as Util_SQS_FIFO$ReventlessAws from "../../util/Util_SQS_FIFO.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as CommandTopicChannel_SQS$ReventlessAws from "./CommandTopicChannel_SQS.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "./CommandTopicChannel_SQS_Runtime.res.mjs";
+
+function make(name, opts) {
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let queue = new (Aws.sqs.Queue)(name, {
+    contentBasedDeduplication: true,
+    fifoQueue: true,
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    tags: tags,
+    visibilityTimeoutSeconds: 180,
+    deduplicationScope: "messageGroup",
+    fifoThroughputLimit: "perMessageGroupId",
+    sqsManagedSseEnabled: false
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let resolvedQueueOutput = Util_SQS$ReventlessAws.toResolvedQueueOutput(queue);
+  return {
+    parts: {
+      queue: queue
+    },
+    resources: [Util_SQS_FIFO$ReventlessAws.toResource(tags, queue)],
+    publishJsons: resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS_FIFO")),
+    publishJsonsStream: resolvedQueueOutput.apply(resolvedQueue => {
+      let publishJsons = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS_FIFO");
+      return stream => Stream$1.runForEach(Stream.grouped(stream, 10), jsons => Effect.promise(() => publishJsons(jsons)));
+    }),
+    publishJsonsAndWait: Pulumi.output(undefined),
+    handleChannelEvent: handleCommands => resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.handleQueueEvent(resolvedQueue, handleCommands)),
+    connect: CommandTopicChannel_SQS$ReventlessAws.connect
+  };
+}
+
+let connect = CommandTopicChannel_SQS$ReventlessAws.connect;
+
+export {
+  connect,
+  make,
+}
+/* Stream Not a pure module */

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res

@@ -0,0 +1,73 @@
+let handleQueueEvent = (
+  queue,
+  handleJsonCommands: ReventlessCore.CommandTopic.jsonCommandsHandler,
+) =>
+  (event: PulumiAws.SQS.Queue.event, _) => {
+    let records = event.records
+    let jsons = records->Array.filterMap(record => {
+      let commandStr = record.body
+      switch JSON.parseOrThrow(commandStr) {
+      | json => Some(json)
+      | exception _err => None
+      }
+    })
+    let topicItems =
+      records
+      ->Array.map(record => record.receiptHandle)
+      ->Array.zip(jsons)
+      ->Array.map(((reference, command)) => {
+        ReventlessInfra.CommandTopic.reference,
+        command,
+      })
+
+    Stream.fromIterable(topicItems)
+    ->handleJsonCommands
+    ->Effect.flatMap(results => {
+      let deleteEntries =
+        results
+        ->Array.mapWithIndex(
+          (result, idx) =>
+            switch result {
+            | Ok(reference) =>
+              let deleteMessageBatchEntry: AwsSdk.SQS.DeleteMessageBatchCommand.deleteMessageBatchEntry = {
+                id: idx->Int.toString,
+                receiptHandle: reference,
+              }
+              deleteMessageBatchEntry->Some
+            | Error(reference) =>
+              ReventlessCore.EffectLogger.logError(
+                ~comp=__MODULE__,
+                "handleQueueEvent: Couldn't handle command with ReceiptHandle: " ++ reference,
+              )->Effect.runSync
+              None
+            },
+        )
+        ->Array.filterMap(x => x)
+
+      switch deleteEntries {
+      | [] => Effect.succeed()
+      | entries =>
+        Util.SQS_Runtime.deleteMessages(entries, queue)
+        ->Effect.tap(_ => ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, "handleQueueEvent: Deleted all commands from queue"))
+        ->Effect.catchAll(errorMsg =>
+          ReventlessCore.EffectLogger.logError(
+            ~comp=__MODULE__,
+            "handleQueueEvent: Couldn't deleteMessageBatch: " ++ errorMsg,
+          )
+        )
+      }
+    })
+  }
+
+let publishJsons = (queue, queueService) =>
+  async jsons =>
+    switch jsons->Array.length {
+    | 0 =>
+      ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, "publishJsons: No commands to send")->Effect.runPromise->ignore
+    | 1 =>
+      await queue->Util_SQS_Runtime.send(queueService, jsons->Array.getUnsafe(0))->Effect.runPromise
+    | _ =>
+      await queue
+      ->Util_SQS_Runtime.sendMessages(queueService, jsons)
+      ->Effect.runPromise
+    }

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as Util_SQS_Runtime$ReventlessAws from "../../util/Util_SQS_Runtime.res.mjs";
+
+function handleQueueEvent(queue, handleJsonCommands) {
+  return (event, param) => {
+    let records = event.Records;
+    let jsons = Stdlib_Array.filterMap(records, record => {
+      let commandStr = record.body;
+      let json;
+      try {
+        json = JSON.parse(commandStr);
+      } catch (_err) {
+        return;
+      }
+      return json;
+    });
+    let topicItems = Stdlib_Array.zip(records.map(record => record.receiptHandle), jsons).map(param => ({
+      command: param[1],
+      reference: param[0]
+    }));
+    return Effect.flatMap(handleJsonCommands(Stream.fromIterable(topicItems)), results => {
+      let deleteEntries = Stdlib_Array.filterMap(results.map((result, idx) => {
+        if (result.TAG === "Ok") {
+          return {
+            Id: idx.toString(),
+            ReceiptHandle: result._0
+          };
+        }
+        Effect.runSync(EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Couldn't handle command with ReceiptHandle: " + result._0));
+      }), x => x);
+      if (deleteEntries.length !== 0) {
+        return Effect.catchAll(Effect.tap(Util_SQS_Runtime$ReventlessAws.deleteMessages(deleteEntries, queue), () => EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Deleted all commands from queue")), errorMsg => EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Couldn't deleteMessageBatch: " + errorMsg));
+      } else {
+        return Effect.succeed();
+      }
+    });
+  };
+}
+
+function publishJsons(queue, queueService) {
+  return async jsons => {
+    let match = jsons.length;
+    if (match !== 0) {
+      if (match !== 1) {
+        return await Effect.runPromise(Util_SQS_Runtime$ReventlessAws.sendMessages(queue, queueService, jsons));
+      } else {
+        return await Effect.runPromise(Util_SQS_Runtime$ReventlessAws.send(queue, queueService, jsons[0]));
+      }
+    } else {
+      Effect.runPromise(EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "publishJsons: No commands to send"));
+      return;
+    }
+  };
+}
+
+export {
+  handleQueueEvent,
+  publishJsons,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res

@@ -0,0 +1,88 @@
+// SQS-backed CommandTopic channel with synchronous command execution.
+// Uses a standard (non-FIFO) SQS queue for infrastructure.
+// publishJsonsAndWait captures the command handler (set via handleChannelEvent) and
+// runs it inline, returning typed CommandResult outcomes without a queue round-trip.
+// Falls back to fire-and-forget + Pending when the handler is not yet registered
+// (e.g. PerAggregate strategy where resolver and handler run in separate Lambdas).
+
+type callbackEvent = PulumiAws.SQS.Queue.event
+type runtimeParts = Util.Lambda.runtimeParts
+type channelParts = Util.SQS.channelParts
+
+let connect = CommandTopicChannel_SQS.connect
+
+// See CommandTopicChannel_SQS_Async for the rationale behind these re-exports.
+let setBatchSize = CommandTopicChannel_SQS.setBatchSize
+let clearBatchSize = CommandTopicChannel_SQS.clearBatchSize
+
+let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  Util.SQS.channelParts,
+  Util.Lambda.runtimeParts,
+> = (~name, ~opts=?) => {
+  // Captured when handleChannelEvent is called; used by publishJsonsAndWait to
+  // run the handler inline and collect typed outcomes without going through SQS.
+  let handleCmdsRef: ref<option<ReventlessCore.CommandTopic.jsonCommandsHandler>> = ref(None)
+
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let queue = PulumiAws.SQS.Queue.make(
+    ~name,
+    ~args={
+      PulumiAws.SQS.Queue.visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
+      redrivePolicy: Util_DeadLetterQueue.queue.arn
+      ->Pulumi.Output.apply(dlqArn =>
+        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+      )
+      ->Pulumi.Output.asInput,
+      sqsManagedSseEnabled: false->Pulumi.Input.make,
+      tags,
+    },
+    ~opts?,
+  )
+
+  let resolvedQueueOutput = queue->Util_SQS.toResolvedQueueOutput
+
+  {
+    ReventlessCore.CommandTopic_Adapter.parts: {queue: queue},
+    resources: [queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    publishJsons: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+      resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...)
+    ),
+    publishJsonsStream: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue => {
+      let publishJsons = resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...)
+      stream =>
+        stream
+        ->Stream.grouped(10)
+        ->Stream.runForEach(jsons => Effect.promise(() => publishJsons(jsons)))
+    }),
+    // publishJsonsAndWait runs the handler inline when available (Single runtime strategy).
+    // Falls back to SQS fire-and-forget + Pending for PerAggregate strategy.
+    publishJsonsAndWait: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue => {
+      let sendToSqs = resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...)
+      let publishJsonsAndWait: ReventlessCore.CommandTopic.publishJsonsAndWait = async jsons => {
+        switch handleCmdsRef.contents {
+        | None =>
+          // Handler not yet registered — fall back to fire-and-forget, return Pending
+          let _ = await sendToSqs(jsons)
+          jsons->Array.map(cmdJson =>
+            ReventlessCore.CommandTopic.Pending({msgId: cmdJson.meta.msgId})
+          )
+        | Some(handleCmds) =>
+          await ReventlessCore.CommandTopic.runInlineAndCollect(jsons, handleCmds)
+        }
+      }
+      Some(publishJsonsAndWait)
+    }),
+    connect,
+    handleChannelEvent: handleCommands => {
+      handleCmdsRef.contents = Some(handleCommands)
+      resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.handleQueueEvent(handleCommands, ...)
+      )
+    },
+  }
+}

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as Util_SQS$ReventlessAws from "../../util/Util_SQS.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as CommandTopicChannel_SQS$ReventlessAws from "./CommandTopicChannel_SQS.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "./CommandTopicChannel_SQS_Runtime.res.mjs";
+
+function make(name, opts) {
+  let handleCmdsRef = {
+    contents: undefined
+  };
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let queue = new (Aws.sqs.Queue)(name, {
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    tags: tags,
+    visibilityTimeoutSeconds: 180,
+    sqsManagedSseEnabled: false
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let resolvedQueueOutput = Util_SQS$ReventlessAws.toResolvedQueueOutput(queue);
+  return {
+    parts: {
+      queue: queue
+    },
+    resources: [Util_SQS$ReventlessAws.toResource(tags, queue)],
+    publishJsons: resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS")),
+    publishJsonsStream: resolvedQueueOutput.apply(resolvedQueue => {
+      let publishJsons = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS");
+      return stream => Stream$1.runForEach(Stream.grouped(stream, 10), jsons => Effect.promise(() => publishJsons(jsons)));
+    }),
+    publishJsonsAndWait: resolvedQueueOutput.apply(resolvedQueue => {
+      let sendToSqs = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS");
+      return async jsons => {
+        let handleCmds = handleCmdsRef.contents;
+        if (handleCmds !== undefined) {
+          return await CommandTopic$ReventlessCore.runInlineAndCollect(jsons, handleCmds);
+        } else {
+          await sendToSqs(jsons);
+          return jsons.map(cmdJson => ({
+            TAG: "Pending",
+            msgId: cmdJson.meta.msgId
+          }));
+        }
+      };
+    }),
+    handleChannelEvent: handleCommands => {
+      handleCmdsRef.contents = handleCommands;
+      return resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.handleQueueEvent(resolvedQueue, handleCommands));
+    },
+    connect: CommandTopicChannel_SQS$ReventlessAws.connect
+  };
+}
+
+let connect = CommandTopicChannel_SQS$ReventlessAws.connect;
+
+let setBatchSize = CommandTopicChannel_SQS$ReventlessAws.setBatchSize;
+
+let clearBatchSize = CommandTopicChannel_SQS$ReventlessAws.clearBatchSize;
+
+export {
+  connect,
+  setBatchSize,
+  clearBatchSize,
+  make,
+}
+/* Stream Not a pure module */

package/src/adapter/CommandTopic/CommandTopicRemoteChannel.res

@@ -0,0 +1 @@
+module SQS = CommandTopicRemoteChannel_SQS

package/src/adapter/CommandTopic/CommandTopicRemoteChannel.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let SQS;
+
+export {
+  SQS,
+}
+/* No side effect */

package/src/adapter/CommandTopic/CommandTopicRemoteChannel_SQS.res

@@ -0,0 +1,7 @@
+let make: ReventlessCore.CommandTopic_Adapter.remoteChannelMaker = resources => {
+  resources,
+  remotePublish: resources
+  ->Util.SQS.findResolvedResource
+  ->Util_SQS_Runtime.toResolvedQueue
+  ->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...),
+}

package/src/adapter/CommandTopic/CommandTopicRemoteChannel_SQS.res.mjs

@@ -0,0 +1,17 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Util_SQS$ReventlessAws from "../../util/Util_SQS.res.mjs";
+import * as Util_SQS_Runtime$ReventlessAws from "../../util/Util_SQS_Runtime.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "./CommandTopicChannel_SQS_Runtime.res.mjs";
+
+function make(resources) {
+  return {
+    resources: resources,
+    remotePublish: CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(Util_SQS_Runtime$ReventlessAws.toResolvedQueue(Util_SQS$ReventlessAws.findResolvedResource(resources)), "SQS")
+  };
+}
+
+export {
+  make,
+}
+/* Util_SQS-ReventlessAws Not a pure module */

package/src/adapter/Counter/CounterHandler_DynamoDbStream.res

@@ -0,0 +1,103 @@
+let make: ReventlessCore.Counter_Adapter.handlerMaker = (
+  ~name,
+  ~referencesName,
+  ~referencesDb,
+  ~countsName,
+  ~countsDb,
+  ~counterHandler as _,
+  ~specModulePath,
+  ~mappingsModulePath,
+  ~publishChannelId,
+  ~opts,
+) => {
+  let referencesDbResource = referencesDb.resources->Util.DynamoDbStream.findResource
+  let referencesStream = referencesDbResource->Util.DynamoDbStream.toStreamResource
+  let countsDbResource = countsDb.resources->Util.DynamoDbStream.findResource
+  let countsStream = countsDbResource->Util.DynamoDbStream.toStreamResource
+
+  let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+
+  let countsTableName = (countsDb.resources->Array.getUnsafe(0)).name
+
+  let targetSpecModule =
+    specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+  let mappingsModule =
+    mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+  let handlerConfigJson =
+    Pulumi.Output.all3((countsTableName, publishChannelId, referencesStream.urn))
+    ->Pulumi.Output.apply(((table, queueUrl, refArn)) => {
+      let countsArn = "" // Will be set separately
+      `{"targetSpecModule":${targetSpecModule},"mappingsModule":${mappingsModule},"countsTableName":"${table}","publishChannelId":"${queueUrl}","referencesStreamArn":"${refArn}","countsStreamArn":"${countsArn}"}`
+    })
+
+  // countsStreamArn is in a separate Output — merge into config
+  let fullHandlerConfigJson =
+    Pulumi.Output.all2((handlerConfigJson, countsStream.urn))
+    ->Pulumi.Output.apply(((config, countsArn)) =>
+      config->String.replace(`"countsStreamArn":""`, `"countsStreamArn":"${countsArn}"`)
+    )
+
+  envVars->Dict.set("HANDLER_CONFIG", fullHandlerConfigJson->Pulumi.Output.asInput)
+
+  // Build code asset
+  let packageDirs: dict<string> = Dict.make()
+  let specPkg = Util_Bundle.extractPackageName(specModulePath)
+  let mappingsPkg = Util_Bundle.extractPackageName(mappingsModulePath)
+  packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+  packageDirs->Dict.set(mappingsPkg, Util_Bundle.resolvePackageRoot(mappingsPkg))
+
+  let reExportCode = `export { handler } from "@reventlessdev/reventless-aws/src/adapter/Runtime/CounterEntryPoint.mjs";`
+
+  let archiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
+  archiveContents->Dict.set(
+    "index.mjs",
+    Pulumi.Asset.stringAsset(reExportCode)->Pulumi.Archive.assetToAssetOrArchive,
+  )
+  let packageContentHashes: ref<array<string>> = ref([])
+  packageDirs->Dict.forEachWithKey((pkgRoot, pkgName) => {
+    let (archive, contentHash) = Util_Bundle.createFilteredPackageArchive(pkgRoot)
+    archiveContents->Dict.set(
+      `node_modules/${pkgName}`,
+      archive->Pulumi.Archive.archiveToAssetOrArchive,
+    )
+    packageContentHashes.contents->Array.push(`${pkgName}:${contentHash}`)
+  })
+
+  let code = Pulumi.Archive.assetArchive(archiveContents)
+  packageContentHashes.contents->Array.sort(String.compare)
+  let sourceCodeHash = Util_Bundle.hashString(
+    reExportCode ++ packageContentHashes.contents->Array.join(","),
+  )
+
+  let componentOpts: Pulumi.ComponentResource.options = {parent: ?opts.parent}
+
+  let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+    ~name,
+    ~code,
+    ~sourceCodeHash,
+    ~envVars,
+    ~memorySize=1024,
+    ~timeout=30,
+    ~opts=componentOpts,
+  )
+
+  let lambda = runtime.parts.lambda
+
+  let subscribe = (sourceName, source) =>
+    Util_EventSourceMapping.subscribe(
+      ~lambda=lambda,
+      ~targetName=name,
+      ~sourceName,
+      ~source,
+      ~opts,
+    )
+
+  let _ = subscribe(referencesName, referencesStream)
+  let _ = subscribe(countsName, countsStream)
+
+  {
+    ReventlessCore.Counter_Adapter.addToCounterTarget: counterTarget =>
+      CounterHandler_DynamoDbStream_Runtime.addToCounterTarget(countsDbResource, counterTarget),
+  }
+}

package/src/adapter/Counter/CounterHandler_DynamoDbStream.res.mjs

@@ -0,0 +1,68 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as Util_DynamoDbStream$ReventlessAws from "../../util/Util_DynamoDbStream.res.mjs";
+import * as Util_EventSourceMapping$ReventlessAws from "../../util/Util_EventSourceMapping.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as CounterHandler_DynamoDbStream_Runtime$ReventlessAws from "./CounterHandler_DynamoDbStream_Runtime.res.mjs";
+
+function make(name, referencesName, referencesDb, countsName, countsDb, param, specModulePath, mappingsModulePath, publishChannelId, opts) {
+  let referencesDbResource = Util_DynamoDbStream$ReventlessAws.findResource(referencesDb.resources);
+  let referencesStream = Util_DynamoDbStream$ReventlessAws.toStreamResource(referencesDbResource);
+  let countsDbResource = Util_DynamoDbStream$ReventlessAws.findResource(countsDb.resources);
+  let countsStream = Util_DynamoDbStream$ReventlessAws.toStreamResource(countsDbResource);
+  let envVars = {};
+  let countsTableName = countsDb.resources[0].name;
+  let targetSpecModule = Stdlib_Option.getOr(JSON.stringify(specModulePath), `""`);
+  let mappingsModule = Stdlib_Option.getOr(JSON.stringify(mappingsModulePath), `""`);
+  let handlerConfigJson = Pulumi.all([
+    countsTableName,
+    publishChannelId,
+    referencesStream.urn
+  ]).apply(param => `{"targetSpecModule":` + targetSpecModule + `,"mappingsModule":` + mappingsModule + `,"countsTableName":"` + param[0] + `","publishChannelId":"` + param[1] + `","referencesStreamArn":"` + param[2] + `","countsStreamArn":""}`);
+  let fullHandlerConfigJson = Pulumi.all([
+    handlerConfigJson,
+    countsStream.urn
+  ]).apply(param => param[0].replace(`"countsStreamArn":""`, `"countsStreamArn":"` + param[1] + `"`));
+  envVars["HANDLER_CONFIG"] = fullHandlerConfigJson;
+  let packageDirs = {};
+  let specPkg = Util_Bundle$ReventlessAws.extractPackageName(specModulePath);
+  let mappingsPkg = Util_Bundle$ReventlessAws.extractPackageName(mappingsModulePath);
+  packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+  packageDirs[mappingsPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(mappingsPkg);
+  let reExportCode = `export { handler } from "@reventlessdev/reventless-aws/src/adapter/Runtime/CounterEntryPoint.mjs";`;
+  let archiveContents = {};
+  archiveContents["index.mjs"] = new (Pulumi.asset.StringAsset)(reExportCode);
+  let packageContentHashes = {
+    contents: []
+  };
+  Stdlib_Dict.forEachWithKey(packageDirs, (pkgRoot, pkgName) => {
+    let match = Util_Bundle$ReventlessAws.createFilteredPackageArchive(pkgRoot);
+    archiveContents[`node_modules/` + pkgName] = match[0];
+    packageContentHashes.contents.push(pkgName + `:` + match[1]);
+  });
+  let code = new (Pulumi.asset.AssetArchive)(archiveContents);
+  packageContentHashes.contents.sort(Primitive_string.compare);
+  let sourceCodeHash = Util_Bundle$ReventlessAws.hashString(reExportCode + packageContentHashes.contents.join(","));
+  let componentOpts_parent = opts.parent;
+  let componentOpts = {
+    parent: componentOpts_parent
+  };
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, code, sourceCodeHash, envVars, 1024, 30, undefined, undefined, undefined, undefined, componentOpts);
+  let lambda = runtime.parts.lambda;
+  let subscribe = (sourceName, source) => Util_EventSourceMapping$ReventlessAws.subscribe(undefined, lambda, name, sourceName, source, opts);
+  subscribe(referencesName, referencesStream);
+  subscribe(countsName, countsStream);
+  return {
+    addToCounterTarget: counterTarget => CounterHandler_DynamoDbStream_Runtime$ReventlessAws.addToCounterTarget(countsDbResource, counterTarget)
+  };
+}
+
+export {
+  make,
+}
+/* @pulumi/pulumi Not a pure module */