@reventlessdev/reventless-aws 3.0.0-alpha.167

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res.mjs

@@ -0,0 +1,742 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.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 testMeta() {
+  return Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+}
+
+let table = {
+  id: "test-table-id",
+  name: "TestTable",
+  arn: "arn:aws:dynamodb:eu-west-1:000000000000:table/TestTable",
+  hashKey: "id"
+};
+
+globalThis.describe("Runtime.fencePartitionKey", () => {
+  globalThis.test("formats the fence partition key", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fencePartitionKey({
+      key: "orderId",
+      value: "ord-1"
+    })).toBe("fence#orderId:ord-1");
+  });
+  globalThis.test("does not collide with event partition keys", () => {
+    let fenceId = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fencePartitionKey({
+      key: "orderId",
+      value: "ord-1"
+    });
+    globalThis.expect(fenceId === "orderId:ord-1").toBe(false);
+  });
+});
+
+globalThis.describe("Runtime.fenceKey", () => {
+  globalThis.test("returns key with id and FENCE sort key", () => {
+    let key = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fenceKey({
+      key: "orderId",
+      value: "ord-1"
+    });
+    globalThis.expect(key["id"]).toEqual("fence#orderId:ord-1");
+    globalThis.expect(key["position"]).toEqual("FENCE");
+  });
+});
+
+globalThis.describe("Runtime.collectQueryTags", () => {
+  globalThis.test("returns empty array for empty query", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectQueryTags([])).toEqual([]);
+  });
+  globalThis.test("returns empty array when no queryItem has tags", () => {
+    let q = [{
+        eventTypes: ["Foo"]
+      }];
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectQueryTags(q)).toEqual([]);
+  });
+  globalThis.test("collects tags from a single queryItem", () => {
+    let q = [{
+        tags: [
+          {
+            key: "orderId",
+            value: "o1"
+          },
+          {
+            key: "customerId",
+            value: "c1"
+          }
+        ]
+      }];
+    let result = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectQueryTags(q);
+    globalThis.expect(result.length).toBe(2);
+  });
+  globalThis.test("dedupes same tag value across queryItems", () => {
+    let q = [
+      {
+        tags: [{
+            key: "productId",
+            value: "p1"
+          }]
+      },
+      {
+        tags: [{
+            key: "productId",
+            value: "p1"
+          }]
+      },
+      {
+        tags: [{
+            key: "productId",
+            value: "p2"
+          }]
+      }
+    ];
+    let result = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectQueryTags(q);
+    globalThis.expect(result.length).toBe(2);
+  });
+  globalThis.test("ignores queryItems without tags but keeps others", () => {
+    let q = [
+      {
+        eventTypes: ["Foo"]
+      },
+      {
+        tags: [{
+            key: "orderId",
+            value: "o1"
+          }]
+      }
+    ];
+    let result = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectQueryTags(q);
+    globalThis.expect(result.length).toBe(1);
+  });
+});
+
+globalThis.describe("Runtime.collectEventTags", () => {
+  globalThis.test("returns empty array for no events", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectEventTags([])).toEqual([]);
+  });
+  globalThis.test("dedupes tag values across events", () => {
+    let event1_data = {};
+    let event1_tags = [
+      {
+        key: "productId",
+        value: "p1"
+      },
+      {
+        key: "categoryId",
+        value: "c1"
+      }
+    ];
+    let event1_meta = testMeta();
+    let event1 = {
+      eventType: "ProductAdded",
+      data: event1_data,
+      tags: event1_tags,
+      meta: event1_meta
+    };
+    let event2_data = {};
+    let event2_tags = [
+      {
+        key: "productId",
+        value: "p1"
+      },
+      {
+        key: "categoryId",
+        value: "c2"
+      }
+    ];
+    let event2_meta = testMeta();
+    let event2 = {
+      eventType: "ProductAdded",
+      data: event2_data,
+      tags: event2_tags,
+      meta: event2_meta
+    };
+    let result = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.collectEventTags([
+      event1,
+      event2
+    ]);
+    globalThis.expect(result.length).toBe(3);
+  });
+});
+
+globalThis.describe("Runtime.buildConditionalFenceUpdate", () => {
+  globalThis.test("after=Some: per-consumed-type OCC check, bumps only produced types", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalFenceUpdate("TestTable", {
+      key: "productId",
+      value: "p1"
+    }, [
+      "ProductAdded",
+      "ProductNameChanged"
+    ], ["ProductNameChanged"], "100", "50");
+    globalThis.expect(update.ConditionExpression).toEqual("(attribute_not_exists(#c0) OR #c0 <= :after) AND (attribute_not_exists(#c1) OR #c1 <= :after)");
+    globalThis.expect(update.UpdateExpression).toBe("SET #p0 = :new");
+    globalThis.expect(update.ExpressionAttributeNames).toEqual(Object.fromEntries([
+      [
+        "#p0",
+        "pos#ProductNameChanged"
+      ],
+      [
+        "#c0",
+        "pos#ProductAdded"
+      ],
+      [
+        "#c1",
+        "pos#ProductNameChanged"
+      ]
+    ]));
+    globalThis.expect(Stdlib_Option.flatMap(update.ExpressionAttributeValues, v => v[":after"])).toEqual("50");
+    globalThis.expect(Stdlib_Option.flatMap(update.ExpressionAttributeValues, v => v[":new"])).toEqual("100");
+  });
+  globalThis.test("after=Some: a non-read type is never referenced in the condition", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalFenceUpdate("TestTable", {
+      key: "productId",
+      value: "p1"
+    }, [
+      "ProductAdded",
+      "ProductNameChanged"
+    ], ["ProductNameChanged"], "100", "50");
+    let referenced = Object.values(Stdlib_Option.getOr(update.ExpressionAttributeNames, {}));
+    globalThis.expect(referenced.includes("pos#ProductPriceChanged")).toBe(false);
+  });
+  globalThis.test("after=None: folded create guard over consumed ∪ produced types", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalFenceUpdate("TestTable", {
+      key: "productId",
+      value: "p1"
+    }, ["ProductAdded"], ["ProductAdded"], "100", undefined);
+    globalThis.expect(update.ConditionExpression).toEqual("attribute_not_exists(#c0)");
+    globalThis.expect(update.UpdateExpression).toBe("SET #p0 = :new");
+    globalThis.expect(Stdlib_Option.flatMap(update.ExpressionAttributeValues, v => v[":after"])).toEqual(undefined);
+  });
+  globalThis.test("targets the fence sentinel item", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalFenceUpdate("TestTable", {
+      key: "orderId",
+      value: "o1"
+    }, ["OrderPlaced"], ["OrderPlaced"], "100", undefined);
+    globalThis.expect(update.Key["id"]).toEqual("fence#orderId:o1");
+    globalThis.expect(update.Key["position"]).toEqual("FENCE");
+  });
+});
+
+globalThis.describe("Runtime.buildUnconditionalFenceUpdate", () => {
+  globalThis.test("does not set a conditionExpression", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildUnconditionalFenceUpdate("TestTable", {
+      key: "orderId",
+      value: "o1"
+    }, ["OrderPlaced"], "100");
+    globalThis.expect(update.ConditionExpression).toEqual(undefined);
+  });
+  globalThis.test("bumps each produced type's position attribute", () => {
+    let update = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildUnconditionalFenceUpdate("TestTable", {
+      key: "orderId",
+      value: "o1"
+    }, [
+      "OrderPlaced",
+      "OrderShipped"
+    ], "100");
+    globalThis.expect(update.UpdateExpression).toBe("SET #p0 = :new, #p1 = :new");
+    globalThis.expect(update.ExpressionAttributeNames).toEqual(Object.fromEntries([
+      [
+        "#p0",
+        "pos#OrderPlaced"
+      ],
+      [
+        "#p1",
+        "pos#OrderShipped"
+      ]
+    ]));
+  });
+});
+
+globalThis.describe("Runtime.buildQueryByPartitionKeyInput", () => {
+  globalThis.test("omits consistentRead by default (eventually consistent)", () => {
+    let input = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildQueryByPartitionKeyInput(table, "orderId:o1", undefined, undefined);
+    globalThis.expect(input.ConsistentRead).toEqual(undefined);
+  });
+  globalThis.test("omits consistentRead when ~strongConsistency=false", () => {
+    let input = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildQueryByPartitionKeyInput(table, "orderId:o1", undefined, false);
+    globalThis.expect(input.ConsistentRead).toEqual(undefined);
+  });
+  globalThis.test("sets consistentRead=true when ~strongConsistency=true", () => {
+    let input = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildQueryByPartitionKeyInput(table, "orderId:o1", undefined, true);
+    globalThis.expect(input.ConsistentRead).toEqual(true);
+  });
+  globalThis.test("does not target a GSI (uses base table)", () => {
+    let input = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildQueryByPartitionKeyInput(table, "orderId:o1", undefined, true);
+    globalThis.expect(input.IndexName).toEqual(undefined);
+  });
+  globalThis.test("threads ~after into the key condition without dropping consistentRead", () => {
+    let input = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildQueryByPartitionKeyInput(table, "orderId:o1", "50", true);
+    globalThis.expect(input.ConsistentRead).toEqual(true);
+    globalThis.expect(input.KeyConditionExpression).toEqual("id = :pk AND #pos > :after");
+  });
+});
+
+globalThis.describe("Runtime.buildScanFilter — excludes fence sentinels (Issue 12)", () => {
+  globalThis.test("tagless, type-less scan still guards against fence# items", () => {
+    let filter = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildScanFilter(undefined);
+    globalThis.expect(filter.filterExpression).toEqual("attribute_exists(#evt)");
+    globalThis.expect(filter.expressionAttributeNames).toEqual(Object.fromEntries([[
+        "#evt",
+        "event"
+      ]]));
+    globalThis.expect(filter.expressionAttributeValues).toEqual(undefined);
+  });
+  globalThis.test("an empty event-type list yields only the fence guard, not a degenerate ()", () => {
+    let filter = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildScanFilter([]);
+    globalThis.expect(filter.filterExpression).toEqual("attribute_exists(#evt)");
+    globalThis.expect(filter.expressionAttributeValues).toEqual(undefined);
+  });
+  globalThis.test("an event-type filter is AND-ed after the fence guard", () => {
+    let filter = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildScanFilter([
+      "OrderPlaced",
+      "OrderShipped"
+    ]);
+    globalThis.expect(filter.filterExpression).toEqual("attribute_exists(#evt) AND (#evt = :type0 OR #evt = :type1)");
+    globalThis.expect(filter.expressionAttributeValues).toEqual(Object.fromEntries([
+      [
+        ":type0",
+        "OrderPlaced"
+      ],
+      [
+        ":type1",
+        "OrderShipped"
+      ]
+    ]));
+  });
+});
+
+globalThis.describe("Runtime.buildEventPuts", () => {
+  let event = (eventType, tags) => ({
+    eventType: eventType,
+    data: {},
+    tags: tags,
+    meta: testMeta()
+  });
+  globalThis.test("emits one Put per event with the table name", () => {
+    let puts = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildEventPuts(table, [
+      event("Created", [{
+          key: "orderId",
+          value: "o1"
+        }]),
+      event("Shipped", [{
+          key: "orderId",
+          value: "o1"
+        }])
+    ], "100", undefined);
+    globalThis.expect(puts.length).toBe(2);
+    let first = puts[0];
+    globalThis.expect(Stdlib_Option.map(first.Put, p => p.TableName)).toEqual("TestTable");
+  });
+  globalThis.test("returns no Puts when events is empty", () => {
+    let puts = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildEventPuts(table, [], "100", undefined);
+    globalThis.expect(puts.length).toBe(0);
+  });
+});
+
+globalThis.describe("Runtime.appendUnconditional", () => {
+  globalThis.test("rejects appends exceeding 100 items with a clear error", async () => {
+    let manyTags = Stdlib_Array.fromInitializer(100, i => ({
+      key: "k",
+      value: `v` + i.toString()
+    }));
+    let events = manyTags.map(t => {
+      let eventType = "Foo";
+      let tags = [t];
+      return {
+        eventType: eventType,
+        data: {},
+        tags: tags,
+        meta: testMeta()
+      };
+    });
+    let result = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendUnconditional(table, events, undefined);
+    if (result.TAG === "Ok") {
+      globalThis.expect("expected Error, got Ok").toBe("");
+      return;
+    }
+    globalThis.expect(result._0.includes("limit exceeded")).toBe(true);
+  });
+});
+
+globalThis.describe("Runtime.buildConditionalTransactItems — fence-scope = read-scope", () => {
+  let event = (eventType, tags) => ({
+    eventType: eventType,
+    data: {},
+    tags: tags,
+    meta: testMeta()
+  });
+  let findFence = (items, fenceId) => items.find(it => {
+    let idOf = key => Primitive_object.equal(key["id"], fenceId);
+    let match = it.Update;
+    let match$1 = it.ConditionCheck;
+    if (match !== undefined) {
+      return idOf(match.Key);
+    } else if (match$1 !== undefined) {
+      return idOf(match$1.Key);
+    } else {
+      return false;
+    }
+  });
+  let isUpdate = it => Stdlib_Option.isSome(Stdlib_Option.flatMap(it, i => i.Update));
+  let isCheck = it => Stdlib_Option.isSome(Stdlib_Option.flatMap(it, i => i.ConditionCheck));
+  globalThis.describe("PlaceOrder shape: OrderPlaced partitioned by orderId, reads orderId + productId", () => {
+    let orderPlaced = event("OrderPlaced", [
+      {
+        key: "orderId",
+        value: "o1"
+      },
+      {
+        key: "customerId",
+        value: "c1"
+      },
+      {
+        key: "productId",
+        value: "p5"
+      }
+    ]);
+    let cond_query = [
+      {
+        eventTypes: ["OrderPlaced"],
+        tags: [{
+            key: "orderId",
+            value: "o1"
+          }]
+      },
+      {
+        eventTypes: [
+          "OrderPlaced",
+          "CatalogProductSynced"
+        ],
+        tags: [{
+            key: "productId",
+            value: "p5"
+          }]
+      }
+    ];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [orderPlaced], cond, "100", {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+    globalThis.test("partition tag (orderId) is a conditional Update that bumps the fence", () => {
+      globalThis.expect(isUpdate(findFence(items, "fence#orderId:o1"))).toBe(true);
+    });
+    globalThis.test("non-partition read tag (productId) is a ConditionCheck, not a bump", () => {
+      let it = findFence(items, "fence#productId:p5");
+      globalThis.expect(isCheck(it)).toBe(true);
+      globalThis.expect(isUpdate(it)).toBe(false);
+    });
+    globalThis.test("secondary event tag (customerId) is not fenced at all", () => {
+      globalThis.expect(Stdlib_Option.isSome(findFence(items, "fence#customerId:c1"))).toBe(false);
+    });
+  });
+  globalThis.describe("composite (multi-tag) read keeps check+bump on all its tags", () => {
+    let demand = event("ProductDemandRecorded", [
+      {
+        key: "productId",
+        value: "p1"
+      },
+      {
+        key: "orderId",
+        value: "o1"
+      }
+    ]);
+    let cond_query = [{
+        eventTypes: ["ProductDemandRecorded"],
+        tags: [
+          {
+            key: "productId",
+            value: "p1"
+          },
+          {
+            key: "orderId",
+            value: "o1"
+          }
+        ]
+      }];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [demand], cond, "100", {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.test("partition tag (productId) is a conditional Update", () => {
+      globalThis.expect(isUpdate(findFence(items, "fence#productId:p1"))).toBe(true);
+    });
+    globalThis.test("other composite tag (orderId) is also a conditional Update — OCC preserved", () => {
+      globalThis.expect(isUpdate(findFence(items, "fence#orderId:o1"))).toBe(true);
+    });
+  });
+  globalThis.describe("cross-partition secondary tag (studentId) is check+bump, not read-only", () => {
+    let subscribed = event("StudentSubscribed", [
+      {
+        key: "courseId",
+        value: "C1"
+      },
+      {
+        key: "studentId",
+        value: "S1"
+      }
+    ]);
+    let partitionTag = {
+      TAG: "Simple",
+      _0: {
+        key: "courseId"
+      }
+    };
+    let cond_query = [
+      {
+        eventTypes: ["StudentSubscribed"],
+        tags: [{
+            key: "courseId",
+            value: "C1"
+          }]
+      },
+      {
+        eventTypes: ["StudentSubscribed"],
+        tags: [{
+            key: "studentId",
+            value: "S1"
+          }]
+      }
+    ];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    globalThis.test("with studentId cross-partition, its fence is a conditional Update (bump)", () => {
+      let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [subscribed], cond, "100", partitionTag, ["studentId"]);
+      globalThis.expect(isUpdate(findFence(items, "fence#courseId:C1"))).toBe(true);
+      globalThis.expect(isUpdate(findFence(items, "fence#studentId:S1"))).toBe(true);
+    });
+    globalThis.test("without the cross-partition flag, studentId is only a read-only ConditionCheck", () => {
+      let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [subscribed], cond, "100", partitionTag, undefined);
+      let it = findFence(items, "fence#studentId:S1");
+      globalThis.expect(isCheck(it)).toBe(true);
+      globalThis.expect(isUpdate(it)).toBe(false);
+    });
+  });
+});
+
+globalThis.describe("Runtime.buildConditionalTransactItems — folded create guard (after=None)", () => {
+  let event = (eventType, tags) => ({
+    eventType: eventType,
+    data: {},
+    tags: tags,
+    meta: testMeta()
+  });
+  let fenceUpdate = (items, fenceId) => Stdlib_Array.findMap(items, it => {
+    let u = it.Update;
+    if (u !== undefined && Primitive_object.equal(u.Key["id"], fenceId)) {
+      return u;
+    }
+  });
+  let hasCreateRow = items => items.some(it => {
+    let u = it.Update;
+    if (u !== undefined) {
+      return Stdlib_Option.mapOr(Stdlib_Option.flatMap(u.Key["id"], Stdlib_JSON.Decode.string), false, id => id.startsWith("create#"));
+    } else {
+      return false;
+    }
+  });
+  let referencedAttrs = u => Object.values(Stdlib_Option.getOr(u.ExpressionAttributeNames, {}));
+  globalThis.describe("first write of a create slice (consumes == produces)", () => {
+    let added = event("ProductAdded", [{
+        key: "productId",
+        value: "p1"
+      }]);
+    let cond_query = [{
+        eventTypes: ["ProductAdded"],
+        tags: [{
+            key: "productId",
+            value: "p1"
+          }]
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [added], cond, "100", {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.test("no separate create# row is emitted (guard folded into the fence)", () => {
+      globalThis.expect(hasCreateRow(items)).toBe(false);
+    });
+    globalThis.test("the partition fence is a conditional Update gated on attribute_not_exists", () => {
+      let u = Stdlib_Option.getOrThrow(fenceUpdate(items, "fence#productId:p1"), undefined);
+      globalThis.expect(u.ConditionExpression).toEqual("attribute_not_exists(#c0)");
+      globalThis.expect(u.UpdateExpression).toBe("SET #p0 = :new");
+      globalThis.expect(Stdlib_Option.flatMap(u.ExpressionAttributeValues, v => v[":after"])).toEqual(undefined);
+    });
+    globalThis.test("the guard references only the produced/consumed type", () => {
+      let u = Stdlib_Option.getOrThrow(fenceUpdate(items, "fence#productId:p1"), undefined);
+      let referenced = referencedAttrs(u);
+      globalThis.expect(referenced.includes("pos#ProductAdded")).toBe(true);
+      globalThis.expect(referenced.includes("pos#ProductPriceChanged")).toBe(false);
+    });
+  });
+  globalThis.describe("produced-not-consumed (the double-create gate — analysis con #1)", () => {
+    let started = event("OrderStarted", [{
+        key: "orderId",
+        value: "o1"
+      }]);
+    let cond_query = [{
+        eventTypes: ["OrderDrafted"],
+        tags: [{
+            key: "orderId",
+            value: "o1"
+          }]
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [started], cond, "100", {
+      TAG: "Simple",
+      _0: {
+        key: "orderId"
+      }
+    }, undefined);
+    globalThis.test("the produced type is in the guard even though it is not consumed", () => {
+      let u = Stdlib_Option.getOrThrow(fenceUpdate(items, "fence#orderId:o1"), undefined);
+      let referenced = referencedAttrs(u);
+      globalThis.expect(referenced.includes("pos#OrderStarted")).toBe(true);
+      globalThis.expect(referenced.includes("pos#OrderDrafted")).toBe(true);
+    });
+    globalThis.test("the bump advances the produced type", () => {
+      let u = Stdlib_Option.getOrThrow(fenceUpdate(items, "fence#orderId:o1"), undefined);
+      globalThis.expect(u.UpdateExpression).toBe("SET #p0 = :new");
+      globalThis.expect(Stdlib_Option.flatMap(u.ExpressionAttributeNames, n => n["#p0"])).toEqual("pos#OrderStarted");
+    });
+  });
+  globalThis.describe("at after=Some (entity exists)", () => {
+    let changed = event("ProductNameChanged", [{
+        key: "productId",
+        value: "p1"
+      }]);
+    let cond_query = [{
+        eventTypes: [
+          "ProductAdded",
+          "ProductNameChanged"
+        ],
+        tags: [{
+            key: "productId",
+            value: "p1"
+          }]
+      }];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [changed], cond, "100", {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    globalThis.test("emits no create# row", () => {
+      globalThis.expect(hasCreateRow(items)).toBe(false);
+    });
+    globalThis.test("the fence check covers consumed types but not unrelated ones (Issue 4 fix)", () => {
+      let u = Stdlib_Option.getOrThrow(fenceUpdate(items, "fence#productId:p1"), undefined);
+      let referenced = referencedAttrs(u);
+      globalThis.expect(referenced.includes("pos#ProductAdded")).toBe(true);
+      globalThis.expect(referenced.includes("pos#ProductNameChanged")).toBe(true);
+      globalThis.expect(referenced.includes("pos#ProductPriceChanged")).toBe(false);
+    });
+  });
+});
+
+globalThis.describe("Runtime.appendConditional", () => {
+  globalThis.test("rejects tagless conditions with a clear error", async () => {
+    let cond_query = [{
+        eventTypes: ["Foo"]
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let result = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [], cond, undefined, undefined);
+    if (result.TAG === "Ok") {
+      globalThis.expect("expected Error, got Ok").toBe("");
+      return;
+    }
+    globalThis.expect(result._0.includes("tagless")).toBe(true);
+  });
+  globalThis.test("rejects appends exceeding 100 items with a clear error", async () => {
+    let manyTags = Stdlib_Array.fromInitializer(100, i => ({
+      key: "k",
+      value: `v` + i.toString()
+    }));
+    let cond_query = manyTags.map(t => ({
+      eventTypes: ["Foo"],
+      tags: [t]
+    }));
+    let cond_after = "0";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let event_data = {};
+    let event_tags = [{
+        key: "k",
+        value: "v0"
+      }];
+    let event_meta = testMeta();
+    let event = {
+      eventType: "Foo",
+      data: event_data,
+      tags: event_tags,
+      meta: event_meta
+    };
+    let result = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event], cond, undefined, undefined);
+    if (result.TAG === "Ok") {
+      globalThis.expect("expected Error, got Ok").toBe("");
+      return;
+    }
+    globalThis.expect(result._0.includes("limit exceeded")).toBe(true);
+  });
+});
+
+globalThis.describe("Runtime.indexKeepsFullProjection", () => {
+  globalThis.test("tag_composite keeps a full projection", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection("tag_composite")).toBe(true);
+  });
+  globalThis.test("per-tag GSIs are KEYS_ONLY (no full projection)", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection("tag_orderId")).toBe(false);
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection("tag_customerId")).toBe(false);
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.indexKeepsFullProjection("tag_productId")).toBe(false);
+  });
+});
+
+let Runtime;
+
+export {
+  Runtime,
+  tag,
+  testMeta,
+  table,
+}
+/*  Not a pure module */