@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Counter/CounterHandler_DynamoDbStream_Runtime.res

@@ -0,0 +1,107 @@
+// open ReventlessInfra.Adapter
+// open ReventlessCore.Counter_Runtime
+open AwsSdk.DynamoDb.DocumentClient
+open Util.DynamoDbStream_Runtime
+
+let log = ReventlessCore.Logger.fromEnv()
+
+let addToCounterTarget = async (
+  table: ReventlessInfra.Adapter.resource,
+  {ReventlessInfra.Counter.counterId: counterId, target, targetRef},
+) => {
+  let tableName = table.name->Pulumi.Output.get
+  log.debug(
+    ~comp="CounterHandler_DynamoDbStream_Runtime",
+    `addToCounterTarget: ${counterId} ${target->Int.toString}`,
+  )
+  let updateOutput: UpdateCommand.output = await UpdateCommand.make({
+    tableName,
+    key: Dict.fromArray([("id", counterId->JSON.Encode.string)]),
+    updateExpression: "ADD #count :inc, #total :inc " ++
+    ("SET #targets = list_append(if_not_exists(#targets, :empty), :targetSingle), " ++
+    "    #targetRefs = list_append(if_not_exists(#targetRefs, :empty), :targetRefSingle)"),
+    expressionAttributeNames: [
+      ("#count", ReventlessCore.Counter.countFieldName),
+      ("#total", "total"),
+      ("#targets", "targets"),
+      ("#targetRefs", "targetRefs"),
+    ]->Dict.fromArray,
+    expressionAttributeValues: [
+      (":inc", target->Int.toFloat->JSON.Encode.float),
+      (":targetSingle", [target->Int.toFloat->JSON.Encode.float]->JSON.Encode.array),
+      (":targetRefSingle", [targetRef->JSON.Encode.string]->JSON.Encode.array),
+      (":targetRef", targetRef->JSON.Encode.string),
+      (":empty", []->JSON.Encode.array),
+    ]->Dict.fromArray,
+    returnValues: #UPDATED_NEW,
+    conditionExpression: "NOT contains(#targetRefs, :targetRef)",
+  })->UpdateCommand.send
+  log.debug(
+    ~comp="CounterHandler_DynamoDbStream_Runtime",
+    `addToCounterTarget: current count for ${counterId}: ${updateOutput.attributes
+      ->AwsSdk.DynamoDb.DocumentClient.getIntAttribute("count")
+      ->Option.mapOr("N/A", v => v->Int.toString)}`,
+  )
+}
+
+@schema
+type referencesView = {
+  id: string,
+  inc: int,
+}
+
+let handleStreamEvent = (
+  ~referencesStream: ReventlessInfra.Adapter.resource,
+  ~countsStream: ReventlessInfra.Adapter.resource,
+  ~counterHandler: ReventlessCore.Counter_Callback.counterHandler,
+  streamEvent: PulumiAws.DynamoDb.Stream.event,
+  _,
+) => {
+  let referencesARN = referencesStream.urn->Pulumi.Output.get
+  let countsARN = countsStream.urn->Pulumi.Output.get
+
+  let (dynamoDbRecords, ignoredRecords) =
+    streamEvent.records->Array.partition(record =>
+      record.eventSource == "aws:dynamodb" &&
+        (record.eventSourceARN == referencesARN || record.eventSourceARN == countsARN)
+    )
+
+  ignoredRecords->Array.forEach(record =>
+    log.warn(
+      ~comp="CounterHandler_DynamoDbStream_Runtime",
+      `ignoring record from eventSource: ${record.eventSource} ${record.eventSourceARN}`,
+    )
+  )
+
+  let (referenceRecords, countRecords) =
+    dynamoDbRecords->Array.partition(record => record.eventSourceARN == referencesARN)
+
+  let references = referenceRecords->Array.filterMap(record =>
+    switch record->parseDynamoDbStreamRecordState {
+    | NewImage(id, newImage) =>
+      let inc = switch newImage->S.parseJsonOrThrow(referencesViewSchema) {
+      | {inc} => inc
+      | exception _err => 1
+      }
+      Some((id, inc))
+    | NewAndOldImage(id, _, _) =>
+      log.debug(
+        ~comp="CounterHandler_DynamoDbStream_Runtime",
+        `(references): ignoring duplicate id: ${id}`,
+      )
+      None
+    | _ => None
+    }
+  )
+
+  let counts = countRecords->Array.filterMap(record =>
+    switch record->parseDynamoDbStreamRecordState {
+    | NewImage(_, newImage)
+    | NewAndOldImage(_, newImage, _) =>
+      Some(newImage)
+    | _ => None
+    }
+  )
+
+  counterHandler(~references, ~counts)
+}

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

@@ -0,0 +1,145 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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 LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+import * as Util_DynamoDbStream_Runtime$ReventlessAws from "../../util/Util_DynamoDbStream_Runtime.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+async function addToCounterTarget(table, param) {
+  let targetRef = param.targetRef;
+  let target = param.target;
+  let counterId = param.counterId;
+  let tableName = table.name.get();
+  log.debug("CounterHandler_DynamoDbStream_Runtime", undefined, `addToCounterTarget: ` + counterId + ` ` + target.toString());
+  let updateOutput = await DynamoDb_DocumentClient$AwsSdk.UpdateCommand.send(new LibDynamodb.UpdateCommand({
+    Key: Object.fromEntries([[
+        "id",
+        counterId
+      ]]),
+    TableName: tableName,
+    ConditionExpression: "NOT contains(#targetRefs, :targetRef)",
+    ExpressionAttributeNames: Object.fromEntries([
+      [
+        "#count",
+        "count"
+      ],
+      [
+        "#total",
+        "total"
+      ],
+      [
+        "#targets",
+        "targets"
+      ],
+      [
+        "#targetRefs",
+        "targetRefs"
+      ]
+    ]),
+    ExpressionAttributeValues: Object.fromEntries([
+      [
+        ":inc",
+        target
+      ],
+      [
+        ":targetSingle",
+        [target]
+      ],
+      [
+        ":targetRefSingle",
+        [targetRef]
+      ],
+      [
+        ":targetRef",
+        targetRef
+      ],
+      [
+        ":empty",
+        []
+      ]
+    ]),
+    ReturnValues: "UPDATED_NEW",
+    UpdateExpression: "ADD #count :inc, #total :inc SET #targets = list_append(if_not_exists(#targets, :empty), :targetSingle),     #targetRefs = list_append(if_not_exists(#targetRefs, :empty), :targetRefSingle)"
+  }));
+  return log.debug("CounterHandler_DynamoDbStream_Runtime", undefined, `addToCounterTarget: current count for ` + counterId + `: ` + Stdlib_Option.mapOr(DynamoDb_DocumentClient$AwsSdk.getIntAttribute(updateOutput.Attributes, "count"), "N/A", v => v.toString()));
+}
+
+let referencesViewSchema = S.schema(s => ({
+  id: s.m(S.string),
+  inc: s.m(S.int)
+}));
+
+function handleStreamEvent(referencesStream, countsStream, counterHandler, streamEvent, param) {
+  let referencesARN = referencesStream.urn.get();
+  let countsARN = countsStream.urn.get();
+  let match = Stdlib_Array.partition(streamEvent.Records, record => {
+    if (record.eventSource === "aws:dynamodb") {
+      if (record.eventSourceARN === referencesARN) {
+        return true;
+      } else {
+        return record.eventSourceARN === countsARN;
+      }
+    } else {
+      return false;
+    }
+  });
+  match[1].forEach(record => log.warn("CounterHandler_DynamoDbStream_Runtime", undefined, `ignoring record from eventSource: ` + record.eventSource + ` ` + record.eventSourceARN));
+  let match$1 = Stdlib_Array.partition(match[0], record => record.eventSourceARN === referencesARN);
+  let references = Stdlib_Array.filterMap(match$1[0], record => {
+    let match = Util_DynamoDbStream_Runtime$ReventlessAws.parseDynamoDbStreamRecordState(record);
+    if (typeof match !== "object") {
+      return;
+    }
+    switch (match.TAG) {
+      case "NewImage" :
+        let inc;
+        let exit = 0;
+        let val;
+        try {
+          val = S.parseJsonOrThrow(match._1, referencesViewSchema);
+          exit = 1;
+        } catch (_err) {
+          inc = 1;
+        }
+        if (exit === 1) {
+          inc = val.inc;
+        }
+        return [
+          match._0,
+          inc
+        ];
+      case "OldImage" :
+        return;
+      case "NewAndOldImage" :
+        log.debug("CounterHandler_DynamoDbStream_Runtime", undefined, `(references): ignoring duplicate id: ` + match._0);
+        return;
+    }
+  });
+  let counts = Stdlib_Array.filterMap(match$1[1], record => {
+    let match = Util_DynamoDbStream_Runtime$ReventlessAws.parseDynamoDbStreamRecordState(record);
+    if (typeof match !== "object") {
+      return;
+    }
+    switch (match.TAG) {
+      case "OldImage" :
+        return;
+      case "NewImage" :
+      case "NewAndOldImage" :
+        return match._1;
+    }
+  });
+  return counterHandler(references, counts);
+}
+
+export {
+  log,
+  addToCounterTarget,
+  referencesViewSchema,
+  handleStreamEvent,
+}
+/* log Not a pure module */

package/src/adapter/DcbEventLog/DcbEventLogStorage.res

@@ -0,0 +1 @@
+module DynamoDb = DcbEventLogStorage_DynamoDb

package/src/adapter/DcbEventLog/DcbEventLogStorage.res.mjs

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

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb.res

@@ -0,0 +1,84 @@
+let make: ReventlessCore.DcbEventLog_Adapter.storageMaker = (
+  ~name,
+  ~indexes,
+  ~partitionTag,
+  ~crossPartitionTagKeys=[],
+  ~opts,
+) => {
+  // Build attributes array from index names
+  let tagAttributes = indexes->Array.map(indexName => {
+    {
+      PulumiAws.DynamoDb.Table.name: indexName,
+      type_: "S",
+    }
+  })
+
+  let attributes = Array.concat(
+    [
+      {PulumiAws.DynamoDb.Table.name: "id", type_: "S"},
+      {PulumiAws.DynamoDb.Table.name: "position", type_: "S"},
+    ],
+    tagAttributes,
+  )
+
+  // Build Global Secondary Indexes from index names.
+  //
+  // Projection: `tag_composite` stays `ALL` — composite (multi-tag) decision
+  // reads resolve events directly from it. The per-tag `tag_<key>` GSIs are
+  // `KEYS_ONLY`: they have no reader today (single-tag reads use the base-table
+  // partition), and a future cross-partition secondary-tag read (Phase 7) goes
+  // `Query` (keys) → `BatchGetItem` (payloads against the base table). KEYS_ONLY
+  // drops the per-GSI event-payload storage multiplier and most of the per-write
+  // WCU while keeping the index queryable. See docs/plans/dcb-consistency-hardening.md
+  // Phase 3.
+  let globalSecondaryIndexes =
+    indexes
+    ->Array.map(indexName => {
+      let projectionType =
+        DcbEventLogStorage_DynamoDb_Runtime.indexKeepsFullProjection(indexName)
+          ? PulumiAws.DynamoDb.Table.ALL
+          : PulumiAws.DynamoDb.Table.KEYS_ONLY
+      {
+        PulumiAws.DynamoDb.Table.name: indexName,
+        hashKey: indexName,
+        rangeKey: "position",
+        projectionType,
+        nonKeyAttributes: ?None,
+      }->Pulumi.Input.make
+    })
+    ->Pulumi.Input.make
+
+  // Create DynamoDB table with stream enabled — EventTopicPublisher_DynamoDbStream
+  // needs a DynamoDbStream resource to connect the EventTopic.
+  let tags = AWS.Tags.make(~name, ReventlessCore.DcbEventLog.componentType)
+  let table = Util_DynamoDbStream.makeTable(
+    name,
+    ~attributes,
+    ~rangeKey="position",
+    ~globalSecondaryIndexes,
+    ~streamViewType=NEW_IMAGE,
+    ~tags,
+    ~opts,
+  )
+
+  {
+    resources: [table->Util_DynamoDbStream.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    operations: table
+    ->Util_DynamoDb.toResolvedTableOutput
+    ->Pulumi.Output.apply(resolvedTable => {
+      let readFn = DcbEventLogStorage_DynamoDb_Runtime.read(resolvedTable, ~crossPartitionTagKeys)
+      {
+        ReventlessCore.DcbEventLog_Adapter.read: readFn,
+        append: DcbEventLogStorage_DynamoDb_Runtime.append(
+          resolvedTable,
+          ~partitionTag,
+          ~crossPartitionTagKeys,
+        ),
+        readStream: DcbEventLogStorage_DynamoDb_Runtime.readStream(
+          resolvedTable,
+          ~crossPartitionTagKeys,
+        ),
+      }
+    }),
+  }
+}

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb.res.mjs

@@ -0,0 +1,52 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as DcbEventLog$ReventlessCore from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog.res.mjs";
+import * as Util_DynamoDb$ReventlessAws from "../../util/Util_DynamoDb.res.mjs";
+import * as Util_DynamoDbStream$ReventlessAws from "../../util/Util_DynamoDbStream.res.mjs";
+import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "./DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+
+function make(name, indexes, partitionTag, crossPartitionTagKeysOpt, opts) {
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let tagAttributes = indexes.map(indexName => ({
+    name: indexName,
+    type: "S"
+  }));
+  let attributes = [
+    {
+      name: "id",
+      type: "S"
+    },
+    {
+      name: "position",
+      type: "S"
+    }
+  ].concat(tagAttributes);
+  let globalSecondaryIndexes = indexes.map(indexName => {
+    let projectionType = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection(indexName) ? "ALL" : "KEYS_ONLY";
+    return {
+      hashKey: indexName,
+      name: indexName,
+      projectionType: projectionType,
+      rangeKey: "position"
+    };
+  });
+  let tags = AWS_Tags$ReventlessAws.make(name, DcbEventLog$ReventlessCore.componentType);
+  let table = Util_DynamoDbStream$ReventlessAws.makeTable(attributes, globalSecondaryIndexes, undefined, "position", "NEW_IMAGE", tags, opts, name);
+  return {
+    resources: [Util_DynamoDbStream$ReventlessAws.toResource(tags, table)],
+    operations: Util_DynamoDb$ReventlessAws.toResolvedTableOutput(table).apply(resolvedTable => {
+      let readFn = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(resolvedTable, crossPartitionTagKeys);
+      return {
+        read: readFn,
+        append: DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.append(resolvedTable, partitionTag, crossPartitionTagKeys),
+        readStream: DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.readStream(resolvedTable, crossPartitionTagKeys)
+      };
+    })
+  };
+}
+
+export {
+  make,
+}
+/* AWS_Tags-ReventlessAws Not a pure module */