@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/CommandAuthorizationTest.res

@@ -0,0 +1,200 @@
+// Resolver-boundary tests for per-constructor authorization (A3.3 + A3.3b).
+// Mirrors the catalog Category aggregate's command shape: a record-payload
+// constructor `Add({name})` defaulting to AllowAuthenticated, plus a
+// payload-less `Archive` constrained to AllowGroups(["Admin"]).
+//
+// The PPX emits a `commandAuthorization` switch at compile time (see
+// examples/online-shop-hybrid/catalog/.../Category.res.mjs). This test hand-
+// writes an equivalent switch and feeds it through the live resolver path
+// (CommandGeneratorResolvers_GraphQL.register), so the test covers the same
+// runtime call shape that PPX-generated code produces.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+// ── Synthetic command schema mirroring Category ──────────────────────────────
+
+@schema
+type command =
+  | Add({name: string})
+  | Rename({name: string})
+  | Archive
+
+// Matches the shape the PPX emits for `@authorize(AllowGroups(["Admin"]))` on
+// the payload-less `Archive` constructor with a file-level default.
+let commandAuthorization = (cmd: unknown): Reventless.Authorization.permission =>
+  if (cmd->Obj.magic: 'a) === "Archive" {
+    AllowGroups(["Admin"])
+  } else {
+    AllowAuthenticated
+  }
+
+// ── Identity fixtures ────────────────────────────────────────────────────────
+
+let adminIdentity: Reventless.Identity.t = {
+  userId: "u-admin",
+  username: "admin",
+  groups: ["Admin", "User"],
+  provider: InMemory,
+}
+
+let userIdentity: Reventless.Identity.t = {
+  userId: "u-user",
+  username: "user",
+  groups: ["User"],
+  provider: InMemory,
+}
+
+let ctxFor = (identity: Reventless.Identity.t): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([("identity", (identity: Reventless.Identity.t)->Obj.magic)]),
+  )
+
+let anonymousCtx: JSON.t =
+  JSON.Encode.object(
+    Dict.fromArray([("identity", (Reventless.Identity.anonymous: Reventless.Identity.t)->Obj.magic)]),
+  )
+
+let getTypename = (response: JSON.t): string =>
+  response
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("__typename"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("")
+
+let getErrorCode = (response: JSON.t): string =>
+  response
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("errorCode"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("")
+
+// ── Per-test fixture — fresh server + handler + resolvers ────────────────────
+
+let buildFixture = (~namespace: string) => {
+  // Use the domain server (a singleton) and reset it before each test so
+  // mutation registrations don't leak across cases.
+  let server = DomainGraphQL_Server.asInterface
+  let calls: ref<array<string>> = ref([])
+
+  let addField = `${namespace}_Add`
+  let renameField = `${namespace}_Rename`
+  let archiveField = `${namespace}_Archive`
+
+  CommandGeneratorResolvers_GraphQL.register(
+    ~fields=[addField, renameField, archiveField],
+    ~commandSchema=commandSchema->S.castToUnknown,
+    ~commandAuthorization,
+    ~server,
+  )
+
+  // Stub generateCommand: record the command name + return Accepted.
+  let stubGenerateCommand: ReventlessCore.CommandGenerator.commandGenerator = payload =>
+    Effect.promise(() => {
+      calls.contents->Array.push(payload.command)
+      Promise.resolve(
+        ReventlessCore.CommandTopic.Accepted({
+          msgId: "msg-" ++ payload.command,
+          eventCount: 1,
+        }),
+      )
+    })
+
+  [addField, renameField, archiveField]->Array.forEach(field =>
+    CommandGeneratorResolvers_GraphQL.bindHandler(~field, ~generateCommand=stubGenerateCommand)
+  )
+
+  let resolverFor = field =>
+    switch server.getMutationResolver(field) {
+    | Some(r) => r
+    | None => JsError.throwWithMessage("resolver not registered: " ++ field)
+    }
+
+  (resolverFor(addField), resolverFor(renameField), resolverFor(archiveField), calls)
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.asInterface.reset()
+  })
+
+  testPromise("admin invoking payload-less Archive succeeds", async () => {
+    let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat1")
+    let response =
+      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), ctxFor(adminIdentity))
+    expect(getTypename(response))->toEqual("CommandAccepted")
+    expect(calls.contents)->toEqual(["Archive"])
+  })
+
+  testPromise("regular user invoking Archive is rejected with Forbidden", async () => {
+    let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat2")
+    let response =
+      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), ctxFor(userIdentity))
+    expect(getTypename(response))->toEqual("CommandRejected")
+    expect(getErrorCode(response))->toEqual("Forbidden")
+    expect(calls.contents)->toEqual([])
+  })
+
+  testPromise("anonymous invoking Archive is rejected with Forbidden", async () => {
+    let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat3")
+    let response =
+      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), anonymousCtx)
+    expect(getTypename(response))->toEqual("CommandRejected")
+    expect(getErrorCode(response))->toEqual("Forbidden")
+    expect(calls.contents)->toEqual([])
+  })
+
+  testPromise("regular user invoking Add (default AllowAuthenticated) succeeds", async () => {
+    let (addResolver, _, _, calls) = buildFixture(~namespace="Cat4")
+    let response =
+      await addResolver(
+        JSON.Encode.null,
+        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+        ctxFor(userIdentity),
+      )
+    expect(getTypename(response))->toEqual("CommandAccepted")
+    expect(calls.contents)->toEqual(["Add"])
+  })
+
+  testPromise("anonymous invoking Add is rejected (AllowAuthenticated default)", async () => {
+    let (addResolver, _, _, calls) = buildFixture(~namespace="Cat5")
+    let response =
+      await addResolver(
+        JSON.Encode.null,
+        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+        anonymousCtx,
+      )
+    expect(getTypename(response))->toEqual("CommandRejected")
+    expect(getErrorCode(response))->toEqual("Forbidden")
+    expect(calls.contents)->toEqual([])
+  })
+
+  testPromise("admin invoking Add also succeeds (admin has User group too)", async () => {
+    let (addResolver, _, _, calls) = buildFixture(~namespace="Cat6")
+    let response =
+      await addResolver(
+        JSON.Encode.null,
+        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+        ctxFor(adminIdentity),
+      )
+    expect(getTypename(response))->toEqual("CommandAccepted")
+    expect(calls.contents)->toEqual(["Add"])
+  })
+
+  testPromise(
+    "payload-less Archive registered as a GraphQL mutation field (no longer filtered)",
+    async () => {
+      let (_, _, _, _) = buildFixture(~namespace="Cat7")
+      let sdl = DomainGraphQL_Server.asInterface.buildSdl()
+      // Three mutation fields should now be present, including Archive.
+      expect(sdl->String.includes("Cat7_Add"))->toEqual(true)
+      expect(sdl->String.includes("Cat7_Rename"))->toEqual(true)
+      expect(sdl->String.includes("Cat7_Archive"))->toEqual(true)
+    },
+  )
+})

package/tests/adapter/CommandAuthorizationTest.res.mjs

@@ -0,0 +1,190 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+import * as CommandGeneratorResolvers_GraphQL$ReventlessLocal from "../../src/adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Add",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Rename",
+    name: s.m(S.string)
+  })),
+  S.literal("Archive")
+]);
+
+function commandAuthorization(cmd) {
+  if (cmd === "Archive") {
+    return {
+      TAG: "AllowGroups",
+      _0: ["Admin"]
+    };
+  } else {
+    return "AllowAuthenticated";
+  }
+}
+
+let adminIdentity_groups = [
+  "Admin",
+  "User"
+];
+
+let adminIdentity = {
+  userId: "u-admin",
+  username: "admin",
+  groups: adminIdentity_groups,
+  provider: "InMemory"
+};
+
+let userIdentity_groups = ["User"];
+
+let userIdentity = {
+  userId: "u-user",
+  username: "user",
+  groups: userIdentity_groups,
+  provider: "InMemory"
+};
+
+function ctxFor(identity) {
+  return Object.fromEntries([[
+      "identity",
+      identity
+    ]]);
+}
+
+let anonymousCtx = Object.fromEntries([[
+    "identity",
+    Identity$Reventless.anonymous
+  ]]);
+
+function getTypename(response) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(response), d => d["__typename"]), Stdlib_JSON.Decode.string), "");
+}
+
+function getErrorCode(response) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(response), d => d["errorCode"]), Stdlib_JSON.Decode.string), "");
+}
+
+function buildFixture(namespace) {
+  let calls = {
+    contents: []
+  };
+  let addField = namespace + `_Add`;
+  let renameField = namespace + `_Rename`;
+  let archiveField = namespace + `_Archive`;
+  CommandGeneratorResolvers_GraphQL$ReventlessLocal.register([
+    addField,
+    renameField,
+    archiveField
+  ], commandSchema, commandAuthorization, DomainGraphQL_Server$ReventlessLocal.asInterface);
+  let stubGenerateCommand = payload => Effect.promise(() => {
+    calls.contents.push(payload.command);
+    return Promise.resolve({
+      TAG: "Accepted",
+      msgId: "msg-" + payload.command,
+      eventCount: 1
+    });
+  });
+  [
+    addField,
+    renameField,
+    archiveField
+  ].forEach(field => CommandGeneratorResolvers_GraphQL$ReventlessLocal.bindHandler(field, stubGenerateCommand));
+  let resolverFor = field => {
+    let r = DomainGraphQL_Server$ReventlessLocal.asInterface.getMutationResolver(field);
+    if (r !== undefined) {
+      return r;
+    } else {
+      return Stdlib_JsError.throwWithMessage("resolver not registered: " + field);
+    }
+  };
+  return [
+    resolverFor(addField),
+    resolverFor(renameField),
+    resolverFor(archiveField),
+    calls
+  ];
+}
+
+globalThis.describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.asInterface.reset());
+  globalThis.test("admin invoking payload-less Archive succeeds", async () => {
+    let match = buildFixture("Cat1");
+    let response = await match[2](null, {}, ctxFor(adminIdentity));
+    globalThis.expect(getTypename(response)).toEqual("CommandAccepted");
+    globalThis.expect(match[3].contents).toEqual(["Archive"]);
+  });
+  globalThis.test("regular user invoking Archive is rejected with Forbidden", async () => {
+    let match = buildFixture("Cat2");
+    let response = await match[2](null, {}, ctxFor(userIdentity));
+    globalThis.expect(getTypename(response)).toEqual("CommandRejected");
+    globalThis.expect(getErrorCode(response)).toEqual("Forbidden");
+    globalThis.expect(match[3].contents).toEqual([]);
+  });
+  globalThis.test("anonymous invoking Archive is rejected with Forbidden", async () => {
+    let match = buildFixture("Cat3");
+    let response = await match[2](null, {}, anonymousCtx);
+    globalThis.expect(getTypename(response)).toEqual("CommandRejected");
+    globalThis.expect(getErrorCode(response)).toEqual("Forbidden");
+    globalThis.expect(match[3].contents).toEqual([]);
+  });
+  globalThis.test("regular user invoking Add (default AllowAuthenticated) succeeds", async () => {
+    let match = buildFixture("Cat4");
+    let response = await match[0](null, Object.fromEntries([[
+        "name",
+        "Books"
+      ]]), ctxFor(userIdentity));
+    globalThis.expect(getTypename(response)).toEqual("CommandAccepted");
+    globalThis.expect(match[3].contents).toEqual(["Add"]);
+  });
+  globalThis.test("anonymous invoking Add is rejected (AllowAuthenticated default)", async () => {
+    let match = buildFixture("Cat5");
+    let response = await match[0](null, Object.fromEntries([[
+        "name",
+        "Books"
+      ]]), anonymousCtx);
+    globalThis.expect(getTypename(response)).toEqual("CommandRejected");
+    globalThis.expect(getErrorCode(response)).toEqual("Forbidden");
+    globalThis.expect(match[3].contents).toEqual([]);
+  });
+  globalThis.test("admin invoking Add also succeeds (admin has User group too)", async () => {
+    let match = buildFixture("Cat6");
+    let response = await match[0](null, Object.fromEntries([[
+        "name",
+        "Books"
+      ]]), ctxFor(adminIdentity));
+    globalThis.expect(getTypename(response)).toEqual("CommandAccepted");
+    globalThis.expect(match[3].contents).toEqual(["Add"]);
+  });
+  globalThis.test("payload-less Archive registered as a GraphQL mutation field (no longer filtered)", async () => {
+    buildFixture("Cat7");
+    let sdl = DomainGraphQL_Server$ReventlessLocal.asInterface.buildSdl();
+    globalThis.expect(sdl.includes("Cat7_Add")).toEqual(true);
+    globalThis.expect(sdl.includes("Cat7_Rename")).toEqual(true);
+    globalThis.expect(sdl.includes("Cat7_Archive")).toEqual(true);
+  });
+});
+
+export {
+  commandSchema,
+  commandAuthorization,
+  adminIdentity,
+  userIdentity,
+  ctxFor,
+  anonymousCtx,
+  getTypename,
+  getErrorCode,
+  buildFixture,
+}
+/*  Not a pure module */

package/tests/adapter/CommandTopicChannelTest.res

@@ -0,0 +1,174 @@
+// Unit tests for LocalCommandTopicChannel.
+// Covers encodeCommandJson (shared helper), decodeId, publishJsons, and connect wiring.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let testMeta: Reventless.Message.meta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001",
+}
+
+describe("LocalCommandTopicChannel", () => {
+  describe("encodeCommandJson", () => {
+    testPromise("produces {id, meta, command} JSON shape", async () => {
+      let cmdJson: Reventless.Message.commandJson = {
+        id: "agg-1",
+        meta: testMeta,
+        commandJson: JSON.Encode.string("DoSomething"),
+      }
+      let encoded = ReventlessCore.CommandTopic.encodeCommandJson(cmdJson)
+      let dict = switch encoded {
+      | JSON.Object(d) => d
+      | _ => Dict.make()
+      }
+      expect(dict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("agg-1")))
+      expect(dict->Dict.get("command"))->toEqual(Some(JSON.Encode.string("DoSomething")))
+      expect(dict->Dict.get("meta")->Option.isSome)->toBe(true)
+    })
+  })
+
+  describe("decodeId", () => {
+    testPromise("extracts id string from encoded message body", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let body = JSON.Encode.object(
+        Dict.fromArray([("id", JSON.Encode.string("agg-42"))]),
+      )
+      expect(TestChannel.decodeId(body))->toBe("agg-42")
+    })
+
+    testPromise("returns empty string for non-object input", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      expect(TestChannel.decodeId(JSON.Encode.string("not-an-object")))->toBe("")
+    })
+
+    testPromise("returns empty string when id field is missing", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let body = JSON.Encode.object(Dict.fromArray([("other", JSON.Encode.int(1))]))
+      expect(TestChannel.decodeId(body))->toBe("")
+    })
+
+    testPromise("returns empty string when id field is not a string", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let body = JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.int(99))]))
+      expect(TestChannel.decodeId(body))->toBe("")
+    })
+  })
+
+  describe("publishJsons", () => {
+    testPromise("dispatches each command to the bus with full {id, meta, command} body", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let received: ref<option<JSON.t>> = ref(None)
+      TestBus.registerCommandHandler("myCmd", async (json, _) => {
+        received := Some(json)
+      })
+      let ch = TestChannel.make(~name="myCmd")
+      let publishFn = await ch.publishJsons->TestRunner.resolve
+      await publishFn([
+        {
+          Reventless.Message.id: "item-1",
+          meta: testMeta,
+          commandJson: JSON.Encode.string("CreateItem"),
+        },
+      ])
+      let receivedJson = received.contents->Option.getOr(JSON.Null)
+      let receivedDict = switch receivedJson {
+      | JSON.Object(d) => d
+      | _ => Dict.make()
+      }
+      expect(receivedDict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("item-1")))
+    })
+
+    testPromise("dispatches multiple commands in order", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.registerCommandHandler("multiCmd", async (_, _) => {
+        count := count.contents + 1
+      })
+      let ch = TestChannel.make(~name="multiCmd")
+      let publishFn = await ch.publishJsons->TestRunner.resolve
+      await publishFn([
+        {
+          Reventless.Message.id: "id-1",
+          meta: testMeta,
+          commandJson: JSON.Null,
+        },
+        {
+          Reventless.Message.id: "id-2",
+          meta: testMeta,
+          commandJson: JSON.Null,
+        },
+      ])
+      expect(count.contents)->toBe(2)
+    })
+  })
+
+  describe("connect", () => {
+    testPromise("registers handler; dispatch reaches the runtime handlerDeferred", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      let received: ref<option<JSON.t>> = ref(None)
+      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+        Deferred.make()->Effect.runSync
+      Deferred.succeed(handlerDeferred, async (json, _ctx) => {
+        received := Some(json)
+      })->Effect.runSync->ignore
+      let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
+        parts: {
+          handlerDeferred,
+          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+        },
+        resources: [],
+      }
+      let ch = TestChannel.make(~name="testCmd")
+      let _ = ch.connect(
+        ~name="testCmd",
+        ~channel=ch,
+        ~runtime,
+        ~resources=[],
+        ~opts={},
+      )
+      await TestBus.dispatchCommand("testCmd", JSON.Encode.string("test-payload"))
+      expect(received.contents)->toEqual(Some(JSON.Encode.string("test-payload")))
+    })
+
+    testPromise("unresolved Deferred does not crash on dispatch", async () => {
+      module TestBus = LocalBus.Make()
+      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+      // Deferred left incomplete — dispatch starts a pending Effect (no crash)
+      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+        Deferred.make()->Effect.runSync
+      let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
+        parts: {
+          handlerDeferred,
+          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+        },
+        resources: [],
+      }
+      let ch = TestChannel.make(~name="noHandlerCmd")
+      let _ = ch.connect(
+        ~name="noHandlerCmd",
+        ~channel=ch,
+        ~runtime,
+        ~resources=[],
+        ~opts={},
+      )
+      // Fire-and-forget — the Deferred.await_ will stay pending
+      TestBus.dispatchCommand("noHandlerCmd", JSON.Null)->ignore
+      expect(true)->toBe(true)
+      // Complete the Deferred to avoid open handle
+      Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
+    })
+  })
+})