@reventlessdev/reventless-spec 3.0.0-alpha.67 → 3.0.0-alpha.68

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.68 (2026-07-07)
+
+### Bug Fixes
+
+* **reventless-aws:** thread inferred DCB scope into the deployed command handler ([4d8327f](https://github.com/ReventlessDev/reventless-core/commit/4d8327fad8659a1cde8c36098c72392737437af1))
+
+
 # 3.0.0-alpha.67 (2026-07-06)
 
 **Note:** Version bump only for package @reventlessdev/reventless-spec

package/package.json

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

package/src/components/DcbTag.res

@@ -989,6 +989,74 @@ let sliceShapeFromSchemas = (
   }
 }
 
+/** One slice's sury schemas — the input to `deriveEffectiveScope`. */
+type sliceSchemas = {
+  name: string,
+  commandSchema: S.t<unknown>,
+  consumedEventSchema: S.t<unknown>,
+  eventSchema: S.t<unknown>,
+}
+
+/**
+The DCB decision-read scope threaded into every StateChangeSlice callback:
+- `crossPartitionTagKeys` — keys whose scalar command tag must be fanned into its
+  own single-tag clause (a cross-entity reference read), and
+- `tagKeysByEventType` — each produced event type's *indexed* tag keys, so a
+  decision query drops vacuous (type, tag) clause combinations.
+*/
+type effectiveScope = {
+  crossPartitionTagKeys: array<string>,
+  tagKeysByEventType: dict<array<string>>,
+}
+
+/**
+Derives the effective DCB decision-read scope for one consistency boundary from
+its slices' schemas.
+
+Prefers the slice-graph inference (`DcbScopeInference.infer`) and falls back to
+the `@crossPartition` / tag *annotations* only when a slice's partition is
+ambiguous — all-or-nothing, matching `Dcb_Builder`. This is the **single source of
+truth** shared by the deploy-time builder (`Dcb_Builder.res`) and the deployed
+command-handler entry point (`DcbCommandTopicEntryPoint.mjs`): both call this so
+the runtime decision query cannot diverge from the storage/GSI scope. Before this
+existed the entry point re-derived scope from annotations alone, silently dropping
+inferred cross-partition reference reads — see
+`docs/analysis/dcb-runtime-scope-annotation-drift.md`.
+*/
+let deriveEffectiveScope = (slices: array<sliceSchemas>): effectiveScope => {
+  let producedSchemas = slices->Array.map(s => s.eventSchema)
+  let annotatedCross = {
+    let seen = Set.make()
+    producedSchemas
+    ->Array.flatMap(extractCrossPartitionTagKeys)
+    ->Array.filter(k =>
+      if seen->Set.has(k) {
+        false
+      } else {
+        seen->Set.add(k)
+        true
+      }
+    )
+  }
+  let annotatedTagKeys =
+    producedSchemas->Array.map(extractTagKeysByEventType)->mergeTagKeysByEventType
+  let shapes =
+    slices->Array.map(s =>
+      sliceShapeFromSchemas(
+        ~name=s.name,
+        ~commandSchema=s.commandSchema,
+        ~consumedEventSchema=s.consumedEventSchema,
+        ~eventSchema=s.eventSchema,
+      )
+    )
+  let inferred = DcbScopeInference.infer(shapes)
+  let useInferred = inferred.ambiguities->Array.length == 0
+  {
+    crossPartitionTagKeys: useInferred ? inferred.crossPartitionTagKeys : annotatedCross,
+    tagKeysByEventType: useInferred ? inferred.tagKeysByEventType : annotatedTagKeys,
+  }
+}
+
 /**
 Checks whether any single variant in a schema has multiple tagged fields.
 If so, a partition tag annotation is needed to disambiguate.

package/src/components/DcbTag.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbScopeInference$Reventless from "./DcbScopeInference.res.mjs";
 
 let tagSchema = S.schema(s => ({
   key: s.m(S.string),
@@ -618,6 +619,27 @@ function sliceShapeFromSchemas(name, commandSchema, consumedEventSchema, eventSc
   };
 }
 
+function deriveEffectiveScope(slices) {
+  let producedSchemas = slices.map(s => s.eventSchema);
+  let seen = new Set();
+  let annotatedCross = producedSchemas.flatMap(extractCrossPartitionTagKeys).filter(k => {
+    if (seen.has(k)) {
+      return false;
+    } else {
+      seen.add(k);
+      return true;
+    }
+  });
+  let annotatedTagKeys = mergeTagKeysByEventType(producedSchemas.map(extractTagKeysByEventType));
+  let shapes = slices.map(s => sliceShapeFromSchemas(s.name, s.commandSchema, s.consumedEventSchema, s.eventSchema));
+  let inferred = DcbScopeInference$Reventless.infer(shapes);
+  let useInferred = inferred.ambiguities.length === 0;
+  return {
+    crossPartitionTagKeys: useInferred ? inferred.crossPartitionTagKeys : annotatedCross,
+    tagKeysByEventType: useInferred ? inferred.tagKeysByEventType : annotatedTagKeys
+  };
+}
+
 function hasMultiTagVariant(schema) {
   switch (schema.type) {
     case "object" :
@@ -866,6 +888,7 @@ export {
   eventShapesOfSchema,
   extractPartitionTagFields,
   sliceShapeFromSchemas,
+  deriveEffectiveScope,
   hasMultiTagVariant,
   findMultiTagVariantNames,
   extractCompositePartitionFieldsFromProperties,