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

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.244",
+  "version": "3.0.0-alpha.245",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {

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 */