@reventlessdev/reventless-core 3.0.0-alpha.135 → 3.0.0-alpha.137

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.137 (2026-07-03)
+
+### Features
+
+* **core,local,aws:** EventLog snapshot storage surface, all backends (aggregate-snapshotting plan, steps 3+4) ([b6e50e2](https://github.com/ReventlessDev/reventless-core/commit/b6e50e2e5fe50b7372e54811f883fa91f6758dd1))
+* **core:** in-process aggregate replay cache (aggregate-snapshotting plan, phase 1) ([89c75f3](https://github.com/ReventlessDev/reventless-core/commit/89c75f33116e929cb8f4208b33498bab42db45e2))
+* **local:** DCB-axis projection checkpoints + startup catch-up (plan B5) ([8f9b11d](https://github.com/ReventlessDev/reventless-core/commit/8f9b11d24627bb6cc105d37af4974745444b80ba))
+### Performance Improvements
+
+* **core:** memoize message schemas, lazy projection logs, fail-closed slice cache (plan B6) ([b9e423c](https://github.com/ReventlessDev/reventless-core/commit/b9e423cb27932c4b6b5a123d3ae80d2239341d61))
+
+
+# 3.0.0-alpha.136 (2026-07-02)
+
+### Bug Fixes
+
+* **core,local:** projection/publisher/bus correctness (plan A5,A7) ([86e27a5](https://github.com/ReventlessDev/reventless-core/commit/86e27a5d68873d7dd9e746f9b4126f4d5bad63c9))
+
+
 # 3.0.0-alpha.135 (2026-06-29)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.135",
+  "version": "3.0.0-alpha.137",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.23",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.3",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.13",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.21",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.62",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.82"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.23",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.64",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.84"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.50"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Message.res

@@ -18,18 +18,51 @@ module type Service = {
 
 include Reventless.Message
 
+// Compose the wrapper schema once per (idSchema, payloadSchema) reference pair.
+// Both are module-level constants per message type, and sury schemas are built
+// to be reused across many parse/serialize calls — so the previous fresh
+// `S.object` on every decode/encode was pure allocation on the hottest path in
+// the framework. The cache is keyed by object identity (nested WeakMaps), so a
+// dropped schema is still collectable. `build` runs only on a miss.
+//
+// The raw closure is typed monomorphically over an opaque type (concrete → no
+// weak-var value-restriction problem); the locally-abstract-typed wrapper below
+// is a syntactic function, so it generalizes and `Obj.magic` bridges the two.
+// This keeps the public `toEventSchema'` / `toCommandSchema'` fully polymorphic.
+type opaqueSchema
+let _rawMemoize: (
+  opaqueSchema,
+  opaqueSchema,
+  (opaqueSchema, opaqueSchema) => opaqueSchema,
+) => opaqueSchema = %raw(`(function(){
+  const outer = new WeakMap();
+  return function(a, b, build){
+    let inner = outer.get(a);
+    if (inner === undefined) { inner = new WeakMap(); outer.set(a, inner); }
+    let v = inner.get(b);
+    if (v === undefined) { v = build(a, b); inner.set(b, v); }
+    return v;
+  };
+})()`)
+let memoizeBySchemaPair = (type a b c, a: a, b: b, build: (a, b) => c): c =>
+  _rawMemoize(Obj.magic(a), Obj.magic(b), Obj.magic(build))->Obj.magic
+
 let toEventSchema' = (idSchema, eventSchema) =>
-  S.object(s => {
-    id: s.field("id", idSchema),
-    meta: s.field("meta", metaSchema),
-    event: s.field("event", eventSchema),
-  })
+  memoizeBySchemaPair(idSchema, eventSchema, (idSchema, eventSchema) =>
+    S.object(s => {
+      id: s.field("id", idSchema),
+      meta: s.field("meta", metaSchema),
+      event: s.field("event", eventSchema),
+    })
+  )
 let toCommandSchema' = (idSchema, commandSchema) =>
-  S.object(s => {
-    id: s.field("id", idSchema),
-    meta: s.field("meta", metaSchema),
-    command: s.field("command", commandSchema),
-  })
+  memoizeBySchemaPair(idSchema, commandSchema, (idSchema, commandSchema) =>
+    S.object(s => {
+      id: s.field("id", idSchema),
+      meta: s.field("meta", metaSchema),
+      command: s.field("command", commandSchema),
+    })
+  )
 
 let decodeEvent' = (json, idSchema, eventSchema) =>
   json->S.parseJsonOrThrow(toEventSchema'(idSchema, eventSchema))

package/src/Message.res.mjs

@@ -12,20 +12,35 @@ import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
 
 let logger = Logger$ReventlessCore.fromEnv();
 
+let _rawMemoize = ((function(){
+  const outer = new WeakMap();
+  return function(a, b, build){
+    let inner = outer.get(a);
+    if (inner === undefined) { inner = new WeakMap(); outer.set(a, inner); }
+    let v = inner.get(b);
+    if (v === undefined) { v = build(a, b); inner.set(b, v); }
+    return v;
+  };
+})());
+
+function memoizeBySchemaPair(a, b, build) {
+  return _rawMemoize(a, b, build);
+}
+
 function toEventSchema$p(idSchema, eventSchema) {
-  return S.object(s => ({
+  return _rawMemoize(idSchema, eventSchema, (idSchema, eventSchema) => S.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     event: s.f("event", eventSchema)
-  }));
+  })));
 }
 
 function toCommandSchema$p(idSchema, commandSchema) {
-  return S.object(s => ({
+  return _rawMemoize(idSchema, commandSchema, (idSchema, commandSchema) => S.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     command: s.f("command", commandSchema)
-  }));
+  })));
 }
 
 function decodeEvent$p(json, idSchema, eventSchema) {
@@ -385,6 +400,8 @@ export {
   decode,
   encode,
   InvalidEvent,
+  _rawMemoize,
+  memoizeBySchemaPair,
   toEventSchema$p,
   toCommandSchema$p,
   decodeEvent$p,

package/src/Projection.res

@@ -16,7 +16,10 @@ module Mapping = {
   }
 }
 
-let logAction = str => log.debug(~comp="Projection", str)
+// Lazy: the message thunk (and any `stateToString` it triggers) runs only when
+// debug logging is enabled, so projection actions don't serialize state on the
+// hot path at the default Info level.
+let logAction = makeStr => log.debugLazy(~comp="Projection", makeStr)
 
 // ── @displayName overlay ────────────────────────────────────────────────────
 // When a read model's state schema carries DisplayName metadata, every state
@@ -86,10 +89,16 @@ let applyChanges = async (
   let addedStates = afterStates->Array.filter(state => addedSubIds->Set.has(state->getSubId))
   let addedCount = addedStates->Array.length
 
-  let changedStates = beforeStates->Array.filterMap(before => {
-    let beforeSubId = before->getSubId
-    afterStates->Array.find(after => after->getSubId == beforeSubId && after != before)
-  })
+  // Index the after-states by subId once instead of scanning them per
+  // before-state (was O(before × after)).
+  let afterBySubId = Dict.make()
+  afterStates->Array.forEach(after => afterBySubId->Dict.set(after->getSubId, after))
+  let changedStates = beforeStates->Array.filterMap(before =>
+    switch afterBySubId->Dict.get(before->getSubId) {
+    | Some(after) if after != before => Some(after)
+    | _ => None
+    }
+  )
   let changedCount = changedStates->Array.length
 
   let batchToSave =
@@ -99,16 +108,27 @@ let applyChanges = async (
   let batchToDelete = deletedSubIds->Array.map(subId => (id, Some((subIdField, subId))))
   let deletedCount = batchToDelete->Array.length
 
-  logAction(
-    `${action}(${id}): beforeStates:${beforeCount->Int.toString} afterStates:${afterCount->Int.toString} added:${addedCount->Int.toString} changed:${changedCount->Int.toString} deleted:${deletedCount->Int.toString}`,
+  logAction(() =>
+    `${action}(${id}): beforeStates:${beforeCount->Int.toString} afterStates:${afterCount->Int.toString} added:${addedCount->Int.toString} changed:${changedCount->Int.toString} deleted:${deletedCount->Int.toString}`
   )
   let result = await [deleteBatch(batchToDelete), saveBatch(batchToSave)]->Promise.all
-  switch result {
-  | _ => Ok() // TODO: Error handling
+  // Propagate the first storage failure instead of swallowing it — a failed
+  // delete/save was previously reported as a successful projection.
+  switch result->Array.find(r =>
+    switch r {
+    | Error(_) => true
+    | Ok(_) => false
+    }
+  ) {
+  | Some(err) => err
+  | None => Ok()
   }
 }
 
-let stateToString: 'a => string = state => state->JSON.stringifyAny->Option.getOrThrow
+// Best-effort: a state that can't be JSON-serialized (e.g. carries a function)
+// must not crash the projection just to produce a debug line.
+let stateToString: 'a => string = state =>
+  state->JSON.stringifyAny->Option.getOr("<unserializable>")
 let statesToString: array<'a> => string = states =>
   states->Array.map(stateToString)->Array.joinUnsafe(", ")
 
@@ -132,17 +152,17 @@ let handleAction = async (
     ->Effect.runPromise
   switch action {
   | Ignore =>
-    logAction("Ignore")
+    logAction(() => "Ignore")
     Ok()
 
   | Create(id, state) =>
-    logAction(`Create(${id}, ${state->stateToString})`)
+    logAction(() => `Create(${id}, ${state->stateToString})`)
     await save(id, state, Init, None)
   | CreateMultiState(id, states) =>
-    logAction(
+    logAction(() =>
       `CreateMultiState(${id}, ${states
         ->Array.map(state => state->stateToString)
-        ->Array.joinUnsafe(", ")})`,
+        ->Array.joinUnsafe(", ")})`
     )
     switch states {
     | [] => Ok()
@@ -153,23 +173,23 @@ let handleAction = async (
     }
   | CreateMany(states) =>
     let batch = states->Array.map(((id, state)) => (id, state, None))
-    let statesStr =
-      batch
-      ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
-      ->Array.joinUnsafe(", ")
-    logAction(`CreateMany(${statesStr})`)
+    logAction(() =>
+      `CreateMany(${batch
+        ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
+        ->Array.joinUnsafe(", ")})`
+    )
     await saveBatch(batch) // TODO: think about using single saves with saveMode Init
 
   | Set(id, state) =>
-    logAction(`Set(${id}, ${state->stateToString})`)
+    logAction(() => `Set(${id}, ${state->stateToString})`)
     await save(id, state, Any, None)
   | SetMany(ids, set) =>
     let batch = ids->Array.map(id => (id, set(id), None))
-    let statesStr =
-      batch
-      ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
-      ->Array.joinUnsafe(", ")
-    logAction(`SetMany(${statesStr})`)
+    logAction(() =>
+      `SetMany(${batch
+        ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
+        ->Array.joinUnsafe(", ")})`
+    )
     await saveBatch(batch)
 
   | Update(id, update) =>
@@ -177,39 +197,39 @@ let handleAction = async (
     | Ok(states) =>
       switch states {
       | [] =>
-        logAction(`Update Error: No oldState for ${id})`)
+        logAction(() => `Update Error: No oldState for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       | [oldState] =>
         let newState = oldState->update
-        logAction(`Update(${id}, ${oldState->stateToString} => ${newState->stateToString})`)
+        logAction(() => `Update(${id}, ${oldState->stateToString} => ${newState->stateToString})`)
         await save(id, newState, Overwrite, None)
       | _ =>
-        logAction(`Update Error: Multiple oldStates for ${id})`)
+        logAction(() => `Update Error: Multiple oldStates for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       }
     | Error(err) => Error(err)
     }
   | UpdateWithDefault(id, default, update) =>
-    log.debug(~comp="Projection", `UpdateWithDefault(${id}, loading ...`)
+    logAction(() => `UpdateWithDefault(${id}, loading ...`)
     switch await loadAtMost(2, id) {
     | Ok(states) =>
       switch states {
       | [] =>
-        logAction(`UpdateWithDefault(${id}, default: ${default->stateToString})`)
+        logAction(() => `UpdateWithDefault(${id}, default: ${default->stateToString})`)
         await save(id, default, Init, None)
       | [oldState] =>
         let newState = oldState->update
-        logAction(
-          `UpdateWithDefault(${id}, ${oldState->stateToString} => ${newState->stateToString})`,
+        logAction(() =>
+          `UpdateWithDefault(${id}, ${oldState->stateToString} => ${newState->stateToString})`
         )
         await save(id, newState, Overwrite, None)
       | _ =>
-        logAction(`UpdateWithDefault Error: Multiple oldStates for ${id})`)
+        logAction(() => `UpdateWithDefault Error: Multiple oldStates for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       }
     | Error(err) =>
-      logAction(
-        `UpdateWithDefault Error: Couldn't load oldState(s) for ${id}: ${err->QueryDb.storageErrorToString})`,
+      logAction(() =>
+        `UpdateWithDefault Error: Couldn't load oldState(s) for ${id}: ${err->QueryDb.storageErrorToString})`
       )
       Error(err)
     }
@@ -221,25 +241,27 @@ let handleAction = async (
       await applyChanges("UpdateMultiState", id, beforeStates, afterStates, operations, subIdConfig)
 
     | (Error(err), Some(_)) =>
-      logAction(
-        `UpdateMultiState Error: Couldn't load states for ${id}: ${err->QueryDb.storageErrorToString})`,
+      logAction(() =>
+        `UpdateMultiState Error: Couldn't load states for ${id}: ${err->QueryDb.storageErrorToString})`
       )
       Error(err)
     | (_, None) =>
-      logAction("UpdateMultiState Error: Missing SubIdConfig !")
+      logAction(() => "UpdateMultiState Error: Missing SubIdConfig !")
       Error(ReventlessInfra.QueryDb.MissingSubIdConfig)
     }
   | Delete(id) =>
-    logAction(`Delete(${id})`)
+    logAction(() => `Delete(${id})`)
     await delete(id, None)
   | DeleteMany(ids) =>
-    logAction(`DeleteMany(${ids->Array.joinUnsafe(", ")})`)
+    logAction(() => `DeleteMany(${ids->Array.joinUnsafe(", ")})`)
     await deleteBatch(ids->Array.map(id => (id, None)))
 
-  // TODO: add missing actions
+  // An action reaching here is one this projection engine doesn't implement.
+  // Returning Ok() reported the read-model write as done while silently losing
+  // it; surface a storage error instead.
   | _ =>
-    logAction("Error: Action not yet supported !")
-    Ok()
+    logAction(() => "Error: projection action not supported")
+    Error(ReventlessInfra.QueryDb.NotSavedToStorage("unsupported projection action"))
   }
 }
 
@@ -261,20 +283,27 @@ let actionsWithId = action =>
 
   // TODO: add missing actions
   | _ =>
-    logAction("Error: Action not yet supported !")
+    logAction(() => "Error: Action not yet supported !")
     []
   }
 
 let groupActionsById = actions => {
   let allActionsWithId = actions->Array.map(action => action->actionsWithId)->Array.flat
-  let ids = allActionsWithId->Array.map(((id, _)) => id)
-  ids
+  // One pass into a dict keyed by id (was O(ids × actions): a filterMap over
+  // every action per unique id). The id ordering is unchanged — still the sorted
+  // Belt.Set order — and each group preserves the actions' original order.
+  let groups = Dict.make()
+  allActionsWithId->Array.forEach(((id, action)) =>
+    switch groups->Dict.get(id) {
+    | Some(arr) => arr->Array.push(action)
+    | None => groups->Dict.set(id, [action])
+    }
+  )
+  groups
+  ->Dict.keysToArray
   ->Belt.Set.String.fromArray
   ->Belt.Set.String.toArray
-  ->Array.map(id => (
-    id,
-    allActionsWithId->Array.filterMap(((actionId, action)) => actionId == id ? Some(action) : None),
-  ))
+  ->Array.map(id => (id, groups->Dict.getUnsafe(id)))
 }
 
 let optimizeActions = actions => {
@@ -285,11 +314,10 @@ let optimizeActions = actions => {
       [action]
     } else {
       let lastAction = optimizedActions->Array.getUnsafe(optimizedActionsCount - 1)
-      let previousActions = if optimizedActionsCount == 1 {
-        []
-      } else {
-        optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount)
-      }
+      // Everything BEFORE the last action. `~end` is exclusive, so this must be
+      // `count - 1`; using `count` kept `lastAction` in the slice while the merged
+      // action was also appended, applying the last action twice.
+      let previousActions = optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount - 1)
 
       switch (lastAction, action) {
       // SINGLE STATES