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

package/src/generator/Pairing.res

@@ -165,6 +165,38 @@ let hasAsyncAttribute = (filePath: string): bool => {
   }
 }
 
+// Partition the ExtensionPoint mapping files into flat (ungrouped) and grouped
+// `extensionPointDef`s: every mapping sharing an `epGroup` collects into one
+// grouped entry; the ungrouped ones share a single flat (`group: None`) entry.
+// Pure (no I/O) so the grouping is unit-testable — in particular the A8 fix:
+// `Option.getOr`'s eager default previously re-created the group's array every
+// iteration, so a group with ≥2 mappings collapsed to `[]` and the generator
+// emitted a `Plugin.res` referencing a never-generated module.
+let groupExtensionPoints = (epFiles: array<Discovery.discoveredFile>): array<extensionPointDef> => {
+  let epByGroup: Dict.t<array<string>> = Dict.make()
+  let flatEpMappings: array<string> = []
+
+  epFiles->Array.forEach(({stem, epGroup}) =>
+    switch epGroup {
+    | None => flatEpMappings->Array.push(stem)
+    | Some(g) =>
+      switch Dict.get(epByGroup, g) {
+      | Some(arr) => arr->Array.push(stem)
+      | None => Dict.set(epByGroup, g, [stem])
+      }
+    }
+  )
+
+  let extensionPoints: array<extensionPointDef> = []
+  if flatEpMappings->Array.length > 0 {
+    extensionPoints->Array.push({group: None, mappings: flatEpMappings->sortedStems})
+  }
+  Dict.toArray(epByGroup)->Array.forEach(((group, mappings)) =>
+    extensionPoints->Array.push({group: Some(group), mappings: mappings->sortedStems})
+  )
+  extensionPoints
+}
+
 let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): resolved => {
   let eventMappings = findEventMappings(~srcDir)
 
@@ -309,35 +341,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   )
 
   // ── ExtensionPoint grouping ────────────────────────────────────────────────
-  let epByGroup: Dict.t<array<string>> = Dict.make()
-  let flatEpMappings: array<string> = []
-
-  epFiles->Array.forEach(({stem, epGroup}) => {
-    switch epGroup {
-    | None => flatEpMappings->Array.push(stem)
-    | Some(g) =>
-      // `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])
-      }
-    }
-  })
-
-  let extensionPoints: array<extensionPointDef> = []
-
-  if flatEpMappings->Array.length > 0 {
-    extensionPoints->Array.push({group: None, mappings: flatEpMappings->sortedStems})
-  }
-
-  Dict.toArray(epByGroup)->Array.forEach(((group, mappings)) => {
-    extensionPoints->Array.push({group: Some(group), mappings: mappings->sortedStems})
-  })
+  let extensionPoints = groupExtensionPoints(epFiles)
 
   // ── targetName extraction ──────────────────────────────────────────────────
   let buildTargets = (stems: array<string>, relPaths: Dict.t<string>): Dict.t<option<string>> => {

package/src/generator/Pairing.res.mjs

@@ -131,6 +131,39 @@ function hasAsyncAttribute(filePath) {
   }
 }
 
+function groupExtensionPoints(epFiles) {
+  let epByGroup = {};
+  let flatEpMappings = [];
+  epFiles.forEach(param => {
+    let epGroup = param.epGroup;
+    let stem = param.stem;
+    if (epGroup !== undefined) {
+      let arr = epByGroup[epGroup];
+      if (arr !== undefined) {
+        arr.push(stem);
+      } else {
+        epByGroup[epGroup] = [stem];
+      }
+      return;
+    }
+    flatEpMappings.push(stem);
+  });
+  let extensionPoints = [];
+  if (flatEpMappings.length !== 0) {
+    extensionPoints.push({
+      group: undefined,
+      mappings: sortedStems(flatEpMappings)
+    });
+  }
+  Object.entries(epByGroup).forEach(param => {
+    extensionPoints.push({
+      group: param[0],
+      mappings: sortedStems(param[1])
+    });
+  });
+  return extensionPoints;
+}
+
 function resolve(discovered, srcDir) {
   let eventMappings = findEventMappings(srcDir);
   let stateChangeSlices = [];
@@ -275,35 +308,7 @@ function resolve(discovered, srcDir) {
     }
   };
   let readModels = Stdlib_Array.filterMap(sortedStems(readModelStems), rm => pairReadModel(false, rm)).concat(Stdlib_Array.filterMap(sortedStems(readModelStreamStems), rm => pairReadModel(true, rm)));
-  let epByGroup = {};
-  let flatEpMappings = [];
-  epFiles.forEach(param => {
-    let epGroup = param.epGroup;
-    let stem = param.stem;
-    if (epGroup !== undefined) {
-      let arr = epByGroup[epGroup];
-      if (arr !== undefined) {
-        arr.push(stem);
-      } else {
-        epByGroup[epGroup] = [stem];
-      }
-      return;
-    }
-    flatEpMappings.push(stem);
-  });
-  let extensionPoints = [];
-  if (flatEpMappings.length !== 0) {
-    extensionPoints.push({
-      group: undefined,
-      mappings: sortedStems(flatEpMappings)
-    });
-  }
-  Object.entries(epByGroup).forEach(param => {
-    extensionPoints.push({
-      group: param[0],
-      mappings: sortedStems(param[1])
-    });
-  });
+  let extensionPoints = groupExtensionPoints(epFiles);
   let buildTargets = (stems, relPaths) => {
     let dict = {};
     stems.forEach(stem => {
@@ -350,6 +355,7 @@ export {
   sortedStems,
   extractTargetName,
   hasAsyncAttribute,
+  groupExtensionPoints,
   resolve,
 }
 /* node:fs Not a pure module */

package/src/types/Behavior.res

@@ -72,6 +72,14 @@ module type T = {
   */
   let decide: (state, Spec.command) => result<array<Spec.event>, Spec.error>
 
+  /** Persisted-snapshot configuration (docs/plans/aggregate-snapshotting.md).
+      `None` — the default, auto-injected by `@@reventless.behavior` — keeps
+      full replay; `Some({interval, stateSchema})` writes a keep-one snapshot
+      every `interval` events and seeds cold replays from the latest one.
+      Enable with `@@reventless.snapshots(<interval>)` (requires
+      `@schema type state`) or a manual binding. */
+  let snapshot: option<Snapshot.config<state>>
+
   /** File URL of this module (`import.meta.url`). Used by AWS builders to derive
       the npm specifier for runtime dynamic imports. */
   let moduleUrl: string