@reventlessdev/reventless-local 3.0.0-alpha.174 → 3.0.0-alpha.175

package/tests/adapter/LocalEvents_ServerTest.res

@@ -0,0 +1,200 @@
+// LocalEvents_Server protocol tests — socket-free.
+//
+// A `connection` is just a capturing `send` callback + subscription dict, so
+// the AppSync Events frame handling, wildcard matching, LocalBus bridge and
+// the publish route are all driven without a WebSocket. The ws attach glue is
+// the only part not covered here (framework territory + a real socket).
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let sentFrames: ref<array<string>> = ref([])
+
+let makeConn = () => {
+  sentFrames := []
+  LocalEvents_Server.addConnection(~send=f => sentFrames.contents->Array.push(f))
+}
+
+let parseFrame = (s: string): dict<JSON.t> =>
+  s->JSON.parseOrThrow->JSON.Decode.object->Option.getOr(Dict.make())
+
+let frameField = (s: string, field: string): option<string> =>
+  parseFrame(s)->Dict.get(field)->Option.flatMap(JSON.Decode.string)
+
+let descriptor = (~id: string): JSON.t =>
+  Dict.fromArray([
+    ("changeKind", JSON.Encode.string("Updated")),
+    ("id", JSON.Encode.string(id)),
+    ("sortKeyValue", JSON.Encode.string("2026-07-28T00:00:00Z")),
+  ])->JSON.Encode.object
+
+describe("LocalEvents_Server", () => {
+  beforeEach(() => LocalEvents_Server.resetConnections())
+
+  describe("channelMatches", () => {
+    testSync("exact match", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/p-1",
+          ~channel="/default/Product/p-1",
+        ),
+      )->toBe(true)
+    })
+    testSync("wildcard prefix matches any depth", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/*",
+          ~channel="/default/Product/p-1",
+        ),
+      )->toBe(true)
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/*",
+          ~channel="/default/Product/p-1/deep",
+        ),
+      )->toBe(true)
+    })
+    testSync("wildcard does not match a sibling with the same stem", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/*",
+          ~channel="/default/ProductArchive/p-1",
+        ),
+      )->toBe(false)
+    })
+    testSync("non-wildcard mismatch", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/p-1",
+          ~channel="/default/Product/p-2",
+        ),
+      )->toBe(false)
+    })
+  })
+
+  describe("subscribe protocol", () => {
+    testSync("connection_init is answered with connection_ack", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(conn, `{"type":"connection_init"}`)
+      expect(sentFrames.contents->Array.length)->toBe(1)
+      expect(sentFrames.contents->Array.getUnsafe(0)->frameField("type"))->toEqual(
+        Some("connection_ack"),
+      )
+    })
+
+    testSync("subscribe → state change → data frame on the subscription id", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`,
+      )
+      expect(sentFrames.contents->Array.getUnsafe(0)->frameField("type"))->toEqual(
+        Some("subscribe_success"),
+      )
+      LocalEvents_Server.broadcastStateChange(~name="Product", ~descriptor=descriptor(~id="p-1"))
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      let data = sentFrames.contents->Array.getUnsafe(1)
+      expect(data->frameField("type"))->toEqual(Some("data"))
+      expect(data->frameField("id"))->toEqual(Some("sub-1"))
+      // `event` is a stringified JSON payload — parse the string to verify.
+      let event =
+        data->frameField("event")->Option.getOr("")->JSON.parseOrThrow->JSON.Decode.object
+      expect(
+        event->Option.flatMap(o => o->Dict.get("id"))->Option.flatMap(JSON.Decode.string),
+      )->toEqual(Some("p-1"))
+    })
+
+    testSync("channel segments are normalized like the AWS publisher", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"s","channel":"/default/My-Model/order-1-2026"}`,
+      )
+      // Read-model name `My.Model` and entity key `order#1@2026` normalize to
+      // the subscribed channel (`[^A-Za-z0-9-]` → `-`).
+      LocalEvents_Server.broadcastStateChange(
+        ~name="My.Model",
+        ~descriptor=descriptor(~id="order#1@2026"),
+      )
+      expect(sentFrames.contents->Array.length)->toBe(2)
+    })
+
+    testSync("unsubscribe stops delivery", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`,
+      )
+      LocalEvents_Server.handleFrame(conn, `{"type":"unsubscribe","id":"sub-1"}`)
+      LocalEvents_Server.broadcastStateChange(~name="Product", ~descriptor=descriptor(~id="p-1"))
+      // subscribe_success + unsubscribe_success, but no data frame
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      expect(sentFrames.contents->Array.getUnsafe(1)->frameField("type"))->toEqual(
+        Some("unsubscribe_success"),
+      )
+    })
+
+    testSync("malformed and unknown frames are ignored", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(conn, `not json`)
+      LocalEvents_Server.handleFrame(conn, `{"type":"mystery"}`)
+      LocalEvents_Server.handleFrame(conn, `{"type":"subscribe","id":"only-id"}`)
+      expect(sentFrames.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("handlePublish", () => {
+    testSync("rejects non-client channels with 403", () => {
+      let (status, _) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/default/Product/p-1","events":["{}"]}`,
+      )
+      expect(status)->toBe(403)
+    })
+
+    testSync("rejects an unverifiable token with 401", () => {
+      let (status, _) = LocalEvents_Server.handlePublish(
+        ~authorization=Some("garbage-token"),
+        ~body=`{"channel":"/client/x","events":["{}"]}`,
+      )
+      expect(status)->toBe(401)
+    })
+
+    testSync("rejects malformed bodies with 400", () => {
+      let (s1, _) = LocalEvents_Server.handlePublish(~authorization=None, ~body=`nope`)
+      let (s2, _) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/client/x","events":[]}`,
+      )
+      expect(s1)->toBe(400)
+      expect(s2)->toBe(400)
+    })
+
+    testSync("fans out to a wildcard subscriber and accounts per event", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-p","channel":"/client/shop/presence/*"}`,
+      )
+      let (status, response) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/client/shop/presence/room-1","events":["{\\"userId\\":\\"u1\\"}","not json",42]}`,
+      )
+      expect(status)->toBe(200)
+      let counts =
+        response
+        ->JSON.Decode.object
+        ->Option.map(o => (
+          o->Dict.get("successful")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length,
+          o->Dict.get("failed")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length,
+        ))
+      expect(counts)->toEqual(Some((1, 2)))
+      // subscribe_success + one data frame for the one valid event
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      let data = sentFrames.contents->Array.getUnsafe(1)
+      expect(data->frameField("id"))->toEqual(Some("sub-p"))
+      expect(data->frameField("event"))->toEqual(Some(`{"userId":"u1"}`))
+    })
+  })
+})

package/tests/adapter/LocalEvents_ServerTest.res.mjs

@@ -0,0 +1,147 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalEvents_Server$ReventlessLocal from "../../src/adapter/Api/LocalEvents_Server.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let sentFrames = {
+  contents: []
+};
+
+function makeConn() {
+  sentFrames.contents = [];
+  return LocalEvents_Server$ReventlessLocal.addConnection(f => {
+    sentFrames.contents.push(f);
+  });
+}
+
+function parseFrame(s) {
+  return Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(s)), {});
+}
+
+function frameField(s, field) {
+  return Stdlib_Option.flatMap(parseFrame(s)[field], Stdlib_JSON.Decode.string);
+}
+
+function descriptor(id) {
+  return Object.fromEntries([
+    [
+      "changeKind",
+      "Updated"
+    ],
+    [
+      "id",
+      id
+    ],
+    [
+      "sortKeyValue",
+      "2026-07-28T00:00:00Z"
+    ]
+  ]);
+}
+
+globalThis.describe("LocalEvents_Server", () => {
+  globalThis.beforeEach(() => LocalEvents_Server$ReventlessLocal.resetConnections());
+  globalThis.describe("channelMatches", () => {
+    globalThis.test("exact match", () => {
+      globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/Product/p-1", "/default/Product/p-1")).toBe(true);
+    });
+    globalThis.test("wildcard prefix matches any depth", () => {
+      globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/Product/*", "/default/Product/p-1")).toBe(true);
+      globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/*", "/default/Product/p-1/deep")).toBe(true);
+    });
+    globalThis.test("wildcard does not match a sibling with the same stem", () => {
+      globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/Product/*", "/default/ProductArchive/p-1")).toBe(false);
+    });
+    globalThis.test("non-wildcard mismatch", () => {
+      globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/Product/p-1", "/default/Product/p-2")).toBe(false);
+    });
+  });
+  globalThis.describe("subscribe protocol", () => {
+    globalThis.test("connection_init is answered with connection_ack", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"connection_init"}`);
+      globalThis.expect(sentFrames.contents.length).toBe(1);
+      globalThis.expect(frameField(sentFrames.contents[0], "type")).toEqual("connection_ack");
+    });
+    globalThis.test("subscribe → state change → data frame on the subscription id", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`);
+      globalThis.expect(frameField(sentFrames.contents[0], "type")).toEqual("subscribe_success");
+      LocalEvents_Server$ReventlessLocal.broadcastStateChange("Product", descriptor("p-1"));
+      globalThis.expect(sentFrames.contents.length).toBe(2);
+      let data = sentFrames.contents[1];
+      globalThis.expect(frameField(data, "type")).toEqual("data");
+      globalThis.expect(frameField(data, "id")).toEqual("sub-1");
+      let event = Stdlib_JSON.Decode.object(JSON.parse(Stdlib_Option.getOr(frameField(data, "event"), "")));
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(event, o => o["id"]), Stdlib_JSON.Decode.string)).toEqual("p-1");
+    });
+    globalThis.test("channel segments are normalized like the AWS publisher", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"s","channel":"/default/My-Model/order-1-2026"}`);
+      LocalEvents_Server$ReventlessLocal.broadcastStateChange("My.Model", descriptor("order#1@2026"));
+      globalThis.expect(sentFrames.contents.length).toBe(2);
+    });
+    globalThis.test("unsubscribe stops delivery", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`);
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"unsubscribe","id":"sub-1"}`);
+      LocalEvents_Server$ReventlessLocal.broadcastStateChange("Product", descriptor("p-1"));
+      globalThis.expect(sentFrames.contents.length).toBe(2);
+      globalThis.expect(frameField(sentFrames.contents[1], "type")).toEqual("unsubscribe_success");
+    });
+    globalThis.test("malformed and unknown frames are ignored", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `not json`);
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"mystery"}`);
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"only-id"}`);
+      globalThis.expect(sentFrames.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("handlePublish", () => {
+    globalThis.test("rejects non-client channels with 403", () => {
+      let match = LocalEvents_Server$ReventlessLocal.handlePublish(undefined, `{"channel":"/default/Product/p-1","events":["{}"]}`);
+      globalThis.expect(match[0]).toBe(403);
+    });
+    globalThis.test("rejects an unverifiable token with 401", () => {
+      let match = LocalEvents_Server$ReventlessLocal.handlePublish("garbage-token", `{"channel":"/client/x","events":["{}"]}`);
+      globalThis.expect(match[0]).toBe(401);
+    });
+    globalThis.test("rejects malformed bodies with 400", () => {
+      let match = LocalEvents_Server$ReventlessLocal.handlePublish(undefined, `nope`);
+      let match$1 = LocalEvents_Server$ReventlessLocal.handlePublish(undefined, `{"channel":"/client/x","events":[]}`);
+      globalThis.expect(match[0]).toBe(400);
+      globalThis.expect(match$1[0]).toBe(400);
+    });
+    globalThis.test("fans out to a wildcard subscriber and accounts per event", () => {
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"sub-p","channel":"/client/shop/presence/*"}`);
+      let match = LocalEvents_Server$ReventlessLocal.handlePublish(undefined, `{"channel":"/client/shop/presence/room-1","events":["{\\"userId\\":\\"u1\\"}","not json",42]}`);
+      globalThis.expect(match[0]).toBe(200);
+      let counts = Stdlib_Option.map(Stdlib_JSON.Decode.object(match[1]), o => [
+        Stdlib_Option.getOr(Stdlib_Option.flatMap(o["successful"], Stdlib_JSON.Decode.array), []).length,
+        Stdlib_Option.getOr(Stdlib_Option.flatMap(o["failed"], Stdlib_JSON.Decode.array), []).length
+      ]);
+      globalThis.expect(counts).toEqual([
+        1,
+        2
+      ]);
+      globalThis.expect(sentFrames.contents.length).toBe(2);
+      let data = sentFrames.contents[1];
+      globalThis.expect(frameField(data, "id")).toEqual("sub-p");
+      globalThis.expect(frameField(data, "event")).toEqual(`{"userId":"u1"}`);
+    });
+  });
+});
+
+export {
+  sentFrames,
+  makeConn,
+  parseFrame,
+  frameField,
+  descriptor,
+}
+/*  Not a pure module */