@reventlessdev/reventless-local 3.0.0-alpha.292 → 3.0.0-alpha.294

package/tests/components/dcb/DcbRejectionCauseTest.res

@@ -0,0 +1,271 @@
+// A rejected command says who said no, on the wire a client reads. Driven through
+// the producer path (`runInlineAndCollect` → `commandOutcomeToJson`) over the real
+// in-memory and SQLite DCB stores: the model (`decide`), the caller (ownership),
+// and the platform (exhausted retries, a failing store).
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+module Message = ReventlessCore.Message
+module CommandTopic_Helpers = ReventlessCore.CommandTopic_Helpers
+
+module OrderSlice = {
+  let name = "CauseOrders"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type event =
+    | OrderPlaced({orderId: @s.matches(Reventless.DcbTag.string) string, customerId: string})
+    | OrderCancelled({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({
+        orderId: @s.matches(Reventless.DcbTag.string) string,
+        customerId: @s.matches(Reventless.Owner.string) string,
+      })
+    | OrderCancelled({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type command =
+    | PlaceOrder({
+        orderId: @s.matches(Reventless.DcbTag.string) string,
+        customerId: @s.matches(Reventless.Owner.string) string,
+      })
+    | CancelOrder({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type error = OrderAlreadyPlaced | OrderNotFound
+}
+
+module OrderDecision = {
+  type state = {placed: bool, cancelled: bool}
+  let initialState = {placed: false, cancelled: false}
+  let moduleUrl = OrderSlice.moduleUrl
+
+  let evolve = (state, event: OrderSlice.consumedEvent) =>
+    switch event {
+    | OrderPlaced(_) => {...state, placed: true}
+    | OrderCancelled(_) => {...state, cancelled: true}
+    }
+
+  let decide = (state, command: OrderSlice.command): result<
+    array<OrderSlice.event>,
+    OrderSlice.error,
+  > =>
+    switch command {
+    | PlaceOrder({orderId, customerId}) =>
+      state.placed ? Error(OrderAlreadyPlaced) : Ok([OrderPlaced({orderId, customerId})])
+    | CancelOrder({orderId}) =>
+      state.placed ? Ok([OrderCancelled({orderId: orderId})]) : Error(OrderNotFound)
+    }
+}
+
+module OrderHandler = ReventlessCore.StateChangeSlice_Callback.Make(OrderSlice, OrderDecision)
+
+let partitionTag = Reventless.DcbTag.Simple({key: "orderId"})
+
+// ─── Callers ────────────────────────────────────────────────────────────────
+
+external asIdentity: 'a => Reventless.Identity.t = "%identity"
+
+let cognito = (~userId): Reventless.Identity.t =>
+  asIdentity({"userId": userId, "username": userId, "groups": ["User"], "provider": "Cognito"})
+
+let owner = cognito(~userId="cust-A")
+let stranger = cognito(~userId="cust-B")
+
+// ─── Generator → producer path ──────────────────────────────────────────────
+
+let generated: ref<array<Message.commandJson>> = ref([])
+
+let generate = ReventlessCore.CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons=async cmds => generated := generated.contents->Array.concat(cmds),
+  ~serviceName=OrderSlice.name,
+  ~commandSchema=OrderSlice.commandSchema->S.castToUnknown,
+  ~componentKind=ReventlessCore.CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+let envelope = async (~command, ~args, ~identity) => {
+  generated := []
+  let p: ReventlessCore.CommandGenerator.payload = Obj.magic({
+    "command": command,
+    "arguments": Obj.magic(Dict.fromArray(args)),
+    "meta": {"ip": [], "user": "test", "info": ""},
+    "identity": identity,
+  })
+  let _ = await generate(p)->Effect.runPromise
+  generated.contents->Array.getUnsafe(0)
+}
+
+let handlerOver = (eventLog): CommandTopic_Helpers.jsonCommandsHandler =>
+  stream =>
+    OrderHandler.handleCommands(
+      ~partitionTag,
+      eventLog,
+      stream->Stream.map((item: CommandTopic_Helpers.topicItem<JSON.t>) => {
+        ReventlessInfra.CommandTopic.command: item.command->Message.decodeCommand'(
+          Reventless.Id.String.schema,
+          OrderSlice.commandSchema,
+        ),
+        reference: item.reference,
+      }),
+    )
+
+// The wire answer a client gets for one command: (`__typename`, `errorCode`, `cause`).
+let send = async (eventLog, cmd: Message.commandJson) => {
+  let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmd], handlerOver(eventLog))
+  let json = outcomes->Array.getUnsafe(0)->CommandTopic_Helpers.commandOutcomeToJson
+  let str = key =>
+    json
+    ->JSON.Decode.object
+    ->Option.flatMap(o => o->Dict.get(key))
+    ->Option.flatMap(JSON.Decode.string)
+  (str("__typename"), str("errorCode"), str("cause"))
+}
+
+let str = JSON.Encode.string
+let place = (~identity) =>
+  envelope(
+    ~command="PlaceOrder",
+    ~args=[("orderId", str("o-1")), ("customerId", str("cust-A"))],
+    ~identity,
+  )
+let cancel = (~identity) =>
+  envelope(~command="CancelOrder", ~args=[("orderId", str("o-1"))], ~identity)
+
+// ─── Backends ───────────────────────────────────────────────────────────────
+
+type appendMode = Real | AlwaysConflict | StoreFails
+
+// One fresh event log per scenario; `mode` replaces the store's append to fail
+// the way the platform can.
+let eventLogOn = async (~name, ~mode) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalDcbEventLogStorage.Make(Bus)
+  let s = Storage.make(
+    ~name,
+    ~indexes=[],
+    ~partitionTag=Reventless.DcbTag.Simple({key: "orderId"}),
+    ~opts,
+  )
+  let real = await s.operations->TestRunner.resolve
+  let storage: ReventlessCore.DcbEventLog_Adapter.operations = switch mode {
+  | Real => real
+  | AlwaysConflict => {...real, append: async (_, ~condition as _=?) => Error(Conflict)}
+  | StoreFails => {
+      ...real,
+      append: async (_, ~condition as _=?) => Error(StorageFailure("disk unavailable")),
+    }
+  }
+  module Log = ReventlessCore.DcbEventLog_Operations.Make({
+    let name = name
+    let serviceName = name
+    let storage = storage
+    let publishJson = async (_, _, _) => ()
+  })
+  let eventLog: ReventlessCore.DcbEventLog.operations = {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream,
+  }
+  eventLog
+}
+
+let runUnderMemory = async fn => {
+  BackendState.setMemory()
+  await fn()
+}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+let _ = beforeEach(() => {
+  Reventless.OwnerScope.setElevatedGroups(["Admin"])
+  OrderHandler.resetCache()
+})
+
+let counter = ref(0)
+let fresh = prefix => {
+  counter := counter.contents + 1
+  `${prefix}-${counter.contents->Int.toString}`
+}
+
+let backends = [("in-memory", runUnderMemory), ("SQLite", runUnderSqlite)]
+
+backends->Array.forEach(((label, runUnder)) =>
+  describe(`a rejection's cause (${label} backend)`, () => {
+    testPromise(
+      "the model's no: a decide error arrives with DOMAIN",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("CauseDomain"), ~mode=Real)
+            let first = await send(log, await place(~identity=owner))
+            expect(first)->toEqual((Some("CommandAccepted"), None, None))
+            let again = await send(log, await place(~identity=owner))
+            expect(again)->toEqual((
+              Some("CommandRejected"),
+              Some("OrderAlreadyPlaced"),
+              Some("DOMAIN"),
+            ))
+          },
+        ),
+    )
+
+    testPromise(
+      "the caller's no: an ownership refusal arrives with ACCESS",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("CauseAccess"), ~mode=Real)
+            let _ = await send(log, await place(~identity=owner))
+            let refused = await send(log, await cancel(~identity=stranger))
+            expect(refused)->toEqual((Some("CommandRejected"), Some("Forbidden"), Some("ACCESS")))
+          },
+        ),
+    )
+
+    testPromise(
+      "the platform's no: an exhausted retry loop arrives with INFRASTRUCTURE",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("CauseConflict"), ~mode=AlwaysConflict)
+            let failed = await send(log, await place(~identity=owner))
+            expect(failed)->toEqual((
+              Some("CommandRejected"),
+              Some("Conflict"),
+              Some("INFRASTRUCTURE"),
+            ))
+          },
+        ),
+    )
+
+    testPromise(
+      "the platform's no: a failing store arrives with INFRASTRUCTURE",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("CauseStore"), ~mode=StoreFails)
+            let failed = await send(log, await place(~identity=owner))
+            expect(failed)->toEqual((
+              Some("CommandRejected"),
+              Some("AppendFailed"),
+              Some("INFRASTRUCTURE"),
+            ))
+          },
+        ),
+    )
+  })
+)

package/tests/components/dcb/DcbRejectionCauseTest.res.mjs

@@ -0,0 +1,440 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../../src/adapter/SqliteDriver.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let name = "CauseOrders";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let consumedEventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Owner$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "PlaceOrder",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Owner$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "CancelOrder",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let errorSchema = Sury.union([
+  Sury.literal("OrderAlreadyPlaced"),
+  Sury.literal("OrderNotFound")
+]);
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let OrderSlice = {
+  name: name,
+  Id: undefined,
+  moduleUrl: moduleUrl,
+  eventSchema: eventSchema,
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema,
+  errorSchema: errorSchema,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  placed: false,
+  cancelled: false
+};
+
+function evolve(state, event) {
+  if (event.TAG === "OrderPlaced") {
+    return {
+      placed: true,
+      cancelled: state.cancelled
+    };
+  } else {
+    return {
+      placed: state.placed,
+      cancelled: true
+    };
+  }
+}
+
+function decide(state, command) {
+  if (command.TAG === "PlaceOrder") {
+    if (state.placed) {
+      return {
+        TAG: "Error",
+        _0: "OrderAlreadyPlaced"
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "OrderPlaced",
+            orderId: command.orderId,
+            customerId: command.customerId
+          }]
+      };
+    }
+  } else if (state.placed) {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "OrderCancelled",
+          orderId: command.orderId
+        }]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "OrderNotFound"
+    };
+  }
+}
+
+let OrderDecision = {
+  initialState: initialState,
+  moduleUrl: moduleUrl,
+  evolve: evolve,
+  decide: decide
+};
+
+let OrderHandler = StateChangeSlice_Callback$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema,
+  commandSchema: commandSchema,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl
+});
+
+let partitionTag = {
+  TAG: "Simple",
+  _0: {
+    key: "orderId"
+  }
+};
+
+function cognito(userId) {
+  return {
+    userId: userId,
+    username: userId,
+    groups: ["User"],
+    provider: "Cognito"
+  };
+}
+
+let owner = {
+  userId: "cust-A",
+  username: "cust-A",
+  groups: ["User"],
+  provider: "Cognito"
+};
+
+let stranger = {
+  userId: "cust-B",
+  username: "cust-B",
+  groups: ["User"],
+  provider: "Cognito"
+};
+
+let generated = {
+  contents: []
+};
+
+let generate = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(async cmds => {
+  generated.contents = generated.contents.concat(cmds);
+}, undefined, name, commandSchema, "StateChangeSlice", false, undefined);
+
+async function envelope(command, args, identity) {
+  generated.contents = [];
+  let p = {
+    command: command,
+    arguments: Object.fromEntries(args),
+    meta: {
+      ip: [],
+      user: "test",
+      info: ""
+    },
+    identity: identity
+  };
+  await Effect.runPromise(generate(p));
+  return generated.contents[0];
+}
+
+function handlerOver(eventLog) {
+  return stream => OrderHandler.handleCommands(undefined, undefined, partitionTag, eventLog, Stream.map(stream, item => ({
+    command: Message$ReventlessCore.decodeCommand$p(item.command, Id$Reventless.$$String.schema, commandSchema),
+    reference: item.reference
+  })));
+}
+
+async function send(eventLog, cmd) {
+  let outcomes = await CommandTopic_Helpers$ReventlessCore.runInlineAndCollect([cmd], handlerOver(eventLog));
+  let json = CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson(outcomes[0]);
+  let str = key => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[key]), Stdlib_JSON.Decode.string);
+  return [
+    str("__typename"),
+    str("errorCode"),
+    str("cause")
+  ];
+}
+
+function str(prim) {
+  return prim;
+}
+
+function place(identity) {
+  return envelope("PlaceOrder", [
+    [
+      "orderId",
+      "o-1"
+    ],
+    [
+      "customerId",
+      "cust-A"
+    ]
+  ], identity);
+}
+
+function cancel(identity) {
+  return envelope("CancelOrder", [[
+      "orderId",
+      "o-1"
+    ]], identity);
+}
+
+async function eventLogOn(name, mode) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(Bus);
+  let s = Storage.make(name, [], {
+    TAG: "Simple",
+    _0: {
+      key: "orderId"
+    }
+  }, undefined, opts);
+  let real = await TestRunner$ReventlessLocal.resolve(s.operations);
+  let storage;
+  switch (mode) {
+    case "Real" :
+      storage = real;
+      break;
+    case "AlwaysConflict" :
+      storage = {
+        read: real.read,
+        append: async (param, param$1) => ({
+          TAG: "Error",
+          _0: "Conflict"
+        }),
+        readStream: real.readStream
+      };
+      break;
+    case "StoreFails" :
+      storage = {
+        read: real.read,
+        append: async (param, param$1) => ({
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: "disk unavailable"
+          }
+        }),
+        readStream: real.readStream
+      };
+      break;
+  }
+  let publishJson = async (param, param$1, param$2) => {};
+  let Log = DcbEventLog_Operations$ReventlessCore.Make({
+    name: name,
+    serviceName: name,
+    storage: storage,
+    publishJson: publishJson
+  });
+  return {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream
+  };
+}
+
+async function runUnderMemory(fn) {
+  BackendState$ReventlessLocal.setMemory();
+  return await fn();
+}
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+globalThis.beforeEach(() => {
+  OwnerScope$Reventless.setElevatedGroups(["Admin"]);
+  OrderHandler.resetCache();
+});
+
+let counter = {
+  contents: 0
+};
+
+function fresh(prefix) {
+  counter.contents = counter.contents + 1 | 0;
+  return prefix + `-` + counter.contents.toString();
+}
+
+let backends = [
+  [
+    "in-memory",
+    runUnderMemory
+  ],
+  [
+    "SQLite",
+    runUnderSqlite
+  ]
+];
+
+backends.forEach(param => {
+  let runUnder = param[1];
+  globalThis.describe(`a rejection's cause (` + param[0] + ` backend)`, () => {
+    globalThis.test("the model's no: a decide error arrives with DOMAIN", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("CauseDomain"), "Real");
+      let first = await send(log, await place(owner));
+      globalThis.expect(first).toEqual([
+        "CommandAccepted",
+        undefined,
+        undefined
+      ]);
+      let again = await send(log, await place(owner));
+      globalThis.expect(again).toEqual([
+        "CommandRejected",
+        "OrderAlreadyPlaced",
+        "DOMAIN"
+      ]);
+    }));
+    globalThis.test("the caller's no: an ownership refusal arrives with ACCESS", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("CauseAccess"), "Real");
+      await send(log, await place(owner));
+      let refused = await send(log, await cancel(stranger));
+      globalThis.expect(refused).toEqual([
+        "CommandRejected",
+        "Forbidden",
+        "ACCESS"
+      ]);
+    }));
+    globalThis.test("the platform's no: an exhausted retry loop arrives with INFRASTRUCTURE", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("CauseConflict"), "AlwaysConflict");
+      let failed = await send(log, await place(owner));
+      globalThis.expect(failed).toEqual([
+        "CommandRejected",
+        "Conflict",
+        "INFRASTRUCTURE"
+      ]);
+    }));
+    globalThis.test("the platform's no: a failing store arrives with INFRASTRUCTURE", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("CauseStore"), "StoreFails");
+      let failed = await send(log, await place(owner));
+      globalThis.expect(failed).toEqual([
+        "CommandRejected",
+        "AppendFailed",
+        "INFRASTRUCTURE"
+      ]);
+    }));
+  });
+});
+
+let Message;
+
+let CommandTopic_Helpers;
+
+export {
+  opts,
+  Message,
+  CommandTopic_Helpers,
+  OrderSlice,
+  OrderDecision,
+  OrderHandler,
+  partitionTag,
+  cognito,
+  owner,
+  stranger,
+  generated,
+  generate,
+  envelope,
+  handlerOver,
+  send,
+  str,
+  place,
+  cancel,
+  eventLogOn,
+  runUnderMemory,
+  runUnderSqlite,
+  counter,
+  fresh,
+  backends,
+}
+/*  Not a pure module */