@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/tests/adapter/LocalAuthLoginTest.res

@@ -19,7 +19,9 @@ let bob: Reventless.Identity.t = {
   provider: InMemory,
 }
 
-let buildContext = (headers: array<(string, string)>): ReventlessCore.Auth_Adapter.requestContext => {
+let buildContext = (
+  headers: array<(string, string)>,
+): ReventlessCore.Auth_Adapter.requestContext => {
   headers: Dict.fromArray(headers),
 }
 
@@ -127,9 +129,7 @@ testPromise("authenticate accepts a valid Bearer token", async () => {
   | Ok(t) => t
   | Error(msg) => JsError.throwWithMessage("issue failed: " ++ msg)
   }
-  let result = await LocalAuth.authenticate(
-    buildContext([("authorization", "Bearer " ++ token)]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("authorization", "Bearer " ++ token)]))
   switch result {
   | Authenticated(identity) =>
     expect(identity.username)->toEqual("bob")
@@ -256,11 +256,7 @@ testPromise("a narrowed token remembers the choice and what it gave up", async (
 // the failure that would hand a tampering client everything it asked for.
 testPromise("a login naming a role the user does not hold is REFUSED", async () => {
   carolLoggedIn()
-  switch await LocalAuth.Login.issue(
-    ~username="carol",
-    ~password="carol-pw",
-    ~activeRole="Admin",
-  ) {
+  switch await LocalAuth.Login.issue(~username="carol", ~password="carol-pw", ~activeRole="Admin") {
   | Ok(_) => JsError.throwWithMessage("expected a request to widen to be refused")
   | Error(msg) => expect(msg->String.includes("Admin"))->toEqual(true)
   }
@@ -275,13 +271,8 @@ testPromise("narrowing cannot smuggle a group in through the claims bag", async
     claims: Dict.fromArray([("availableRoles", "Admin,Fulfilment,Shopper")]),
   }
   LocalAuth.Login.setCredentials(~username="carol", ~password="carol-pw", ~identity=withClaims)
-  switch await LocalAuth.Login.issue(
-    ~username="carol",
-    ~password="carol-pw",
-    ~activeRole="Admin",
-  ) {
-  | Ok(_) =>
-    JsError.throwWithMessage("expected membership to be judged by groups, not by a claim")
+  switch await LocalAuth.Login.issue(~username="carol", ~password="carol-pw", ~activeRole="Admin") {
+  | Ok(_) => JsError.throwWithMessage("expected membership to be judged by groups, not by a claim")
   | Error(_) => expect(true)->toEqual(true)
   }
 })
@@ -298,9 +289,7 @@ testPromise("a narrowed token authenticates as the narrowed identity", async ()
   | Ok(t) => t
   | Error(e) => JsError.throwWithMessage(e)
   }
-  let result = await LocalAuth.authenticate(
-    buildContext([("authorization", "Bearer " ++ token)]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("authorization", "Bearer " ++ token)]))
   switch result {
   | Authenticated(identity) => expect(identity.groups)->toEqual(["Shopper"])
   | _ => JsError.throwWithMessage("expected the narrowed token to authenticate")
@@ -408,32 +397,35 @@ describe("the conformance table, minted locally", () => {
     requested,
     expected,
   }) =>
-    testPromise(label, async () => {
-      resetAll()
-      LocalAuth.Login.setCredentials(
-        ~username="conformance",
-        ~password="pw",
-        ~identity={
-          userId: "u-conformance",
-          username: "conformance",
-          groups: membership,
-          provider: InMemory,
-        },
-      )
-      let minted = await LocalAuth.Login.issue(
-        ~username="conformance",
-        ~password="pw",
-        ~activeRole=?requested,
-      )
-      switch (minted, expected) {
-      | (Ok(token), Some(groups)) => expect(decodeOrThrow(token).groups)->toEqual(groups)
-      // `None` means refused — not honoured, not ignored, and not reduced to the
-      // empty set. A token minted here at all would be the vulnerability.
-      | (Ok(_), None) => JsError.throwWithMessage("expected the request to be refused")
-      | (Error(msg), Some(_)) => JsError.throwWithMessage("expected a token, got: " ++ msg)
-      | (Error(_), None) => expect(true)->toEqual(true)
-      }
-    })
+    testPromise(
+      label,
+      async () => {
+        resetAll()
+        LocalAuth.Login.setCredentials(
+          ~username="conformance",
+          ~password="pw",
+          ~identity={
+            userId: "u-conformance",
+            username: "conformance",
+            groups: membership,
+            provider: InMemory,
+          },
+        )
+        let minted = await LocalAuth.Login.issue(
+          ~username="conformance",
+          ~password="pw",
+          ~activeRole=?requested,
+        )
+        switch (minted, expected) {
+        | (Ok(token), Some(groups)) => expect(decodeOrThrow(token).groups)->toEqual(groups)
+        // `None` means refused — not honoured, not ignored, and not reduced to the
+        // empty set. A token minted here at all would be the vulnerability.
+        | (Ok(_), None) => JsError.throwWithMessage("expected the request to be refused")
+        | (Error(msg), Some(_)) => JsError.throwWithMessage("expected a token, got: " ++ msg)
+        | (Error(_), None) => expect(true)->toEqual(true)
+        }
+      },
+    )
   )
 })
 
@@ -453,11 +445,11 @@ describe("Login token secret", () => {
     let first = LocalAuth.Login._resolveIn(~dir)
     // A second call with no memoised value is what the next process does.
     let second = LocalAuth.Login._resolveIn(~dir)
-    expect((first == second, NodeFs.existsSync(secretPath(dir)), String.length(first) >= 16))->toEqual((
-      true,
-      true,
-      true,
-    ))
+    expect((
+      first == second,
+      NodeFs.existsSync(secretPath(dir)),
+      String.length(first) >= 16,
+    ))->toEqual((true, true, true))
   })
 
   testSync("reads a secret a previous boot left behind", () => {

package/tests/adapter/LocalAuthTest.res

@@ -5,7 +5,9 @@
 
 open JestGlobals
 
-let buildContext = (headers: array<(string, string)>): ReventlessCore.Auth_Adapter.requestContext => {
+let buildContext = (
+  headers: array<(string, string)>,
+): ReventlessCore.Auth_Adapter.requestContext => {
   headers: Dict.fromArray(headers),
 }
 
@@ -22,9 +24,7 @@ testPromise("no X-User, no X-Groups → defaultUser (in-memory dev convenience)"
 
 testPromise("X-User: admin resolves built-in admin identity", async () => {
   LocalAuth.resetUsers()
-  let result = await LocalAuth.authenticate(
-    buildContext([("x-user", "admin")]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("x-user", "admin")]))
   switch result {
   | Authenticated(identity) =>
     expect(identity.username)->toEqual("admin")
@@ -35,9 +35,7 @@ testPromise("X-User: admin resolves built-in admin identity", async () => {
 
 testPromise("X-User: user resolves built-in default identity", async () => {
   LocalAuth.resetUsers()
-  let result = await LocalAuth.authenticate(
-    buildContext([("x-user", "user")]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("x-user", "user")]))
   switch result {
   | Authenticated(identity) =>
     expect(identity.username)->toEqual("user")
@@ -48,9 +46,7 @@ testPromise("X-User: user resolves built-in default identity", async () => {
 
 testPromise("unknown X-User falls back to Anonymous", async () => {
   LocalAuth.resetUsers()
-  let result = await LocalAuth.authenticate(
-    buildContext([("x-user", "unknown")]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("x-user", "unknown")]))
   switch result {
   | Anonymous => ()
   | _ => JsError.throwWithMessage("expected Anonymous")
@@ -72,9 +68,7 @@ testPromise("X-Groups overrides the resolved identity's groups", async () => {
 
 testPromise("X-Groups alone yields defaultUser tagged with the override groups", async () => {
   LocalAuth.resetUsers()
-  let result = await LocalAuth.authenticate(
-    buildContext([("x-groups", "Tester")]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("x-groups", "Tester")]))
   switch result {
   | Authenticated(identity) =>
     expect(identity.userId)->toEqual("local-user")
@@ -94,9 +88,7 @@ testPromise("registerUser injects a custom identity", async () => {
       provider: InMemory,
     },
   )
-  let result = await LocalAuth.authenticate(
-    buildContext([("x-user", "alice")]),
-  )
+  let result = await LocalAuth.authenticate(buildContext([("x-user", "alice")]))
   switch result {
   | Authenticated(identity) =>
     expect(identity.userId)->toEqual("alice-id")

package/tests/adapter/LocalAuthUserStoreTest.res

@@ -4,7 +4,6 @@
 
 open JestGlobals
 
-
 let resetAll = () => {
   LocalAuth.resetUsers()
   LocalAuth.Login.resetStore()
@@ -115,8 +114,7 @@ testPromise("load() with no args + no default file returns Empty", async () => {
   // no such file exists.)
   switch UserStore.load() {
   | Ok(Empty) => ()
-  | Ok(DefaultFile(_)) =>
-    // If a .reventless/users.yaml happens to exist in CI, accept it.
+  | Ok(DefaultFile(_)) => // If a .reventless/users.yaml happens to exist in CI, accept it.
     ()
   | Ok(_) => JsError.throwWithMessage("expected Empty or DefaultFile")
   | Error(msg) => JsError.throwWithMessage("load failed: " ++ msg)
@@ -152,10 +150,7 @@ testPromise("inline users win over a file path", async () => {
 
 testPromise("autoLoadOnce is a no-op after an explicit load", async () => {
   resetAll()
-  let _ = UserStore.load(
-    ~users=[{username: "x", password: "x", groups: []}],
-    (),
-  )
+  let _ = UserStore.load(~users=[{username: "x", password: "x", groups: []}], ())
   // Second call should not crash even if .reventless/users.yaml doesn't
   // exist; resolved=true prevents the default-discovery branch.
   UserStore.autoLoadOnce()

package/tests/adapter/LocalBusBoundedTest.res

@@ -21,137 +21,207 @@ let defaultMeta: Reventless.Message.meta = {
 
 describe("LocalBus bounded PubSub (Phase G)", () => {
   describe("basic delivery", () => {
-    testPromise("delivers a message to a subscriber in bounded mode", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 10})
-      let delivered = ref(false)
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        delivered := true
-      })
-      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      expect(delivered.contents)->toBe(true)
-    })
+    testPromise(
+      "delivers a message to a subscriber in bounded mode",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 10
+        })
+        let delivered = ref(false)
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            delivered := true
+          },
+        )
+        let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        expect(delivered.contents)->toBe(true)
+      },
+    )
 
-    testPromise("bounded mode with no subscribers returns immediately", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 5})
-      // No subscribers — should not hang
-      await TestBus.publishEvent("empty-topic", "svc", defaultMeta, JSON.Null)
-    })
+    testPromise(
+      "bounded mode with no subscribers returns immediately",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 5
+        })
+        // No subscribers — should not hang
+        await TestBus.publishEvent("empty-topic", "svc", defaultMeta, JSON.Null)
+      },
+    )
 
-    testPromise("passes service, meta, and json to the subscriber handler", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 10})
-      let capturedService = ref("")
-      let capturedJson = ref(JSON.Null)
-      TestBus.subscribeToEvents("T", async (svc, _meta, json) => {
-        capturedService := svc
-        capturedJson := json
-      })
-      let payload = JSON.parseOrThrow("{\"x\":42}")
-      let _ = await TestBus.publishEvent("T", "my-service", defaultMeta, payload)
-      expect(capturedService.contents)->toBe("my-service")
-      expect(capturedJson.contents)->toEqual(payload)
-    })
+    testPromise(
+      "passes service, meta, and json to the subscriber handler",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 10
+        })
+        let capturedService = ref("")
+        let capturedJson = ref(JSON.Null)
+        TestBus.subscribeToEvents(
+          "T",
+          async (svc, _meta, json) => {
+            capturedService := svc
+            capturedJson := json
+          },
+        )
+        let payload = JSON.parseOrThrow("{\"x\":42}")
+        let _ = await TestBus.publishEvent("T", "my-service", defaultMeta, payload)
+        expect(capturedService.contents)->toBe("my-service")
+        expect(capturedJson.contents)->toEqual(payload)
+      },
+    )
   })
 
   describe("fan-out", () => {
-    testPromise("delivers to all subscribers on the same topic", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 10})
-      let count = ref(0)
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      expect(count.contents)->toBe(3)
-    })
+    testPromise(
+      "delivers to all subscribers on the same topic",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 10
+        })
+        let count = ref(0)
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        expect(count.contents)->toBe(3)
+      },
+    )
 
-    testPromise("topic isolation preserved in bounded mode", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 10})
-      let countA = ref(0)
-      let countB = ref(0)
-      TestBus.subscribeToEvents("topic-a", async (_, _, _) => {
-        countA := countA.contents + 1
-      })
-      TestBus.subscribeToEvents("topic-b", async (_, _, _) => {
-        countB := countB.contents + 1
-      })
-      let _ = await TestBus.publishEvent("topic-a", "svc", defaultMeta, JSON.Null)
-      expect(countA.contents)->toBe(1)
-      expect(countB.contents)->toBe(0)
-    })
+    testPromise(
+      "topic isolation preserved in bounded mode",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 10
+        })
+        let countA = ref(0)
+        let countB = ref(0)
+        TestBus.subscribeToEvents(
+          "topic-a",
+          async (_, _, _) => {
+            countA := countA.contents + 1
+          },
+        )
+        TestBus.subscribeToEvents(
+          "topic-b",
+          async (_, _, _) => {
+            countB := countB.contents + 1
+          },
+        )
+        let _ = await TestBus.publishEvent("topic-a", "svc", defaultMeta, JSON.Null)
+        expect(countA.contents)->toBe(1)
+        expect(countB.contents)->toBe(0)
+      },
+    )
   })
 
   describe("backpressure", () => {
-    testPromise("publisher suspends when subscriber queue is full (capacity=1)", async () => {
-      // capacity=1: subscriber queue can buffer 1 message while the subscriber is processing.
-      // Timeline:
-      //   p1 publish: drain fiber D has a pending Queue.take → msg1 goes to D directly
-      //   p2 publish: no pending take (D is processing msg1, blocked on gate) → msg2 buffered
-      //   p3 publish: queue is full (msg2 there, capacity=1) → F3 SUSPENDS
-      //   After opening gate: msg1 processed → done_1 → D takes msg2 → F3 wakes, delivers msg3
-      module TestBus = LocalBus.MakeBounded({let capacity = 1})
-      let processedCount = ref(0)
-      // Gate Deferred: subscriber blocks until explicitly opened
-      let gate: Deferred.t<unit, unit> = Deferred.make()->Effect.runSync
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        let _ = await Deferred.await_(gate)->Effect.runPromise
-        processedCount := processedCount.contents + 1
-      })
-      // Start 3 publishes without awaiting.
-      // p1: D's pending Queue.take resolves with msg1; D starts processing (blocks on gate)
-      // p2: msg2 buffered in queue (capacity=1, fits since D already took msg1)
-      // p3: queue full → F3 fiber suspends inside PubSub.publish
-      let p1 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      let p2 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      let p3 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      // Tick 1: drain fiber D runs, takes msg1, calls handler → handler blocks on gate
-      let _ = await Promise.resolve()
-      // Gate not open yet — no messages fully processed
-      expect(processedCount.contents)->toBe(0)
-      // Open gate: subscriber can now process all pending messages
-      let _ = Deferred.succeed(gate, ())->Effect.runSync
-      // Await each publish promise; by the time all resolve, all 3 handlers have run
-      let _ = await p1
-      let _ = await p2
-      let _ = await p3
-      expect(processedCount.contents)->toBe(3)
-    })
+    testPromise(
+      "publisher suspends when subscriber queue is full (capacity=1)",
+      async () => {
+        // capacity=1: subscriber queue can buffer 1 message while the subscriber is processing.
+        // Timeline:
+        //   p1 publish: drain fiber D has a pending Queue.take → msg1 goes to D directly
+        //   p2 publish: no pending take (D is processing msg1, blocked on gate) → msg2 buffered
+        //   p3 publish: queue is full (msg2 there, capacity=1) → F3 SUSPENDS
+        //   After opening gate: msg1 processed → done_1 → D takes msg2 → F3 wakes, delivers msg3
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 1
+        })
+        let processedCount = ref(0)
+        // Gate Deferred: subscriber blocks until explicitly opened
+        let gate: Deferred.t<unit, unit> = Deferred.make()->Effect.runSync
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            let _ = await Deferred.await_(gate)->Effect.runPromise
+            processedCount := processedCount.contents + 1
+          },
+        )
+        // Start 3 publishes without awaiting.
+        // p1: D's pending Queue.take resolves with msg1; D starts processing (blocks on gate)
+        // p2: msg2 buffered in queue (capacity=1, fits since D already took msg1)
+        // p3: queue full → F3 fiber suspends inside PubSub.publish
+        let p1 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        let p2 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        let p3 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        // Tick 1: drain fiber D runs, takes msg1, calls handler → handler blocks on gate
+        let _ = await Promise.resolve()
+        // Gate not open yet — no messages fully processed
+        expect(processedCount.contents)->toBe(0)
+        // Open gate: subscriber can now process all pending messages
+        let _ = Deferred.succeed(gate, ())->Effect.runSync
+        // Await each publish promise; by the time all resolve, all 3 handlers have run
+        let _ = await p1
+        let _ = await p2
+        let _ = await p3
+        expect(processedCount.contents)->toBe(3)
+      },
+    )
   })
 
   describe("timing", () => {
-    testPromise("bounded mode completes within 3 microtask ticks", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 10})
-      let delivered = ref(false)
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        delivered := true
-      })
-      let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      // Not delivered synchronously
-      expect(delivered.contents)->toBe(false)
-      let _ = await Promise.resolve() // tick 1
-      let _ = await Promise.resolve() // tick 2
-      let _ = await Promise.resolve() // tick 3 (bounded adds 1 vs unbounded's 2)
-      let _ = await pubPromise
-      expect(delivered.contents)->toBe(true)
-    })
+    testPromise(
+      "bounded mode completes within 3 microtask ticks",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 10
+        })
+        let delivered = ref(false)
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            delivered := true
+          },
+        )
+        let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        // Not delivered synchronously
+        expect(delivered.contents)->toBe(false)
+        let _ = await Promise.resolve() // tick 1
+        let _ = await Promise.resolve() // tick 2
+        let _ = await Promise.resolve() // tick 3 (bounded adds 1 vs unbounded's 2)
+        let _ = await pubPromise
+        expect(delivered.contents)->toBe(true)
+      },
+    )
   })
 
   describe("reset", () => {
-    testPromise("reset shuts down bounded hubs cleanly", async () => {
-      module TestBus = LocalBus.MakeBounded({let capacity = 5})
-      let count = ref(0)
-      TestBus.subscribeToEvents("T", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
-      expect(count.contents)->toBe(1)
-      // reset should not throw or hang
-      TestBus.reset()
-      expect(count.contents)->toBe(1) // count unchanged by reset itself
-    })
+    testPromise(
+      "reset shuts down bounded hubs cleanly",
+      async () => {
+        module TestBus = LocalBus.MakeBounded({
+          let capacity = 5
+        })
+        let count = ref(0)
+        TestBus.subscribeToEvents(
+          "T",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+        expect(count.contents)->toBe(1)
+        // reset should not throw or hang
+        TestBus.reset()
+        expect(count.contents)->toBe(1) // count unchanged by reset itself
+      },
+    )
   })
 })