@reventlessdev/reventless-aws 3.0.0-alpha.167

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res.mjs

@@ -0,0 +1,435 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as DcbIntegrationHarness$ReventlessAws from "./DcbIntegrationHarness.res.mjs";
+import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../../src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+
+function tag(key, value) {
+  return {
+    key: key,
+    value: value
+  };
+}
+
+function meta() {
+  return Message$ReventlessCore.generateMeta("dcb-it", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+}
+
+function event(eventType, tags) {
+  return {
+    eventType: eventType,
+    data: {},
+    tags: tags,
+    meta: meta()
+  };
+}
+
+function simple(key) {
+  return {
+    TAG: "Simple",
+    _0: {
+      key: key
+    }
+  };
+}
+
+function isOk(r) {
+  return r.TAG === "Ok";
+}
+
+function isConflict(r) {
+  if (r.TAG === "Ok") {
+    return false;
+  } else {
+    return r._0.includes("Conflict");
+  }
+}
+
+async function readAfter(table, query) {
+  return (await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(table, undefined)(query, undefined)).headPosition;
+}
+
+function seed(table, ev, partitionTag) {
+  return DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendUnconditional(table, [ev], partitionTag);
+}
+
+globalThis.describe("DCB DynamoDb integration — fence-scope = read-scope (Issue 1 regression)", () => {
+  let productTag = {
+    key: "productId",
+    value: "P5"
+  };
+  let placeOrder = async (table, orderId, customerId) => {
+    let query = [
+      {
+        tags: [{
+            key: "orderId",
+            value: orderId
+          }]
+      },
+      {
+        tags: [productTag]
+      }
+    ];
+    let after = await readAfter(table, query);
+    return await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderPlaced", [
+        {
+          key: "orderId",
+          value: orderId
+        },
+        {
+          key: "customerId",
+          value: customerId
+        },
+        productTag
+      ])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+  };
+  globalThis.test("a second order of the same product (different order + customer) succeeds", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("CatalogProductSynced", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    let r1 = await placeOrder(table, "O1", "C1");
+    let r2 = await placeOrder(table, "O2", "C2");
+    globalThis.expect(isOk(r1)).toBe(true);
+    globalThis.expect(isOk(r2)).toBe(true);
+  });
+  globalThis.test("two concurrent orders of the same product both succeed (no productId contention)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("CatalogProductSynced", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    let results = await Promise.all([
+      placeOrder(table, "OA", "CA"),
+      placeOrder(table, "OB", "CB")
+    ]);
+    globalThis.expect(results.every(isOk)).toBe(true);
+  });
+  globalThis.test("a concurrent product re-sync after the order's read still conflicts (OCC preserved)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("CatalogProductSynced", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    let query = [
+      {
+        tags: [{
+            key: "orderId",
+            value: "O1"
+          }]
+      },
+      {
+        tags: [productTag]
+      }
+    ];
+    let after = Stdlib_Option.getOr(await readAfter(table, query), "");
+    globalThis.expect(after === "").toBe(false);
+    await DcbIntegrationHarness$ReventlessAws.setFence(table, productTag, after + "z");
+    let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderPlaced", [
+        {
+          key: "orderId",
+          value: "O1"
+        },
+        {
+          key: "customerId",
+          value: "C1"
+        },
+        productTag
+      ])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+    globalThis.expect(isConflict(r)).toBe(true);
+  });
+  globalThis.test("placing an order does not poison the customer slice (secondary customerId not fenced)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let customerTag = {
+      key: "customerId",
+      value: "C1"
+    };
+    await seed(table, event("CustomerRegistered", [customerTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "customerId"
+      }
+    });
+    let orderQuery = [{
+        tags: [{
+            key: "orderId",
+            value: "O1"
+          }]
+      }];
+    let orderAfter = await readAfter(table, orderQuery);
+    await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderPlaced", [
+        {
+          key: "orderId",
+          value: "O1"
+        },
+        customerTag,
+        productTag
+      ])], {
+      query: orderQuery,
+      after: orderAfter
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+    let customerQuery = [{
+        tags: [customerTag]
+      }];
+    let customerAfter = await readAfter(table, customerQuery);
+    let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("EmailChanged", [customerTag])], {
+      query: customerQuery,
+      after: customerAfter
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "customerId"
+      }
+    }, undefined);
+    globalThis.expect(isOk(r)).toBe(true);
+  });
+});
+
+globalThis.describe("DCB DynamoDb integration — optimistic concurrency primitives", () => {
+  globalThis.test("fresh first-writer (after=None) succeeds and seeds the fence", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let query = [{
+        tags: [{
+            key: "counterId",
+            value: "K0"
+          }]
+      }];
+    let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("CounterStarted", [{
+          key: "counterId",
+          value: "K0"
+        }])], {
+      query: query
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "counterId"
+      }
+    }, undefined);
+    globalThis.expect(isOk(r)).toBe(true);
+    let after = await readAfter(table, query);
+    globalThis.expect(Stdlib_Option.isSome(after)).toBe(true);
+  });
+  globalThis.test("two concurrent commits at the same after never both win (no duplicate)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let counterTag = {
+      key: "counterId",
+      value: "K1"
+    };
+    await seed(table, event("CounterStarted", [counterTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "counterId"
+      }
+    });
+    let query = [{
+        tags: [counterTag]
+      }];
+    let after = await readAfter(table, query);
+    let increment = () => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("CounterIncremented", [counterTag])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "counterId"
+      }
+    }, undefined);
+    let results = await Promise.all([
+      increment(),
+      increment()
+    ]);
+    let oks = results.filter(isOk).length;
+    let conflicts = results.filter(isConflict).length;
+    globalThis.expect(oks <= 1).toBe(true);
+    globalThis.expect(oks + conflicts | 0).toBe(2);
+    globalThis.expect(conflicts >= 1).toBe(true);
+  });
+  globalThis.test("two concurrent first-writers to the same entity — exactly one creates it (Issue 2)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let create = () => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderCreated", [{
+          key: "orderId",
+          value: "O1"
+        }])], {
+      query: [{
+          tags: [{
+              key: "orderId",
+              value: "O1"
+            }]
+        }]
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+    let results = await Promise.all([
+      create(),
+      create()
+    ]);
+    let oks = results.filter(isOk).length;
+    globalThis.expect(oks <= 1).toBe(true);
+    globalThis.expect(oks + results.filter(isConflict).length | 0).toBe(2);
+    let readResult = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(table, undefined)([{
+        tags: [{
+            key: "orderId",
+            value: "O1"
+          }]
+      }], undefined);
+    globalThis.expect(readResult.events.length).toBe(oks);
+  });
+  globalThis.test("the create guard does not false-conflict a subset-event-type writer (Issue 4)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let productTag = {
+      key: "productId",
+      value: "P"
+    };
+    let r1 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductAdded", [productTag])], {
+      query: [{
+          tags: [productTag]
+        }]
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.expect(isOk(r1)).toBe(true);
+    let r2 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("NameChanged", [productTag])], {
+      query: [{
+          tags: [productTag]
+        }]
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.expect(isOk(r2)).toBe(true);
+  });
+  globalThis.test("a chain of compatible commits all succeed", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let counterTag = {
+      key: "counterId",
+      value: "K2"
+    };
+    await seed(table, event("CounterStarted", [counterTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "counterId"
+      }
+    });
+    let query = [{
+        tags: [counterTag]
+      }];
+    let step = async () => {
+      let after = await readAfter(table, query);
+      return await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("CounterIncremented", [counterTag])], {
+        query: query,
+        after: after
+      }, {
+        TAG: "Simple",
+        _0: {
+          key: "counterId"
+        }
+      }, undefined);
+    };
+    let r1 = await step();
+    let r2 = await step();
+    let r3 = await step();
+    globalThis.expect([
+      r1,
+      r2,
+      r3
+    ].every(isOk)).toBe(true);
+  });
+  globalThis.test("a failed fence condition aborts the whole transaction (multi-tag atomicity)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let tags = [
+      {
+        key: "productId",
+        value: "p1"
+      },
+      {
+        key: "orderId",
+        value: "o1"
+      }
+    ];
+    let query = [{
+        tags: tags
+      }];
+    let seedRes = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
+      query: query
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.expect(isOk(seedRes)).toBe(true);
+    let after = Stdlib_Option.getOr(await readAfter(table, query), "");
+    globalThis.expect(after === "").toBe(false);
+    await DcbIntegrationHarness$ReventlessAws.setFence(table, {
+      key: "productId",
+      value: "p1"
+    }, after + "z");
+    let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.expect(isConflict(r)).toBe(true);
+    let readResult = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(table, undefined)(query, undefined);
+    globalThis.expect(readResult.events.length).toBe(1);
+  });
+});
+
+let H;
+
+let Runtime;
+
+export {
+  H,
+  Runtime,
+  tag,
+  meta,
+  event,
+  simple,
+  isOk,
+  isConflict,
+  readAfter,
+  seed,
+}
+/*  Not a pure module */

package/tests/integration/DcbIntegrationHarness.res

@@ -0,0 +1,102 @@
+// Test-only harness for the DCB DynamoDB integration suite.
+//
+// Boots against a DynamoDB Local instance (see
+// `scripts/run-integration-tests.sh` + `docker-compose.dynamodb-local.yml`).
+// The production adapter's singleton DynamoDB client (`AwsSdk.DynamoDb.*`)
+// resolves its endpoint from `AWS_ENDPOINT_URL_DYNAMODB`, set by
+// `jest.integration.setup.cjs`, so no binding changes are needed — the runtime
+// under test talks to the local engine exactly as it would to AWS.
+//
+// This module only adds the table-lifecycle commands (`CreateTable`,
+// `DeleteTable`) that the shared SDK package does not bind, since they are only
+// ever needed for tests.
+
+type command
+
+@new @module("@aws-sdk/client-dynamodb")
+external createTableCommand: JSON.t => command = "CreateTableCommand"
+
+@new @module("@aws-sdk/client-dynamodb")
+external deleteTableCommand: JSON.t => command = "DeleteTableCommand"
+
+@send
+external sendRaw: (AwsSdk.DynamoDb.DynamoDb.client, command) => promise<JSON.t> = "send"
+
+let send = cmd => sendRaw(AwsSdk.DynamoDb.DynamoDb.client(), cmd)
+
+let s = JSON.Encode.string
+
+let attrDef = name =>
+  Dict.fromArray([("AttributeName", s(name)), ("AttributeType", s("S"))])->JSON.Encode.object
+
+let keyEl = (name, keyType) =>
+  Dict.fromArray([("AttributeName", s(name)), ("KeyType", s(keyType))])->JSON.Encode.object
+
+// Mirror the production projection policy (Phase 3): `tag_composite` keeps a
+// full (ALL) projection; per-tag `tag_<key>` GSIs are KEYS_ONLY. Uses the same
+// predicate as the deploy-time `make` so the two never drift.
+let gsi = indexName => {
+  let projection =
+    DcbEventLogStorage_DynamoDb_Runtime.indexKeepsFullProjection(indexName) ? "ALL" : "KEYS_ONLY"
+  Dict.fromArray([
+    ("IndexName", s(indexName)),
+    ("KeySchema", [keyEl(indexName, "HASH"), keyEl("position", "RANGE")]->JSON.Encode.array),
+    ("Projection", Dict.fromArray([("ProjectionType", s(projection))])->JSON.Encode.object),
+  ])->JSON.Encode.object
+}
+
+// Superset of tag GSIs used across the scenarios. GSIs are sparse, so an event
+// missing a given tag attribute is simply absent from that index — matching the
+// production `Dcb_Builder` schema (one `tag_<key>` GSI per tagged field +
+// `tag_composite`).
+let gsiNames = ["tag_productId", "tag_orderId", "tag_customerId", "tag_counterId", "tag_composite"]
+
+let createDcbTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
+  let attributeDefinitions = Array.concat(
+    [attrDef("id"), attrDef("position")],
+    gsiNames->Array.map(attrDef),
+  )
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", attributeDefinitions->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH"), keyEl("position", "RANGE")]->JSON.Encode.array),
+      ("GlobalSecondaryIndexes", gsiNames->Array.map(gsi)->JSON.Encode.array),
+      ("BillingMode", s("PAY_PER_REQUEST")),
+    ])->JSON.Encode.object
+  let _ = await send(createTableCommand(input))
+  {
+    Util_DynamoDb_Runtime.id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/${tableName}`,
+    hashKey: "id",
+  }
+}
+
+let deleteTable = async (table: Util_DynamoDb_Runtime.resolvedTable) => {
+  let input = Dict.fromArray([("TableName", s(table.name))])->JSON.Encode.object
+  let _ = await send(deleteTableCommand(input))
+}
+
+// Unique table per test so persisted fence sentinels never leak across scenarios.
+let counter = ref(0)
+let freshTable = async () => {
+  counter := counter.contents + 1
+  await createDcbTable(`DcbItTest_${counter.contents->Int.toString}`)
+}
+
+// Directly overwrite a fence sentinel's `lastPosition` — used to simulate a
+// concurrent writer having advanced a fence between a slice's read and append.
+let setFence = async (
+  table: Util_DynamoDb_Runtime.resolvedTable,
+  tag: Reventless.DcbTag.tag,
+  ~lastPosition: string,
+) => {
+  let item =
+    Dict.fromArray([
+      ("id", s(DcbEventLogStorage_DynamoDb_Runtime.fencePartitionKey(tag))),
+      ("position", s("FENCE")),
+      ("lastPosition", s(lastPosition)),
+    ])->JSON.Encode.object
+  await Util_DynamoDb_Runtime.put(table, item)
+}

package/tests/integration/DcbIntegrationHarness.res.mjs

@@ -0,0 +1,163 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "../../src/util/Util_DynamoDb_Runtime.res.mjs";
+import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../../src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+
+function send(cmd) {
+  return DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+}
+
+function s(prim) {
+  return prim;
+}
+
+function attrDef(name) {
+  return Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "AttributeType",
+      "S"
+    ]
+  ]);
+}
+
+function keyEl(name, keyType) {
+  return Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "KeyType",
+      keyType
+    ]
+  ]);
+}
+
+function gsi(indexName) {
+  let projection = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection(indexName) ? "ALL" : "KEYS_ONLY";
+  return Object.fromEntries([
+    [
+      "IndexName",
+      indexName
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl(indexName, "HASH"),
+        keyEl("position", "RANGE")
+      ]
+    ],
+    [
+      "Projection",
+      Object.fromEntries([[
+          "ProjectionType",
+          projection
+        ]])
+    ]
+  ]);
+}
+
+let gsiNames = [
+  "tag_productId",
+  "tag_orderId",
+  "tag_customerId",
+  "tag_counterId",
+  "tag_composite"
+];
+
+async function createDcbTable(tableName) {
+  let attributeDefinitions = [
+    attrDef("id"),
+    attrDef("position")
+  ].concat(gsiNames.map(attrDef));
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      attributeDefinitions
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl("id", "HASH"),
+        keyEl("position", "RANGE")
+      ]
+    ],
+    [
+      "GlobalSecondaryIndexes",
+      gsiNames.map(gsi)
+    ],
+    [
+      "BillingMode",
+      "PAY_PER_REQUEST"
+    ]
+  ]);
+  let cmd = new ClientDynamodb.CreateTableCommand(input);
+  await DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+  return {
+    id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/` + tableName,
+    hashKey: "id"
+  };
+}
+
+async function deleteTable(table) {
+  let input = Object.fromEntries([[
+      "TableName",
+      table.name
+    ]]);
+  let cmd = new ClientDynamodb.DeleteTableCommand(input);
+  await DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+}
+
+let counter = {
+  contents: 0
+};
+
+async function freshTable() {
+  counter.contents = counter.contents + 1 | 0;
+  return await createDcbTable(`DcbItTest_` + counter.contents.toString());
+}
+
+async function setFence(table, tag, lastPosition) {
+  let item = Object.fromEntries([
+    [
+      "id",
+      DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fencePartitionKey(tag)
+    ],
+    [
+      "position",
+      "FENCE"
+    ],
+    [
+      "lastPosition",
+      lastPosition
+    ]
+  ]);
+  return await Util_DynamoDb_Runtime$ReventlessAws.put(table, item);
+}
+
+export {
+  send,
+  s,
+  attrDef,
+  keyEl,
+  gsi,
+  gsiNames,
+  createDcbTable,
+  deleteTable,
+  counter,
+  freshTable,
+  setFence,
+}
+/* @aws-sdk/client-dynamodb Not a pure module */