@reventlessdev/reventless-spec 3.0.0-alpha.62 → 3.0.0-alpha.63

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.63 (2026-07-02)
+
+### Bug Fixes
+
+* **spec,interop,layer-builder:** generator/protocol/build failure modes (plan A8,A9) ([66d7a54](https://github.com/ReventlessDev/reventless-core/commit/66d7a54e3a0afdbfe3ea2975f517d1d64d52c180))
+
+
 # 3.0.0-alpha.62 (2026-06-29)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.62",
+  "version": "3.0.0-alpha.63",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbDecode.res

@@ -120,7 +120,15 @@ let makeDecoder = (schema: S.t<'event>): makeDecoderResult<'event> => {
       try {
         Some(JSON.Object(jsonDict)->S.parseJsonOrThrow(schema))
       } catch {
-      | _ => None
+      | _ =>
+        // A parse failure here means a stored event no longer matches the
+        // current schema (drift). Dropping it silently hid real data loss;
+        // surface it as a warning so it's diagnosable.
+        Console.warn(
+          "DcbDecode: dropped event `" ++
+          eventType ++ "` — payload does not match the current schema (drift?)",
+        )
+        None
       }
     }
 

package/src/components/DcbDecode.res.mjs

@@ -100,6 +100,7 @@ function makeDecoder(schema) {
     try {
       return Primitive_option.some(S.parseJsonOrThrow(jsonDict, schema));
     } catch (exn) {
+      console.warn("DcbDecode: dropped event `" + eventType + "` — payload does not match the current schema (drift?)");
       return;
     }
   };

package/src/components/DcbValidation.res

@@ -56,7 +56,10 @@ let extractAllVariants = (schema: S.t<unknown>): array<variantInfo> =>
 // Check if a variant has no payload fields (only TAG)
 let isPayloadLess = (info: variantInfo): bool => info.fields->Dict.toArray->Array.length == 0
 
-// Compare two sury schema types for structural compatibility
+// Compare two sury schema types for structural compatibility. Objects and
+// unions recurse: previously any (Object, Object) / (Union, Union) pair was
+// declared compatible, so nested payload drift (a renamed/retyped nested field,
+// a changed variant) passed validation undetected.
 let rec schemasAreCompatible = (a: S.t<unknown>, b: S.t<unknown>): bool =>
   switch (a, b) {
   | (String(_), String(_)) => true
@@ -65,10 +68,35 @@ let rec schemasAreCompatible = (a: S.t<unknown>, b: S.t<unknown>): bool =>
   | (BigInt(_), BigInt(_)) => true
   | (Array({additionalItems: Schema(aItem)}), Array({additionalItems: Schema(bItem)})) =>
     schemasAreCompatible(aItem, bItem)
-  | (Union(_), Union(_)) => true
-  | (Object(_), Object(_)) => true
+  | (Object({properties: aProps}), Object({properties: bProps})) => propsCompatible(aProps, bProps)
+  | (Union(_), Union(_)) =>
+    // Same set of variant tags, and each shared variant's payload compatible.
+    let av = extractAllVariants(a)
+    let bv = extractAllVariants(b)
+    let at = av->Array.map(v => v.tagName)->Array.toSorted(String.compare)
+    let bt = bv->Array.map(v => v.tagName)->Array.toSorted(String.compare)
+    at == bt &&
+    at->Array.every(tag =>
+      switch (av->Array.find(v => v.tagName == tag), bv->Array.find(v => v.tagName == tag)) {
+      | (Some(x), Some(y)) => propsCompatible(x.fields, y.fields)
+      | _ => false
+      }
+    )
   | _ => false
   }
+// Two property maps are compatible when they carry the same field names and each
+// field's schema is compatible.
+and propsCompatible = (aProps: dict<S.t<unknown>>, bProps: dict<S.t<unknown>>): bool => {
+  let aKeys = aProps->Dict.keysToArray->Array.toSorted(String.compare)
+  let bKeys = bProps->Dict.keysToArray->Array.toSorted(String.compare)
+  aKeys == bKeys &&
+  aKeys->Array.every(k =>
+    switch (aProps->Dict.get(k), bProps->Dict.get(k)) {
+    | (Some(av), Some(bv)) => schemasAreCompatible(av, bv)
+    | _ => false
+    }
+  )
+}
 
 // Get a human-readable type name for a schema
 let schemaTypeName = (schema: S.t<unknown>): string =>

package/src/components/DcbValidation.res.mjs

@@ -95,15 +95,56 @@ function schemasAreCompatible(_a, _b) {
         _a = aItem;
         continue;
       case "object" :
-        return b.type === "object";
+        if (b.type === "object") {
+          return propsCompatible(a.properties, b.properties);
+        } else {
+          return false;
+        }
       case "union" :
-        return b.type === "union";
+        if (b.type !== "union") {
+          return false;
+        }
+        let av = extractAllVariants(a);
+        let bv = extractAllVariants(b);
+        let at = av.map(v => v.tagName).toSorted(Primitive_string.compare);
+        let bt = bv.map(v => v.tagName).toSorted(Primitive_string.compare);
+        if (Primitive_object.equal(at, bt)) {
+          return at.every(tag => {
+            let match = av.find(v => v.tagName === tag);
+            let match$1 = bv.find(v => v.tagName === tag);
+            if (match !== undefined && match$1 !== undefined) {
+              return propsCompatible(match.fields, match$1.fields);
+            } else {
+              return false;
+            }
+          });
+        } else {
+          return false;
+        }
       default:
         return false;
     }
   };
 }
 
+function propsCompatible(aProps, bProps) {
+  let aKeys = Object.keys(aProps).toSorted(Primitive_string.compare);
+  let bKeys = Object.keys(bProps).toSorted(Primitive_string.compare);
+  if (Primitive_object.equal(aKeys, bKeys)) {
+    return aKeys.every(k => {
+      let match = aProps[k];
+      let match$1 = bProps[k];
+      if (match !== undefined && match$1 !== undefined) {
+        return schemasAreCompatible(match, match$1);
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
 function schemaTypeName(schema) {
   switch (schema.type) {
     case "never" :
@@ -381,6 +422,7 @@ export {
   extractAllVariants,
   isPayloadLess,
   schemasAreCompatible,
+  propsCompatible,
   schemaTypeName,
   dedupeKeys,
   validateCompositeReads,

package/src/generator/Pairing.res

@@ -316,12 +316,16 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
     switch epGroup {
     | None => flatEpMappings->Array.push(stem)
     | Some(g) =>
-      let arr = Dict.get(epByGroup, g)->Option.getOr({
-        let a: array<string> = []
-        Dict.set(epByGroup, g, a)
-        a
-      })
-      arr->Array.push(stem)
+      // `Option.getOr`'s default is evaluated eagerly, so the previous shape
+      // re-created and re-set a fresh empty array every iteration — overwriting
+      // the group's real entry and pushing onto a now-detached array. A group
+      // with ≥2 mappings ended up empty, emitting a Plugin.res that referenced a
+      // never-generated module (`Array.getUnsafe(0)` on `[]`). Use a switch so
+      // the create branch runs only when the group is genuinely absent.
+      switch Dict.get(epByGroup, g) {
+      | Some(arr) => arr->Array.push(stem)
+      | None => Dict.set(epByGroup, g, [stem])
+      }
     }
   })
 

package/src/generator/Pairing.res.mjs

@@ -3,7 +3,6 @@
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 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 Generator_Node$Reventless from "./Generator_Node.res.mjs";
 
 let implSuffixForStateChange = "_Behavior";
@@ -282,9 +281,12 @@ function resolve(discovered, srcDir) {
     let epGroup = param.epGroup;
     let stem = param.stem;
     if (epGroup !== undefined) {
-      let a = [];
-      let arr = Stdlib_Option.getOr(epByGroup[epGroup], (epByGroup[epGroup] = a, a));
-      arr.push(stem);
+      let arr = epByGroup[epGroup];
+      if (arr !== undefined) {
+        arr.push(stem);
+      } else {
+        epByGroup[epGroup] = [stem];
+      }
       return;
     }
     flatEpMappings.push(stem);

package/src/generator/PluginGenerator.res

@@ -2,6 +2,8 @@
 // Usage: generate-plugin <srcDir>
 //        generate-plugin --aws <Namespace> <srcDir>
 
+@val external processExit: int => unit = "process.exit"
+
 let () = {
   let argv2 = Generator_Node.argv->Array.get(2)->Option.getOr("")
   let argv3 = Generator_Node.argv->Array.get(3)->Option.getOr("")
@@ -23,6 +25,9 @@ let () = {
       Console.error("Usage: generate-plugin <srcDir>")
       Console.error("       generate-plugin --aws <Namespace> <srcDir>")
     }
+    // Exit non-zero on a usage error so `prebuild` (and CI) actually fail
+    // instead of continuing green with no Plugin.res generated.
+    processExit(1)
   } else {
     // Resolve to absolute path (handles relative paths and trailing slashes)
     let srcDir = Generator_Node.resolve([srcDirArg])

package/src/generator/PluginGenerator.res.mjs

@@ -39,6 +39,7 @@ if (srcDirArg === "") {
     console.error("Usage: generate-plugin <srcDir>");
     console.error("       generate-plugin --aws <Namespace> <srcDir>");
   }
+  process.exit(1);
 } else {
   let srcDir = Nodepath.resolve(srcDirArg);
   let init = Config$Reventless.read(srcDir);