@reventlessdev/reventless-core 3.0.0-alpha.241 → 3.0.0-alpha.243

package/src/components/QueryDb/QueryDb_Operations.res.mjs

@@ -8,6 +8,7 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 
 function Make(ReadModelSpec) {
   return Ops => {
@@ -76,12 +77,14 @@ function Make(ReadModelSpec) {
         dict[attrName$1] = value$1;
       });
     };
+    let stampUnionMembers = dict => TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
     let save = async (id, state, saveMode, ttl) => {
       let dict = Stdlib_JSON.Decode.object(Message$ReventlessCore.encode(state, ReadModelSpec.stateSchema));
       if (dict !== undefined) {
         dict["id"] = Message$ReventlessCore.encode(id, ReadModelSpec.Id.schema);
         injectSubId(dict, state);
         injectCompositeIndexAttrs(dict);
+        TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
         return await Ops.jsonOps.save(ReadModelSpec.Id.toString(id), dict, saveMode, ttl);
       } else {
         return {
@@ -107,6 +110,7 @@ function Make(ReadModelSpec) {
             dict["id"] = Message$ReventlessCore.encode(id, ReadModelSpec.Id.schema);
             injectSubId(dict, state);
             injectCompositeIndexAttrs(dict);
+            TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
             return {
               TAG: "Ok",
               _0: batch.concat([[
@@ -150,6 +154,7 @@ function Make(ReadModelSpec) {
       load: load,
       injectSubId: injectSubId,
       injectCompositeIndexAttrs: injectCompositeIndexAttrs,
+      stampUnionMembers: stampUnionMembers,
       save: save,
       saveBatch: saveBatch,
       count: count,

package/src/plugin/component/Plugin_Structure.res

@@ -23,6 +23,11 @@ let rec isLabelShape = (t: SchemaType.schemaType): bool =>
   switch t {
   | ScalarString => true
   | Nullable(inner) => isLabelShape(inner)
+  // Written out rather than left to the catch-all: a union is a composite whose
+  // rendering depends on which arm a row is in, so no single string names the
+  // record. The label picker's fallback rung is a *guess*, and this is the shape
+  // it would guess most confidently and most wrongly.
+  | TaggedUnion(_, _) => false
   | _ => false
   }
 
@@ -33,6 +38,10 @@ let rec isLifecycleShape = (t: SchemaType.schemaType): bool =>
   switch t {
   | Enum(_, _) => true
   | Nullable(inner) => isLifecycleShape(inner)
+  // A union is a closed set of *shapes*, not of values, and `allowedStates`
+  // compares values. The same answer the ppx gives `@lifecycle` on a union
+  // field, which is a compile error — this is the convention rung agreeing.
+  | TaggedUnion(_, _) => false
   | _ => false
   }
 

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -32,11 +32,13 @@ function isLabelShape(_t) {
     if (typeof t !== "object") {
       return t === "ScalarString";
     }
-    if (t.TAG !== "Nullable") {
-      return false;
+    switch (t.TAG) {
+      case "Nullable" :
+        _t = t._0;
+        continue;
+      default:
+        return false;
     }
-    _t = t._0;
-    continue;
   };
 }
 

package/src/plugin/component/SchemaWalker.res

@@ -28,9 +28,22 @@ let rec describeSchema = (schema: S.t<unknown>): string =>
       | _ => true
       }
     )
-    switch nonNull->Array.get(0) {
-    | Some(inner) => "option<" ++ describeSchema(inner) ++ ">"
-    | None => "unknown"
+    let isOptional = nonNull->Array.length < anyOf->Array.length
+    switch nonNull {
+    | [inner] => "option<" ++ describeSchema(inner) ++ ">"
+    | [] => "unknown"
+    | members =>
+      // A field holding a variant. Described by every arm, sorted, rather than by
+      // the first one: the structural hash is computed from this string, and a
+      // description that mentions one arm is blind to a change in any other —
+      // which is drift detection reporting "no change" for a changed schema.
+      let inner =
+        members
+        ->Array.map(describeSchema)
+        ->Array.toSorted(String.compare)
+        ->Array.join("|")
+      let union = "union<" ++ inner ++ ">"
+      isOptional ? "option<" ++ union ++ ">" : union
     }
   | Array({additionalItems}) =>
     let itemDesc = switch additionalItems {

package/src/plugin/component/SchemaWalker.res.mjs

@@ -26,7 +26,8 @@ function describeSchema(schema) {
       let inner = Object.entries(schema.properties).filter(param => param[0] !== "TAG").toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => param[0] + ":" + describeSchema(param[1])).join(",");
       return "{" + inner + "}";
     case "anyOf" :
-      let nonNull = schema.anyOf.filter(v => {
+      let anyOf = schema.anyOf;
+      let nonNull = anyOf.filter(v => {
         switch (v.type) {
           case "null" :
           case "undefined" :
@@ -35,12 +36,22 @@ function describeSchema(schema) {
             return true;
         }
       });
-      let inner$1 = nonNull[0];
-      if (inner$1 !== undefined) {
-        return "option<" + describeSchema(inner$1) + ">";
-      } else {
-        return "unknown";
+      let isOptional = nonNull.length < anyOf.length;
+      let len = nonNull.length;
+      if (len !== 1) {
+        if (len === 0) {
+          return "unknown";
+        }
+        let inner$1 = nonNull.map(describeSchema).toSorted(Primitive_string.compare).join("|");
+        let union = "union<" + inner$1 + ">";
+        if (isOptional) {
+          return "option<" + union + ">";
+        } else {
+          return union;
+        }
       }
+      let inner$2 = nonNull[0];
+      return "option<" + describeSchema(inner$2) + ">";
     default:
       return "unknown";
   }

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -10,7 +10,7 @@
 // this (spec-level `permission` outranks the legacy `{tableName, group}` pair),
 // and so does the `requiredAccess` the platform publishes — so a shell can gate
 // the Plugins view up front instead of offering it and meeting a refusal.
-@@reventless.authorize(Reventless.Authorization.AllowGroups(["Admin"]))
+@@reventless.authorize(AllowGroups(["Admin"]))
 
 // Current view — one row per plugin **name**, holding the currently-active
 // version's definition. Keyed by the aggregate id (= plugin name). The status

package/tests/admin/Platform_Admin_StructureTest.res

@@ -269,7 +269,7 @@ describe("the Plugins queryableDef is what the generic helpers produce", () => {
     // nested object types whose own fields would match a naive `includes`.
     let props =
       rm.schema
-      ->JSON.parseExn
+      ->JSON.parseOrThrow
       ->JSON.Decode.object
       ->Option.flatMap(o => o->Dict.get("properties"))
       ->Option.flatMap(JSON.Decode.object)
@@ -289,7 +289,7 @@ describe("the Plugins queryableDef is what the generic helpers produce", () => {
   testSync("while the internal fields are not published at all", () => {
     let props =
       rm.schema
-      ->JSON.parseExn
+      ->JSON.parseOrThrow
       ->JSON.Decode.object
       ->Option.flatMap(o => o->Dict.get("properties"))
       ->Option.flatMap(JSON.Decode.object)

package/tests/api/GeolocationSemanticTest.res

@@ -0,0 +1,108 @@
+open JestGlobals
+open TaggedUnionFixtures
+
+// Two markers ride on one schema; a lost one emits the field as `String` with
+// nothing reporting it. Also pins a negative: the name does NOT come from
+// `semanticCompositeNames`, so an entry there would be inert.
+
+module GeoCustomersSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "SemanticGeolocationCustomers"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {customerId: string, geolocation: Reventless.Geolocation.t}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+let fragment = GraphQL_FragmentGenerator.generate(
+  ~mutationEntries=[],
+  ~queryEntries=[
+    queryEntryFor(
+      ~returnTypeName="SemanticGeoCustomer",
+      ~specName=GeoCustomersSpec.name,
+      GeoCustomersSpec.stateSchema,
+    ),
+  ],
+)
+
+let types = GraphQL_Stitcher.decode(fragment).types
+let typeDefFor = needle => types->Array.find(t => t->String.includes(needle))->Option.getOr("")
+
+describe("the Geolocation semantic reaches the IR as a named union", () => {
+  let field = switch SchemaType.fromSuryObject(
+    ~typeName="SemanticGeoCustomer",
+    GeoCustomersSpec.stateSchema->S.castToUnknown,
+  ) {
+  | Some(fields) => fields->Dict.get("geolocation")
+  | None => None
+  }
+
+  // If the walk stopped at the marker, the field would classify as `Unknown`.
+  testSync("the semantic marker does not swallow the union", () => {
+    switch field {
+    | Some(Semantic({id}, TaggedUnion(name, arms))) =>
+      expect((id, name, arms->Array.length))->toEqual((
+        Reventless.Semantic.Id.geolocation,
+        "Geolocation",
+        3,
+      ))
+    | _ => expect("geolocation")->toBe("Semantic(geolocation, TaggedUnion(Geolocation, 3 arms))")
+    }
+  })
+
+  // A path-composed name would carry the spec's name; this one must not.
+  testSync("the union is named from the schema, not from where it was found", () => {
+    switch field {
+    | Some(Semantic(_, TaggedUnion(name, _))) =>
+      expect(name->String.includes("Customer"))->toBe(false)
+      expect(name)->toBe("Geolocation")
+    | _ => expect("geolocation")->toBe("a named TaggedUnion")
+    }
+  })
+
+  // An entry there would leave this passing — it decides nothing.
+  testSync("semanticCompositeNames does not name this union", () => {
+    expect(SchemaType.canonicalName(Reventless.Semantic.Id.geolocation))->toEqual(None)
+  })
+})
+
+// The breaking half, asserted rather than assumed.
+describe("a row in the pre-union shape does not decode", () => {
+  let oldShapedRow = JSON.parseOrThrow(`{
+    "customerId": "c1",
+    "location": {"lat": 48.2082, "lng": 16.3738},
+    "locationStatus": "Located",
+    "locationNote": null
+  }`)
+
+  testSync("the three-field shape is refused against the union schema", () => {
+    let decodes = switch oldShapedRow->S.parseOrThrow(~to=GeoCustomersSpec.stateSchema) {
+    | _ => true
+    | exception _ => false
+    }
+    expect(decodes)->toBe(false)
+  })
+})
+
+describe("the Geolocation semantic emits its three member types", () => {
+  testSync("the union declaration lists all three members", () => {
+    let union = typeDefFor("union Geolocation")
+    expect(union->String.includes("GeolocationPending"))->toBe(true)
+    expect(union->String.includes("GeolocationLocated"))->toBe(true)
+    expect(union->String.includes("GeolocationUnresolvable"))->toBe(true)
+  })
+
+  // Also says a composite nested in an arm keeps its own canonical name.
+  testSync("the located member carries a GeoPoint", () => {
+    expect(typeDefFor("type GeolocationLocated")->String.includes("GeoPoint"))->toBe(true)
+  })
+
+  testSync("the field is typed as the union", () => {
+    expect(typeDefFor("type SemanticGeoCustomer")->String.includes("geolocation: Geolocation"))->toBe(
+      true,
+    )
+  })
+})

package/tests/api/GeolocationSemanticTest.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Geolocation$Reventless from "@reventlessdev/reventless-spec/src/semantic/Geolocation.res.mjs";
+import * as SchemaType$ReventlessCore from "../../src/components/Api/SchemaType.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as TaggedUnionFixtures$ReventlessCore from "../fixtures/TaggedUnionFixtures.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let name = "SemanticGeolocationCustomers";
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  geolocation: s.m(Geolocation$Reventless.schema)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let GeoCustomersSpec = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [TaggedUnionFixtures$ReventlessCore.queryEntryFor("SemanticGeoCustomer", name, stateSchema)]);
+
+let types = GraphQL_Stitcher$ReventlessCore.decode(fragment).types;
+
+function typeDefFor(needle) {
+  return Stdlib_Option.getOr(types.find(t => t.includes(needle)), "");
+}
+
+globalThis.describe("the Geolocation semantic reaches the IR as a named union", () => {
+  let fields = SchemaType$ReventlessCore.fromSuryObject("SemanticGeoCustomer", stateSchema);
+  let field = fields !== undefined ? fields["geolocation"] : undefined;
+  globalThis.test("the semantic marker does not swallow the union", () => {
+    if (typeof field === "object" && field.TAG === "Semantic") {
+      let match = field._1;
+      if (typeof match === "object" && match.TAG === "TaggedUnion") {
+        globalThis.expect([
+          field._0.id,
+          match._0,
+          match._1.length
+        ]).toEqual([
+          Semantic$Reventless.Id.geolocation,
+          "Geolocation",
+          3
+        ]);
+        return;
+      }
+    }
+    globalThis.expect("geolocation").toBe("Semantic(geolocation, TaggedUnion(Geolocation, 3 arms))");
+  });
+  globalThis.test("the union is named from the schema, not from where it was found", () => {
+    if (typeof field === "object" && field.TAG === "Semantic") {
+      let match = field._1;
+      if (typeof match === "object" && match.TAG === "TaggedUnion") {
+        let name = match._0;
+        globalThis.expect(name.includes("Customer")).toBe(false);
+        globalThis.expect(name).toBe("Geolocation");
+        return;
+      }
+    }
+    globalThis.expect("geolocation").toBe("a named TaggedUnion");
+  });
+  globalThis.test("semanticCompositeNames does not name this union", () => {
+    globalThis.expect(SchemaType$ReventlessCore.canonicalName(Semantic$Reventless.Id.geolocation)).toEqual(undefined);
+  });
+});
+
+globalThis.describe("a row in the pre-union shape does not decode", () => {
+  let oldShapedRow = JSON.parse(`{
+    "customerId": "c1",
+    "location": {"lat": 48.2082, "lng": 16.3738},
+    "locationStatus": "Located",
+    "locationNote": null
+  }`);
+  globalThis.test("the three-field shape is refused against the union schema", () => {
+    let decodes;
+    try {
+      S.parseOrThrow(oldShapedRow, stateSchema);
+      decodes = true;
+    } catch (exn) {
+      decodes = false;
+    }
+    globalThis.expect(decodes).toBe(false);
+  });
+});
+
+globalThis.describe("the Geolocation semantic emits its three member types", () => {
+  globalThis.test("the union declaration lists all three members", () => {
+    let union = typeDefFor("union Geolocation");
+    globalThis.expect(union.includes("GeolocationPending")).toBe(true);
+    globalThis.expect(union.includes("GeolocationLocated")).toBe(true);
+    globalThis.expect(union.includes("GeolocationUnresolvable")).toBe(true);
+  });
+  globalThis.test("the located member carries a GeoPoint", () => {
+    globalThis.expect(typeDefFor("type GeolocationLocated").includes("GeoPoint")).toBe(true);
+  });
+  globalThis.test("the field is typed as the union", () => {
+    globalThis.expect(typeDefFor("type SemanticGeoCustomer").includes("geolocation: Geolocation")).toBe(true);
+  });
+});
+
+export {
+  GeoCustomersSpec,
+  fragment,
+  types,
+  typeDefFor,
+}
+/* moduleUrl Not a pure module */

package/tests/api/TaggedUnionSchemaTest.res

@@ -0,0 +1,198 @@
+open JestGlobals
+open TaggedUnionFixtures
+
+let fragmentFor = (~returnTypeName, ~specName, stateSchema) =>
+  GraphQL_FragmentGenerator.generate(
+    ~mutationEntries=[],
+    ~queryEntries=[queryEntryFor(~returnTypeName, ~specName, stateSchema)],
+  )
+
+let typesOf = fragment => GraphQL_Stitcher.decode(fragment).types
+let typeDefFor = (fragment, needle) =>
+  typesOf(fragment)->Array.find(t => t->String.includes(needle))->Option.getOr("")
+
+// ── The IR ────────────────────────────────────────────────────────────────
+
+describe("SchemaType classifies a named union", () => {
+  let shapeOfField = (schema, field) =>
+    switch SchemaType.fromSuryObject(~typeName="X", schema->S.castToUnknown) {
+    | Some(fields) => fields->Dict.get(field)
+    | None => None
+    }
+
+  testSync("arms are keyed by TAG and carry the member type's own name", () => {
+    switch shapeOfField(CustomersSpec.stateSchema, "geolocation") {
+    | Some(TaggedUnion(name, arms)) =>
+      expect(name)->toBe("Geolocation")
+      expect(arms->Array.map(((tag, _)) => tag))->toEqual(["Pending", "Located", "Unresolvable"])
+      switch arms->Array.find(((tag, _)) => tag === "Located") {
+      | Some((_, ObjectRef(memberName, fields))) =>
+        expect(memberName)->toBe("GeolocationLocated")
+        expect(fields->Dict.keysToArray)->toEqual(["point"])
+      | _ => expect("Located arm")->toBe("an ObjectRef")
+      }
+    | other =>
+      expect(other->Option.isSome ? "some other shape" : "nothing")->toBe("a TaggedUnion")
+    }
+  })
+
+  testSync("an optional union keeps its arms behind Nullable", () => {
+    switch shapeOfField(SightingsSpec.stateSchema, "lastSeen") {
+    | Some(Nullable(TaggedUnion(name, arms))) =>
+      expect((name, arms->Array.length))->toEqual(("Geolocation", 3))
+    | _ => expect("lastSeen")->toBe("Nullable(TaggedUnion(...))")
+    }
+  })
+
+  testSync("an array of unions keeps its arms behind ArrayOf", () => {
+    switch shapeOfField(SightingsSpec.stateSchema, "history") {
+    | Some(ArrayOf(TaggedUnion(name, _))) => expect(name)->toBe("Geolocation")
+    | _ => expect("history")->toBe("ArrayOf(TaggedUnion(...))")
+    }
+  })
+
+  // The silent degradation this plan set out to end: an unclassifiable union
+  // rendered as `String!` with nothing said anywhere.
+  testSync("an unnamed union is reported by field and by reason", () => {
+    switch SchemaType.unclassifiedUnions(UnnamedSpec.stateSchema->S.castToUnknown) {
+    | [{path, reason}] =>
+      expect(path)->toBe("verdict")
+      expect(reason->String.includes("no name"))->toBe(true)
+    | found =>
+      expect(found->Array.length)->toBe(1)
+    }
+  })
+
+  testSync("a classified union and an enum are not reported", () => {
+    expect(
+      SchemaType.unclassifiedUnions(CustomersSpec.stateSchema->S.castToUnknown)->Array.length,
+    )->toBe(0)
+  })
+})
+
+// ── The SDL ───────────────────────────────────────────────────────────────
+
+describe("GraphQL_FragmentGenerator emits a union", () => {
+  let fragment = fragmentFor(
+    ~returnTypeName="Ordering_TuCustomer",
+    ~specName="TaggedUnionCustomers",
+    CustomersSpec.stateSchema,
+  )
+
+  testSync("the field is typed as the union", () => {
+    expect(
+      typeDefFor(fragment, "type Ordering_TuCustomer ")->String.includes(
+        "geolocation: Geolocation!",
+      ),
+    )->toBe(true)
+  })
+
+  testSync("the union names one member type per arm", () => {
+    expect(typeDefFor(fragment, "union Geolocation"))->toBe(
+      "union Geolocation = GeolocationPending | GeolocationLocated | GeolocationUnresolvable",
+    )
+  })
+
+  testSync("each member type declares the arm's own fields, and no TAG", () => {
+    let located = typeDefFor(fragment, "type GeolocationLocated ")
+    expect(located->String.includes("point: GeoPoint!"))->toBe(true)
+    expect(located->String.includes("TAG"))->toBe(false)
+    expect(
+      typeDefFor(fragment, "type GeolocationUnresolvable ")->String.includes("reason: String!"),
+    )->toBe(true)
+  })
+
+  // The merged-API property. AppSync unions same-named types from each source
+  // API, and a union of identical definitions is that definition — so a second
+  // plugin's copy has to be byte-identical, not merely equivalent. This is the
+  // assertion that fails quietly: a name composed from the field path would pass
+  // every other test in this file.
+  testSync("a second plugin's copy of the union is byte-identical", () => {
+    let other = fragmentFor(
+      ~returnTypeName="Catalog_TuSighting",
+      ~specName="TaggedUnionSightings",
+      SightingsSpec.stateSchema,
+    )
+    let unionOf = f => typeDefFor(f, "union Geolocation")
+    expect(unionOf(other))->toBe(unionOf(fragment))
+    expect(typeDefFor(other, "type GeolocationLocated "))->toBe(
+      typeDefFor(fragment, "type GeolocationLocated "),
+    )
+  })
+
+  testSync("an optional union is nullable and an array of them is a list", () => {
+    let sightings = fragmentFor(
+      ~returnTypeName="Catalog_TuSighting",
+      ~specName="TaggedUnionSightings",
+      SightingsSpec.stateSchema,
+    )
+    let row = typeDefFor(sightings, "type Catalog_TuSighting ")
+    expect(row->String.includes("lastSeen: Geolocation\n"))->toBe(true)
+    expect(row->String.includes("history: [Geolocation!]!"))->toBe(true)
+  })
+
+  // Unchanged behaviour, pinned: without a name there is no type to emit, and
+  // inventing one would publish a contract nothing can stamp a `__typename` for.
+  testSync("an unnamed union stays a String", () => {
+    let unnamed = fragmentFor(
+      ~returnTypeName="Ordering_TuCase",
+      ~specName="TaggedUnionUnnamed",
+      UnnamedSpec.stateSchema,
+    )
+    expect(
+      typeDefFor(unnamed, "type Ordering_TuCase ")->String.includes("verdict: String!"),
+    )->toBe(true)
+    expect(typesOf(unnamed)->Array.some(t => t->String.startsWith("union ")))->toBe(false)
+  })
+})
+
+// ── The JSON Schema ───────────────────────────────────────────────────────
+
+let objAt = (json, key) =>
+  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
+
+describe("SuryToJsonSchema emits the arms as oneOf", () => {
+  let json = SuryToJsonSchema.deriveObjectSchema(CustomersSpec.stateSchema->S.castToUnknown)
+  let field =
+    objAt(json, "properties")
+    ->Option.flatMap(p => p->JSON.Decode.object)
+    ->Option.flatMap(p => p->Dict.get("geolocation"))
+    ->Option.getOr(JSON.Encode.null)
+
+  testSync("the field names the union it is", () => {
+    expect(objAt(field, "x-reventless-union")->Option.flatMap(JSON.Decode.string))->toEqual(
+      Some("Geolocation"),
+    )
+  })
+
+  testSync("one member per arm, each discriminated by its TAG const", () => {
+    let members =
+      objAt(field, "oneOf")->Option.flatMap(JSON.Decode.array)->Option.getOr([])
+    expect(members->Array.length)->toBe(3)
+    let tags = members->Array.filterMap(m =>
+      objAt(m, "properties")
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.flatMap(p => p->Dict.get("TAG"))
+      ->Option.flatMap(t => objAt(t, "const"))
+      ->Option.flatMap(JSON.Decode.string)
+    )
+    expect(tags)->toEqual(["Pending", "Located", "Unresolvable"])
+  })
+
+  // Without this a reader has to re-derive `<UnionName><Arm>` in a second repo to
+  // map a raw live-channel payload onto an inline fragment.
+  testSync("each member publishes the GraphQL type it is emitted as", () => {
+    let names =
+      objAt(field, "oneOf")
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.getOr([])
+      ->Array.filterMap(m =>
+        objAt(m, "x-reventless-union-member")->Option.flatMap(JSON.Decode.string)
+      )
+    expect(names)->toEqual([
+      "GeolocationPending",
+      "GeolocationLocated",
+      "GeolocationUnresolvable",
+    ])
+  })
+})