@reventlessdev/reventless-spec 3.0.0-alpha.103 → 3.0.0-alpha.104

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.104 (2026-08-09)
+
+### Bug Fixes
+
+* **spec:** see payload-less variants inside a mixed union, and say what differs ([e82e742](https://github.com/ReventlessDev/reventless-core/commit/e82e742201941f978bfde809eeb2581fdda453c5))
+
+
 # 3.0.0-alpha.103 (2026-08-09)
 
 ### Bug Fixes

package/package.json

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

package/src/components/DcbValidation.res

@@ -26,22 +26,28 @@ let extractVariantInfo = (variantSchema: S.t<unknown>): option<variantInfo> =>
         )
       {tagName, fields: properties, taggedFields}
     })
+  // Payload-less variant — sury compiles a constructor with no payload to
+  // String({const}), whether it stands alone (`type t = Foo`) or sits beside
+  // payload-carrying constructors in one union (`Foo | Bar(string)`). Matching it
+  // here rather than only at the top level is what makes it visible inside a
+  // mixed union: the Union branch below filters members through this function, so
+  // while this case lived only in `extractAllVariants` every payload-less arm of a
+  // mixed union was silently dropped — `NoPriorType | PriorType(string)` extracted
+  // as just `[PriorType]`, and a tag-set comparison could not tell it apart from a
+  // union that genuinely has only that one arm.
+  | String({const: ?Some(name)}) => Some({tagName: name, fields: Dict.make(), taggedFields: []})
   | _ => None
   }
 
-// Extract all variant infos from a schema (handles Union and single Object)
+// Extract all variant infos from a schema (handles Union and single variants)
 let extractAllVariants = (schema: S.t<unknown>): array<variantInfo> =>
   switch schema {
   | Union({anyOf}) => anyOf->Array.filterMap(extractVariantInfo)
-  | Object(_) =>
+  | _ =>
     switch extractVariantInfo(schema) {
     | Some(info) => [info]
     | None => []
     }
-  | String({const: ?Some(name)}) =>
-    // Single payload-less variant — sury compiles `type t = Foo` to String({const: "Foo"})
-    [{tagName: name, fields: Dict.make(), taggedFields: []}]
-  | _ => []
   }
 
 // Check if a variant has no payload fields (only TAG)
@@ -105,6 +111,31 @@ let schemaTypeName = (schema: S.t<unknown>): string =>
   | _ => "unknown"
   }
 
+// One level deeper than `schemaTypeName`, for the mismatch messages.
+//
+// `schemaTypeName` alone makes an incompatibility unreadable whenever both sides
+// share a top-level kind: `schemasAreCompatible` rejects two unions on their
+// variant tags or a variant's payload, but both stringify to "union", so the
+// message read "consumes X as union but producer declares it as union" and named
+// nothing a reader could act on. Listing the members turns that into the actual
+// difference — e.g. `union[string | unknown]` against
+// `union[NoPriorType | PriorType]`, which names the drift outright.
+//
+// A union of *tagged* variants is described by its tag names; one whose members
+// carry no TAG (what `option<t>` compiles to) falls back to the member kinds,
+// since that is all there is to say about it.
+let describeSchema = (schema: S.t<unknown>): string =>
+  switch schema {
+  | Union({anyOf}) =>
+    let tags = extractAllVariants(schema)->Array.map(v => v.tagName)
+    let members = tags->Array.length > 0 ? tags : anyOf->Array.map(schemaTypeName)
+    `union[${members->Array.join(" | ")}]`
+  | Object({properties}) =>
+    `object{${properties->Dict.keysToArray->Array.toSorted(String.compare)->Array.join(", ")}}`
+  | Array({additionalItems: Schema(item)}) => `array<${schemaTypeName(item)}>`
+  | _ => schemaTypeName(schema)
+  }
+
 type producerEntry = {
   sliceName: string,
   variant: variantInfo,
@@ -314,7 +345,7 @@ let validateProducedAndConsumed = (
                 let _ =
                   errors->Array.push({
                     sliceName,
-                    message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' as ${schemaTypeName(consumedFieldSchema)} but producer declares it as ${schemaTypeName(producedFieldSchema)}`,
+                    message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' as ${describeSchema(consumedFieldSchema)} but producer '${producer.sliceName}' declares it as ${describeSchema(producedFieldSchema)}`,
                   })
               }
             }

package/src/components/DcbValidation.res.mjs

@@ -7,48 +7,46 @@ import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js
 import * as DcbTag$Reventless from "./DcbTag.res.mjs";
 
 function extractVariantInfo(variantSchema) {
-  if (variantSchema.type !== "object") {
-    return;
-  }
-  let properties = variantSchema.properties;
-  return Stdlib_Option.map(DcbTag$Reventless.variantTagName(variantSchema.items), tagName => {
-    let taggedFields = Stdlib_Array.filterMap(Object.entries(properties), param => {
-      if (DcbTag$Reventless.isTagged(param[1])) {
-        return param[0];
-      }
-    });
-    return {
-      tagName: tagName,
-      fields: properties,
-      taggedFields: taggedFields
-    };
-  });
-}
-
-function extractAllVariants(schema) {
-  switch (schema.type) {
+  switch (variantSchema.type) {
     case "string" :
-      let name = schema.const;
+      let name = variantSchema.const;
       if (name !== undefined) {
-        return [{
-            tagName: name,
-            fields: {},
-            taggedFields: []
-          }];
+        return {
+          tagName: name,
+          fields: {},
+          taggedFields: []
+        };
       } else {
-        return [];
+        return;
       }
     case "object" :
-      let info = extractVariantInfo(schema);
-      if (info !== undefined) {
-        return [info];
-      } else {
-        return [];
-      }
-    case "union" :
-      return Stdlib_Array.filterMap(schema.anyOf, extractVariantInfo);
+      let properties = variantSchema.properties;
+      return Stdlib_Option.map(DcbTag$Reventless.variantTagName(variantSchema.items), tagName => {
+        let taggedFields = Stdlib_Array.filterMap(Object.entries(properties), param => {
+          if (DcbTag$Reventless.isTagged(param[1])) {
+            return param[0];
+          }
+        });
+        return {
+          tagName: tagName,
+          fields: properties,
+          taggedFields: taggedFields
+        };
+      });
     default:
-      return [];
+      return;
+  }
+}
+
+function extractAllVariants(schema) {
+  if (schema.type === "union") {
+    return Stdlib_Array.filterMap(schema.anyOf, extractVariantInfo);
+  }
+  let info = extractVariantInfo(schema);
+  if (info !== undefined) {
+    return [info];
+  } else {
+    return [];
   }
 }
 
@@ -160,6 +158,26 @@ function schemaTypeName(schema) {
   }
 }
 
+function describeSchema(schema) {
+  switch (schema.type) {
+    case "array" :
+      let item = schema.additionalItems;
+      if (item === "strip" || item === "strict") {
+        return schemaTypeName(schema);
+      } else {
+        return `array<` + schemaTypeName(item) + `>`;
+      }
+    case "object" :
+      return `object{` + Object.keys(schema.properties).toSorted(Primitive_string.compare).join(", ") + `}`;
+    case "union" :
+      let tags = extractAllVariants(schema).map(v => v.tagName);
+      let members = tags.length !== 0 ? tags : schema.anyOf.map(schemaTypeName);
+      return `union[` + members.join(" | ") + `]`;
+    default:
+      return schemaTypeName(schema);
+  }
+}
+
 function dedupeKeys(keys) {
   let seen = new Set();
   return keys.filter(k => {
@@ -298,7 +316,7 @@ function validateProducedAndConsumed(produced, consumed) {
               if (!schemasAreCompatible(consumedFieldSchema, producedFieldSchema)) {
                 errors.push({
                   sliceName: sliceName,
-                  message: `Slice '` + sliceName + `' consumes '` + variant.tagName + `.` + fieldName + `' as ` + schemaTypeName(consumedFieldSchema) + ` but producer declares it as ` + schemaTypeName(producedFieldSchema)
+                  message: `Slice '` + sliceName + `' consumes '` + variant.tagName + `.` + fieldName + `' as ` + describeSchema(consumedFieldSchema) + ` but producer '` + producer.sliceName + `' declares it as ` + describeSchema(producedFieldSchema)
                 });
                 return;
               } else {
@@ -414,6 +432,7 @@ export {
   schemasAreCompatible,
   propsCompatible,
   schemaTypeName,
+  describeSchema,
   dedupeKeys,
   validateCompositeReads,
   validateProducedAndConsumed,