@reventlessdev/reventless-aws 3.0.0-alpha.181 → 3.0.0-alpha.183

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res.mjs

@@ -129,18 +129,20 @@ globalThis.describe("DCB DynamoDb integration — fence-scope = read-scope (Issu
     });
     let query = [
       {
+        eventTypes: ["OrderPlaced"],
         tags: [{
             key: "orderId",
             value: "O1"
           }]
       },
       {
+        eventTypes: ["CatalogProductSynced"],
         tags: [productTag]
       }
     ];
     let after = Stdlib_Option.getOr(await readAfter(table, query), "");
     globalThis.expect(after === "").toBe(false);
-    await DcbIntegrationHarness$ReventlessAws.setFence(table, productTag, after + "z");
+    await DcbIntegrationHarness$ReventlessAws.setFence(table, productTag, ["CatalogProductSynced"], after + "z");
     let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderPlaced", [
         {
           key: "orderId",
@@ -384,6 +386,7 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
       }
     ];
     let query = [{
+        eventTypes: ["ProductDemandRecorded"],
         tags: tags
       }];
     let seedRes = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
@@ -400,7 +403,7 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
     await DcbIntegrationHarness$ReventlessAws.setFence(table, {
       key: "productId",
       value: "p1"
-    }, after + "z");
+    }, ["ProductDemandRecorded"], after + "z");
     let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
       query: query,
       after: after
@@ -416,6 +419,150 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
   });
 });
 
+globalThis.describe("DCB DynamoDb integration — composite partition hot-fence fix", () => {
+  let specKeys = [
+    "environment",
+    "platformName",
+    "pluginName",
+    "resourceName"
+  ];
+  let specSeps = [
+    "/",
+    "/",
+    "/"
+  ];
+  let pt = {
+    TAG: "Composite",
+    _0: {
+      keys: specKeys,
+      seps: specSeps
+    }
+  };
+  let members = resourceName => [
+    {
+      key: "environment",
+      value: "prod"
+    },
+    {
+      key: "platformName",
+      value: "plat"
+    },
+    {
+      key: "pluginName",
+      value: "plug"
+    },
+    {
+      key: "resourceName",
+      value: resourceName
+    }
+  ];
+  globalThis.test("distinct composite entities sharing a prefix do NOT false-conflict", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let tagsA = members("resA");
+    let tagsB = members("resB");
+    let rA = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tagsA)], {
+      query: [{
+          tags: tagsA
+        }]
+    }, pt, undefined);
+    let rB = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tagsB)], {
+      query: [{
+          tags: tagsB
+        }]
+    }, pt, undefined);
+    globalThis.expect(isOk(rA)).toBe(true);
+    globalThis.expect(isOk(rB)).toBe(true);
+  });
+  globalThis.test("two first-writers of the SAME composite key still serialize (OCC preserved)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let tags = members("resA");
+    let query = [{
+        tags: tags
+      }];
+    let r1 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tags)], {
+      query: query
+    }, pt, undefined);
+    let r2 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tags)], {
+      query: query
+    }, pt, undefined);
+    globalThis.expect(isOk(r1)).toBe(true);
+    globalThis.expect(isConflict(r2)).toBe(true);
+  });
+});
+
+globalThis.describe("DCB DynamoDb integration — per-type fence granularity", () => {
+  let productTag = {
+    key: "productId",
+    value: "P"
+  };
+  let change = async (table, eventType) => {
+    let query = [{
+        eventTypes: [eventType],
+        tags: [productTag]
+      }];
+    let after = await readAfter(table, query);
+    return await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event(eventType, [productTag])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+  };
+  globalThis.test("interleaved distinct-type changes on one product all succeed (never wedges)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("ProductAdded", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    let results = [
+      await change(table, "PriceChanged"),
+      await change(table, "NameChanged"),
+      await change(table, "DescriptionChanged"),
+      await change(table, "PriceChanged"),
+      await change(table, "NameChanged")
+    ];
+    globalThis.expect(results.every(isOk)).toBe(true);
+  });
+  globalThis.test("two concurrent SAME-type changes still serialize (per-type OCC preserved)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("ProductAdded", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    await change(table, "NameChanged");
+    let query = [{
+        eventTypes: ["NameChanged"],
+        tags: [productTag]
+      }];
+    let after = await readAfter(table, query);
+    let rename = () => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("NameChanged", [productTag])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    let results = await Promise.all([
+      rename(),
+      rename()
+    ]);
+    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);
+  });
+});
+
 let H;
 
 let Runtime;

package/tests/integration/DcbIntegrationHarness.res

@@ -85,18 +85,29 @@ let freshTable = async () => {
   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.
+// Directly advance a fence sentinel — used to simulate a concurrent writer having
+// bumped a fence between a slice's read and append. The fence model is per event
+// type (`pos#<eventType>` attributes, not a scalar `lastPosition`), so the caller
+// names the event type(s) whose position to set; each `pos#<eventType>` is written
+// to `position`, exactly as a real conditional append would advance them.
 let setFence = async (
   table: Util_DynamoDb_Runtime.resolvedTable,
   tag: Reventless.DcbTag.tag,
-  ~lastPosition: string,
+  ~eventTypes: array<string>,
+  ~position: string,
 ) => {
   let item =
-    Dict.fromArray([
-      ("id", s(DcbEventLogStorage_DynamoDb_Runtime.fencePartitionKey(tag))),
-      ("position", s("FENCE")),
-      ("lastPosition", s(lastPosition)),
-    ])->JSON.Encode.object
+    Array.concat(
+      [
+        ("id", s(DcbEventLogStorage_DynamoDb_Runtime.fencePartitionKey(tag))),
+        ("position", s("FENCE")),
+      ],
+      eventTypes->Array.map(et => (
+        DcbEventLogStorage_DynamoDb_Runtime.fenceTypeAttr(et),
+        s(position),
+      )),
+    )
+    ->Dict.fromArray
+    ->JSON.Encode.object
   await Util_DynamoDb_Runtime.put(table, item)
 }

package/tests/integration/DcbIntegrationHarness.res.mjs

@@ -129,7 +129,7 @@ async function freshTable() {
   return await createDcbTable(`DcbItTest_` + counter.contents.toString());
 }
 
-async function setFence(table, tag, lastPosition) {
+async function setFence(table, tag, eventTypes, position) {
   let item = Object.fromEntries([
     [
       "id",
@@ -138,12 +138,11 @@ async function setFence(table, tag, lastPosition) {
     [
       "position",
       "FENCE"
-    ],
-    [
-      "lastPosition",
-      lastPosition
     ]
-  ]);
+  ].concat(eventTypes.map(et => [
+    DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fenceTypeAttr(et),
+    position
+  ])));
   return await Util_DynamoDb_Runtime$ReventlessAws.put(table, item);
 }