@reventlessdev/reventless-local 3.0.0-alpha.164 → 3.0.0-alpha.166

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.166 (2026-07-23)
+
+### Bug Fixes
+
+* **aws:** round-trip the DynamoDB Scan cursor in full-list connections ([0e21008](https://github.com/ReventlessDev/reventless-core/commit/0e2100860767a153a5c2f50a88fd6b501787c7f4))
+
+
+# 3.0.0-alpha.165 (2026-07-22)
+
+### Bug Fixes
+
+* **aws:** keep an empty DCB tag value from breaking the append ([1c0ab40](https://github.com/ReventlessDev/reventless-core/commit/1c0ab40f25b596702a81f42686d77c5e423e9b44))
+
+
 # 3.0.0-alpha.164 (2026-07-22)
 
 * refactor!: retire the stale "Admin" vocabulary for platform-owned resources ([2770bd9](https://github.com/ReventlessDev/reventless-core/commit/2770bd96f309142bdfc65b9f36bd1a3ef60641bd))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.164",
+  "version": "3.0.0-alpha.166",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -32,16 +32,16 @@
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.24",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.177",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.24",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.124",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.179",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.26",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.126",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.80",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.41"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.43"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/tests/adapter/DcbEventLogStorageSqliteTest.res

@@ -91,6 +91,39 @@ describe("DcbEventLogStorage_Sqlite", () => {
     })
   })
 
+  // Backend contract: an empty tag value (an absent composite-partition member) is
+  // legitimate — it appends, is recorded verbatim, and keeps matching through both
+  // the partition read and a composite read. Held identically by the in-memory and
+  // DynamoDB backends. See docs/plans/dcb-empty-tag-values-break-append.md.
+  testPromise("an empty tag value appends and stays readable", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-emptytag",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "itemId"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let tags = [{Reventless.DcbTag.key: "itemId", value: "i1"}, {key: "variantId", value: ""}]
+      let result = await ops.append([stored("ItemAdded", tags, JSON.Encode.string("x"))])
+      switch result {
+      | Ok(_) => expect(true)->toBe(true)
+      | Error(e) => expect(appendErrMsg(e))->toBe("Ok")
+      }
+
+      let byPartition = await ops.read(~query=[{tags: [{key: "itemId", value: "i1"}]}])
+      expect(byPartition.events->Array.length)->toBe(1)
+      expect((byPartition.events->Array.getUnsafe(0)).tags->Array.map(t => (t.key, t.value)))
+      ->toEqual([("itemId", "i1"), ("variantId", "")])
+
+      let byComposite = await ops.read(~query=[{tags: tags}])
+      expect(byComposite.events->Array.length)->toBe(1)
+    })
+  })
+
   testPromise("batched tag hydration preserves per-event tags and order", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/DcbEventLogStorageSqliteTest.res.mjs

@@ -96,6 +96,57 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
       }], undefined);
     globalThis.expect(read.events.length).toBe(2);
   }));
+  globalThis.test("an empty tag value appends and stays readable", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-emptytag", [], {
+      TAG: "Simple",
+      _0: {
+        key: "itemId"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let tags = [
+      {
+        key: "itemId",
+        value: "i1"
+      },
+      {
+        key: "variantId",
+        value: ""
+      }
+    ];
+    let result = await ops.append([stored("ItemAdded", tags, "x")], undefined);
+    if (result.TAG === "Ok") {
+      globalThis.expect(true).toBe(true);
+    } else {
+      globalThis.expect(appendErrMsg(result._0)).toBe("Ok");
+    }
+    let byPartition = await ops.read([{
+        tags: [{
+            key: "itemId",
+            value: "i1"
+          }]
+      }], undefined);
+    globalThis.expect(byPartition.events.length).toBe(1);
+    globalThis.expect(byPartition.events[0].tags.map(t => [
+      t.key,
+      t.value
+    ])).toEqual([
+      [
+        "itemId",
+        "i1"
+      ],
+      [
+        "variantId",
+        ""
+      ]
+    ]);
+    let byComposite = await ops.read([{
+        tags: tags
+      }], undefined);
+    globalThis.expect(byComposite.events.length).toBe(1);
+  }));
   globalThis.test("batched tag hydration preserves per-event tags and order", async () => await runUnderSqlite(async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
     let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);

package/tests/adapter/DcbEventLogStorageTest.res

@@ -142,6 +142,32 @@ describe("DcbEventLogStorage_InMemory", () => {
       expect((result.events->Array.getUnsafe(1)).eventType)->toBe("B")
     })
 
+    // An empty tag value is a legitimate model state — an absent member of a
+    // composite partition key. Every backend must accept it, record it verbatim,
+    // and keep matching the event through its partition and composite reads. See
+    // docs/plans/dcb-empty-tag-values-break-append.md.
+    testPromise("an empty tag value appends and stays readable", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let tags = [
+        {Reventless.DcbTag.key: "itemId", value: "i1"},
+        {Reventless.DcbTag.key: "variantId", value: ""},
+      ]
+      let appended = await ops.append([makeEvent(~eventType="ItemAdded", ~data=JSON.Null, ~tags)])
+      expect(appended)->toEqual(Ok("1"))
+
+      let byPartition = await ops.read(
+        ~query=[{Reventless.DcbTag.tags: [{Reventless.DcbTag.key: "itemId", value: "i1"}]}],
+      )
+      expect(byPartition.events->Array.length)->toBe(1)
+      // The empty value is recorded verbatim, not dropped or substituted.
+      expect((byPartition.events->Array.getUnsafe(0)).tags->Array.map(t => (t.key, t.value)))
+      ->toEqual([("itemId", "i1"), ("variantId", "")])
+
+      let byComposite = await ops.read(~query=[{Reventless.DcbTag.tags: tags}])
+      expect(byComposite.events->Array.length)->toBe(1)
+    })
+
     testPromise("after parameter skips events at or before that position", async () => {
       let storage = makeStorage()
       let ops = await storage.operations->TestRunner.resolve

package/tests/adapter/DcbEventLogStorageTest.res.mjs

@@ -165,6 +165,49 @@ globalThis.describe("DcbEventLogStorage_InMemory", () => {
       globalThis.expect(result.events[0].eventType).toBe("A");
       globalThis.expect(result.events[1].eventType).toBe("B");
     });
+    globalThis.test("an empty tag value appends and stays readable", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      let tags = [
+        {
+          key: "itemId",
+          value: "i1"
+        },
+        {
+          key: "variantId",
+          value: ""
+        }
+      ];
+      let appended = await ops.append([makeEvent("ItemAdded", null, tags)], undefined);
+      globalThis.expect(appended).toEqual({
+        TAG: "Ok",
+        _0: "1"
+      });
+      let byPartition = await ops.read([{
+          tags: [{
+              key: "itemId",
+              value: "i1"
+            }]
+        }], undefined);
+      globalThis.expect(byPartition.events.length).toBe(1);
+      globalThis.expect(byPartition.events[0].tags.map(t => [
+        t.key,
+        t.value
+      ])).toEqual([
+        [
+          "itemId",
+          "i1"
+        ],
+        [
+          "variantId",
+          ""
+        ]
+      ]);
+      let byComposite = await ops.read([{
+          tags: tags
+        }], undefined);
+      globalThis.expect(byComposite.events.length).toBe(1);
+    });
     globalThis.test("after parameter skips events at or before that position", async () => {
       let storage = makeStorage();
       let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -667,6 +667,8 @@ describe("GraphQL_SchemaInspector", () => {
         expect(msg->String.includes("ScanItem"))->toBe(true)
         expect(msg->String.includes("name"))->toBe(true)
         expect(msg->String.includes("per-page"))->toBe(true)
+        // The warning must state the correctness consequence, not just the cost.
+        expect(msg->String.includes("globally ordered"))->toBe(true)
       },
     )
     testPromise(

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -500,6 +500,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
       globalThis.expect(msg.includes("ScanItem")).toBe(true);
       globalThis.expect(msg.includes("name")).toBe(true);
       globalThis.expect(msg.includes("per-page")).toBe(true);
+      globalThis.expect(msg.includes("globally ordered")).toBe(true);
     });
     globalThis.test("validateScanSortAlignment is silent when @scanSort field aligns with a known sort key", async () => {
       let warnings = GraphQL_FragmentGenerator$ReventlessCore.validateScanSortAlignment(scanStateSchemaWithAnnotations, "ScanItem", ["name"]);