@reventlessdev/reventless-aws 3.0.0-alpha.311 → 3.0.0-alpha.313

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.313 (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.312 (2026-08-19)
+
+### Bug Fixes
+
+* **aws:** build the platform's definition asset from the shared value ([c0e432d](https://github.com/ReventlessDev/reventless-core/commit/c0e432d98d96af3ff4c305b62f658ae102c5d142))
+
+
 # 3.0.0-alpha.311 (2026-08-19)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.311",
+  "version": "3.0.0-alpha.313",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -13,17 +13,17 @@
     "sury": "11.0.0-rc.1",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.12",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.1",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.240",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.242",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.106",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.119",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.118",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.104",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.146"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.147"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -683,8 +683,12 @@ let loadPluginDefinition = (): Reventless.Plugin.pluginDefinition =>
     ->Reventless.Util_Sury.fromJsonString(Reventless.Plugin.pluginDefinitionSchema)
   } catch {
   | exn =>
+    // Util_Sury.exnMessage, not the local one: sury raises S.Exn, which is not a
+    // JsExn, so the local reader yields "unknown error" and loses the field path —
+    // the whole diagnosis for a decode failure here.
     JsError.throwWithMessage(
-      "Failed to load pluginDefinition.json from asset zip: " ++ exnMessage(exn),
+      "Failed to load pluginDefinition.json from asset zip: " ++
+      Reventless.Util_Sury.exnMessage(exn),
     )
   }
 

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs

@@ -524,7 +524,7 @@ function loadPluginDefinition() {
     return Util_Sury$Reventless.fromJsonString(Nodefs.readFileSync(assetPath("pluginDefinition.json"), "utf8"), Plugin$Reventless.pluginDefinitionSchema);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
-    return Stdlib_JsError.throwWithMessage("Failed to load pluginDefinition.json from asset zip: " + exnMessage(exn));
+    return Stdlib_JsError.throwWithMessage("Failed to load pluginDefinition.json from asset zip: " + Util_Sury$Reventless.exnMessage(exn, undefined));
   }
 }
 

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -268,12 +268,13 @@ module Make = (
   // keeps the JSON shape consistent so the entry point can parse uniformly.
   let synthesizeAdminContext = (): ReventlessCore.Plugin_Helpers.eventCollectorContext => {
     let config = configRef.contents
-    // Stable JSON literal — matches Reventless.Plugin.pluginDefinitionSchema
-    // (optional fields encoded as null via js_nullable). Must stay byte-aligned with
-    // the ReScript-built twin in `Platform_Admin.construct`'s `fakePluginDefinition`.
-    let platformId = ReventlessCore.Platform_Admin_Structure.pluginId
+    // Encoded from the one placeholder value, through the same schema the entry
+    // point decodes with. It was a hand-written JSON literal, which drifted: the
+    // schema gained `dcbEventLog` and `kind` and the literal did not follow.
     let fakePluginDefinitionJson =
-      `{"id":"${platformId}@INTERNAL","name":"${platformId}","version":"INTERNAL","extensionPoints":[],"extensions":[],"eventCollector":"NOT-SET","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"structure":null}`->Pulumi.Output.make
+      ReventlessCore.Platform_Admin_Structure.internalPluginDefinition
+      ->Reventless.Util_Sury.toJsonString(Reventless.Plugin.pluginDefinitionSchema)
+      ->Pulumi.Output.make
     let adminEpEventTopicArn = switch config.eventTopicArn {
     | Some(arn) => arn
     | None => Pulumi.Output.make("NOT_AVAILABLE")

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -5,6 +5,8 @@ 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 Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as DcbBackend$ReventlessAws from "../../adapter/DcbEventLog/DcbBackend.res.mjs";
@@ -202,7 +204,7 @@ function Make(EventCollectorChannel) {
   };
   let synthesizeAdminContext = () => {
     let config = configRef.contents;
-    let fakePluginDefinitionJson = Pulumi.output(`{"id":"` + Platform_Admin_Structure$ReventlessCore.pluginId + `@INTERNAL","name":"` + Platform_Admin_Structure$ReventlessCore.pluginId + `","version":"INTERNAL","extensionPoints":[],"extensions":[],"eventCollector":"NOT-SET","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"structure":null}`);
+    let fakePluginDefinitionJson = Pulumi.output(Util_Sury$Reventless.toJsonString(Platform_Admin_Structure$ReventlessCore.internalPluginDefinition, Plugin$Reventless.pluginDefinitionSchema, undefined));
     let arn = config.eventTopicArn;
     let adminEpEventTopicArn = arn !== undefined ? arn : Pulumi.output("NOT_AVAILABLE");
     return {

package/tests/EventCollectorPluginDefinitionAssetTest.res

@@ -101,4 +101,15 @@ describe("pluginDefinition.json write/read symmetry", () => {
     expect(def.structure->Option.isNone)->toBe(true)
     expect(def.dcbEventLog->Option.isNone)->toBe(true)
   })
+
+  // The platform's own EventCollector ships a placeholder rather than a real
+  // definition — the admin IS the Plugin extension point — but it is read back on
+  // this same path, so it has to satisfy the same schema. Its asset used to be a
+  // hand-written JSON literal in PluginRuntime_Builder and fell two fields behind
+  // (dcbEventLog, kind) with nothing to notice.
+  testSync("the platform's own placeholder asset survives the same round trip", () => {
+    let def = ReventlessCore.Platform_Admin_Structure.internalPluginDefinition->writeAsset->readAsset
+    expect(def.id)->toBe(ReventlessCore.Platform_Admin_Structure.pluginId ++ "@INTERNAL")
+    expect(def.kind)->toBe(Reventless.Plugin.Domain)
+  })
 })

package/tests/EventCollectorPluginDefinitionAssetTest.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Platform_Admin_Structure$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin_Structure.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 import * as EventCollectorEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs";
 
@@ -118,6 +119,11 @@ globalThis.describe("pluginDefinition.json write/read symmetry", () => {
     globalThis.expect(Stdlib_Option.isNone(def.structure)).toBe(true);
     globalThis.expect(Stdlib_Option.isNone(def.dcbEventLog)).toBe(true);
   });
+  globalThis.test("the platform's own placeholder asset survives the same round trip", () => {
+    let def = readAsset(Util_Sury$Reventless.toJsonString(Platform_Admin_Structure$ReventlessCore.internalPluginDefinition, Plugin$Reventless.pluginDefinitionSchema, undefined));
+    globalThis.expect(def.id).toBe(Platform_Admin_Structure$ReventlessCore.pluginId + "@INTERNAL");
+    globalThis.expect(def.kind).toBe("Domain");
+  });
 });
 
 export {

package/tests/PgQueryDbUnion_IntegrationTest.res

@@ -0,0 +1,101 @@
+// A tagged-union state field, saved and read back through the real Postgres
+// QueryDb path.
+//
+// Run via `pnpm run test:integration:pg` (boots a Postgres sidecar, runs the PG
+// suites serially, tears down). Self-skips unless PG_URL is set.
+//
+// The Postgres resolver is the one backend that stamps a `__typename` of its own
+// — the top-level row's ([PgQueryResolver_Lambda]) — and it stamps only that one.
+// A union field sits one level in, which is precisely why the member stamp is
+// written by the *write* path instead: what this suite proves is that the key
+// survives the jsonb round trip, so the resolver has something to return.
+
+open JestGlobals
+
+@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 = "PgUnionCustomers"
+  let moduleUrl = ""
+
+  @schema
+  type state = {customerId: string, geolocation: geolocation}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+  let authorization: Reventless.Authorization.permission = AllowAuthenticated
+  let visibility: Reventless.Visibility.t = Public
+}
+
+switch NodeProcess.env->Dict.get("PG_URL") {
+| None =>
+  testSync("Postgres union round trip (skipped — set PG_URL to run)", () =>
+    expect(true)->toBe(true)
+  )
+| Some(url) =>
+  let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})
+
+  let jsonOps = ReventlessPostgres.QueryDbStorage_Postgres.makeOperations(
+    ~pool,
+    ~name=CustomersSpec.name,
+    ~indexes=[],
+    ~subIdField=None,
+  )
+
+  module Ops = ReventlessCore.QueryDb_Operations.Make(
+    CustomersSpec,
+    {
+      let jsonOps = jsonOps
+    },
+  )
+
+  beforeAllAsync(async () => {
+    await ReventlessPostgres.PgSchema.ensureSchema(pool)
+    await ReventlessPostgres.PgSchema.truncateAll(pool)
+    let _ = await pool->ReventlessPostgres.PgDriver.query(
+      `DROP TABLE IF EXISTS qdb_${CustomersSpec.name}`,
+      [],
+    )
+  })
+  afterAll(() => {
+    let _ = pool->ReventlessPostgres.PgDriver.endPool
+  })
+
+  describe("QueryDb (Postgres) round-trips a union field", () => {
+    testPromise("a stored Located keeps its member type and its point", async () => {
+      let _ = await Ops.save(
+        "c-1"->CustomersSpec.Id.makeFromString,
+        {customerId: "c-1", geolocation: Located({lat: 48.2082, lng: 16.3738})},
+        ReventlessCore.QueryDb.Any,
+        None,
+      )
+
+      switch await jsonOps.load("c-1") {
+      | Ok(rows) =>
+        let typename =
+          rows
+          ->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"))
+      | Error(_) => expect("load failed")->toBe("Ok")
+      }
+
+      switch await Ops.load("c-1"->CustomersSpec.Id.makeFromString) {
+      | Ok([{geolocation: Located({lat, lng})}]) =>
+        expect((lat, lng))->toEqual((48.2082, 16.3738))
+      | _ => expect("round trip")->toBe("Located with its point intact")
+      }
+    })
+  })
+}

package/tests/PgQueryDbUnion_IntegrationTest.res.mjs

@@ -0,0 +1,139 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+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 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 PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Operations.res.mjs";
+import * as QueryDbStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/QueryDbStorage_Postgres.res.mjs";
+
+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 = "PgUnionCustomers";
+
+let moduleUrl = "";
+
+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"
+};
+
+let url = process.env["PG_URL"];
+
+if (url !== undefined) {
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: url
+  });
+  let jsonOps = QueryDbStorage_Postgres$ReventlessPostgres.makeOperations(pool, name, [], undefined);
+  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
+  });
+  globalThis.beforeAll(async () => {
+    await PgSchema$ReventlessPostgres.ensureSchema(pool);
+    await PgSchema$ReventlessPostgres.truncateAll(pool);
+    await PgDriver$ReventlessPostgres.query(pool, `DROP TABLE IF EXISTS qdb_` + name, []);
+  });
+  globalThis.afterAll(() => {
+    PgDriver$ReventlessPostgres.endPool(pool);
+  });
+  globalThis.describe("QueryDb (Postgres) round-trips a union field", () => {
+    globalThis.test("a stored Located keeps its member type and its point", async () => {
+      await Ops.save("c-1", {
+        customerId: "c-1",
+        geolocation: {
+          TAG: "Located",
+          lat: 48.2082,
+          lng: 16.3738
+        }
+      }, "Any", undefined);
+      let rows = await jsonOps.load("c-1");
+      if (rows.TAG === "Ok") {
+        let typename = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(rows._0[0], Stdlib_JSON.Decode.object), o => o["geolocation"]), Stdlib_JSON.Decode.object), o => o["__typename"]), Stdlib_JSON.Decode.string);
+        globalThis.expect(typename).toEqual("GeolocationLocated");
+      } else {
+        globalThis.expect("load failed").toBe("Ok");
+      }
+      let match = await Ops.load("c-1");
+      if (match.TAG === "Ok") {
+        let match$1 = match._0;
+        if (match$1.length === 1) {
+          let match$2 = match$1[0];
+          let match$3 = match$2.geolocation;
+          switch (match$3.TAG) {
+            case "Located" :
+              globalThis.expect([
+                match$3.lat,
+                match$3.lng
+              ]).toEqual([
+                48.2082,
+                16.3738
+              ]);
+              return;
+            case "Pending" :
+            case "Unresolvable" :
+              break;
+          }
+        }
+      }
+      globalThis.expect("round trip").toBe("Located with its point intact");
+    });
+  });
+} else {
+  globalThis.test("Postgres union round trip (skipped — set PG_URL to run)", () => {
+    globalThis.expect(true).toBe(true);
+  });
+}
+
+export {
+  geolocationSchema$1 as geolocationSchema,
+  CustomersSpec,
+}
+/* geolocationSchema Not a pure module */

package/tests/integration/AggIntegrationHarness.res

@@ -47,6 +47,26 @@ let createEventLogTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable
   }
 }
 
+// A read-model table: `id` (HASH) alone. No range key — a projection with no
+// `@subId` writes one row per id, which is the shape `QueryDbStorage_DynamoDb`
+// provisions when `subIdField` is absent.
+let createQueryDbTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", [attrDef("id")]->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH")]->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))

package/tests/integration/AggIntegrationHarness.res.mjs

@@ -72,6 +72,35 @@ async function createEventLogTable(tableName) {
   };
 }
 
+async function createQueryDbTable(tableName) {
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      [attrDef("id")]
+    ],
+    [
+      "KeySchema",
+      [keyEl("id", "HASH")]
+    ],
+    [
+      "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",
@@ -87,6 +116,7 @@ export {
   attrDef,
   keyEl,
   createEventLogTable,
+  createQueryDbTable,
   deleteTable,
 }
 /* @aws-sdk/client-dynamodb Not a pure module */

package/tests/integration/QueryDbUnion_DynamoDb_IntegrationTest.res

@@ -0,0 +1,87 @@
+// A tagged-union state field, saved and read back through the real DynamoDB
+// QueryDb path (DynamoDB Local — NOT run by the default unit suite; see
+// `jest.integration.config.js` + `scripts/run-integration-tests.sh`).
+//
+// What a backend has to do here is carry a nested map with one extra key and
+// hand it back unchanged. That is exactly what the AppSync resolvers rely on:
+// they return the stored item as it is, and the `__typename` the write path
+// stamped is the only thing that tells GraphQL which union member the value is.
+// A backend that dropped or renamed the key would not produce a decode error —
+// it would produce a member that resolves to null, and a null in a non-nullable
+// field takes its parent row with it.
+
+open JestGlobals
+
+module H = AggIntegrationHarness
+
+@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 = ""
+
+  @schema
+  type state = {customerId: string, geolocation: geolocation}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+  let authorization: Reventless.Authorization.permission = AllowAuthenticated
+  let visibility: Reventless.Visibility.t = Public
+}
+
+let tableName = "qdb-union-round-trip"
+
+describe("QueryDb (DynamoDB) round-trips a union field", () => {
+  testPromise("a stored Located keeps its member type and its point", async () => {
+    let table = await H.createQueryDbTable(tableName)
+    let jsonOps = QueryDbEntryPoint_Ops.makeDynamoQueryDbOps(~tableName=table.name)
+    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 item as a read door hands 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")
+    }
+
+    await H.deleteTable(table)
+  })
+})

package/tests/integration/QueryDbUnion_DynamoDb_IntegrationTest.res.mjs

@@ -0,0 +1,128 @@
+// 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 QueryDb_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Operations.res.mjs";
+import * as AggIntegrationHarness$ReventlessAws from "./AggIntegrationHarness.res.mjs";
+import * as QueryDbEntryPoint_Ops$ReventlessAws from "../../src/adapter/Runtime/QueryDbEntryPoint_Ops.res.mjs";
+
+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 = "";
+
+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"
+};
+
+let tableName = "qdb-union-round-trip";
+
+globalThis.describe("QueryDb (DynamoDB) round-trips a union field", () => {
+  globalThis.test("a stored Located keeps its member type and its point", async () => {
+    let table = await AggIntegrationHarness$ReventlessAws.createQueryDbTable(tableName);
+    let jsonOps = QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(table.name);
+    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([])));
+    let exit = 0;
+    if (items.length !== 1) {
+      exit = 1;
+    } else {
+      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
+          ]);
+          break;
+        case "Pending" :
+        case "Unresolvable" :
+          exit = 1;
+          break;
+      }
+    }
+    if (exit === 1) {
+      globalThis.expect("round trip").toBe("Located with its point intact");
+    }
+    return await AggIntegrationHarness$ReventlessAws.deleteTable(table);
+  });
+});
+
+let H;
+
+export {
+  H,
+  geolocationSchema$1 as geolocationSchema,
+  CustomersSpec,
+  tableName,
+}
+/* geolocationSchema Not a pure module */