@reventlessdev/reventless-local 3.0.0-alpha.229 → 3.0.0-alpha.231

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.231 (2026-08-20)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.230 (2026-08-20)
+
+### Features
+
+* **api:** emit a tagged-union state field as a GraphQL union ([3a380c0](https://github.com/ReventlessDev/reventless-core/commit/3a380c0ab055b87048d90a852ec1664f6aab6b00))
+
+
 # 3.0.0-alpha.229 (2026-08-19)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.229",
+  "version": "3.0.0-alpha.231",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,23 +35,23 @@
     "sury": "11.0.0-rc.1",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.241",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.89",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.188",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.146",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.243",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.91",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.148",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.190",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.16",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.118"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.120",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.107"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.1",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.71"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.72"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/tests/adapter/QueryDbListResolverTest.res

@@ -12,11 +12,22 @@ let _ = TestRunner.setup()
 // Test state spec — five-row fixture exercising filter / sort / paginate
 // ─────────────────────────────────────────────────────────────
 
+// A union field on an *indexed* view: the by-index door is one of two in the
+// mechanism plan's table that no fixture carried a union through. Optional so the
+// existing five-row literals below are untouched.
+@schema
+type geolocation =
+  | Pending({requestedFor: string})
+  | Located({lat: float, lng: float})
+
+let geolocationSchema = Reventless.TaggedUnion.named(~name="Geolocation", geolocationSchema)
+
 @schema
 type rowState = {
   productId: @s.matches(Reventless.DcbTag.string) string,
   status: string,
   name: string,
+  geolocation?: geolocation,
 }
 
 let rowStateSchemaWithAnnotations =
@@ -85,6 +96,13 @@ let edgeNodeField = (edge: JSON.t, field: string): string =>
   ->Option.flatMap(n => n->getString(field))
   ->Option.getOr("")
 
+let edges2Find = (edges: array<JSON.t>, pid: string): JSON.t =>
+  edges->Array.find(e => e->getField("node")->Option.flatMap(n => n->getString("productId")) === Some(pid))
+  ->Option.getOr(JSON.Encode.null)
+
+let edgeNodeJson = (edge: JSON.t, field: string): option<JSON.t> =>
+  edge->getField("node")->Option.flatMap(n => n->getField(field))
+
 let pageInfo = (response: JSON.t): JSON.t =>
   response->getField("pageInfo")->Option.getOr(JSON.Encode.null)
 
@@ -175,7 +193,13 @@ let buildFixture = async (~name: string, ~indexes: array<Reventless.ReadModel.in
   ]
   for i in 0 to rows->Array.length - 1 {
     let (pid, status, n) = rows->Array.getUnsafe(i)
-    let _ = await ops.save(pid, ({productId: pid, status, name: n}: rowState), Init, None)
+    // p-1 carries the union; the rest leave it absent, which also proves an
+    // absent optional union is not stamped into something.
+    let state: rowState =
+      pid === "p-1"
+        ? {productId: pid, status, name: n, geolocation: Located({lat: 48.2082, lng: 16.3738})}
+        : {productId: pid, status, name: n}
+    let _ = await ops.save(pid, state, Init, None)
   }
 
   (resolver, listFieldName)
@@ -497,6 +521,36 @@ describe("QueryDb by-index resolver", () => {
     expect(pageInfoBool(page2, "hasNextPage"))->toBe(false)
   })
 
+  // The gap this fixture exists to close: a union field reaching a caller through
+  // the by-index door, carrying the `__typename` the write-time stamp put on it.
+  // A member without one resolves to null and takes its non-nullable parent with
+  // it, so the whole row would vanish rather than error.
+  testPromise("carries a union field's member type through", async () => {
+    let resolver = await indexResolver(~name="IdxU")
+    let response = await resolver(JSON.Encode.null, argsOf([("status", strJson("active"))]), emptyCtx)
+    let edges = getEdges(response)
+    let seeded =
+      edges->Array.find(e => edgeNodeField(e, "productId") === "p-1")->Option.getOr(JSON.Encode.null)
+    let geo = edgeNodeJson(seeded, "geolocation")->Option.flatMap(JSON.Decode.object)
+    expect(geo->Option.flatMap(o => o->Dict.get("__typename"))->Option.flatMap(JSON.Decode.string))
+    ->toEqual(Some("GeolocationLocated"))
+    expect(
+      geo
+      ->Option.flatMap(o => o->Dict.get("lat"))
+      ->Option.flatMap(JSON.Decode.float),
+    )->toEqual(Some(48.2082))
+  })
+
+  // An absent optional union is left absent rather than stamped into an arm.
+  testPromise("leaves an absent union absent", async () => {
+    let resolver = await indexResolver(~name="IdxV")
+    let response = await resolver(JSON.Encode.null, argsOf([("status", strJson("active"))]), emptyCtx)
+    let other = edges2Find(getEdges(response), "p-2")
+    // Assert the row is real first, so an absent field cannot pass as an absent row.
+    expect(edgeNodeField(other, "name"))->toBe("Alpha")
+    expect(edgeNodeJson(other, "geolocation")->Option.isNone)->toBe(true)
+  })
+
   // Refused rather than ignored, and refused here because AppSync cannot do it:
   // a door that paged backward on one backend and quietly returned the forward
   // page on the other is the divergence this whole field was rebuilt to remove.

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -11,6 +11,7 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
@@ -26,10 +27,25 @@ import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../../src/adapter/Que
 
 TestRunner$ReventlessLocal.setup();
 
+let geolocationSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Pending",
+    requestedFor: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Located",
+    lat: s.m(Sury.float),
+    lng: s.m(Sury.float)
+  }))
+]);
+
+let geolocationSchema$1 = TaggedUnion$Reventless.named("Geolocation", geolocationSchema);
+
 let rowStateSchema = Sury.$schema(s => ({
   productId: s.m(DcbTag$Reventless.string),
   status: s.m(Sury.string),
-  name: s.m(Sury.string)
+  name: s.m(Sury.string),
+  geolocation: s.m(Sury.$option(geolocationSchema$1))
 }));
 
 let rowStateSchemaWithAnnotations = Sury.$Metadata_set(rowStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
@@ -102,6 +118,14 @@ function edgeNodeField(edge, field) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(getField(edge, "node"), n => getString(n, field)), "");
 }
 
+function edges2Find(edges, pid) {
+  return Stdlib_Option.getOr(edges.find(e => Stdlib_Option.flatMap(getField(e, "node"), n => getString(n, "productId")) === pid), null);
+}
+
+function edgeNodeJson(edge, field) {
+  return Stdlib_Option.flatMap(getField(edge, "node"), n => getField(n, field));
+}
+
 function pageInfo(response) {
   return Stdlib_Option.getOr(getField(response, "pageInfo"), null);
 }
@@ -186,12 +210,24 @@ async function buildFixture(name, indexesOpt) {
   ];
   for (let i = 0, i_finish = rows.length; i < i_finish; ++i) {
     let match = rows[i];
+    let n = match[2];
+    let status = match[1];
     let pid = match[0];
-    await ops.save(pid, {
-      productId: pid,
-      status: match[1],
-      name: match[2]
-    }, "Init", undefined);
+    let state = pid === "p-1" ? ({
+        productId: pid,
+        status: status,
+        name: n,
+        geolocation: {
+          TAG: "Located",
+          lat: 48.2082,
+          lng: 16.3738
+        }
+      }) : ({
+        productId: pid,
+        status: status,
+        name: n
+      });
+    await ops.save(pid, state, "Init", undefined);
   }
   return [
     resolver,
@@ -557,6 +593,28 @@ globalThis.describe("QueryDb by-index resolver", () => {
     globalThis.expect(edgeNodeField(edges2[0], "productId")).toBe("p-4");
     globalThis.expect(pageInfoBool(page2, "hasNextPage")).toBe(false);
   });
+  globalThis.test("carries a union field's member type through", async () => {
+    let resolver = await indexResolver("IdxU");
+    let response = await resolver(null, Object.fromEntries([[
+        "status",
+        "active"
+      ]]), emptyCtx);
+    let edges = getEdges(response);
+    let seeded = Stdlib_Option.getOr(edges.find(e => edgeNodeField(e, "productId") === "p-1"), null);
+    let geo = Stdlib_Option.flatMap(edgeNodeJson(seeded, "geolocation"), Stdlib_JSON.Decode.object);
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["__typename"]), Stdlib_JSON.Decode.string)).toEqual("GeolocationLocated");
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["lat"]), Stdlib_JSON.Decode.float)).toEqual(48.2082);
+  });
+  globalThis.test("leaves an absent union absent", async () => {
+    let resolver = await indexResolver("IdxV");
+    let response = await resolver(null, Object.fromEntries([[
+        "status",
+        "active"
+      ]]), emptyCtx);
+    let other = edges2Find(getEdges(response), "p-2");
+    globalThis.expect(edgeNodeField(other, "name")).toBe("Alpha");
+    globalThis.expect(Stdlib_Option.isNone(edgeNodeJson(other, "geolocation"))).toBe(true);
+  });
   globalThis.test("refuses backward paging instead of answering forward", async () => {
     let resolver = await indexResolver("IdxC");
     let outcome;
@@ -591,6 +649,7 @@ globalThis.describe("QueryDb by-index resolver", () => {
 });
 
 export {
+  geolocationSchema$1 as geolocationSchema,
   rowStateSchema,
   rowStateSchemaWithAnnotations,
   emptyCtx,
@@ -602,6 +661,8 @@ export {
   getEdges,
   edgeCursor,
   edgeNodeField,
+  edges2Find,
+  edgeNodeJson,
   pageInfo,
   pageInfoBool,
   pageInfoString,

package/tests/adapter/QueryDbUnionRoundTripTest.res

@@ -0,0 +1,107 @@
+// A tagged-union state field, saved and read back under both local backends.
+//
+// The stamp that puts `__typename` beside `TAG` runs in QueryDb_Operations, so
+// what a backend has to do is carry a nested object with one extra key and hand
+// it back. Cheap to assume and cheap to check — and the failure it guards
+// against is not a decode error but a union member that resolves to null, which
+// takes its non-nullable parent with it and reads as data loss.
+//
+// The spec is declared here rather than shared with reventless-core's fixture:
+// a package's `type: dev` sources are not visible to another package, and the
+// union is four lines.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+@schema
+type geolocation =
+  | Pending({requestedFor: string})
+  | Located({lat: float, lng: float})
+  | Unresolvable({reason: string})
+
+let geolocationSchema = Reventless.TaggedUnion.named(~name="Geolocation", geolocationSchema)
+
+module CustomersSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "UnionRoundTripCustomers"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {customerId: string, geolocation: geolocation}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+let runUnderMemory = async fn => {
+  BackendState.setMemory()
+  await fn()
+}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+describe("QueryDb round-trips a union field", () => {
+  let scenario = async () => {
+    module TestBus = LocalBus.Make()
+    module Storage = LocalQueryDbStorage.Make(TestBus)
+    let s = Storage.make(
+      ~name="union-round-trip",
+      ~indexes=[],
+      ~api=(),
+      ~apiRole=(),
+      ~owner=None,
+      ~opts,
+    )
+    let jsonOps = await s.operations->TestRunner.resolve
+    module Ops = ReventlessCore.QueryDb_Operations.Make(
+      CustomersSpec,
+      {
+        let jsonOps = jsonOps
+      },
+    )
+
+    let _ = await Ops.save(
+      "c-1",
+      {customerId: "c-1", geolocation: Located({lat: 48.2082, lng: 16.3738})},
+      ReventlessCore.QueryDb.Any,
+      None,
+    )
+
+    // The stored row, as any read door would hand it back.
+    let stored =
+      await jsonOps.loadStream("c-1")
+      ->Stream.runCollect
+      ->Effect.catchAll(_ => Effect.succeed([]))
+      ->Effect.runPromise
+    let typename =
+      stored
+      ->Array.get(0)
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.flatMap(o => o->Dict.get("geolocation"))
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.flatMap(o => o->Dict.get("__typename"))
+      ->Option.flatMap(JSON.Decode.string)
+    expect(typename)->toEqual(Some("GeolocationLocated"))
+
+    let items =
+      await Ops.loadStream("c-1"->CustomersSpec.Id.makeFromString)
+      ->Stream.runCollect
+      ->Effect.catchAll(_ => Effect.succeed([]))
+      ->Effect.runPromise
+    switch items {
+    | [{geolocation: Located({lat, lng})}] => expect((lat, lng))->toEqual((48.2082, 16.3738))
+    | _ => expect("round trip")->toBe("Located with its point intact")
+    }
+  }
+
+  testPromise("in-memory", () => runUnderMemory(scenario))
+  testPromise("sqlite", () => runUnderSqlite(scenario))
+})

package/tests/adapter/QueryDbUnionRoundTripTest.res.mjs

@@ -0,0 +1,142 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Operations.res.mjs";
+import * as LocalQueryDbStorage$ReventlessLocal from "../../src/adapter/QueryDb/LocalQueryDbStorage.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let geolocationSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Pending",
+    requestedFor: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Located",
+    lat: s.m(Sury.float),
+    lng: s.m(Sury.float)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Unresolvable",
+    reason: s.m(Sury.string)
+  }))
+]);
+
+let geolocationSchema$1 = TaggedUnion$Reventless.named("Geolocation", geolocationSchema);
+
+let name = "UnionRoundTripCustomers";
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  geolocation: s.m(geolocationSchema$1)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let CustomersSpec = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+async function runUnderMemory(fn) {
+  BackendState$ReventlessLocal.setMemory();
+  return await fn();
+}
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+globalThis.describe("QueryDb round-trips a union field", () => {
+  let scenario = async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("union-round-trip", [], undefined, undefined, undefined, undefined, undefined, opts);
+    let jsonOps = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let Ops = QueryDb_Operations$ReventlessCore.Make({
+      Id: {
+        schema: Id$Reventless.StringPure.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: Id$Reventless.StringPure.cmp
+      },
+      name: name,
+      moduleUrl: moduleUrl,
+      stateSchema: stateSchema,
+      config: config,
+      subIdConfig: undefined,
+      authorization: "AllowAuthenticated",
+      visibility: "Public"
+    })({
+      jsonOps: jsonOps
+    });
+    await Ops.save("c-1", {
+      customerId: "c-1",
+      geolocation: {
+        TAG: "Located",
+        lat: 48.2082,
+        lng: 16.3738
+      }
+    }, "Any", undefined);
+    let stored = await Effect.runPromise(Effect.catchAll(Stream.runCollect(jsonOps.loadStream("c-1")), param => Effect.succeed([])));
+    let typename = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(stored[0], Stdlib_JSON.Decode.object), o => o["geolocation"]), Stdlib_JSON.Decode.object), o => o["__typename"]), Stdlib_JSON.Decode.string);
+    globalThis.expect(typename).toEqual("GeolocationLocated");
+    let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(Ops.loadStream("c-1")), param => Effect.succeed([])));
+    if (items.length === 1) {
+      let match = items[0];
+      let match$1 = match.geolocation;
+      switch (match$1.TAG) {
+        case "Located" :
+          globalThis.expect([
+            match$1.lat,
+            match$1.lng
+          ]).toEqual([
+            48.2082,
+            16.3738
+          ]);
+          return;
+        case "Pending" :
+        case "Unresolvable" :
+          break;
+      }
+    }
+    globalThis.expect("round trip").toBe("Located with its point intact");
+  };
+  globalThis.test("in-memory", () => runUnderMemory(scenario));
+  globalThis.test("sqlite", () => runUnderSqlite(scenario));
+});
+
+export {
+  opts,
+  geolocationSchema$1 as geolocationSchema,
+  CustomersSpec,
+  runUnderMemory,
+  runUnderSqlite,
+}
+/*  Not a pure module */