@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/RunnerTypes.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function statusString(s) {
+  switch (s) {
+    case "Pass" :
+      return "pass";
+    case "Fail" :
+      return "fail";
+    case "Skip" :
+      return "skip";
+  }
+}
+
+function summaryOf(files, durationMs, startedAt) {
+  let total = {
+    contents: 0
+  };
+  let passed = {
+    contents: 0
+  };
+  let failed = {
+    contents: 0
+  };
+  let skipped = {
+    contents: 0
+  };
+  files.forEach(f => {
+    f.tests.forEach(t => {
+      total.contents = total.contents + 1 | 0;
+      let match = t.status;
+      switch (match) {
+        case "Pass" :
+          passed.contents = passed.contents + 1 | 0;
+          return;
+        case "Fail" :
+          failed.contents = failed.contents + 1 | 0;
+          return;
+        case "Skip" :
+          skipped.contents = skipped.contents + 1 | 0;
+          return;
+      }
+    });
+  });
+  return {
+    total: total.contents,
+    passed: passed.contents,
+    failed: failed.contents,
+    skipped: skipped.contents,
+    files: files.length,
+    durationMs: durationMs,
+    startedAt: startedAt
+  };
+}
+
+export {
+  statusString,
+  summaryOf,
+}
+/* No side effect */

package/src/SideEffect_GWT.res

@@ -0,0 +1,157 @@
+open ReventlessCore
+
+// Test DSL for aggregate-style egress (`SideEffect.T`). Mirrors
+// `OutboundTranslation_GWT` adapted to the SideEffect runtime contract: the
+// unit under test is `SE.execute`, which returns `promise<unit>` and reaches
+// external services through direct module imports. Option C of the
+// `sideeffect-gwt` plan: the framework stays out of the import mechanics —
+// per-service `*_Mock.res` modules own the recording state and surface it
+// through this `mock` handle. The GWT runs `execute`, then reads the snapshot
+// and renders assertions against captured calls.
+
+// Polymorphic mock handle a test passes to `whenExecuted`. The mock module
+// owns the recording state (a `ref<array<call>>` mutated as the SE calls the
+// service); `snapshot` reads it; `encode` is used to render mismatched calls
+// in failure messages.
+type mock<'call> = {
+  snapshot: unit => array<'call>,
+  encode: 'call => JSON.t,
+}
+
+// Stub `QueryEngine.operations` used when a test doesn't pass its own.
+// Returns empty result sets — enough for SEs that never query, which is the
+// idiomatic shape.
+let stubQueryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+module type T = {
+  module SE: Reventless.SideEffect.T
+
+  let describe: (string, unit => unit) => unit
+  let test: (string, ~timeout: int=?, unit => promise<Outcome.outcome>) => unit
+
+  type input = {
+    id: SE.Source.Id.t,
+    meta: Message.meta,
+    event: SE.Source.event,
+  }
+
+  // Post-execution state the pipeline carries forward. Holds the inputs (so
+  // failure messages can quote them), the captured calls, and the encoder
+  // (passed through from the mock) used to render them.
+  type attempt<'call> = {
+    input: input,
+    captured: array<'call>,
+    encode: 'call => JSON.t,
+  }
+
+  // given*
+  let givenEvent: SE.Source.event => input
+  let givenEventForId: (SE.Source.Id.t, SE.Source.event) => input
+  let givenMeta: (input, Message.meta) => input
+
+  // when — runs `SE.execute` against a stub QueryEngine (override via
+  // ~queryEngine) and the supplied mock's snapshot. The mock module is
+  // expected to install itself into the service it shadows BEFORE this is
+  // called (the per-service `*_Mock.res` convention; see the example).
+  let whenExecuted: (
+    input,
+    mock<'call>,
+    ~queryEngine: Reventless.QueryEngine.operations=?,
+  ) => promise<attempt<'call>>
+
+  // then*
+  let thenNoExternalCalls: promise<attempt<'call>> => promise<Outcome.outcome>
+  let thenExternalCalls: (promise<attempt<'call>>, array<'call>) => promise<Outcome.outcome>
+  let thenExternalCallCount: (promise<attempt<'call>>, int) => promise<Outcome.outcome>
+}
+
+module Make = (SE: Reventless.SideEffect.T): (T with module SE = SE) => {
+  module SE = SE
+
+  S.enableJson()
+
+  let describe = JestBind.describe
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=SE.Source.name, name, ~timeout?, body)
+
+  type input = {
+    id: SE.Source.Id.t,
+    meta: Message.meta,
+    event: SE.Source.event,
+  }
+
+  type attempt<'call> = {
+    input: input,
+    captured: array<'call>,
+    encode: 'call => JSON.t,
+  }
+
+  let defaultId = SE.Source.Id.makeFromString("test-id-1")
+  let defaultMeta: Message.meta = {
+    service: SE.Source.name,
+    time: "2024-01-01T00:00:00Z",
+    msgId: "test-msg-1",
+    correlationId: "test-msg-1",
+  }
+
+  let givenEvent = event => {id: defaultId, meta: defaultMeta, event}
+  let givenEventForId = (id, event) => {id, meta: defaultMeta, event}
+  let givenMeta = (input, meta) => {...input, meta}
+
+  let whenExecuted = async (input, mock, ~queryEngine=stubQueryEngine) => {
+    await SE.execute(input.id, input.meta, input.event, queryEngine)
+    {input, captured: mock.snapshot(), encode: mock.encode}
+  }
+
+  let encCalls = (calls, encode) => calls->Array.map(encode)
+
+  let thenNoExternalCalls = async pending => {
+    let {captured, encode, _} = await pending
+    if captured == [] {
+      Outcome.pass
+    } else {
+      Outcome.fail(NoEventExpected({actual: encCalls(captured, encode)}))
+    }
+  }
+
+  let thenExternalCalls = async (pending, expected) => {
+    let {captured, encode, _} = await pending
+    if captured == expected {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        EventsMismatch({
+          expected: encCalls(expected, encode),
+          actual: encCalls(captured, encode),
+        }),
+      )
+    }
+  }
+
+  let thenExternalCallCount = async (pending, expected) => {
+    let {captured, _} = await pending
+    let actual = Array.length(captured)
+    if actual == expected {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "external-call-count",
+          expected: Some(JSON.Encode.int(expected)),
+          actual: Some(JSON.Encode.int(actual)),
+        }),
+      )
+    }
+  }
+}

package/src/SideEffect_GWT.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+
+async function stubQueryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function stubQueryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let stubQueryEngine = {
+  scan: stubQueryEngine_scan,
+  query: stubQueryEngine_query
+};
+
+function Make(SE) {
+  S.enableJson();
+  let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(SE.Source.name, name, timeout, body);
+  let defaultId = SE.Source.Id.makeFromString("test-id-1");
+  let defaultMeta_service = SE.Source.name;
+  let defaultMeta = {
+    service: defaultMeta_service,
+    time: "2024-01-01T00:00:00Z",
+    msgId: "test-msg-1",
+    correlationId: "test-msg-1"
+  };
+  let givenEvent = event => ({
+    id: defaultId,
+    meta: defaultMeta,
+    event: event
+  });
+  let givenEventForId = (id, event) => ({
+    id: id,
+    meta: defaultMeta,
+    event: event
+  });
+  let givenMeta = (input, meta) => ({
+    id: input.id,
+    meta: meta,
+    event: input.event
+  });
+  let whenExecuted = async (input, mock, queryEngineOpt) => {
+    let queryEngine = queryEngineOpt !== undefined ? queryEngineOpt : stubQueryEngine;
+    await SE.execute(input.id, input.meta, input.event, queryEngine);
+    return {
+      input: input,
+      captured: mock.snapshot(),
+      encode: mock.encode
+    };
+  };
+  let thenNoExternalCalls = async pending => {
+    let match = await pending;
+    let captured = match.captured;
+    if (Primitive_object.equal(captured, [])) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "NoEventExpected",
+        actual: captured.map(match.encode)
+      });
+    }
+  };
+  let thenExternalCalls = async (pending, expected) => {
+    let match = await pending;
+    let captured = match.captured;
+    if (Primitive_object.equal(captured, expected)) {
+      return Outcome$ReventlessGwt.pass;
+    }
+    let encode = match.encode;
+    return Outcome$ReventlessGwt.fail({
+      TAG: "EventsMismatch",
+      expected: expected.map(encode),
+      actual: captured.map(encode)
+    });
+  };
+  let thenExternalCallCount = async (pending, expected) => {
+    let match = await pending;
+    let actual = match.captured.length;
+    if (actual === expected) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: "external-call-count",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  return {
+    SE: SE,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    givenEvent: givenEvent,
+    givenEventForId: givenEventForId,
+    givenMeta: givenMeta,
+    whenExecuted: whenExecuted,
+    thenNoExternalCalls: thenNoExternalCalls,
+    thenExternalCalls: thenExternalCalls,
+    thenExternalCallCount: thenExternalCallCount
+  };
+}
+
+export {
+  stubQueryEngine,
+  Make,
+}
+/* S Not a pure module */

package/src/StateChange/ExternalAddCategorySlice.res

@@ -0,0 +1,25 @@
+// Production-shaped StateChangeSlice Spec used by the external-Spec
+// verification test at [tests/StateChange/ExternalAddCategorySlice_GWT.res].
+// Mirrors the worked-example AddCategory slice shape: DCB-tagged categoryId
+// on command + event, payload-less consumed events.
+//
+// Spec half (Plan 02 Phase 6) — types, schemas, name. The matching impl
+// half lives in [ExternalAddCategorySlice_Behavior.res].
+
+let name = "ExternalAddCategory"
+
+@schema
+type consumedEvent =
+  | CategoryAdded
+  | CategoryArchived
+
+@schema
+type command =
+  AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+@schema
+type error = CategoryAlreadyExists
+
+@schema
+type event =
+  CategoryAdded({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})

package/src/StateChange/ExternalAddCategorySlice.res.mjs

@@ -0,0 +1,34 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.literal("CategoryAdded"),
+  S.literal("CategoryArchived")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("CategoryAlreadyExists");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let name = "ExternalAddCategory";
+
+export {
+  name,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+}
+/* consumedEventSchema Not a pure module */

package/src/StateChange/ExternalAddCategorySlice_Behavior.res

@@ -0,0 +1,19 @@
+// Implementation half — pure decision/projection functions for the external
+// AddCategory StateChangeSlice. Pairs with [ExternalAddCategorySlice.res].
+
+open ExternalAddCategorySlice
+
+type state = {exists: bool, archived: bool}
+let initialState: state = {exists: false, archived: false}
+
+let evolve = (state: state, event: consumedEvent): state =>
+  switch event {
+  | CategoryAdded => {exists: true, archived: false}
+  | CategoryArchived => {...state, archived: true}
+  }
+
+let decide = (state: state, command: command): result<array<event>, error> =>
+  switch command {
+  | AddCategory({categoryId, name}) =>
+    state.exists ? Error(CategoryAlreadyExists) : Ok([CategoryAdded({categoryId, name})])
+  }

package/src/StateChange/ExternalAddCategorySlice_Behavior.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(state, event) {
+  if (event === "CategoryAdded") {
+    return {
+      exists: true,
+      archived: false
+    };
+  } else {
+    return {
+      exists: state.exists,
+      archived: true
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let initialState = {
+  exists: false,
+  archived: false
+};
+
+export {
+  initialState,
+  evolve,
+  decide,
+}
+/* No side effect */

package/src/StateChange/WithFixtures.res

@@ -0,0 +1,22 @@
+// Production-shaped Spec for the companion-fixtures auto-open verification
+// tests at [tests/StateChange/WithFixtures_GWT.res] and
+// [tests/StateChange/WithManualOpen_GWT.res].
+//
+// Spec half — pairs with [WithFixtures_Behavior.res].
+
+let name = "WithFixtures"
+
+@schema
+type consumedEvent =
+  | CategoryAdded
+
+@schema
+type command =
+  AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+@schema
+type error = CategoryAlreadyExists
+
+@schema
+type event =
+  CategoryAdded({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})

package/src/StateChange/WithFixtures.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.literal("CategoryAdded");
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("CategoryAlreadyExists");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let name = "WithFixtures";
+
+export {
+  name,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+}
+/* consumedEventSchema Not a pure module */

package/src/StateChange/WithFixtures_Behavior.res

@@ -0,0 +1,17 @@
+// Implementation half — pairs with [WithFixtures.res].
+
+open WithFixtures
+
+type state = {exists: bool}
+let initialState: state = {exists: false}
+
+let evolve = (_state: state, event: consumedEvent): state =>
+  switch event {
+  | CategoryAdded => {exists: true}
+  }
+
+let decide = (state: state, command: command): result<array<event>, error> =>
+  switch command {
+  | AddCategory({categoryId, name}) =>
+    state.exists ? Error(CategoryAlreadyExists) : Ok([CategoryAdded({categoryId, name})])
+  }

package/src/StateChange/WithFixtures_Behavior.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(_state, event) {
+  return {
+    exists: true
+  };
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let initialState = {
+  exists: false
+};
+
+export {
+  initialState,
+  evolve,
+  decide,
+}
+/* No side effect */

package/src/StateChange/WithManualOpen.res

@@ -0,0 +1,23 @@
+// Second Spec used by the companion-fixtures manual-open dedup verification
+// test at [tests/StateChange/WithManualOpen_GWT.res]. Identical shape to
+// [WithFixtures]; named differently so it gets its own companion
+// [<Stem>_Fixtures] sibling that the PPX considers for auto-open.
+//
+// Spec half — pairs with [WithManualOpen_Behavior.res].
+
+let name = "WithManualOpen"
+
+@schema
+type consumedEvent =
+  | CategoryAdded
+
+@schema
+type command =
+  AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+@schema
+type error = CategoryAlreadyExists
+
+@schema
+type event =
+  CategoryAdded({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})

package/src/StateChange/WithManualOpen.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.literal("CategoryAdded");
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("CategoryAlreadyExists");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let name = "WithManualOpen";
+
+export {
+  name,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+}
+/* consumedEventSchema Not a pure module */

package/src/StateChange/WithManualOpen_Behavior.res

@@ -0,0 +1,17 @@
+// Implementation half — pairs with [WithManualOpen.res].
+
+open WithManualOpen
+
+type state = {exists: bool}
+let initialState: state = {exists: false}
+
+let evolve = (_state: state, event: consumedEvent): state =>
+  switch event {
+  | CategoryAdded => {exists: true}
+  }
+
+let decide = (state: state, command: command): result<array<event>, error> =>
+  switch command {
+  | AddCategory({categoryId, name}) =>
+    state.exists ? Error(CategoryAlreadyExists) : Ok([CategoryAdded({categoryId, name})])
+  }

package/src/StateChange/WithManualOpen_Behavior.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(_state, event) {
+  return {
+    exists: true
+  };
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let initialState = {
+  exists: false
+};
+
+export {
+  initialState,
+  evolve,
+  decide,
+}
+/* No side effect */