@reventlessdev/reventless-aws 3.0.0-alpha.175 → 3.0.0-alpha.176

package/src/adapter/EventLog/EventLogBackend.res

@@ -0,0 +1,82 @@
+// AWS-side selection for the classic (aggregate) EventLog storage backend — the
+// aggregate analogue of `DcbBackend` (B2.3c).
+//
+// When `Platform.MakeWithConfig` is given a `~pgConnection`, it records the resolved
+// selection here BEFORE any admin/plugin `construct` runs. Read by:
+//   - `EventLogStorage.Selectable` — route classic EventLog storage to Postgres (no
+//     DynamoDB table/stream) and bind the Postgres operation set;
+//   - `Aggregate_Builder_Single(_Async)` — substitute the stable `event_log.log_name`
+//     for the DynamoDB table name registered with the runtime builder;
+//   - `AggregateRuntime_Builder_Single(_Async).finish()` — inject `pgConnection` into
+//     each handler's HANDLER_CONFIG entry (activates the AggregateEntryPoint.mjs
+//     Postgres branch) and put the AllAggregates Lambda in-VPC with secret access;
+//   - `Platform.provisionPgChangeFeedRelay` — relay each classic `event_log` log to
+//     its plugin's EventCollector SQS queue.
+//
+// All classic EventLogs in the platform share one selection, mirroring the DCB
+// toggle. Only the Single (sync/async) aggregate strategies honour it; the
+// PerAggregate and Micro strategies stay DynamoDB-only.
+
+type selection = {
+  connectionConfig: Pulumi.Output.t<PgConnection.connectionConfig>,
+  /** DB-access security group every aggregate/relay Lambda attaches (PgConnection.securityGroupId). */
+  securityGroupId: Pulumi.Output.t<string>,
+  /** Private subnets for the in-VPC aggregate/relay Lambdas (PgConnection.subnetIds). */
+  subnetIds: array<Pulumi.Input.t<string>>,
+}
+
+let selectionRef: ref<option<selection>> = ref(None)
+
+/** Record the classic-EventLog Postgres selection. Called once by the platform before construct. */
+let set = (sel: selection) => selectionRef := Some(sel)
+
+/** The active classic-EventLog Postgres selection, if the platform was given a `PgConnection`. */
+let get = (): option<selection> => selectionRef.contents
+
+/** Whether classic EventLog storage is Postgres-backed on this platform. */
+let isPostgres = (): bool => selectionRef.contents->Option.isSome
+
+// ---------------------------------------------------------------------------
+// Relay-log registry — classic counterpart of DcbBackend's (B2.3d).
+//
+// One entry per Postgres-backed classic log (one per aggregate), assembled across
+// the plugin build in two steps so `makePlatform` can provision the change-feed
+// relay from complete inputs:
+//   1. `EventLogStorage_Postgres.make` registers `{logName, aggregateName}` when
+//      the classic storage is created (logName = `<Aggregate>EventLog`, the
+//      ComponentType-derived name the deploy-time ops and the entry point share).
+//   2. `PluginRuntime_Builder.forPluginEventCollector` attaches that plugin's
+//      EventCollector SQS queue — its `~eventTopics` dict is keyed by aggregate
+//      name, so each key attaches exactly the logs whose DynamoDB stream the
+//      collector would have subscribed to on the DynamoDB path.
+// ---------------------------------------------------------------------------
+type relayLogEntry = {
+  logName: string,
+  aggregateName: string,
+  mutable collectorQueueUrl: option<Pulumi.Output.t<string>>,
+  mutable collectorQueueArn: option<Pulumi.Output.t<string>>,
+}
+
+let relayLogs: array<relayLogEntry> = []
+
+/** Step 1: record a Postgres classic log (from the storage maker). */
+let registerRelayLog = (~logName: string, ~aggregateName: string) =>
+  relayLogs
+  ->Array.push({logName, aggregateName, collectorQueueUrl: None, collectorQueueArn: None})
+  ->ignore
+
+/** Step 2: attach a plugin's EventCollector SQS queue to one aggregate's relay entry. */
+let attachCollectorQueue = (
+  ~aggregateName: string,
+  ~url: Pulumi.Output.t<string>,
+  ~arn: Pulumi.Output.t<string>,
+) =>
+  relayLogs
+  ->Array.find(e => e.aggregateName == aggregateName)
+  ->Option.forEach(e => {
+    e.collectorQueueUrl = Some(url)
+    e.collectorQueueArn = Some(arn)
+  })
+
+/** All registered relay logs (read by `makePlatform` to provision the relay). */
+let getRelayLogs = (): array<relayLogEntry> => relayLogs

package/src/adapter/EventLog/EventLogBackend.res.mjs

@@ -0,0 +1,53 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let selectionRef = {
+  contents: undefined
+};
+
+function set(sel) {
+  selectionRef.contents = sel;
+}
+
+function get() {
+  return selectionRef.contents;
+}
+
+function isPostgres() {
+  return Stdlib_Option.isSome(selectionRef.contents);
+}
+
+let relayLogs = [];
+
+function registerRelayLog(logName, aggregateName) {
+  relayLogs.push({
+    logName: logName,
+    aggregateName: aggregateName,
+    collectorQueueUrl: undefined,
+    collectorQueueArn: undefined
+  });
+}
+
+function attachCollectorQueue(aggregateName, url, arn) {
+  Stdlib_Option.forEach(relayLogs.find(e => e.aggregateName === aggregateName), e => {
+    e.collectorQueueUrl = url;
+    e.collectorQueueArn = arn;
+  });
+}
+
+function getRelayLogs() {
+  return relayLogs;
+}
+
+export {
+  selectionRef,
+  set,
+  get,
+  isPostgres,
+  relayLogs,
+  registerRelayLog,
+  attachCollectorQueue,
+  getRelayLogs,
+}
+/* No side effect */

package/src/adapter/EventLog/EventLogStorage.res

@@ -1,3 +1,18 @@
 module DynamoDb = EventLogStorage_DynamoDb
 module DynamoDbStream = EventLogStorage_DynamoDbStream
 module DynamoDb_Runtime = EventLogStorage_DynamoDb_Runtime
+module Postgres = EventLogStorage_Postgres
+
+// Build-time classic storage selector — the aggregate analogue of
+// `DcbEventLogStorage.Selectable`. Reads `EventLogBackend` — set by the platform
+// when a `PgConnection` is supplied — and dispatches to Postgres (no table/stream)
+// or the streamed DynamoDB maker. Used by the Single (sync/async) aggregate
+// builders; PerAggregate and Micro stay on `DynamoDbStream` directly.
+module Selectable = {
+  let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) =>
+    if EventLogBackend.isPostgres() {
+      Postgres.make(~name, ~opts)
+    } else {
+      DynamoDbStream.make(~name, ~opts)
+    }
+}

package/src/adapter/EventLog/EventLogStorage.res.mjs

@@ -1,5 +1,20 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as EventLogBackend$ReventlessAws from "./EventLogBackend.res.mjs";
+import * as EventLogStorage_Postgres$ReventlessAws from "./EventLogStorage_Postgres.res.mjs";
+import * as EventLogStorage_DynamoDbStream$ReventlessAws from "./EventLogStorage_DynamoDbStream.res.mjs";
+
+function make(name, opts) {
+  if (EventLogBackend$ReventlessAws.isPostgres()) {
+    return EventLogStorage_Postgres$ReventlessAws.make(name, opts);
+  } else {
+    return EventLogStorage_DynamoDbStream$ReventlessAws.make(name, opts);
+  }
+}
+
+let Selectable = {
+  make: make
+};
 
 let DynamoDb;
 
@@ -7,9 +22,13 @@ let DynamoDbStream;
 
 let DynamoDb_Runtime;
 
+let Postgres;
+
 export {
   DynamoDb,
   DynamoDbStream,
   DynamoDb_Runtime,
+  Postgres,
+  Selectable,
 }
-/* No side effect */
+/* EventLogStorage_Postgres-ReventlessAws Not a pure module */

package/src/adapter/EventLog/EventLogStorage_Postgres.res

@@ -0,0 +1,37 @@
+// Deploy-time classic (aggregate) EventLog storage for the Postgres backend — the
+// aggregate analogue of `DcbEventLogStorage_Postgres` (B2.3c).
+//
+// Creates NO DynamoDB table and NO stream: classic events live in Postgres
+// (`event_log`, discriminated by `log_name`) and the shared `PgChangeFeedRelay`
+// drives propagation. Returns:
+//   - `resources: []` — so the aggregate's EventTopic `DynamoDbStream` publisher
+//     becomes a passive marker with nothing to subscribe to, and
+//   - `operations` — the classic runtime op set bound to the shared `PgConnection`
+//     pool (lazy: no connection opens during `pulumi up`).
+//
+// Selected by `EventLogStorage.Selectable` when `EventLogBackend` holds a selection.
+
+let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts as _) => {
+  // `name` is the ComponentType-derived `<Aggregate>EventLog` — the canonical
+  // `event_log.log_name`. Register it so `makePlatform` can wire the change-feed
+  // relay; the collector queue is attached later in forPluginEventCollector,
+  // keyed by the aggregate name (the `~eventTopics` dict key).
+  let aggregateName = name->String.endsWith("EventLog")
+    ? name->String.slice(~start=0, ~end=name->String.length - 8)
+    : name
+  EventLogBackend.registerRelayLog(~logName=name, ~aggregateName)
+
+  let operations = switch EventLogBackend.get() {
+  | Some({connectionConfig}) =>
+    connectionConfig->Pulumi.Output.apply(config =>
+      EventLogStorage_Postgres_Runtime.opsFor(config, ~logName=name)
+    )
+  | None =>
+    // Selectable only routes here when a selection is set; guard defensively.
+    JsError.throwWithMessage("EventLogStorage_Postgres.make called without an EventLogBackend selection")
+  }
+  {
+    ReventlessCore.EventLog_Adapter.resources: [],
+    operations,
+  }
+}

package/src/adapter/EventLog/EventLogStorage_Postgres.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as EventLogBackend$ReventlessAws from "./EventLogBackend.res.mjs";
+import * as EventLogStorage_Postgres_Runtime$ReventlessAws from "./EventLogStorage_Postgres_Runtime.res.mjs";
+
+function make(name, param) {
+  let aggregateName = name.endsWith("EventLog") ? name.slice(0, name.length - 8 | 0) : name;
+  EventLogBackend$ReventlessAws.registerRelayLog(name, aggregateName);
+  let match = EventLogBackend$ReventlessAws.get();
+  let operations = match !== undefined ? match.connectionConfig.apply(config => EventLogStorage_Postgres_Runtime$ReventlessAws.opsFor(config, name)) : Stdlib_JsError.throwWithMessage("EventLogStorage_Postgres.make called without an EventLogBackend selection");
+  return {
+    resources: [],
+    operations: operations
+  };
+}
+
+export {
+  make,
+}
+/* EventLogStorage_Postgres_Runtime-ReventlessAws Not a pure module */

package/src/adapter/Postgres/PgChangeFeedRelay_Builder.res

@@ -11,16 +11,24 @@
 // >= 1 minute. Sub-minute latency needs a self-invoking loop / EventBridge
 // Scheduler (follow-up) or the Fargate-LISTEN upgrade.
 
-// One Postgres-backed DCB log to relay.
+// Which Postgres feed a relay log drains.
+type feed =
+  /** `dcb_event` log; the partition tag is sury-encoded into HANDLER_CONFIG so the
+      relay computes the same `id` (partition key) the DynamoDB-stream path would. */
+  | Dcb({partitionTag: Reventless.DcbTag.derivedPartitionTag})
+  /** Classic `event_log` log (one per aggregate); the stored payload already is
+      the DynamoDB item shape, so no extra config is needed. */
+  | Classic
+
+// One Postgres-backed log to relay.
 type relayLog = {
   connectionConfig: Pulumi.Output.t<PgConnection.connectionConfig>,
-  /** dcb_event.log_name — also the DCB `event_log` discriminator. */
+  /** dcb_event.log_name / event_log.log_name discriminator. */
   logName: string,
-  /** dcb_subscription checkpoint key for this relay. */
+  /** dcb_subscription / event_log_subscription checkpoint key for this relay.
+      Both tables key by subscriber alone, so this MUST be unique per log. */
   subscriber: string,
-  /** The DCB log's partition tag — sury-encoded into HANDLER_CONFIG so the relay
-      computes the same `id` (partition key) the DynamoDB-stream path would. */
-  partitionTag: Reventless.DcbTag.derivedPartitionTag,
+  feed: feed,
   /** Plugin EventCollector SQS queue this log's events are relayed to. */
   targetQueueUrl: Pulumi.Output.t<string>,
   targetQueueArn: Pulumi.Output.t<string>,
@@ -60,16 +68,23 @@ let make = (
         ]
         ->Dict.fromArray
         ->JSON.Encode.object
-      [
+      let entries = [
         ("pgConnection", pgConnectionJson),
         ("logName", l.logName->JSON.Encode.string),
         ("subscriber", l.subscriber->JSON.Encode.string),
-        (
-          "partitionTag",
-          l.partitionTag->S.reverseConvertToJsonOrThrow(Reventless.DcbTag.derivedPartitionTagSchema),
-        ),
         ("targetQueueUrl", queueUrl->JSON.Encode.string),
       ]
+      switch l.feed {
+      | Dcb({partitionTag}) =>
+        entries
+        ->Array.push((
+          "partitionTag",
+          partitionTag->S.reverseConvertToJsonOrThrow(Reventless.DcbTag.derivedPartitionTagSchema),
+        ))
+        ->ignore
+      | Classic => entries->Array.push(("kind", "classic"->JSON.Encode.string))->ignore
+      }
+      entries
       ->Dict.fromArray
       ->JSON.Encode.object
       ->JSON.stringify

package/src/adapter/Postgres/PgChangeFeedRelay_Builder.res.mjs

@@ -49,7 +49,7 @@ function make(name, logs, securityGroupId, subnetIds, intervalMinutesOpt, opts)
         cc.secretArn
       ]
     ]);
-    return JSON.stringify(Object.fromEntries([
+    let entries = [
       [
         "pgConnection",
         pgConnectionJson
@@ -62,15 +62,24 @@ function make(name, logs, securityGroupId, subnetIds, intervalMinutesOpt, opts)
         "subscriber",
         l.subscriber
       ],
-      [
-        "partitionTag",
-        S.reverseConvertToJsonOrThrow(l.partitionTag, DcbTag$Reventless.derivedPartitionTagSchema)
-      ],
       [
         "targetQueueUrl",
         param[1]
       ]
-    ]));
+    ];
+    let match = l.feed;
+    if (typeof match !== "object") {
+      entries.push([
+        "kind",
+        "classic"
+      ]);
+    } else {
+      entries.push([
+        "partitionTag",
+        S.reverseConvertToJsonOrThrow(match.partitionTag, DcbTag$Reventless.derivedPartitionTagSchema)
+      ]);
+    }
+    return JSON.stringify(Object.fromEntries(entries));
   }));
   let handlerConfigOutput = Pulumi.all(logJsonOutputs).apply(items => `{"logs":[` + items.join(",") + `]}`);
   let envVars = Object.fromEntries([[

package/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res

@@ -87,3 +87,57 @@ let relay = async (
   let pool = PgRuntime.poolFor(config)
   await relayWithPool(~pool, ~logName, ~subscriber, ~partitionTagJson?, ~sendBatch)
 }
+
+// ─── Classic (aggregate) event_log relay ───
+
+/**
+ * Transform one classic feed event into the EventCollector JSON body. The stored
+ * `payload` IS the flat item the DynamoDB append would have put (id, position,
+ * event, data, decomposed meta) — classic appends write the serialized event JSON
+ * verbatim on both backends — so the transform is exactly the DynamoDB-stream
+ * decoder and the SQS handler cannot tell the difference. Returns `None` for a
+ * malformed row (mirrors `buildJsonEvent'`; snapshots live in a separate Postgres
+ * table and never enter the feed).
+ */
+let toClassicEventCollectorJson = (
+  event: ReventlessPostgres.EventLogChangeFeed.classicEvent,
+): option<JSON.t> =>
+  event.payload
+  ->JSON.Decode.object
+  ->Option.flatMap(Util_DynamoDbStream_Runtime.buildJsonEvent')
+
+/**
+ * Drain a classic Postgres `event_log` log from its checkpoint on the given `pool`
+ * and relay its events to the EventCollector via the injected `sendBatch`. Same
+ * injection seam and at-least-once semantics as `relayWithPool`.
+ */
+let relayClassicWithPool = async (
+  ~pool: ReventlessPostgres.PgDriver.pool,
+  ~logName: string,
+  ~subscriber: string,
+  ~sendBatch: array<JSON.t> => promise<unit>,
+): int =>
+  await ReventlessPostgres.EventLogChangeFeed.drain(
+    pool,
+    ~logName,
+    ~subscriber,
+    ~handle=async events => {
+      let jsons = events->Array.filterMap(toClassicEventCollectorJson)
+      if jsons->Array.length > 0 {
+        await sendBatch(jsons)
+      }
+    },
+  )
+
+/**
+ * Deployed-Lambda entry for a classic log. Thin wrapper over `relayClassicWithPool`.
+ */
+let relayClassic = async (
+  ~config: PgConnection.connectionConfig,
+  ~logName: string,
+  ~subscriber: string,
+  ~sendBatch: array<JSON.t> => promise<unit>,
+): int => {
+  let pool = PgRuntime.poolFor(config)
+  await relayClassicWithPool(~pool, ~logName, ~subscriber, ~sendBatch)
+}

package/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs

@@ -1,12 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as PgRuntime$ReventlessAws from "./PgRuntime.res.mjs";
 import * as PgChangeFeed$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgChangeFeed.res.mjs";
+import * as EventLogChangeFeed$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogChangeFeed.res.mjs";
 import * as Util_DynamoDbStream_Runtime$ReventlessAws from "../../util/Util_DynamoDbStream_Runtime.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
 
@@ -37,9 +39,30 @@ async function relay(config, logName, subscriber, partitionTagJson, sendBatch) {
   return await relayWithPool(pool, logName, subscriber, partitionTagJson, sendBatch);
 }
 
+function toClassicEventCollectorJson(event) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(event.payload), Util_DynamoDbStream_Runtime$ReventlessAws.buildJsonEvent$p);
+}
+
+async function relayClassicWithPool(pool, logName, subscriber, sendBatch) {
+  return await EventLogChangeFeed$ReventlessPostgres.drain(pool, logName, subscriber, undefined, async events => {
+    let jsons = Stdlib_Array.filterMap(events, toClassicEventCollectorJson);
+    if (jsons.length !== 0) {
+      return await sendBatch(jsons);
+    }
+  });
+}
+
+async function relayClassic(config, logName, subscriber, sendBatch) {
+  let pool = PgRuntime$ReventlessAws.poolFor(config);
+  return await relayClassicWithPool(pool, logName, subscriber, sendBatch);
+}
+
 export {
   toEventCollectorJson,
   relayWithPool,
   relay,
+  toClassicEventCollectorJson,
+  relayClassicWithPool,
+  relayClassic,
 }
 /* S Not a pure module */

package/src/adapter/Postgres/PgProjectionFeed.res

@@ -0,0 +1,100 @@
+// B3.0 — projection delivery on Postgres platforms
+// (docs/plans/aws-postgres-querydb-adapter.md).
+//
+// On DynamoDB platforms the ReadModel / StateViewSlice Lambdas consume their
+// source event logs via DynamoDB-stream event-source mappings. Postgres logs have
+// no streams — instead the shared `PgChangeFeedRelay` fans every Postgres log's
+// events out to one SQS "feed queue" per consumer Lambda, registered here and
+// read by `Platform.provisionPgChangeFeedRelay`. Handlers are keyed by the feed
+// queue's ARN (the sourceUrn analogue of the stream ARN), and per-projection
+// filtering happens in the callbacks (meta.service / event-type matching), so
+// delivering a log's events to a consumer that doesn't project them is a no-op —
+// the same property the DynamoDB path relies on when several read models share
+// one source stream.
+//
+// Checkpoints: each (feed queue, log) pair drains under subscriber
+// `<scope>:<logName>` — per-log isolation, same rule as the EventCollector relay
+// targets (the subscription tables key by subscriber alone).
+
+type feedQueue = {
+  /** Subscriber prefix — the checkpoint key is `<scope>:<logName>` per relayed log. */
+  scope: string,
+  /** Relay classic `event_log` logs into this queue. */
+  includeClassic: bool,
+  /** Relay DCB `dcb_event` logs into this queue. */
+  includeDcb: bool,
+  url: Pulumi.Output.t<string>,
+  arn: Pulumi.Output.t<string>,
+}
+
+let feedQueues: array<feedQueue> = []
+
+/** All registered feed queues (read by `Platform.provisionPgChangeFeedRelay`). */
+let getFeedQueues = (): array<feedQueue> => feedQueues
+
+/** Create a consumer Lambda's feed queue and register it for relay fan-out.
+    ESM + IAM attach separately via `connect` once the Lambda exists. */
+let makeQueue = (
+  ~name: string,
+  ~scope: string,
+  ~includeClassic: bool,
+  ~includeDcb: bool,
+  ~opts: Pulumi.CustomResourceOptions.t,
+): PulumiAws.SQS.Queue.t => {
+  let queue = PulumiAws.SQS.Queue.make(
+    ~name,
+    ~args={
+      PulumiAws.SQS.Queue.visibilityTimeoutSeconds: 120->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,
+    },
+    ~opts,
+  )
+  feedQueues
+  ->Array.push({scope, includeClassic, includeDcb, url: queue.id, arn: queue.arn})
+  ->ignore
+  queue
+}
+
+/** Wire a feed queue into its consumer Lambda: SQS event-source mapping +
+    receive IAM on the Lambda role. */
+let connect = (
+  ~name: string,
+  ~queue: PulumiAws.SQS.Queue.t,
+  ~lambda: Pulumi.Output.t<PulumiAws.Lambda.Function.t>,
+  ~lambdaRole: PulumiAws.IAM.Role.t,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => {
+  let _esm = Util_EventSourceMapping.subscribeSqs(~lambda, ~name, ~queue, ~opts)
+  let _policy = queue.arn->Pulumi.Output.apply(queueArn => {
+    open PulumiAws.PolicyDocument
+    PulumiAws.IAM.RolePolicy.make(
+      ~name=`${name}Receive`,
+      ~args={
+        policy: PulumiAws.PolicyDocument.make(
+          ~id=`${name}ReceivePolicy`,
+          ~statements=[
+            {
+              sid: "AllowReceiveFeedQueue",
+              effect: Allow,
+              actions: Actions([
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sqs:GetQueueAttributes",
+              ]),
+              resources: Resource(queueArn),
+            },
+          ],
+        )
+        ->PulumiAws.PolicyDocument.toJsonString
+        ->Pulumi.Input.make,
+        role: lambdaRole.id->Pulumi.Output.asInput,
+      },
+      ~opts,
+    )
+  })
+}

package/src/adapter/Postgres/PgProjectionFeed.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as Util_EventSourceMapping$ReventlessAws from "../../util/Util_EventSourceMapping.res.mjs";
+
+let feedQueues = [];
+
+function getFeedQueues() {
+  return feedQueues;
+}
+
+function makeQueue(name, scope, includeClassic, includeDcb, opts) {
+  let queue = new (Aws.sqs.Queue)(name, {
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    visibilityTimeoutSeconds: 120,
+    sqsManagedSseEnabled: false
+  }, opts);
+  feedQueues.push({
+    scope: scope,
+    includeClassic: includeClassic,
+    includeDcb: includeDcb,
+    url: queue.id,
+    arn: queue.arn
+  });
+  return queue;
+}
+
+function connect(name, queue, lambda, lambdaRole, opts) {
+  Util_EventSourceMapping$ReventlessAws.subscribeSqs(lambda, name, queue, undefined, opts);
+  queue.arn.apply(queueArn => new (Aws.iam.RolePolicy)(name + `Receive`, {
+    policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `ReceivePolicy`, [{
+        Sid: "AllowReceiveFeedQueue",
+        Effect: "Allow",
+        Action: [
+          "sqs:ReceiveMessage",
+          "sqs:DeleteMessage",
+          "sqs:GetQueueAttributes"
+        ],
+        Resource: queueArn
+      }])),
+    role: lambdaRole.id
+  }, opts));
+}
+
+export {
+  feedQueues,
+  getFeedQueues,
+  makeQueue,
+  connect,
+}
+/* @pulumi/aws Not a pure module */