@reventlessdev/reventless-core 3.0.0-alpha.179 → 3.0.0-alpha.181

package/tests/querydb/QueryDbFixtures.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+S.enableJson();
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  count: s.m(S.int)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let ItemQueryDbSpec = {
+  Id: undefined,
+  name: "TestItemQueryDb",
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let store = {
+  contents: {}
+};
+
+let failNextWrite = {
+  contents: false
+};
+
+async function mockJsonOps_load(id) {
+  return {
+    TAG: "Ok",
+    _0: Stdlib_Option.getOr(store.contents[id], [])
+  };
+}
+
+function mockJsonOps_loadStream(id) {
+  return Stream.fromIterable(Stdlib_Option.getOr(store.contents[id], []));
+}
+
+async function mockJsonOps_save(id, state, _saveMode, _ttl) {
+  if (failNextWrite.contents) {
+    failNextWrite.contents = false;
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "NotSavedToStorage",
+        _0: "mock failure"
+      }
+    };
+  } else {
+    store.contents[id] = [state];
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function mockJsonOps_saveBatch(batch) {
+  if (failNextWrite.contents) {
+    failNextWrite.contents = false;
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "BatchNotFullyWrittenToStorage",
+        _0: "mock failure"
+      }
+    };
+  } else {
+    batch.forEach(param => {
+      store.contents[param[0]] = [param[1]];
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function mockJsonOps_count(_id, _field, inc) {
+  return {
+    TAG: "Ok",
+    _0: inc
+  };
+}
+
+async function mockJsonOps_delete(id, _subId) {
+  Stdlib_Dict.$$delete(store.contents, id);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function mockJsonOps_deleteBatch(ids) {
+  ids.forEach(param => Stdlib_Dict.$$delete(store.contents, param[0]));
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let mockJsonOps = {
+  load: mockJsonOps_load,
+  loadStream: mockJsonOps_loadStream,
+  save: mockJsonOps_save,
+  saveBatch: mockJsonOps_saveBatch,
+  count: mockJsonOps_count,
+  delete: mockJsonOps_delete,
+  deleteBatch: mockJsonOps_deleteBatch
+};
+
+function reset() {
+  store.contents = {};
+  failNextWrite.contents = false;
+}
+
+export {
+  ItemQueryDbSpec,
+  store,
+  failNextWrite,
+  mockJsonOps,
+  reset,
+}
+/*  Not a pure module */

package/tests/querydb/QueryDbOperationsTest.res.mjs

@@ -0,0 +1,168 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as QueryDbFixtures$ReventlessCore from "./QueryDbFixtures.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "../../src/components/QueryDb/QueryDb_Operations.res.mjs";
+
+let Ops = QueryDb_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.name,
+  moduleUrl: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.moduleUrl,
+  stateSchema: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.stateSchema,
+  config: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.config,
+  subIdConfig: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.subIdConfig,
+  authorization: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.authorization,
+  visibility: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.visibility
+})({
+  jsonOps: QueryDbFixtures$ReventlessCore.mockJsonOps
+});
+
+globalThis.beforeEach(() => QueryDbFixtures$ReventlessCore.reset());
+
+globalThis.describe("QueryDb_Operations:", () => {
+  globalThis.describe("loadStream", () => {
+    globalThis.test("returns empty stream for unknown id", async () => {
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("unknown-id")));
+      globalThis.expect(result).toEqual([]);
+    });
+    globalThis.test("decodes saved state back to typed state", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 5
+      }, "Init", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      if (result.length !== 1) {
+        globalThis.expect("unexpected result").toEqual("Ok([state])");
+        return;
+      }
+      let s = result[0];
+      globalThis.expect([
+        s.name,
+        s.count
+      ]).toEqual([
+        "Widget",
+        5
+      ]);
+    });
+    globalThis.test("returns updated state after overwrite", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      await Ops.save("item-1", {
+        name: "Widget Updated",
+        count: 2
+      }, "Overwrite", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      if (result.length !== 1) {
+        globalThis.expect("unexpected result").toEqual("Ok([state])");
+        return;
+      }
+      let s = result[0];
+      globalThis.expect(s.name).toBe("Widget Updated");
+    });
+  });
+  globalThis.describe("save", () => {
+    globalThis.test("returns Ok on success", async () => {
+      let result = await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    });
+    globalThis.test("stores id field in JSON", async () => {
+      await Ops.save("item-42", {
+        name: "Widget",
+        count: 0
+      }, "Init", undefined);
+      let stored = Stdlib_Option.getOr(QueryDbFixtures$ReventlessCore.store.contents["item-42"], []);
+      globalThis.expect(stored.length).toBe(1);
+      let json = stored[0];
+      let idField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      });
+      globalThis.expect(idField).toEqual("item-42");
+    });
+    globalThis.test("returns Error when storage fails", async () => {
+      QueryDbFixtures$ReventlessCore.failNextWrite.contents = true;
+      let result = await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+    });
+  });
+  globalThis.describe("saveBatch", () => {
+    globalThis.test("saves multiple states", async () => {
+      let batch = [
+        [
+          "item-1",
+          {
+            name: "A",
+            count: 1
+          },
+          undefined
+        ],
+        [
+          "item-2",
+          {
+            name: "B",
+            count: 2
+          },
+          undefined
+        ]
+      ];
+      await Ops.saveBatch(batch);
+      let r1 = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      let r2 = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-2")));
+      globalThis.expect([
+        r1.length !== 0,
+        r2.length !== 0
+      ]).toEqual([
+        true,
+        true
+      ]);
+    });
+    globalThis.test("returns Error when storage fails", async () => {
+      QueryDbFixtures$ReventlessCore.failNextWrite.contents = true;
+      let result = await Ops.saveBatch([[
+          "item-1",
+          {
+            name: "A",
+            count: 1
+          },
+          undefined
+        ]]);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+    });
+  });
+  globalThis.describe("delete", () => {
+    globalThis.test("removes state from storage", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      await Ops.$$delete("item-1", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      globalThis.expect(result).toEqual([]);
+    });
+  });
+});
+
+export {
+  Ops,
+}
+/* Ops Not a pure module */

package/tests/sideeffecthandler/SideEffectHandlerCallbackTest.res.mjs

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as SideEffectHandlerFixtures$ReventlessCore from "./SideEffectHandlerFixtures.res.mjs";
+
+globalThis.beforeEach(() => SideEffectHandlerFixtures$ReventlessCore.reset());
+
+globalThis.describe("SideEffectHandler_Callback.handleJsonEvents:", () => {
+  globalThis.describe("event matching registered side effect", () => {
+    globalThis.test("execute called with decoded id and event", async () => {
+      let event = {
+        TAG: "SomethingHappened",
+        value: "hello"
+      };
+      let eventJson = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-1", event);
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([eventJson])));
+      let call = SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents[0];
+      globalThis.expect([
+        call.id,
+        call.event
+      ]).toEqual([
+        "entity-1",
+        event
+      ]);
+    });
+  });
+  globalThis.describe("event with no matching source name", () => {
+    globalThis.test("execute not called, no error", async () => {
+      let eventJson = SideEffectHandlerFixtures$ReventlessCore.makeEventJson("UnknownService", "entity-1", {
+        TAG: "SomethingHappened",
+        value: "ignored"
+      });
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([eventJson])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("event with malformed JSON", () => {
+    globalThis.test("caught gracefully — does not throw, execute not called", async () => {
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable(["not-an-object"])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("execute throws", () => {
+    globalThis.test("error caught per-event, other events still processed", async () => {
+      SideEffectHandlerFixtures$ReventlessCore.executeThrowOnCall.contents = 1;
+      let event = {
+        TAG: "SomethingHappened",
+        value: "v"
+      };
+      let event1 = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-1", event);
+      let event2 = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-2", event);
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([
+        event1,
+        event2
+      ])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(1);
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents[0].id).toBe("entity-2");
+    });
+  });
+  globalThis.describe("multiple events in batch", () => {
+    globalThis.test("each handled independently", async () => {
+      let events = [
+        "entity-1",
+        "entity-2",
+        "entity-3"
+      ].map(id => SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, id, {
+        TAG: "SomethingHappened",
+        value: "v"
+      }));
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable(events)));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(3);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/sideeffecthandler/SideEffectHandlerFixtures.res.mjs

@@ -0,0 +1,139 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as SideEffectHandler_Callback$ReventlessCore from "../../src/components/SideEffectHandler/SideEffectHandler_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "TestSideEffectSource";
+
+let eventSchema = S.schema(s => ({
+  TAG: "SomethingHappened",
+  value: s.m(S.string)
+}));
+
+let TestSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let capturedExecuteCalls = {
+  contents: []
+};
+
+let executeThrowOnCall = {
+  contents: 0
+};
+
+let executeCallCount = {
+  contents: 0
+};
+
+let moduleUrl = import.meta.url;
+
+async function execute(id, _meta, event, _queryEngine) {
+  executeCallCount.contents = executeCallCount.contents + 1 | 0;
+  if (executeThrowOnCall.contents > 0 && executeCallCount.contents === executeThrowOnCall.contents) {
+    Stdlib_JsError.throwWithMessage("side effect failed");
+  }
+  capturedExecuteCalls.contents = capturedExecuteCalls.contents.concat([{
+      id: id,
+      event: event
+    }]);
+}
+
+let TestSideEffect_Source = {
+  name: name,
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  eventSchema: eventSchema
+};
+
+let TestSideEffect = {
+  Source: TestSideEffect_Source,
+  moduleUrl: moduleUrl,
+  execute: execute
+};
+
+let sideEffects = [TestSideEffect];
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let TestSpec = {
+  sideEffects: sideEffects,
+  queryEngine: queryEngine
+};
+
+let TestHandler = SideEffectHandler_Callback$ReventlessCore.Make(TestSpec);
+
+let testMeta_ip = "127.0.0.1";
+
+let testMeta_user = "test-user";
+
+let testMeta = {
+  service: name,
+  time: "2024-01-01T00:00:00Z",
+  ip: testMeta_ip,
+  user: testMeta_user,
+  msgId: "se-msg-1",
+  correlationId: "se-corr-1"
+};
+
+function makeEventJson(serviceOpt, id, event) {
+  let service = serviceOpt !== undefined ? serviceOpt : name;
+  let newrecord = {...testMeta};
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      Message$ReventlessCore.encode((newrecord.service = service, newrecord), Message$ReventlessCore.metaSchema)
+    ],
+    [
+      "event",
+      Message$ReventlessCore.encode(event, eventSchema)
+    ]
+  ]);
+}
+
+function reset() {
+  capturedExecuteCalls.contents = [];
+  executeThrowOnCall.contents = 0;
+  executeCallCount.contents = 0;
+}
+
+export {
+  TestSource,
+  capturedExecuteCalls,
+  executeThrowOnCall,
+  executeCallCount,
+  TestSideEffect,
+  TestSpec,
+  TestHandler,
+  testMeta,
+  makeEventJson,
+  reset,
+}
+/*  Not a pure module */

package/tests/util/CommandPublisherTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as CommandPublisher$ReventlessCore from "../../src/util/CommandPublisher.res.mjs";
+
+S.enableJson();
+
+let published = {
+  contents: []
+};
+
+let commandSchema = S.schema(s => ({
+  value: s.m(S.int)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let TestSpec = {
+  name: "TestCmd",
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization
+};
+
+function publishCommands(_name, cmds) {
+  published.contents = published.contents.concat(cmds);
+  return Promise.resolve();
+}
+
+let TestConfig = {
+  user: "tester",
+  publishCommands: publishCommands,
+  mode: "SendAllInOneChunk"
+};
+
+let Pub = CommandPublisher$ReventlessCore.Make(TestSpec)(TestConfig);
+
+globalThis.describe("CommandPublisher", () => {
+  globalThis.test("flush sends all buffered commands in order and drains the buffer", async () => {
+    published.contents = [];
+    Pub.publish("id1", {
+      value: 1
+    });
+    Pub.publish("id2", {
+      value: 2
+    });
+    await Pub.flush();
+    let ids = published.contents.map(c => c.id);
+    globalThis.expect(ids).toEqual([
+      "id1",
+      "id2"
+    ]);
+    published.contents = [];
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("clear truncates the whole buffer so nothing is later published", async () => {
+    published.contents = [];
+    Pub.publish("id3", {
+      value: 3
+    });
+    Pub.publish("id4", {
+      value: 4
+    });
+    Pub.clear();
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+});
+
+export {
+  published,
+  TestSpec,
+  TestConfig,
+  Pub,
+}
+/*  Not a pure module */

package/tests/util/CsvStreamTest.res.mjs

@@ -0,0 +1,51 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as CsvStream$ReventlessCore from "../../src/util/CsvStream.res.mjs";
+
+let fileCounter = {
+  contents: 0
+};
+
+function writeTempCsv(content) {
+  fileCounter.contents = fileCounter.contents + 1 | 0;
+  let path = `/tmp/reventless-csvstream-test-` + fileCounter.contents.toString() + `.csv`;
+  Fs.writeFileSync(path, content);
+  return path;
+}
+
+globalThis.describe("CsvStream.parseRows", () => {
+  globalThis.test("parses all rows from a small CSV file", async () => {
+    let path = writeTempCsv("name,age\nAlice,30\nBob,25");
+    let rows = await Effect.runPromise(Stream.runCollect(CsvStream$ReventlessCore.parseRows(path)));
+    globalThis.expect(rows.length).toBe(2);
+  });
+  globalThis.test("emits rows in file order", async () => {
+    let path = writeTempCsv("name\nfirst\nsecond\nthird");
+    let first = await Effect.runPromise(Stream.runHead(CsvStream$ReventlessCore.parseRows(path)));
+    let name = Stdlib_Option.flatMap(first, row => row["name"]);
+    globalThis.expect(name).toEqual("first");
+  });
+  globalThis.test("take(2) returns only 2 rows", async () => {
+    let dataRows = Stdlib_Array.make(10, 0).map((i, param) => `row-` + i.toString()).join("\n");
+    let path = writeTempCsv("name\n" + dataRows);
+    let result = await Effect.runPromise(Stream.runCollect(Stream$1.take(CsvStream$ReventlessCore.parseRows(path), 2)));
+    globalThis.expect(result.length).toBe(2);
+  });
+  globalThis.test("empty CSV file (header only) returns empty stream", async () => {
+    let path = writeTempCsv("name");
+    let rows = await Effect.runPromise(Stream.runCollect(CsvStream$ReventlessCore.parseRows(path)));
+    globalThis.expect(rows.length).toBe(0);
+  });
+});
+
+export {
+  fileCounter,
+  writeTempCsv,
+}
+/*  Not a pure module */