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

package/tests/adapter/GraphQL_SubscriptionResolversTest.res

@@ -60,104 +60,113 @@ describe("LocalGraphQL_SubscriptionResolvers", () => {
   })
 
   describe("Source B — state-change bridge", () => {
-    testPromise("Bus.publishStateChange → yoga PubSub subscriber receives descriptor", async () => {
-      module TestBus = LocalBus.Make()
-
-      // Wire the bridge before subscribing, so the bus callback publishes to the PubSub.
-      LocalGraphQL_SubscriptionResolvers.bridgeSourceB(
-        ~subscribeToStateChanges=TestBus.subscribeToStateChanges,
-        ~readModelName="Product",
-        ~returnTypeName="CatalogProduct",
-      )
-
-      // Start the consumer BEFORE publishing — yoga's PubSub drops messages
-      // on topics whose AsyncIterable listener isn't registered yet.
-      let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
-      let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogProduct_stateChanged")
-      let consumerPromise = startConsumer(iter, 1000)
-      await yieldTick() // ensure listener is registered before publish
-
-      // Bus payload is the change descriptor matching the AWS StateTopic Lambda
-      // output shape: {changeKind, id, sortKeyValue?, seq, state?}.
-      let state = JSON.Encode.object(
-        Dict.fromArray([
-          ("id", JSON.Encode.string("prod-1")),
-          ("name", JSON.Encode.string("Widget")),
-          ("updatedAt", JSON.Encode.string("2026-05-19T12:00:00Z")),
-        ]),
-      )
-      let descriptor = LocalStateChangeDescriptor.make(
-        ~changeKind="Updated",
-        ~id="prod-1",
-        ~state=Some(state),
-        ~seq=LocalStateChangeDescriptor.nextSequence(),
-      )
-      TestBus.publishStateChange(~name="Product", ~descriptor)
-
-      let received = await consumerPromise
-      switch received->Null.toOption {
-      | Some(msg) => expect(msg)->toEqual(descriptor)
-      | None => expect("onCatalogProduct_stateChanged: timed out")->toBe("received")
-      }
-    })
-
-    testPromise("state change for unregistered ReadModel → no publish", async () => {
-      module TestBus = LocalBus.Make()
-
-      LocalGraphQL_SubscriptionResolvers.bridgeSourceB(
-        ~subscribeToStateChanges=TestBus.subscribeToStateChanges,
-        ~readModelName="Product",
-        ~returnTypeName="CatalogProduct",
-      )
-
-      let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
-      let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogProduct_stateChanged")
-      let consumerPromise = startConsumer(iter, 300)
-      await yieldTick()
-
-      // Publish for a DIFFERENT ReadModel — should NOT reach our topic.
-      let foreignDescriptor = LocalStateChangeDescriptor.make(
-        ~changeKind="Updated",
-        ~id="cat-1",
-        ~state=Some(JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("cat-1"))]))),
-        ~seq=LocalStateChangeDescriptor.nextSequence(),
-      )
-      TestBus.publishStateChange(~name="Category", ~descriptor=foreignDescriptor)
-
-      let received = await consumerPromise
-      expect(received->Null.toOption)->toEqual(None)
-    })
+    testPromise(
+      "Bus.publishStateChange → yoga PubSub subscriber receives descriptor",
+      async () => {
+        module TestBus = LocalBus.Make()
+
+        // Wire the bridge before subscribing, so the bus callback publishes to the PubSub.
+        LocalGraphQL_SubscriptionResolvers.bridgeSourceB(
+          ~subscribeToStateChanges=TestBus.subscribeToStateChanges,
+          ~readModelName="Product",
+          ~returnTypeName="CatalogProduct",
+        )
+
+        // Start the consumer BEFORE publishing — yoga's PubSub drops messages
+        // on topics whose AsyncIterable listener isn't registered yet.
+        let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
+        let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogProduct_stateChanged")
+        let consumerPromise = startConsumer(iter, 1000)
+        await yieldTick() // ensure listener is registered before publish
+
+        // Bus payload is the change descriptor matching the AWS StateTopic Lambda
+        // output shape: {changeKind, id, sortKeyValue?, seq, state?}.
+        let state = JSON.Encode.object(
+          Dict.fromArray([
+            ("id", JSON.Encode.string("prod-1")),
+            ("name", JSON.Encode.string("Widget")),
+            ("updatedAt", JSON.Encode.string("2026-05-19T12:00:00Z")),
+          ]),
+        )
+        let descriptor = LocalStateChangeDescriptor.make(
+          ~changeKind="Updated",
+          ~id="prod-1",
+          ~state=Some(state),
+          ~seq=LocalStateChangeDescriptor.nextSequence(),
+        )
+        TestBus.publishStateChange(~name="Product", ~descriptor)
+
+        let received = await consumerPromise
+        switch received->Null.toOption {
+        | Some(msg) => expect(msg)->toEqual(descriptor)
+        | None => expect("onCatalogProduct_stateChanged: timed out")->toBe("received")
+        }
+      },
+    )
+
+    testPromise(
+      "state change for unregistered ReadModel → no publish",
+      async () => {
+        module TestBus = LocalBus.Make()
+
+        LocalGraphQL_SubscriptionResolvers.bridgeSourceB(
+          ~subscribeToStateChanges=TestBus.subscribeToStateChanges,
+          ~readModelName="Product",
+          ~returnTypeName="CatalogProduct",
+        )
+
+        let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
+        let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogProduct_stateChanged")
+        let consumerPromise = startConsumer(iter, 300)
+        await yieldTick()
+
+        // Publish for a DIFFERENT ReadModel — should NOT reach our topic.
+        let foreignDescriptor = LocalStateChangeDescriptor.make(
+          ~changeKind="Updated",
+          ~id="cat-1",
+          ~state=Some(JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("cat-1"))]))),
+          ~seq=LocalStateChangeDescriptor.nextSequence(),
+        )
+        TestBus.publishStateChange(~name="Category", ~descriptor=foreignDescriptor)
+
+        let received = await consumerPromise
+        expect(received->Null.toOption)->toEqual(None)
+      },
+    )
   })
 
   describe("Source A — event-stream bridge", () => {
-    testPromise("Bus.publishEvent → yoga PubSub subscriber receives event", async () => {
-      module TestBus = LocalBus.Make()
-
-      LocalGraphQL_SubscriptionResolvers.bridgeSourceA(
-        ~subscribeToEvents=TestBus.subscribeToEvents,
-        ~displayName="Catalog",
-        ~busTopicName="catalog-events",
-      )
-
-      let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
-      let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogEventLog_eventAppended")
-      let consumerPromise = startConsumer(iter, 1000)
-      await yieldTick()
-
-      let event = JSON.Encode.object(
-        Dict.fromArray([
-          ("eventType", JSON.Encode.string("ProductAdded")),
-          ("id", JSON.Encode.string("prod-1")),
-          ("name", JSON.Encode.string("Widget")),
-        ]),
-      )
-      await TestBus.publishEvent("catalog-events", "svc", testMeta, event)
-
-      let received = await consumerPromise
-      switch received->Null.toOption {
-      | Some(msg) => expect(msg)->toEqual(event)
-      | None => expect("onCatalogEventLog_eventAppended: timed out")->toBe("received")
-      }
-    })
+    testPromise(
+      "Bus.publishEvent → yoga PubSub subscriber receives event",
+      async () => {
+        module TestBus = LocalBus.Make()
+
+        LocalGraphQL_SubscriptionResolvers.bridgeSourceA(
+          ~subscribeToEvents=TestBus.subscribeToEvents,
+          ~displayName="Catalog",
+          ~busTopicName="catalog-events",
+        )
+
+        let ps = LocalGraphQL_SubscriptionResolvers.getPubSub()
+        let iter = ps->GraphqlYoga.pubSubSubscribe("onCatalogEventLog_eventAppended")
+        let consumerPromise = startConsumer(iter, 1000)
+        await yieldTick()
+
+        let event = JSON.Encode.object(
+          Dict.fromArray([
+            ("eventType", JSON.Encode.string("ProductAdded")),
+            ("id", JSON.Encode.string("prod-1")),
+            ("name", JSON.Encode.string("Widget")),
+          ]),
+        )
+        await TestBus.publishEvent("catalog-events", "svc", testMeta, event)
+
+        let received = await consumerPromise
+        switch received->Null.toOption {
+        | Some(msg) => expect(msg)->toEqual(event)
+        | None => expect("onCatalogEventLog_eventAppended: timed out")->toBe("received")
+        }
+      },
+    )
   })
 })

package/tests/adapter/HeartbeatRunnerTest.res

@@ -31,9 +31,9 @@ let _ = afterAll(() => {
 // Helper: build a minimal runtime with a completed handler Deferred
 // ─────────────────────────────────────────────────────────────
 
-let makeRuntime = (
-  handler: LocalRuntimeEnvironment.handler,
-): ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> => {
+let makeRuntime = (handler: LocalRuntimeEnvironment.handler): ReventlessCore.Runtime.environment<
+  LocalHeartbeatRunner.runtimeParts,
+> => {
   let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
     Deferred.make()->Effect.runSync
   // Complete before any fiber waits — runSync is safe here
@@ -49,88 +49,106 @@ let makeRuntime = (
 
 describe("LocalHeartbeatRunner", () => {
   describe("make", () => {
-    testPromise("after advanceTimersByTime(timeout * 60 * 1000), handler is called", async () => {
-      let count: ref<int> = ref(0)
-      let runtime = makeRuntime(async (_, _) => {
-        count := count.contents + 1
-      })
-      let _runner = LocalHeartbeatRunner.make(
-        ~name="hb-test",
-        ~remoteChannel=Obj.magic(()),
-        ~timeout=1,
-        ~runtime,
-        ~opts={},
-      )
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      // Give the Effect.runPromise microtask one tick to complete
-      let _ = await Promise.resolve()
-      expect(count.contents)->toBe(1)
-      LocalHeartbeatRunner.reset()
-    })
+    testPromise(
+      "after advanceTimersByTime(timeout * 60 * 1000), handler is called",
+      async () => {
+        let count: ref<int> = ref(0)
+        let runtime = makeRuntime(
+          async (_, _) => {
+            count := count.contents + 1
+          },
+        )
+        let _runner = LocalHeartbeatRunner.make(
+          ~name="hb-test",
+          ~remoteChannel=Obj.magic(),
+          ~timeout=1,
+          ~runtime,
+          ~opts={},
+        )
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        // Give the Effect.runPromise microtask one tick to complete
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(1)
+        LocalHeartbeatRunner.reset()
+      },
+    )
 
-    testPromise("handler fires again on each subsequent interval", async () => {
-      let count: ref<int> = ref(0)
-      let runtime = makeRuntime(async (_, _) => {
-        count := count.contents + 1
-      })
-      let _runner = LocalHeartbeatRunner.make(
-        ~name="hb-test-2",
-        ~remoteChannel=Obj.magic(()),
-        ~timeout=2,
-        ~runtime,
-        ~opts={},
-      )
-      jest->advanceTimersByTime(2 * 60 * 1000)
-      let _ = await Promise.resolve()
-      jest->advanceTimersByTime(2 * 60 * 1000)
-      let _ = await Promise.resolve()
-      expect(count.contents)->toBe(2)
-      LocalHeartbeatRunner.reset()
-    })
+    testPromise(
+      "handler fires again on each subsequent interval",
+      async () => {
+        let count: ref<int> = ref(0)
+        let runtime = makeRuntime(
+          async (_, _) => {
+            count := count.contents + 1
+          },
+        )
+        let _runner = LocalHeartbeatRunner.make(
+          ~name="hb-test-2",
+          ~remoteChannel=Obj.magic(),
+          ~timeout=2,
+          ~runtime,
+          ~opts={},
+        )
+        jest->advanceTimersByTime(2 * 60 * 1000)
+        let _ = await Promise.resolve()
+        jest->advanceTimersByTime(2 * 60 * 1000)
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(2)
+        LocalHeartbeatRunner.reset()
+      },
+    )
 
-    testPromise("unresolved Deferred does not crash when interval fires", async () => {
-      // Deferred intentionally left incomplete — simulates handler not yet registered.
-      // Effect.runPromise stays pending (no crash); test verifies no exception.
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
-        parts: {
-          handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      let _runner = LocalHeartbeatRunner.make(
-        ~name="hb-no-handler",
-        ~remoteChannel=Obj.magic(()),
-        ~timeout=1,
-        ~runtime,
-        ~opts={},
-      )
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      expect(true)->toBe(true)
-      LocalHeartbeatRunner.reset()
-      // Complete the Deferred to avoid open handle — interval is already cleared
-      Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
-    })
+    testPromise(
+      "unresolved Deferred does not crash when interval fires",
+      async () => {
+        // Deferred intentionally left incomplete — simulates handler not yet registered.
+        // Effect.runPromise stays pending (no crash); test verifies no exception.
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        let _runner = LocalHeartbeatRunner.make(
+          ~name="hb-no-handler",
+          ~remoteChannel=Obj.magic(),
+          ~timeout=1,
+          ~runtime,
+          ~opts={},
+        )
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        expect(true)->toBe(true)
+        LocalHeartbeatRunner.reset()
+        // Complete the Deferred to avoid open handle — interval is already cleared
+        Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
+      },
+    )
   })
 
   describe("reset", () => {
-    testPromise("clears all intervals; subsequent advance does not fire handler", async () => {
-      let count: ref<int> = ref(0)
-      let runtime = makeRuntime(async (_, _) => {
-        count := count.contents + 1
-      })
-      let _runner = LocalHeartbeatRunner.make(
-        ~name="hb-reset",
-        ~remoteChannel=Obj.magic(()),
-        ~timeout=1,
-        ~runtime,
-        ~opts={},
-      )
-      LocalHeartbeatRunner.reset()
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      expect(count.contents)->toBe(0)
-    })
+    testPromise(
+      "clears all intervals; subsequent advance does not fire handler",
+      async () => {
+        let count: ref<int> = ref(0)
+        let runtime = makeRuntime(
+          async (_, _) => {
+            count := count.contents + 1
+          },
+        )
+        let _runner = LocalHeartbeatRunner.make(
+          ~name="hb-reset",
+          ~remoteChannel=Obj.magic(),
+          ~timeout=1,
+          ~runtime,
+          ~opts={},
+        )
+        LocalHeartbeatRunner.reset()
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        expect(count.contents)->toBe(0)
+      },
+    )
   })
 })

package/tests/adapter/InboundTranslationMutationTest.res

@@ -68,7 +68,10 @@ let payload = (result: GraphqlYoga.executionResult): JSON.t =>
   ->Option.getOr(JSON.Encode.null)
 
 let str = (node: JSON.t, key: string): option<string> =>
-  node->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+  node
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(key))
+  ->Option.flatMap(JSON.Decode.string)
 
 let num = (node: JSON.t, key: string): option<float> =>
   node->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.float)

package/tests/adapter/LocalAuthHttpTest.res

@@ -40,33 +40,34 @@ type httpRes
 let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
   Promise.make((resolve, reject) => {
     let bodyStr = body->JSON.Encode.object->JSON.stringify
-    let req =
-      _request(
-        {
-          hostname: "localhost",
-          port,
-          path,
-          method: "POST",
-          headers: Dict.fromArray([
-            ("content-type", "application/json"),
-            ("content-length", bodyStr->String.length->Int.toString),
-          ]),
-        },
-        res => {
-          let status = _resStatusCode(res)
-          let buf = ref("")
-          res->_resSetEncoding("utf8")
-          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
-          res->_resOnEnd(() => {
+    let req = _request(
+      {
+        hostname: "localhost",
+        port,
+        path,
+        method: "POST",
+        headers: Dict.fromArray([
+          ("content-type", "application/json"),
+          ("content-length", bodyStr->String.length->Int.toString),
+        ]),
+      },
+      res => {
+        let status = _resStatusCode(res)
+        let buf = ref("")
+        res->_resSetEncoding("utf8")
+        res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+        res->_resOnEnd(
+          () => {
             let parsed = try {
               buf.contents->JSON.parseOrThrow
             } catch {
             | _ => JSON.Encode.null
             }
             resolve((status, parsed))
-          })
-        },
-      )
+          },
+        )
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqWrite(bodyStr)
     req->_reqEnd
@@ -74,40 +75,38 @@ let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
 
 let postEmpty = (path: string): promise<int> =>
   Promise.make((resolve, reject) => {
-    let req =
-      _request(
-        {hostname: "localhost", port, path, method: "POST", headers: Dict.make()},
-        res => {
-          let status = _resStatusCode(res)
-          // Drain (otherwise the socket may stay open under HTTP keep-alive).
-          res->_resOnData(_ => ())
-          res->_resOnEnd(() => resolve(status))
-        },
-      )
+    let req = _request(
+      {hostname: "localhost", port, path, method: "POST", headers: Dict.make()},
+      res => {
+        let status = _resStatusCode(res)
+        // Drain (otherwise the socket may stay open under HTTP keep-alive).
+        res->_resOnData(_ => ())
+        res->_resOnEnd(() => resolve(status))
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqEnd
   })
 
 let postRaw = (path: string, body: string): promise<int> =>
   Promise.make((resolve, reject) => {
-    let req =
-      _request(
-        {
-          hostname: "localhost",
-          port,
-          path,
-          method: "POST",
-          headers: Dict.fromArray([
-            ("content-type", "application/json"),
-            ("content-length", body->String.length->Int.toString),
-          ]),
-        },
-        res => {
-          let status = _resStatusCode(res)
-          res->_resOnData(_ => ())
-          res->_resOnEnd(() => resolve(status))
-        },
-      )
+    let req = _request(
+      {
+        hostname: "localhost",
+        port,
+        path,
+        method: "POST",
+        headers: Dict.fromArray([
+          ("content-type", "application/json"),
+          ("content-length", body->String.length->Int.toString),
+        ]),
+      },
+      res => {
+        let status = _resStatusCode(res)
+        res->_resOnData(_ => ())
+        res->_resOnEnd(() => resolve(status))
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqWrite(body)
     req->_reqEnd
@@ -148,14 +147,13 @@ afterAll(() => {
 // ── Tests ──────────────────────────────────────────────────────────────────
 
 testPromise("POST /__inmemory/login returns {token, identity} for valid credentials", async () => {
-  let (status, body) =
-    await postJson(
-      "/__inmemory/login",
-      Dict.fromArray([
-        ("username", JSON.Encode.string("alice")),
-        ("password", JSON.Encode.string("alice-pw")),
-      ]),
-    )
+  let (status, body) = await postJson(
+    "/__inmemory/login",
+    Dict.fromArray([
+      ("username", JSON.Encode.string("alice")),
+      ("password", JSON.Encode.string("alice-pw")),
+    ]),
+  )
   expect(status)->toEqual(200)
   let token = getString(body, "token")
   expect(token->String.length > 0)->toEqual(true)
@@ -171,27 +169,25 @@ testPromise("POST /__inmemory/login returns {token, identity} for valid credenti
 })
 
 testPromise("POST /__inmemory/login returns 401 for wrong password", async () => {
-  let (status, body) =
-    await postJson(
-      "/__inmemory/login",
-      Dict.fromArray([
-        ("username", JSON.Encode.string("alice")),
-        ("password", JSON.Encode.string("WRONG")),
-      ]),
-    )
+  let (status, body) = await postJson(
+    "/__inmemory/login",
+    Dict.fromArray([
+      ("username", JSON.Encode.string("alice")),
+      ("password", JSON.Encode.string("WRONG")),
+    ]),
+  )
   expect(status)->toEqual(401)
   expect(getString(body, "error")->String.length > 0)->toEqual(true)
 })
 
 testPromise("POST /__inmemory/login returns 401 for missing user", async () => {
-  let (status, _) =
-    await postJson(
-      "/__inmemory/login",
-      Dict.fromArray([
-        ("username", JSON.Encode.string("ghost")),
-        ("password", JSON.Encode.string("x")),
-      ]),
-    )
+  let (status, _) = await postJson(
+    "/__inmemory/login",
+    Dict.fromArray([
+      ("username", JSON.Encode.string("ghost")),
+      ("password", JSON.Encode.string("x")),
+    ]),
+  )
   expect(status)->toEqual(401)
 })
 
@@ -206,19 +202,17 @@ testPromise("POST /__inmemory/logout always returns 204", async () => {
 })
 
 testPromise("Bearer token issued via HTTP round-trips through authenticate", async () => {
-  let (_, body) =
-    await postJson(
-      "/__inmemory/login",
-      Dict.fromArray([
-        ("username", JSON.Encode.string("alice")),
-        ("password", JSON.Encode.string("alice-pw")),
-      ]),
-    )
+  let (_, body) = await postJson(
+    "/__inmemory/login",
+    Dict.fromArray([
+      ("username", JSON.Encode.string("alice")),
+      ("password", JSON.Encode.string("alice-pw")),
+    ]),
+  )
   let token = getString(body, "token")
-  let result =
-    await LocalAuth.authenticate({
-      headers: Dict.fromArray([("authorization", "Bearer " ++ token)]),
-    })
+  let result = await LocalAuth.authenticate({
+    headers: Dict.fromArray([("authorization", "Bearer " ++ token)]),
+  })
   switch result {
   | Authenticated(identity) =>
     expect(identity.username)->toEqual("alice")