@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/DcbEventLogStorageSqliteTest.res.mjs

@@ -0,0 +1,165 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as DcbEventLogStorage_InMemory$ReventlessLocal from "../../src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+function stored(eventType, tags, data) {
+  return {
+    eventType: eventType,
+    data: data,
+    tags: tags,
+    meta: Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  };
+}
+
+globalThis.describe("DcbEventLogStorage_Sqlite", () => {
+  globalThis.test("append + read round-trips events with tags", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-rt", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let e1 = stored("ItemAdded", [{
+        key: "itemId",
+        value: "x1"
+      }], Object.fromEntries([[
+        "name",
+        "widget"
+      ]]));
+    let result = await ops.append([e1], undefined);
+    if (result.TAG === "Ok") {
+      globalThis.expect(true).toBe(true);
+    } else {
+      globalThis.expect(result._0).toBe("Ok");
+    }
+    let read = await ops.read([], undefined);
+    globalThis.expect(read.events.length).toBe(1);
+    let first = read.events[0];
+    globalThis.expect(first.eventType).toBe("ItemAdded");
+    globalThis.expect(first.tags.length).toBe(1);
+    globalThis.expect(first.tags[0].key).toBe("itemId");
+    globalThis.expect(first.tags[0].value).toBe("x1");
+  }));
+  globalThis.test("read filters by tag", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-tagfilter", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let mk = (id, name) => stored("ItemAdded", [{
+        key: "itemId",
+        value: id
+      }], Object.fromEntries([[
+        "name",
+        name
+      ]]));
+    await ops.append([mk("a1", "alpha")], undefined);
+    await ops.append([mk("b1", "beta")], undefined);
+    await ops.append([mk("a1", "again")], undefined);
+    let read = await ops.read([{
+        tags: [{
+            key: "itemId",
+            value: "a1"
+          }]
+      }], undefined);
+    globalThis.expect(read.events.length).toBe(2);
+  }));
+  globalThis.test("append with conflicting condition returns Error", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-conflict", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let e = stored("Created", [{
+        key: "id",
+        value: "x"
+      }], "first");
+    await ops.append([e], undefined);
+    let cond_query = [{
+        tags: [{
+            key: "id",
+            value: "x"
+          }]
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let result = await ops.append([e], cond);
+    if (result.TAG === "Ok") {
+      globalThis.expect("expected conflict").toBe("got Ok");
+      return;
+    }
+    globalThis.expect(true).toBe(true);
+  }));
+  globalThis.test("events persist across a file reopen", async () => {
+    let path = `/tmp/reventless-test-dcb-` + Date.now().toString() + `.db`;
+    let db = SqliteDriver$ReventlessLocal.openDb(path);
+    BackendState$ReventlessLocal.setSqlite(db, path);
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("persist", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let e = stored("Created", [{
+        key: "id",
+        value: "p"
+      }], 1);
+    await ops.append([e], undefined);
+    SqliteDriver$ReventlessLocal.close(db);
+    BackendState$ReventlessLocal.setMemory();
+    let db2 = SqliteDriver$ReventlessLocal.openDb(path);
+    BackendState$ReventlessLocal.setSqlite(db2, path);
+    let TestBus2 = LocalBus$ReventlessLocal.Make({});
+    let Storage2 = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus2);
+    let s2 = Storage2.make("persist", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops2 = await TestRunner$ReventlessLocal.resolve(s2.operations);
+    let read = await ops2.read([], undefined);
+    globalThis.expect(read.events.length).toBe(1);
+    SqliteDriver$ReventlessLocal.close(db2);
+    return BackendState$ReventlessLocal.setMemory();
+  });
+});
+
+export {
+  opts,
+  runUnderSqlite,
+  stored,
+}
+/*  Not a pure module */

package/tests/adapter/DcbEventLogStorageTest.res

@@ -0,0 +1,187 @@
+// Unit tests for DcbEventLogStorage_InMemory.
+// Covers append, read (with filtering), headPosition, and conditional append.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let makeStorage = () =>
+  DcbEventLogStorage_InMemory.make(
+    ~name="test-dcb",
+    ~indexes=[],
+    ~partitionTag=Reventless.DcbTag.Simple({key: "itemId"}),
+    ~opts,
+  )
+
+let makeEvent = (~eventType, ~data, ~tags=[]): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data,
+  tags,
+  meta: ReventlessCore.Message.generateMeta(~service="test"),
+}
+
+describe("DcbEventLogStorage_InMemory", () => {
+  describe("append", () => {
+    testPromise("stores events and returns incrementing position", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let result1 = await ops.append([makeEvent(~eventType="ItemCreated", ~data=JSON.Null)])
+      let result2 = await ops.append([makeEvent(~eventType="ItemUpdated", ~data=JSON.Null)])
+      expect(result1)->toEqual(Ok("1"))
+      expect(result2)->toEqual(Ok("2"))
+    })
+
+    testPromise("appending multiple events at once returns position of last event", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let result = await ops.append([
+        makeEvent(~eventType="A", ~data=JSON.Null),
+        makeEvent(~eventType="B", ~data=JSON.Null),
+      ])
+      expect(result)->toEqual(Ok("2"))
+    })
+  })
+
+  describe("read", () => {
+    testPromise("empty query returns all events", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(~eventType="Evt1", ~data=JSON.Null),
+        makeEvent(~eventType="Evt2", ~data=JSON.Null),
+      ])
+      let result = await ops.read(~query=[])
+      expect(result.events->Array.length)->toBe(2)
+    })
+
+    testPromise("filters by eventType", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(~eventType="Created", ~data=JSON.Null),
+        makeEvent(~eventType="Updated", ~data=JSON.Null),
+        makeEvent(~eventType="Created", ~data=JSON.Null),
+      ])
+      // Optional record fields use direct value syntax (not Some(...))
+      let result = await ops.read(
+        ~query=[{Reventless.DcbTag.eventTypes: ["Created"]}],
+      )
+      expect(result.events->Array.length)->toBe(2)
+      let firstEvent = result.events->Array.getUnsafe(0)
+      expect(firstEvent.eventType)->toBe("Created")
+    })
+
+    testPromise("filters by tags", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(
+          ~eventType="Evt",
+          ~data=JSON.Null,
+          ~tags=[{Reventless.DcbTag.key: "tenant", value: "acme"}],
+        ),
+        makeEvent(~eventType="Evt", ~data=JSON.Null, ~tags=[]),
+      ])
+      let result = await ops.read(
+        ~query=[
+          {
+            Reventless.DcbTag.tags: [{Reventless.DcbTag.key: "tenant", value: "acme"}],
+          },
+        ],
+      )
+      expect(result.events->Array.length)->toBe(1)
+      let firstEvent = result.events->Array.getUnsafe(0)
+      expect(firstEvent.tags->Array.length)->toBe(1)
+    })
+
+    testPromise("after parameter skips events at or before that position", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(~eventType="E1", ~data=JSON.Null),
+        makeEvent(~eventType="E2", ~data=JSON.Null),
+        makeEvent(~eventType="E3", ~data=JSON.Null),
+      ])
+      let result = await ops.read(~query=[], ~after="1")
+      // Events at position > "1" — positions 2 and 3
+      expect(result.events->Array.length)->toBe(2)
+      let firstEvent = result.events->Array.getUnsafe(0)
+      expect(firstEvent.eventType)->toBe("E2")
+    })
+  })
+
+  describe("headPosition", () => {
+    testPromise("equals the position of the last appended event", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(~eventType="E1", ~data=JSON.Null),
+        makeEvent(~eventType="E2", ~data=JSON.Null),
+      ])
+      let result = await ops.read(~query=[])
+      expect(result.headPosition)->toEqual(Some("2"))
+    })
+
+    testPromise("headPosition is absent when no events have been stored", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let result = await ops.read(~query=[])
+      expect(result.headPosition)->toEqual(None)
+    })
+  })
+
+  describe("conditional append", () => {
+    testPromise("append with matching condition query returns Error (conflict)", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([makeEvent(~eventType="ItemCreated", ~data=JSON.Null)])
+      let condition: Reventless.DcbTag.appendCondition = {
+        query: [{Reventless.DcbTag.eventTypes: ["ItemCreated"]}],
+      }
+      let result = await ops.append(
+        [makeEvent(~eventType="ItemUpdated", ~data=JSON.Null)],
+        ~condition,
+      )
+      expect(
+        switch result {
+        | Error(_) => true
+        | Ok(_) => false
+        },
+      )->toBe(true)
+    })
+
+    testPromise("append with condition that matches no events succeeds", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([makeEvent(~eventType="OtherEvent", ~data=JSON.Null)])
+      let condition: Reventless.DcbTag.appendCondition = {
+        query: [{Reventless.DcbTag.eventTypes: ["ItemCreated"]}],
+      }
+      let result = await ops.append(
+        [makeEvent(~eventType="ItemCreated", ~data=JSON.Null)],
+        ~condition,
+      )
+      expect(result)->toEqual(Ok("2"))
+    })
+
+    testPromise("condition with after only checks events after that position", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      // Position 1: ItemCreated
+      let _ = await ops.append([makeEvent(~eventType="ItemCreated", ~data=JSON.Null)])
+      // Condition checks for ItemCreated only AFTER position "1" — no such events
+      let condition: Reventless.DcbTag.appendCondition = {
+        query: [{Reventless.DcbTag.eventTypes: ["ItemCreated"]}],
+        after: "1",
+      }
+      let result = await ops.append(
+        [makeEvent(~eventType="ItemUpdated", ~data=JSON.Null)],
+        ~condition,
+      )
+      // No conflict because ItemCreated is at position 1, not > 1
+      expect(result)->toEqual(Ok("2"))
+    })
+  })
+})

package/tests/adapter/DcbEventLogStorageTest.res.mjs

@@ -0,0 +1,195 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as DcbEventLogStorage_InMemory$ReventlessLocal from "../../src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function makeStorage() {
+  return DcbEventLogStorage_InMemory$ReventlessLocal.make("test-dcb", [], {
+    TAG: "Simple",
+    _0: {
+      key: "itemId"
+    }
+  }, undefined, opts);
+}
+
+function makeEvent(eventType, data, tagsOpt) {
+  let tags = tagsOpt !== undefined ? tagsOpt : [];
+  return {
+    eventType: eventType,
+    data: data,
+    tags: tags,
+    meta: Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  };
+}
+
+globalThis.describe("DcbEventLogStorage_InMemory", () => {
+  globalThis.describe("append", () => {
+    globalThis.test("stores events and returns incrementing position", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      let result1 = await ops.append([makeEvent("ItemCreated", null, undefined)], undefined);
+      let result2 = await ops.append([makeEvent("ItemUpdated", null, undefined)], undefined);
+      globalThis.expect(result1).toEqual({
+        TAG: "Ok",
+        _0: "1"
+      });
+      globalThis.expect(result2).toEqual({
+        TAG: "Ok",
+        _0: "2"
+      });
+    });
+    globalThis.test("appending multiple events at once returns position of last event", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      let result = await ops.append([
+        makeEvent("A", null, undefined),
+        makeEvent("B", null, undefined)
+      ], undefined);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: "2"
+      });
+    });
+  });
+  globalThis.describe("read", () => {
+    globalThis.test("empty query returns all events", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("Evt1", null, undefined),
+        makeEvent("Evt2", null, undefined)
+      ], undefined);
+      let result = await ops.read([], undefined);
+      globalThis.expect(result.events.length).toBe(2);
+    });
+    globalThis.test("filters by eventType", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("Created", null, undefined),
+        makeEvent("Updated", null, undefined),
+        makeEvent("Created", null, undefined)
+      ], undefined);
+      let result = await ops.read([{
+          eventTypes: ["Created"]
+        }], undefined);
+      globalThis.expect(result.events.length).toBe(2);
+      let firstEvent = result.events[0];
+      globalThis.expect(firstEvent.eventType).toBe("Created");
+    });
+    globalThis.test("filters by tags", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("Evt", null, [{
+            key: "tenant",
+            value: "acme"
+          }]),
+        makeEvent("Evt", null, [])
+      ], undefined);
+      let result = await ops.read([{
+          tags: [{
+              key: "tenant",
+              value: "acme"
+            }]
+        }], undefined);
+      globalThis.expect(result.events.length).toBe(1);
+      let firstEvent = result.events[0];
+      globalThis.expect(firstEvent.tags.length).toBe(1);
+    });
+    globalThis.test("after parameter skips events at or before that position", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("E1", null, undefined),
+        makeEvent("E2", null, undefined),
+        makeEvent("E3", null, undefined)
+      ], undefined);
+      let result = await ops.read([], "1");
+      globalThis.expect(result.events.length).toBe(2);
+      let firstEvent = result.events[0];
+      globalThis.expect(firstEvent.eventType).toBe("E2");
+    });
+  });
+  globalThis.describe("headPosition", () => {
+    globalThis.test("equals the position of the last appended event", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("E1", null, undefined),
+        makeEvent("E2", null, undefined)
+      ], undefined);
+      let result = await ops.read([], undefined);
+      globalThis.expect(result.headPosition).toEqual("2");
+    });
+    globalThis.test("headPosition is absent when no events have been stored", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      let result = await ops.read([], undefined);
+      globalThis.expect(result.headPosition).toEqual(undefined);
+    });
+  });
+  globalThis.describe("conditional append", () => {
+    globalThis.test("append with matching condition query returns Error (conflict)", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([makeEvent("ItemCreated", null, undefined)], undefined);
+      let condition_query = [{
+          eventTypes: ["ItemCreated"]
+        }];
+      let condition = {
+        query: condition_query
+      };
+      let result = await ops.append([makeEvent("ItemUpdated", null, undefined)], condition);
+      let tmp;
+      tmp = result.TAG !== "Ok";
+      globalThis.expect(tmp).toBe(true);
+    });
+    globalThis.test("append with condition that matches no events succeeds", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([makeEvent("OtherEvent", null, undefined)], undefined);
+      let condition_query = [{
+          eventTypes: ["ItemCreated"]
+        }];
+      let condition = {
+        query: condition_query
+      };
+      let result = await ops.append([makeEvent("ItemCreated", null, undefined)], condition);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: "2"
+      });
+    });
+    globalThis.test("condition with after only checks events after that position", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([makeEvent("ItemCreated", null, undefined)], undefined);
+      let condition_query = [{
+          eventTypes: ["ItemCreated"]
+        }];
+      let condition_after = "1";
+      let condition = {
+        query: condition_query,
+        after: condition_after
+      };
+      let result = await ops.append([makeEvent("ItemUpdated", null, undefined)], condition);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: "2"
+      });
+    });
+  });
+});
+
+export {
+  opts,
+  makeStorage,
+  makeEvent,
+}
+/*  Not a pure module */