@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/GraphQL_SubscriptionResolversTest.res

@@ -0,0 +1,161 @@
+// Integration test: Bus events + QueryDb writes → yoga PubSub → subscription delivery.
+//
+// Phase 6 verification (Sources A and B).
+// Source C (mutation-triggered) is not covered: in-memory mutation resolvers would
+// need to cross-publish to the subscription PubSub, which is future work.
+//
+// The test subscribes to the yoga PubSub topic directly (rather than going through
+// a real WebSocket connection) — this validates the bus→PubSub bridge, which is the
+// integration Reventless owns. yoga's own graphql-ws transport is framework territory.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+// AsyncIterable.next() binding. yoga's PubSub returns `{value: JSON.t, done: bool}`.
+type asyncIterResult = {value: JSON.t, done: bool}
+@send external iterNext: 'a => promise<asyncIterResult> = "next"
+
+@val external setTimeout: (unit => unit, int) => int = "setTimeout"
+
+// Start consuming an AsyncIterable eagerly so its listener registers before
+// the publisher fires. Returns a Promise resolving to the first message
+// (or null on timeout / iterator close / error). yoga's Repeater-based
+// AsyncIterable registers its push callback lazily on first next() — so this
+// must be called (and then yieldTick awaited) before publishing.
+let startConsumer = (iter: 'iter, timeoutMs: int): promise<Null.t<JSON.t>> => {
+  let timeoutP = Promise.make((resolve, _) => {
+    let _: int = setTimeout(() => resolve(Null.null), timeoutMs)
+  })
+  let consumeP = async () =>
+    try {
+      let result = await iter->iterNext
+      result.done ? Null.null : result.value->Null.make
+    } catch {
+    | _ => Null.null
+    }
+  Promise.race([timeoutP, consumeP()])
+}
+
+// Yield one macrotask so the consumer above has registered its push listener.
+let yieldTick = (): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _: int = setTimeout(() => resolve(), 10)
+  })
+
+let testMeta: ReventlessCore.Message.meta = {
+  service: "test",
+  time: "2025-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1",
+}
+
+describe("LocalGraphQL_SubscriptionResolvers", () => {
+  beforeEach(() => {
+    LocalGraphQL_SubscriptionResolvers.reset()
+  })
+
+  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 now the change descriptor (Phase 8) matching the
+      // AWS StateTopic Lambda output shape: {changeKind, id, sortKeyValue?}.
+      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 = LocalBus.makeStateChangeDescriptor(
+        ~changeKind="Updated",
+        ~id="prod-1",
+        ~state=Some(state),
+      )
+      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 = LocalBus.makeStateChangeDescriptor(
+        ~changeKind="Updated",
+        ~id="cat-1",
+        ~state=Some(JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("cat-1"))]))),
+      )
+      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")
+      }
+    })
+  })
+})

package/tests/adapter/GraphQL_SubscriptionResolversTest.res.mjs

@@ -0,0 +1,134 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalGraphQL_SubscriptionResolvers$ReventlessLocal from "../../src/adapter/Api/LocalGraphQL_SubscriptionResolvers.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+function startConsumer(iter, timeoutMs) {
+  let timeoutP = new Promise((resolve, param) => {
+    setTimeout(() => resolve(null), timeoutMs);
+  });
+  let consumeP = async () => {
+    try {
+      let result = await iter.next();
+      if (result.done) {
+        return null;
+      } else {
+        return result.value;
+      }
+    } catch (exn) {
+      return null;
+    }
+  };
+  return Promise.race([
+    timeoutP,
+    consumeP()
+  ]);
+}
+
+function yieldTick() {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 10);
+  });
+}
+
+let testMeta = {
+  service: "test",
+  time: "2025-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1"
+};
+
+globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
+  globalThis.beforeEach(() => LocalGraphQL_SubscriptionResolvers$ReventlessLocal.reset());
+  globalThis.describe("Source B — state-change bridge", () => {
+    globalThis.test("Bus.publishStateChange → yoga PubSub subscriber receives descriptor", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      LocalGraphQL_SubscriptionResolvers$ReventlessLocal.bridgeSourceB(TestBus.subscribeToStateChanges, "Product", "CatalogProduct");
+      let ps = LocalGraphQL_SubscriptionResolvers$ReventlessLocal.getPubSub();
+      let iter = ps.subscribe("onCatalogProduct_stateChanged");
+      let consumerPromise = startConsumer(iter, 1000);
+      await yieldTick();
+      let state = Object.fromEntries([
+        [
+          "id",
+          "prod-1"
+        ],
+        [
+          "name",
+          "Widget"
+        ],
+        [
+          "updatedAt",
+          "2026-05-19T12:00:00Z"
+        ]
+      ]);
+      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "prod-1", state);
+      TestBus.publishStateChange("Product", descriptor);
+      let received = await consumerPromise;
+      if (received !== null) {
+        globalThis.expect(received).toEqual(descriptor);
+      } else {
+        globalThis.expect("onCatalogProduct_stateChanged: timed out").toBe("received");
+      }
+    });
+    globalThis.test("state change for unregistered ReadModel → no publish", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      LocalGraphQL_SubscriptionResolvers$ReventlessLocal.bridgeSourceB(TestBus.subscribeToStateChanges, "Product", "CatalogProduct");
+      let ps = LocalGraphQL_SubscriptionResolvers$ReventlessLocal.getPubSub();
+      let iter = ps.subscribe("onCatalogProduct_stateChanged");
+      let consumerPromise = startConsumer(iter, 300);
+      await yieldTick();
+      let foreignDescriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "cat-1", Object.fromEntries([[
+          "id",
+          "cat-1"
+        ]]));
+      TestBus.publishStateChange("Category", foreignDescriptor);
+      let received = await consumerPromise;
+      globalThis.expect(received === null ? undefined : Primitive_option.some(received)).toEqual(undefined);
+    });
+  });
+  globalThis.describe("Source A — event-stream bridge", () => {
+    globalThis.test("Bus.publishEvent → yoga PubSub subscriber receives event", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      LocalGraphQL_SubscriptionResolvers$ReventlessLocal.bridgeSourceA(TestBus.subscribeToEvents, "Catalog", "catalog-events");
+      let ps = LocalGraphQL_SubscriptionResolvers$ReventlessLocal.getPubSub();
+      let iter = ps.subscribe("onCatalogEventLog_eventAppended");
+      let consumerPromise = startConsumer(iter, 1000);
+      await yieldTick();
+      let event = Object.fromEntries([
+        [
+          "eventType",
+          "ProductAdded"
+        ],
+        [
+          "id",
+          "prod-1"
+        ],
+        [
+          "name",
+          "Widget"
+        ]
+      ]);
+      await TestBus.publishEvent("catalog-events", "svc", testMeta, event);
+      let received = await consumerPromise;
+      if (received !== null) {
+        globalThis.expect(received).toEqual(event);
+      } else {
+        globalThis.expect("onCatalogEventLog_eventAppended: timed out").toBe("received");
+      }
+    });
+  });
+});
+
+export {
+  startConsumer,
+  yieldTick,
+  testMeta,
+}
+/*  Not a pure module */

package/tests/adapter/HeartbeatRunnerTest.res

@@ -0,0 +1,136 @@
+// Unit tests for LocalHeartbeatRunner.
+// Uses fake timers to verify that the heartbeat interval fires the runtime handler.
+
+open JestGlobals
+
+// ─────────────────────────────────────────────────────────────
+// Fake timer bindings
+// ─────────────────────────────────────────────────────────────
+
+type jestObj
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: jestObj => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external advanceTimersByTime: (jestObj, int) => unit = "advanceTimersByTime"
+
+// In Jest ESM mode, jest global is only available inside callbacks (not at module top level).
+let _ = beforeAll(() => {
+  jest->useFakeTimers
+})
+
+// ─────────────────────────────────────────────────────────────
+// Restore real timers and clear heartbeat intervals after all tests
+// ─────────────────────────────────────────────────────────────
+
+let _ = afterAll(() => {
+  LocalHeartbeatRunner.reset()
+  jest->useRealTimers
+})
+
+// ─────────────────────────────────────────────────────────────
+// Helper: build a minimal runtime with a completed handler Deferred
+// ─────────────────────────────────────────────────────────────
+
+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
+  Deferred.succeed(handlerDeferred, handler)->Effect.runSync->ignore
+  {
+    parts: {
+      handlerDeferred,
+      subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+    },
+    resources: [],
+  }
+}
+
+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("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
+    })
+  })
+
+  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)
+    })
+  })
+})

package/tests/adapter/HeartbeatRunnerTest.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as LocalHeartbeatRunner$ReventlessLocal from "../../src/adapter/Heartbeat/LocalHeartbeatRunner.res.mjs";
+
+globalThis.beforeAll(() => {
+  Globals.jest.useFakeTimers();
+});
+
+globalThis.afterAll(() => {
+  LocalHeartbeatRunner$ReventlessLocal.reset();
+  Globals.jest.useRealTimers();
+});
+
+function makeRuntime(handler) {
+  let handlerDeferred = Effect.runSync(Deferred.make());
+  Effect.runSync(Deferred.succeed(handlerDeferred, handler));
+  return {
+    parts: {
+      handlerDeferred: handlerDeferred,
+      subscriptionLatch: Effect.runSync(Effect.makeLatch(false))
+    },
+    resources: []
+  };
+}
+
+globalThis.describe("LocalHeartbeatRunner", () => {
+  globalThis.describe("make", () => {
+    globalThis.test("after advanceTimersByTime(timeout * 60 * 1000), handler is called", async () => {
+      let count = {
+        contents: 0
+      };
+      let runtime = makeRuntime(async (param, param$1) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      LocalHeartbeatRunner$ReventlessLocal.make("hb-test", undefined, 1, runtime, {});
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(1);
+      return LocalHeartbeatRunner$ReventlessLocal.reset();
+    });
+    globalThis.test("handler fires again on each subsequent interval", async () => {
+      let count = {
+        contents: 0
+      };
+      let runtime = makeRuntime(async (param, param$1) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      LocalHeartbeatRunner$ReventlessLocal.make("hb-test-2", undefined, 2, runtime, {});
+      Globals.jest.advanceTimersByTime(120000);
+      await Promise.resolve();
+      Globals.jest.advanceTimersByTime(120000);
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(2);
+      return LocalHeartbeatRunner$ReventlessLocal.reset();
+    });
+    globalThis.test("unresolved Deferred does not crash when interval fires", async () => {
+      let handlerDeferred = Effect.runSync(Deferred.make());
+      let runtime_parts = {
+        handlerDeferred: handlerDeferred,
+        subscriptionLatch: Effect.runSync(Effect.makeLatch(false))
+      };
+      let runtime_resources = [];
+      let runtime = {
+        parts: runtime_parts,
+        resources: runtime_resources
+      };
+      LocalHeartbeatRunner$ReventlessLocal.make("hb-no-handler", undefined, 1, runtime, {});
+      Globals.jest.advanceTimersByTime(60000);
+      globalThis.expect(true).toBe(true);
+      LocalHeartbeatRunner$ReventlessLocal.reset();
+      Effect.runSync(Deferred.succeed(handlerDeferred, async (param, param$1) => {}));
+    });
+  });
+  globalThis.describe("reset", () => {
+    globalThis.test("clears all intervals; subsequent advance does not fire handler", async () => {
+      let count = {
+        contents: 0
+      };
+      let runtime = makeRuntime(async (param, param$1) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      LocalHeartbeatRunner$ReventlessLocal.make("hb-reset", undefined, 1, runtime, {});
+      LocalHeartbeatRunner$ReventlessLocal.reset();
+      Globals.jest.advanceTimersByTime(60000);
+      globalThis.expect(count.contents).toBe(0);
+    });
+  });
+});
+
+export {
+  makeRuntime,
+}
+/*  Not a pure module */