@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/CommandTopicChannelTest.res.mjs

@@ -0,0 +1,170 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as LocalCommandTopicChannel$ReventlessLocal from "../../src/adapter/CommandTopic/LocalCommandTopicChannel.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let testMeta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001"
+};
+
+globalThis.describe("LocalCommandTopicChannel", () => {
+  globalThis.describe("encodeCommandJson", () => {
+    globalThis.test("produces {id, meta, command} JSON shape", async () => {
+      let cmdJson = {
+        id: "agg-1",
+        meta: testMeta,
+        commandJson: "DoSomething"
+      };
+      let encoded = CommandTopic$ReventlessCore.encodeCommandJson(cmdJson);
+      let dict;
+      dict = typeof encoded === "object" && encoded !== null && !Array.isArray(encoded) ? encoded : ({});
+      globalThis.expect(dict["id"]).toEqual("agg-1");
+      globalThis.expect(dict["command"]).toEqual("DoSomething");
+      globalThis.expect(Stdlib_Option.isSome(dict["meta"])).toBe(true);
+    });
+  });
+  globalThis.describe("decodeId", () => {
+    globalThis.test("extracts id string from encoded message body", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let body = Object.fromEntries([[
+          "id",
+          "agg-42"
+        ]]);
+      globalThis.expect(TestChannel.decodeId(body)).toBe("agg-42");
+    });
+    globalThis.test("returns empty string for non-object input", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      globalThis.expect(TestChannel.decodeId("not-an-object")).toBe("");
+    });
+    globalThis.test("returns empty string when id field is missing", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let body = Object.fromEntries([[
+          "other",
+          1
+        ]]);
+      globalThis.expect(TestChannel.decodeId(body)).toBe("");
+    });
+    globalThis.test("returns empty string when id field is not a string", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let body = Object.fromEntries([[
+          "id",
+          99
+        ]]);
+      globalThis.expect(TestChannel.decodeId(body)).toBe("");
+    });
+  });
+  globalThis.describe("publishJsons", () => {
+    globalThis.test("dispatches each command to the bus with full {id, meta, command} body", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let received = {
+        contents: undefined
+      };
+      TestBus.registerCommandHandler("myCmd", async (json, param) => {
+        received.contents = json;
+      });
+      let ch = TestChannel.make("myCmd", undefined);
+      let publishFn = await TestRunner$ReventlessLocal.resolve(ch.publishJsons);
+      await publishFn([{
+          id: "item-1",
+          meta: testMeta,
+          commandJson: "CreateItem"
+        }]);
+      let receivedJson = Stdlib_Option.getOr(received.contents, null);
+      let receivedDict;
+      receivedDict = typeof receivedJson === "object" && receivedJson !== null && !Array.isArray(receivedJson) ? receivedJson : ({});
+      globalThis.expect(receivedDict["id"]).toEqual("item-1");
+    });
+    globalThis.test("dispatches multiple commands in order", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.registerCommandHandler("multiCmd", async (param, param$1) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let ch = TestChannel.make("multiCmd", undefined);
+      let publishFn = await TestRunner$ReventlessLocal.resolve(ch.publishJsons);
+      await publishFn([
+        {
+          id: "id-1",
+          meta: testMeta,
+          commandJson: null
+        },
+        {
+          id: "id-2",
+          meta: testMeta,
+          commandJson: null
+        }
+      ]);
+      globalThis.expect(count.contents).toBe(2);
+    });
+  });
+  globalThis.describe("connect", () => {
+    globalThis.test("registers handler; dispatch reaches the runtime handlerDeferred", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      let received = {
+        contents: undefined
+      };
+      let handlerDeferred = Effect.runSync(Deferred.make());
+      Effect.runSync(Deferred.succeed(handlerDeferred, async (json, _ctx) => {
+        received.contents = json;
+      }));
+      let runtime_parts = {
+        handlerDeferred: handlerDeferred,
+        subscriptionLatch: Effect.runSync(Effect.makeLatch(false))
+      };
+      let runtime_resources = [];
+      let runtime = {
+        parts: runtime_parts,
+        resources: runtime_resources
+      };
+      let ch = TestChannel.make("testCmd", undefined);
+      ch.connect("testCmd", ch, runtime, [], {});
+      await TestBus.dispatchCommand("testCmd", "test-payload");
+      globalThis.expect(received.contents).toEqual("test-payload");
+    });
+    globalThis.test("unresolved Deferred does not crash on dispatch", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let TestChannel = LocalCommandTopicChannel$ReventlessLocal.Make(TestBus);
+      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
+      };
+      let ch = TestChannel.make("noHandlerCmd", undefined);
+      ch.connect("noHandlerCmd", ch, runtime, [], {});
+      TestBus.dispatchCommand("noHandlerCmd", null);
+      globalThis.expect(true).toBe(true);
+      Effect.runSync(Deferred.succeed(handlerDeferred, async (param, param$1) => {}));
+    });
+  });
+});
+
+export {
+  testMeta,
+}
+/*  Not a pure module */

package/tests/adapter/CounterHandlerTest.res

@@ -0,0 +1,113 @@
+// Unit tests for LocalCounterHandler.
+// CounterHandler uses module-level refs — call reset() in beforeEach for isolation.
+
+open JestGlobals
+
+// No Pulumi mock needed (LocalCounterHandler uses no Output)
+
+let _ = beforeEach(() => {
+  LocalCounterHandler.reset()
+})
+
+// Create a handler instance; all parameters are ignored by the in-memory implementation
+let makeHandler = () =>
+  LocalCounterHandler.make(
+    ~name="counter",
+    ~referencesName="refs",
+    ~referencesDb=Obj.magic(()),
+    ~countsName="counts",
+    ~countsDb=Obj.magic(()),
+    ~counterHandler=Obj.magic(()),
+    ~specModulePath="",
+    ~mappingsModulePath="",
+    ~publishChannelId=Pulumi.Output.make(""),
+    ~opts={},
+  )
+
+describe("LocalCounterHandler", () => {
+  describe("addToCounterTarget", () => {
+    testPromise("increments counter by target amount", async () => {
+      let handler = makeHandler()
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "likes",
+        target: 3,
+        targetRef: "ref-1",
+      })
+      expect(LocalCounterHandler.getCount("likes"))->toBe(3)
+    })
+
+    testPromise("same (counterId, targetRef) pair is counted only once", async () => {
+      let handler = makeHandler()
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "likes",
+        target: 5,
+        targetRef: "ref-dup",
+      })
+      // Duplicate — should be ignored
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "likes",
+        target: 5,
+        targetRef: "ref-dup",
+      })
+      expect(LocalCounterHandler.getCount("likes"))->toBe(5)
+    })
+
+    testPromise("different targetRef values for same counterId accumulate", async () => {
+      let handler = makeHandler()
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "views",
+        target: 2,
+        targetRef: "ref-a",
+      })
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "views",
+        target: 3,
+        targetRef: "ref-b",
+      })
+      expect(LocalCounterHandler.getCount("views"))->toBe(5)
+    })
+
+    testPromise("multiple counters are tracked independently", async () => {
+      let handler = makeHandler()
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "alpha",
+        target: 10,
+        targetRef: "r1",
+      })
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "beta",
+        target: 7,
+        targetRef: "r1",
+      })
+      expect(LocalCounterHandler.getCount("alpha"))->toBe(10)
+      expect(LocalCounterHandler.getCount("beta"))->toBe(7)
+    })
+  })
+
+  describe("getCount", () => {
+    testPromise("returns 0 for unknown counterId", async () => {
+      expect(LocalCounterHandler.getCount("no-such-counter"))->toBe(0)
+    })
+  })
+
+  describe("reset", () => {
+    testPromise("clears all counter values and deduplication state", async () => {
+      let handler = makeHandler()
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "x",
+        target: 99,
+        targetRef: "ref-x",
+      })
+      expect(LocalCounterHandler.getCount("x"))->toBe(99)
+      LocalCounterHandler.reset()
+      expect(LocalCounterHandler.getCount("x"))->toBe(0)
+      // After reset, the same (counterId, targetRef) pair should count again
+      await handler.addToCounterTarget({
+        ReventlessInfra.Counter.counterId: "x",
+        target: 99,
+        targetRef: "ref-x",
+      })
+      expect(LocalCounterHandler.getCount("x"))->toBe(99)
+    })
+  })
+})

package/tests/adapter/CounterHandlerTest.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as LocalCounterHandler$ReventlessLocal from "../../src/adapter/Counter/LocalCounterHandler.res.mjs";
+
+globalThis.beforeEach(() => LocalCounterHandler$ReventlessLocal.reset());
+
+function makeHandler() {
+  return LocalCounterHandler$ReventlessLocal.make("counter", "refs", undefined, "counts", undefined, undefined, "", "", Pulumi.output(""), {});
+}
+
+globalThis.describe("LocalCounterHandler", () => {
+  globalThis.describe("addToCounterTarget", () => {
+    globalThis.test("increments counter by target amount", async () => {
+      let handler = makeHandler();
+      await handler.addToCounterTarget({
+        counterId: "likes",
+        target: 3,
+        targetRef: "ref-1"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("likes")).toBe(3);
+    });
+    globalThis.test("same (counterId, targetRef) pair is counted only once", async () => {
+      let handler = makeHandler();
+      await handler.addToCounterTarget({
+        counterId: "likes",
+        target: 5,
+        targetRef: "ref-dup"
+      });
+      await handler.addToCounterTarget({
+        counterId: "likes",
+        target: 5,
+        targetRef: "ref-dup"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("likes")).toBe(5);
+    });
+    globalThis.test("different targetRef values for same counterId accumulate", async () => {
+      let handler = makeHandler();
+      await handler.addToCounterTarget({
+        counterId: "views",
+        target: 2,
+        targetRef: "ref-a"
+      });
+      await handler.addToCounterTarget({
+        counterId: "views",
+        target: 3,
+        targetRef: "ref-b"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("views")).toBe(5);
+    });
+    globalThis.test("multiple counters are tracked independently", async () => {
+      let handler = makeHandler();
+      await handler.addToCounterTarget({
+        counterId: "alpha",
+        target: 10,
+        targetRef: "r1"
+      });
+      await handler.addToCounterTarget({
+        counterId: "beta",
+        target: 7,
+        targetRef: "r1"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("alpha")).toBe(10);
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("beta")).toBe(7);
+    });
+  });
+  globalThis.describe("getCount", () => {
+    globalThis.test("returns 0 for unknown counterId", async () => {
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("no-such-counter")).toBe(0);
+    });
+  });
+  globalThis.describe("reset", () => {
+    globalThis.test("clears all counter values and deduplication state", async () => {
+      let handler = makeHandler();
+      await handler.addToCounterTarget({
+        counterId: "x",
+        target: 99,
+        targetRef: "ref-x"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("x")).toBe(99);
+      LocalCounterHandler$ReventlessLocal.reset();
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("x")).toBe(0);
+      await handler.addToCounterTarget({
+        counterId: "x",
+        target: 99,
+        targetRef: "ref-x"
+      });
+      globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("x")).toBe(99);
+    });
+  });
+});
+
+export {
+  makeHandler,
+}
+/*  Not a pure module */

package/tests/adapter/DcbEventLogStorageSqliteTest.res

@@ -0,0 +1,157 @@
+// Round-trip test for DcbEventLogStorage_Sqlite.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+let stored = (eventType, tags, data): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data,
+  tags,
+  meta: ReventlessCore.Message.generateMeta(~service="test"),
+}
+
+describe("DcbEventLogStorage_Sqlite", () => {
+  testPromise("append + read round-trips events with tags", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-rt",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let tag1: Reventless.DcbTag.tag = {key: "itemId", value: "x1"}
+      let e1 = stored(
+        "ItemAdded",
+        [tag1],
+        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("widget"))])),
+      )
+      let result = await ops.append([e1])
+      switch result {
+      | Ok(_) => expect(true)->toBe(true)
+      | Error(m) => expect(m)->toBe("Ok")
+      }
+
+      let read = await ops.read(~query=[])
+      expect(read.events->Array.length)->toBe(1)
+      let first = read.events->Array.getUnsafe(0)
+      expect(first.eventType)->toBe("ItemAdded")
+      expect(first.tags->Array.length)->toBe(1)
+      expect((first.tags->Array.getUnsafe(0)).key)->toBe("itemId")
+      expect((first.tags->Array.getUnsafe(0)).value)->toBe("x1")
+    })
+  })
+
+  testPromise("read filters by tag", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-tagfilter",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let mk = (id, name) =>
+        stored(
+          "ItemAdded",
+          [{key: "itemId", value: id}],
+          JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string(name))])),
+        )
+
+      let _ = await ops.append([mk("a1", "alpha")])
+      let _ = await ops.append([mk("b1", "beta")])
+      let _ = await ops.append([mk("a1", "again")])
+
+      let read = await ops.read(~query=[{tags: [{key: "itemId", value: "a1"}]}])
+      expect(read.events->Array.length)->toBe(2)
+    })
+  })
+
+  testPromise("append with conflicting condition returns Error", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-conflict",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let e = stored(
+        "Created",
+        [{key: "id", value: "x"}],
+        JSON.Encode.string("first"),
+      )
+      let _ = await ops.append([e])
+
+      let cond: Reventless.DcbTag.appendCondition = {
+        query: [{tags: [{key: "id", value: "x"}]}],
+      }
+      let result = await ops.append([e], ~condition=cond)
+      switch result {
+      | Error(_) => expect(true)->toBe(true)
+      | Ok(_) => expect("expected conflict")->toBe("got Ok")
+      }
+    })
+  })
+
+  testPromise("events persist across a file reopen", async () => {
+    let path = `/tmp/reventless-test-dcb-${Float.toString(Date.now())}.db`
+
+    {
+      let db = SqliteDriver.openDb(~path)
+      BackendState.setSqlite(~db, ~path)
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="persist",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+      let e = stored(
+        "Created",
+        [{key: "id", value: "p"}],
+        JSON.Encode.int(1),
+      )
+      let _ = await ops.append([e])
+      db->SqliteDriver.close
+      BackendState.setMemory()
+    }
+
+    let db2 = SqliteDriver.openDb(~path)
+    BackendState.setSqlite(~db=db2, ~path)
+    module TestBus2 = LocalBus.Make()
+    module Storage2 = DcbEventLogStorage_InMemory.Make(TestBus2)
+    let s2 = Storage2.make(
+      ~name="persist",
+      ~indexes=[],
+      ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+      ~opts,
+    )
+    let ops2 = await s2.operations->TestRunner.resolve
+    let read = await ops2.read(~query=[])
+    expect(read.events->Array.length)->toBe(1)
+    db2->SqliteDriver.close
+    BackendState.setMemory()
+  })
+})