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

package/tests/aggregate/AggregateCallbackTest.res.mjs

@@ -4,7 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback.handleCommands:", () => {
   globalThis.describe("single command — new aggregate", () => {

package/tests/aggregate/AggregateCausationTest.res

@@ -8,7 +8,10 @@
 open JestGlobals
 open AggregateFixtures
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 describe("Aggregate_Callback causation propagation:", () => {
   testPromise("event.meta.causationId = command.meta.msgId", async () => {

package/tests/aggregate/AggregateCausationTest.res.mjs

@@ -4,7 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback causation propagation:", () => {
   globalThis.test("event.meta.causationId = command.meta.msgId", async () => {

package/tests/aggregate/AggregateConflictTest.res

@@ -27,6 +27,10 @@ module TestBehavior = {
 
   let initialState = {name: ""}
 
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
   let moduleUrl: string = %raw(`import.meta.url`)
 
   let evolve = (_state: state, event: AggSpec.event): state =>
@@ -116,8 +120,10 @@ module TestOps = {
     type operations = {
       append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
-      replayStream: string => Stream.t<AggSpec.event, string, unit>,
+      replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
+      writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
@@ -125,8 +131,10 @@ module TestOps = {
   let eventLog: EventLog.operations = {
     append: mock.appendFn,
     replay: mock.replayFn,
-    replayStream: mock.replayStreamFn,
+    replayStream: (id, ~fromSeq as _=?) => mock.replayStreamFn(id),
     appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+    latestSnapshot: async _ => Ok(None),
+    writeSnapshot: async (_, _) => Ok(),
   }
 }
 
@@ -152,7 +160,10 @@ let makeTopicItem = (reference, command): CommandTopic.topicItem<
   reference,
 }
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 describe("Aggregate_Callback — conflict retry:", () => {
   testPromise("1 conflict retries and succeeds", async () => {

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -63,6 +63,7 @@ function decide(_state, command) {
 let TestBehavior = {
   Spec: undefined,
   initialState: initialState,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1,
   evolve: evolve,
   decide: decide
@@ -145,17 +146,35 @@ let eventLog_append = mock.appendFn;
 
 let eventLog_replay = mock.replayFn;
 
-let eventLog_replayStream = mock.replayStreamFn;
+function eventLog_replayStream(id, param) {
+  return mock.replayStreamFn(id);
+}
 
 function eventLog_appendStream(_startingSeqNr, _id, stream) {
   return Stream.runDrain(stream);
 }
 
+async function eventLog_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let eventLog = {
   append: eventLog_append,
   replay: eventLog_replay,
   replayStream: eventLog_replayStream,
-  appendStream: eventLog_appendStream
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
 };
 
 let TestOps = {
@@ -182,6 +201,7 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   initialState: initialState,
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 })({
   Spec: {
@@ -236,7 +256,10 @@ function makeTopicItem(reference, command) {
   };
 }
 
-globalThis.beforeEach(() => mock.reset());
+globalThis.beforeEach(() => {
+  mock.reset();
+  TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback — conflict retry:", () => {
   globalThis.test("1 conflict retries and succeeds", async () => {

package/tests/aggregate/AggregateFixtures.res

@@ -38,6 +38,10 @@ module TestBehavior = {
 
   let initialState = NotCreated
 
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
   let moduleUrl: string = %raw(`import.meta.url`)
 
   let evolve = (_state: state, event: AggSpec.event): state =>
@@ -131,8 +135,10 @@ module TestOps = {
         array<Message.event'<string, AggSpec.event>>,
       ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
-      replayStream: string => Stream.t<AggSpec.event, string, unit>,
+      replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
+      writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
@@ -141,8 +147,10 @@ module TestOps = {
   let eventLog: EventLog.operations = {
     append: mock.appendFn,
     replay: mock.replayFn,
-    replayStream: mock.replayStreamFn,
+    replayStream: (id, ~fromSeq as _=?) => mock.replayStreamFn(id),
     appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+    latestSnapshot: async _ => Ok(None),
+    writeSnapshot: async (_, _) => Ok(),
   }
 }
 

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -112,6 +112,7 @@ let TestBehavior = {
   Spec: undefined,
   stateSchema: stateSchema,
   initialState: "NotCreated",
+  snapshot: undefined,
   moduleUrl: moduleUrl$1,
   evolve: evolve,
   decide: decide
@@ -180,17 +181,35 @@ let eventLog_append = mock.appendFn;
 
 let eventLog_replay = mock.replayFn;
 
-let eventLog_replayStream = mock.replayStreamFn;
+function eventLog_replayStream(id, param) {
+  return mock.replayStreamFn(id);
+}
 
 function eventLog_appendStream(_startingSeqNr, _id, stream) {
   return Stream.runDrain(stream);
 }
 
+async function eventLog_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let eventLog = {
   append: eventLog_append,
   replay: eventLog_replay,
   replayStream: eventLog_replayStream,
-  appendStream: eventLog_appendStream
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
 };
 
 let TestOps = {
@@ -217,6 +236,7 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   initialState: "NotCreated",
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 })({
   Spec: {

package/tests/aggregate/AggregateRejectionTest.res

@@ -7,7 +7,10 @@
 open JestGlobals
 open AggregateFixtures
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 // Captures whatever flows through CommandTopic_Helpers.reportRejected during a test.
 let capturedRejections: ref<array<(string, CommandTopic_Helpers.rejectedResult)>> = ref([])

package/tests/aggregate/AggregateRejectionTest.res.mjs

@@ -5,7 +5,10 @@ import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 let capturedRejections = {
   contents: []

package/tests/eventlog/EventLogFixtures.res

@@ -17,6 +17,7 @@ module ItemEventLogSpec = {
 // ─────────────────────────────────────────────────────────────
 
 let storedEvents: ref<dict<array<JSON.t>>> = ref(Dict.make())
+let storedSnapshots: ref<dict<EventLog.snapshot>> = ref(Dict.make())
 let failNextAppend = ref(false)
 // Inject N transient failures: each call decrements the counter and returns ThrottlingException
 let failNextAppendsWithTransient: ref<int> = ref(0)
@@ -41,8 +42,12 @@ let mockStorage: EventLog_Adapter.operations = {
   replay: async id => {
     storedEvents.contents->Dict.get(id)->Option.getOr([])
   },
-  replayStream: id =>
-    storedEvents.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
+  replayStream: (id, ~fromSeq=0) =>
+    storedEvents.contents
+    ->Dict.get(id)
+    ->Option.getOr([])
+    ->Array.slice(~start=fromSeq)
+    ->Stream.fromIterable,
   appendStream: (_startingSeqNr, id, stream) =>
     stream->Stream.runForEach(json =>
       Effect.sync(() => {
@@ -50,6 +55,11 @@ let mockStorage: EventLog_Adapter.operations = {
         storedEvents.contents->Dict.set(id, existing->Array.concat([json]))
       })
     ),
+  latestSnapshot: async id => Ok(storedSnapshots.contents->Dict.get(id)),
+  writeSnapshot: async (id, snap) => {
+    storedSnapshots.contents->Dict.set(id, snap)
+    Ok()
+  },
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -106,6 +116,7 @@ let makeEvent' = (id, event) => {
 
 let reset = () => {
   storedEvents := Dict.make()
+  storedSnapshots := Dict.make()
   failNextAppend := false
   failNextAppendsWithTransient := 0
   appendCallCount := 0

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -29,6 +29,10 @@ let storedEvents = {
   contents: {}
 };
 
+let storedSnapshots = {
+  contents: {}
+};
+
 let failNextAppend = {
   contents: false
 };
@@ -75,8 +79,9 @@ async function mockStorage_replay(id) {
   return Stdlib_Option.getOr(storedEvents.contents[id], []);
 }
 
-function mockStorage_replayStream(id) {
-  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []));
+function mockStorage_replayStream(id, fromSeqOpt) {
+  let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []).slice(fromSeq));
 }
 
 function mockStorage_appendStream(_startingSeqNr, id, stream) {
@@ -86,11 +91,28 @@ function mockStorage_appendStream(_startingSeqNr, id, stream) {
   }));
 }
 
+async function mockStorage_latestSnapshot(id) {
+  return {
+    TAG: "Ok",
+    _0: storedSnapshots.contents[id]
+  };
+}
+
+async function mockStorage_writeSnapshot(id, snap) {
+  storedSnapshots.contents[id] = snap;
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let mockStorage = {
   append: mockStorage_append,
   replay: mockStorage_replay,
   replayStream: mockStorage_replayStream,
-  appendStream: mockStorage_appendStream
+  appendStream: mockStorage_appendStream,
+  latestSnapshot: mockStorage_latestSnapshot,
+  writeSnapshot: mockStorage_writeSnapshot
 };
 
 let capturedPublishes = {
@@ -149,6 +171,7 @@ function makeEvent$p(id, event) {
 
 function reset() {
   storedEvents.contents = {};
+  storedSnapshots.contents = {};
   failNextAppend.contents = false;
   failNextAppendsWithTransient.contents = 0;
   appendCallCount.contents = 0;
@@ -158,6 +181,7 @@ function reset() {
 export {
   ItemEventLogSpec,
   storedEvents,
+  storedSnapshots,
   failNextAppend,
   failNextAppendsWithTransient,
   appendCallCount,

package/tests/logger/LoggerLazyTest.res

@@ -0,0 +1,36 @@
+// Unit tests for Logger.debugLazy (B6): the message thunk must run only when
+// debug output is actually enabled, so hot paths (per-projection-action logging)
+// don't pay to build/serialize a string that is dropped at Info level.
+
+open JestGlobals
+
+describe("Logger.debugLazy", () => {
+  testSync("does NOT invoke the thunk at the default Info level", () => {
+    let called = ref(false)
+    let log = Logger.makeLogger(~minLevel=Logger.Info)
+    log.debugLazy(~comp="Test", () => {
+      called := true
+      "should never be built"
+    })
+    expect(called.contents)->toEqual(false)
+  })
+
+  testSync("invokes the thunk when debug output is enabled", () => {
+    let called = ref(false)
+    let log = Logger.makeLogger(~minLevel=Logger.Debug)
+    log.debugLazy(~comp="Test", () => {
+      called := true
+      "built"
+    })
+    expect(called.contents)->toEqual(true)
+  })
+
+  testSync("the silent logger never invokes the thunk", () => {
+    let called = ref(false)
+    Logger.silent.debugLazy(~comp="Test", () => {
+      called := true
+      "x"
+    })
+    expect(called.contents)->toEqual(false)
+  })
+})

package/tests/logger/LoggerLazyTest.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logger$ReventlessCore from "../../src/util/Logger.res.mjs";
+
+globalThis.describe("Logger.debugLazy", () => {
+  globalThis.test("does NOT invoke the thunk at the default Info level", () => {
+    let called = {
+      contents: false
+    };
+    let log = Logger$ReventlessCore.makeLogger("Info");
+    log.debugLazy("Test", () => {
+      called.contents = true;
+      return "should never be built";
+    });
+    globalThis.expect(called.contents).toEqual(false);
+  });
+  globalThis.test("invokes the thunk when debug output is enabled", () => {
+    let called = {
+      contents: false
+    };
+    let log = Logger$ReventlessCore.makeLogger("Debug");
+    log.debugLazy("Test", () => {
+      called.contents = true;
+      return "built";
+    });
+    globalThis.expect(called.contents).toEqual(true);
+  });
+  globalThis.test("the silent logger never invokes the thunk", () => {
+    let called = {
+      contents: false
+    };
+    Logger$ReventlessCore.silent.debugLazy("Test", () => {
+      called.contents = true;
+      return "x";
+    });
+    globalThis.expect(called.contents).toEqual(false);
+  });
+});
+
+/*  Not a pure module */