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

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.245 (2026-08-20)
+
+### Features
+
+* **core:** report a union value stored without its member type ([3a834b5](https://github.com/ReventlessDev/reventless-core/commit/3a834b51d1d9441f5dfcaebec5fac365063c905e))
+
+
+# 3.0.0-alpha.244 (2026-08-20)
+
+### Bug Fixes
+
+* **api:** name a union after itself, not after the keyword ([58ab956](https://github.com/ReventlessDev/reventless-core/commit/58ab956b8fa310c60f118595768e40e750d61784))
+
+
 # 3.0.0-alpha.243 (2026-08-20)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.243",
+  "version": "3.0.0-alpha.245",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -35,9 +35,9 @@
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.148",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.120",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.32"
   },
   "devDependencies": {

package/src/components/Api/GraphQL_Stitcher.res

@@ -122,17 +122,19 @@ let collectSubscriptionSources = (
 // Extract the first identifier from a SDL field/type string.
 // e.g. "  fieldName(args): Type" → "fieldName"
 //      "type TypeName {" → "TypeName"
+// Every SDL keyword that introduces a named definition. `union` was missing while
+// `CommandResult` was the only union in the schema: a keyword left in place makes
+// every declaration of that kind name itself after the keyword, so the second one
+// deduped against the first and vanished — AppSync then rejected the schema for a
+// type that was never emitted.
+let definitionKeywords = ["type ", "enum ", "input ", "union ", "interface ", "scalar "]
+
 let extractLeadingName = (str: string): string => {
   let trimmed = str->String.trim
-  // Remove "type ", "enum ", or "input " prefix if present
-  let afterType = if trimmed->String.startsWith("type ") {
-    trimmed->String.slice(~start=5, ~end=trimmed->String.length)->String.trim
-  } else if trimmed->String.startsWith("enum ") {
-    trimmed->String.slice(~start=5, ~end=trimmed->String.length)->String.trim
-  } else if trimmed->String.startsWith("input ") {
-    trimmed->String.slice(~start=6, ~end=trimmed->String.length)->String.trim
-  } else {
-    trimmed
+  let afterType = switch definitionKeywords->Array.find(kw => trimmed->String.startsWith(kw)) {
+  | Some(kw) =>
+    trimmed->String.slice(~start=kw->String.length, ~end=trimmed->String.length)->String.trim
+  | None => trimmed
   }
   // Split on "(" first to remove arg list, then on " ", "{", and ":" for the name.
   // The ":" split is load-bearing for ARG-LESS fields: `Foo: [Bar!]!` has no "(" to

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -115,11 +115,19 @@ function collectSubscriptionSources(baseFragment, pluginFragments) {
   });
 }
 
+let definitionKeywords = [
+  "type ",
+  "enum ",
+  "input ",
+  "union ",
+  "interface ",
+  "scalar "
+];
+
 function extractLeadingName(str) {
   let trimmed = str.trim();
-  let afterType = trimmed.startsWith("type ") || trimmed.startsWith("enum ") ? trimmed.slice(5, trimmed.length).trim() : (
-      trimmed.startsWith("input ") ? trimmed.slice(6, trimmed.length).trim() : trimmed
-    );
+  let kw = definitionKeywords.find(kw => trimmed.startsWith(kw));
+  let afterType = kw !== undefined ? trimmed.slice(kw.length, trimmed.length).trim() : trimmed;
   return Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(afterType.split("(")[0], "").trim().split(" ")[0], "").trim().split("{")[0], "").trim().split(":")[0], "").trim();
 }
 
@@ -231,6 +239,7 @@ export {
   encode,
   decode,
   collectSubscriptionSources,
+  definitionKeywords,
   extractLeadingName,
   relayBaseTypes,
   relayBaseQueries,

package/src/components/QueryDb/QueryDb_Operations.res

@@ -1,3 +1,5 @@
+let log = Logger.fromEnv()
+
 module type Ops = {
   let jsonOps: QueryDb.operations<string, JSON.t>
 }
@@ -72,11 +74,53 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
   // backends — and, unlike a read-time stamp, it is also on the row the live
   // change channel hands over as raw JSON. A view with no union field is walked
   // and left exactly as it was.
-  let stampUnionMembers = dict =>
+  // The union fields this view declares, read once. Empty for most views, and
+  // the whole diagnostic below costs nothing when it is.
+  let declaredUnionFields =
+    Reventless.TaggedUnion.fieldsOf(ReadModelSpec.stateSchema->S.castToUnknown)
+
+  // Logged once per instantiation, and unconditionally: "none" has to be
+  // distinguishable from "never instantiated", because a schema that resolves no
+  // union fields and a stamp that failed to run leave the same stored row.
+  log.debug(
+    ~comp="QueryDb",
+    `${ReadModelSpec.name}: union fields ${switch declaredUnionFields {
+      | [] => "none"
+      | fields =>
+        fields->Array.map(((f, n)) => `${f}:${n->Option.getOr("<unnamed>")}`)->Array.join(", ")
+      }}`,
+  )
+
+  // A union value stored without `__typename` is the failure D1 exists to
+  // prevent, and it is silent: the member resolves to null, the null takes its
+  // non-nullable parent, and a list loses the row rather than erroring. Nothing
+  // downstream can tell that from "no such row", so it is reported here — the
+  // one place that knows both the schema and the row.
+  let reportUnstamped = dict =>
+    declaredUnionFields->Array.forEach(((field, unionName)) =>
+      switch dict->Dict.get(field)->Option.flatMap(JSON.Decode.object) {
+      | Some(value) if value->Dict.get("TAG")->Option.isSome =>
+        if value->Dict.get(Reventless.TaggedUnion.typenameKey)->Option.isNone {
+          log.warn(
+            ~comp="QueryDb",
+            `${ReadModelSpec.name}.${field}: stored a union value with no ${Reventless.TaggedUnion.typenameKey} ` ++
+            `(union ${unionName->Option.getOr("<unnamed>")}). The field will resolve to null and take its ` ++
+            `parent with it. Union fields seen on this spec: ${declaredUnionFields
+              ->Array.map(((f, _)) => f)
+              ->Array.join(", ")}`,
+          )
+        }
+      | _ => ()
+      }
+    )
+
+  let stampUnionMembers = dict => {
     Reventless.TaggedUnion.stampInto(
       ~schema=ReadModelSpec.stateSchema->S.castToUnknown,
       JSON.Encode.object(dict),
     )
+    reportUnstamped(dict)
+  }
 
   let save = async (id, state, saveMode, ttl) =>
     switch state->Message.encode(ReadModelSpec.stateSchema)->JSON.Decode.object {

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

@@ -7,9 +7,12 @@ import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 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 Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 
+let log = Logger$ReventlessCore.fromEnv();
+
 function Make(ReadModelSpec) {
   return Ops => {
     let decode = (id, stateJson) => {
@@ -77,14 +80,30 @@ function Make(ReadModelSpec) {
         dict[attrName$1] = value$1;
       });
     };
-    let stampUnionMembers = dict => TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
+    let declaredUnionFields = TaggedUnion$Reventless.fieldsOf(ReadModelSpec.stateSchema);
+    log.debug("QueryDb", undefined, ReadModelSpec.name + `: union fields ` + (
+      declaredUnionFields.length !== 0 ? declaredUnionFields.map(param => param[0] + `:` + Stdlib_Option.getOr(param[1], "<unnamed>")).join(", ") : "none"
+    ));
+    let reportUnstamped = dict => {
+      declaredUnionFields.forEach(param => {
+        let field = param[0];
+        let value = Stdlib_Option.flatMap(dict[field], Stdlib_JSON.Decode.object);
+        if (value !== undefined && Stdlib_Option.isSome(value["TAG"]) && Stdlib_Option.isNone(value[TaggedUnion$Reventless.typenameKey])) {
+          return log.warn("QueryDb", undefined, ReadModelSpec.name + `.` + field + `: stored a union value with no ` + TaggedUnion$Reventless.typenameKey + ` ` + (`(union ` + Stdlib_Option.getOr(param[1], "<unnamed>") + `). The field will resolve to null and take its `) + (`parent with it. Union fields seen on this spec: ` + declaredUnionFields.map(param => param[0]).join(", ")));
+        }
+      });
+    };
+    let stampUnionMembers = dict => {
+      TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
+      reportUnstamped(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);
+        stampUnionMembers(dict);
         return await Ops.jsonOps.save(ReadModelSpec.Id.toString(id), dict, saveMode, ttl);
       } else {
         return {
@@ -110,7 +129,7 @@ function Make(ReadModelSpec) {
             dict["id"] = Message$ReventlessCore.encode(id, ReadModelSpec.Id.schema);
             injectSubId(dict, state);
             injectCompositeIndexAttrs(dict);
-            TaggedUnion$Reventless.stampInto(ReadModelSpec.stateSchema, dict);
+            stampUnionMembers(dict);
             return {
               TAG: "Ok",
               _0: batch.concat([[
@@ -154,6 +173,8 @@ function Make(ReadModelSpec) {
       load: load,
       injectSubId: injectSubId,
       injectCompositeIndexAttrs: injectCompositeIndexAttrs,
+      declaredUnionFields: declaredUnionFields,
+      reportUnstamped: reportUnstamped,
       stampUnionMembers: stampUnionMembers,
       save: save,
       saveBatch: saveBatch,
@@ -165,6 +186,7 @@ function Make(ReadModelSpec) {
 }
 
 export {
+  log,
   Make,
 }
-/* effect/Effect Not a pure module */
+/* log Not a pure module */

package/tests/api/GraphQL_StitcherTest.res

@@ -64,6 +64,51 @@ describe("GraphQL_Stitcher.subscriptionSources", () => {
   })
 })
 
+// Two unions in one schema is what caught this: every definition keyword the name
+// extractor does not strip makes each declaration of that kind name itself after
+// the keyword, so the second dedupes against the first and is dropped. With
+// `CommandResult` the only union, nothing showed it. The local path does not use
+// this dedup, so a golden carrying both unions still passed while AppSync rejected
+// the schema for a type that was never emitted.
+describe("GraphQL_Stitcher.extractLeadingName", () => {
+  testSync("names a union after the union, not after the keyword", () => {
+    expect(extractLeadingName("union Geolocation = GeolocationLocated | GeolocationPending"))->toBe(
+      "Geolocation",
+    )
+    expect(extractLeadingName("union CommandResult = CommandAccepted | CommandRejected"))->toBe(
+      "CommandResult",
+    )
+  })
+
+  testSync("names an interface and a scalar after themselves", () => {
+    expect(extractLeadingName("interface Node { id: ID! }"))->toBe("Node")
+    expect(extractLeadingName("scalar AWSDateTime"))->toBe("AWSDateTime")
+  })
+
+  // The cases that already worked, kept so a rewrite of the keyword list has to
+  // keep them working.
+  testSync("still names types, enums and inputs", () => {
+    expect(extractLeadingName("type Ordering_Customer implements Node { id: ID! }"))->toBe(
+      "Ordering_Customer",
+    )
+    expect(extractLeadingName("enum SortOrder { ASC DESC }"))->toBe("SortOrder")
+    expect(extractLeadingName("input Ordering_CustomerFilter { id: ID }"))->toBe(
+      "Ordering_CustomerFilter",
+    )
+  })
+
+  // Fields go through the same extractor, and an arg-less one has no "(" to cleave
+  // the type off.
+  testSync("still names fields, with and without args", () => {
+    expect(extractLeadingName("  Catalog_AddProduct(input: AddInput): CommandResult"))->toBe(
+      "Catalog_AddProduct",
+    )
+    expect(extractLeadingName("  Platform_ApiFragments: [Fragment!]!"))->toBe(
+      "Platform_ApiFragments",
+    )
+  })
+})
+
 describe("GraphQL_Stitcher.stitchStandalone", () => {
   let pluginFragment = encode({
     types: [

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -77,6 +77,26 @@ globalThis.describe("GraphQL_Stitcher.subscriptionSources", () => {
   });
 });
 
+globalThis.describe("GraphQL_Stitcher.extractLeadingName", () => {
+  globalThis.test("names a union after the union, not after the keyword", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("union Geolocation = GeolocationLocated | GeolocationPending")).toBe("Geolocation");
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("union CommandResult = CommandAccepted | CommandRejected")).toBe("CommandResult");
+  });
+  globalThis.test("names an interface and a scalar after themselves", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("interface Node { id: ID! }")).toBe("Node");
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("scalar AWSDateTime")).toBe("AWSDateTime");
+  });
+  globalThis.test("still names types, enums and inputs", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("type Ordering_Customer implements Node { id: ID! }")).toBe("Ordering_Customer");
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("enum SortOrder { ASC DESC }")).toBe("SortOrder");
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("input Ordering_CustomerFilter { id: ID }")).toBe("Ordering_CustomerFilter");
+  });
+  globalThis.test("still names fields, with and without args", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("  Catalog_AddProduct(input: AddInput): CommandResult")).toBe("Catalog_AddProduct");
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.extractLeadingName("  Platform_ApiFragments: [Fragment!]!")).toBe("Platform_ApiFragments");
+  });
+});
+
 globalThis.describe("GraphQL_Stitcher.stitchStandalone", () => {
   let pluginFragment = GraphQL_Stitcher$ReventlessCore.encode({
     types: [