@reventlessdev/reventless-local 3.0.0-alpha.316 → 3.0.0-alpha.318

package/tests/adapter/LocalEventLogReadTest.res.mjs

@@ -0,0 +1,466 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+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 PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "../../src/adapter/LocalEventLogRead.res.mjs";
+import * as LocalEventLogStorage$ReventlessLocal from "../../src/adapter/EventLog/LocalEventLogStorage.res.mjs";
+import * as EventLogStorage_Sqlite$ReventlessLocal from "../../src/adapter/EventLog/EventLogStorage_Sqlite.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
+import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "../../src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let ordersLog = "OrderAggrEventLog";
+
+let customersLog = "CustomerAggrEventLog";
+
+let catalogLog = "CatalogDcbEventLog";
+
+async function resolveOrThrow(r) {
+  let match = await r;
+  if (match.TAG === "Ok") {
+    return;
+  } else {
+    return Stdlib_JsError.throwWithMessage("append failed");
+  }
+}
+
+async function makeWorld() {
+  LocalEventLogRead$ReventlessLocal.resetForTests();
+  let Bus = LocalBus$ReventlessLocal.MakeSilent({});
+  let Agg = LocalEventLogStorage$ReventlessLocal.Make(Bus);
+  let Dcb = LocalDcbEventLogStorage$ReventlessLocal.Make(Bus);
+  let orders = await TestRunner$ReventlessLocal.resolve(Agg.make(ordersLog, undefined, opts).operations);
+  let customers = await TestRunner$ReventlessLocal.resolve(Agg.make(customersLog, undefined, opts).operations);
+  let catalog = await TestRunner$ReventlessLocal.resolve(Dcb.make(catalogLog, [], {
+    TAG: "Simple",
+    _0: {
+      key: "productId"
+    }
+  }, undefined, opts).operations);
+  LocalEventLogRead$ReventlessLocal.notePlugin(ordersLog, "Ordering");
+  LocalEventLogRead$ReventlessLocal.notePlugin(customersLog, "Ordering");
+  LocalEventLogRead$ReventlessLocal.notePlugin(catalogLog, "Catalog");
+  let appended = [];
+  let seqs = {};
+  let flat = (id, eventType, meta) => Object.fromEntries(Object.entries(Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "position",
+      "000000000"
+    ],
+    [
+      "event",
+      eventType
+    ],
+    [
+      "data",
+      Object.fromEntries([[
+          "TAG",
+          eventType
+        ]])
+    ],
+    [
+      "recordedAt",
+      new Date().toISOString()
+    ]
+  ])).concat(Message$ReventlessCore.decomposeMeta(meta)));
+  let appendAggregate = async (ops, log, plugin, id, eventType, correlationId, user) => {
+    let meta = Message$ReventlessCore.generateMeta("test", user, `cause-of-` + correlationId, undefined, correlationId, undefined, undefined);
+    let key = log + "/" + id;
+    let seq = Stdlib_Option.getOr(seqs[key], 0);
+    await resolveOrThrow(ops.append(seq, id, [flat(id, eventType, meta)]));
+    seqs[key] = seq + 1 | 0;
+    appended.push({
+      log: log,
+      plugin: plugin,
+      msgId: meta.msgId,
+      eventType: eventType,
+      entityId: id,
+      tags: [],
+      correlationId: correlationId,
+      causationId: `cause-of-` + correlationId,
+      user: user
+    });
+  };
+  return {
+    appendOrder: (id, eventType, correlationId, user) => appendAggregate(orders, ordersLog, "Ordering", id, eventType, correlationId, user),
+    appendCustomer: (id, correlationId, user) => appendAggregate(customers, customersLog, "Ordering", id, "Registered", correlationId, user),
+    appendProduct: async (productId, eventType, correlationId, user) => {
+      let meta = Message$ReventlessCore.generateMeta("test", user, `cause-of-` + correlationId, undefined, correlationId, undefined, undefined);
+      let tags = [{
+          key: "productId",
+          value: productId
+        }];
+      await resolveOrThrow(catalog.append([{
+          eventType: eventType,
+          data: Object.fromEntries([[
+              "TAG",
+              eventType
+            ]]),
+          tags: tags,
+          meta: meta
+        }], undefined));
+      appended.push({
+        log: catalogLog,
+        plugin: "Catalog",
+        msgId: meta.msgId,
+        eventType: eventType,
+        tags: tags,
+        correlationId: correlationId,
+        causationId: `cause-of-` + correlationId,
+        user: user
+      });
+    },
+    appended: appended
+  };
+}
+
+async function seed(w) {
+  for (let i = 1; i <= 12; ++i) {
+    let correlationId = i % 3 === 0 ? "flow-a" : "flow-b";
+    let user = i % 2 === 0 ? "u-even" : "u-odd";
+    await w.appendOrder(`o-` + (i % 3).toString(), i % 2 === 0 ? "Placed" : "Paid", correlationId, user);
+    await w.appendProduct(`p-` + (i % 2).toString(), i % 4 === 0 ? "Archived" : "Added", correlationId, user);
+    if (i % 4 === 1) {
+      await w.appendCustomer(`c-` + i.toString(), correlationId, user);
+    }
+  }
+}
+
+function msgIdOf(r) {
+  return Stdlib_Option.getOr(LocalEventLogRead$ReventlessLocal.metaString(r.meta, "msgId"), "");
+}
+
+async function readAll(filter, first) {
+  let out = [];
+  let after;
+  let more = true;
+  while (more) {
+    let page = await LocalEventLogRead$ReventlessLocal.read(filter, first, after);
+    page.edges.forEach(param => {
+      out.push(param[0]);
+    });
+    more = page.hasNextPage;
+    after = page.endCursor;
+  };
+  return out;
+}
+
+function sorted(ids) {
+  return ids.toSorted(Primitive_string.compare);
+}
+
+function scenario(name, setup, teardown) {
+  globalThis.describe(`LocalEventLogRead on ` + name, () => {
+    let run = async body => {
+      await setup();
+      let outcome;
+      try {
+        await body();
+        outcome = {
+          TAG: "Ok",
+          _0: undefined
+        };
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        outcome = {
+          TAG: "Error",
+          _0: e
+        };
+      }
+      await teardown();
+      if (outcome.TAG === "Ok") {
+        return;
+      }
+      throw outcome._0;
+    };
+    globalThis.test("pages run newest first and join without a gap or a double while events are appended", () => run(async () => {
+      let w = await makeWorld();
+      await seed(w);
+      let total = w.appended.length;
+      let everything = await readAll({}, 1000);
+      globalThis.expect(everything.length).toBe(total);
+      globalThis.expect(sorted(everything.map(msgIdOf))).toEqual(sorted(w.appended.map(a => a.msgId)));
+      everything.forEach((r, i) => {
+        let next = everything[i + 1 | 0];
+        if (next !== undefined) {
+          globalThis.expect(r.recordedAt >= next.recordedAt).toBe(true);
+          return;
+        }
+      });
+      globalThis.expect(everything.some(r => Primitive_object.equal(r.plugin, "Catalog"))).toBe(true);
+      globalThis.expect(everything.some(r => Primitive_object.equal(r.plugin, "Ordering"))).toBe(true);
+      let first = await LocalEventLogRead$ReventlessLocal.read({}, 5, undefined);
+      globalThis.expect(first.hasNextPage).toBe(true);
+      await w.appendOrder("o-new", "Placed", "late", "u");
+      await w.appendProduct("p-new", "Added", "late", "u");
+      await w.appendCustomer("c-new", "late", "u");
+      let rest = [];
+      let after = first.endCursor;
+      let more = true;
+      while (more) {
+        let page = await LocalEventLogRead$ReventlessLocal.read({}, 5, after);
+        page.edges.forEach(param => {
+          rest.push(param[0]);
+        });
+        more = page.hasNextPage;
+        after = page.endCursor;
+      };
+      let paged = first.edges.map(param => param[0]).concat(rest);
+      globalThis.expect(paged.map(msgIdOf)).toEqual(everything.map(msgIdOf));
+      let match = first.edges[2];
+      let fromThird = await LocalEventLogRead$ReventlessLocal.read({}, 2, match[1]);
+      globalThis.expect(fromThird.edges.map(param => msgIdOf(param[0]))).toEqual(everything.slice(3, 5).map(msgIdOf));
+      let fresh = await LocalEventLogRead$ReventlessLocal.read({}, 3, undefined);
+      globalThis.expect(fresh.edges.every(param => Primitive_object.equal(LocalEventLogRead$ReventlessLocal.metaString(param[0].meta, "correlationId"), "late"))).toBe(true);
+    }));
+    globalThis.test("every filter narrows", () => run(async () => {
+      let w = await makeWorld();
+      await seed(w);
+      let expectFilter = async (filter, keep) => {
+        let got = await readAll(filter, 4);
+        let wanted = sorted(w.appended.filter(keep).map(a => a.msgId));
+        globalThis.expect(wanted.length !== 0).toBe(true);
+        globalThis.expect(wanted.length < w.appended.length).toBe(true);
+        globalThis.expect(sorted(got.map(msgIdOf))).toEqual(wanted);
+      };
+      await expectFilter({
+        plugins: ["Catalog"]
+      }, a => a.plugin === "Catalog");
+      await expectFilter({
+        logs: [
+          customersLog,
+          catalogLog
+        ]
+      }, a => a.log !== ordersLog);
+      await expectFilter({
+        eventTypes: [
+          "Placed",
+          "Archived"
+        ]
+      }, a => {
+        if (a.eventType === "Placed") {
+          return true;
+        } else {
+          return a.eventType === "Archived";
+        }
+      });
+      await expectFilter({
+        entityId: "o-1"
+      }, a => Primitive_object.equal(a.entityId, "o-1"));
+      await expectFilter({
+        entityId: "p-1"
+      }, a => a.tags.some(t => t.value === "p-1"));
+      await expectFilter({
+        tagKey: "productId",
+        tagValue: "p-0"
+      }, a => a.tags.some(t => {
+        if (t.key === "productId") {
+          return t.value === "p-0";
+        } else {
+          return false;
+        }
+      }));
+      let one = w.appended[5];
+      await expectFilter({
+        msgId: one.msgId
+      }, a => a.msgId === one.msgId);
+      await expectFilter({
+        correlationId: "flow-a"
+      }, a => a.correlationId === "flow-a");
+      await expectFilter({
+        causationId: "cause-of-flow-a"
+      }, a => a.causationId === "cause-of-flow-a");
+      await expectFilter({
+        user: "u-even"
+      }, a => a.user === "u-even");
+      await expectFilter({
+        plugins: ["Ordering"],
+        correlationId: "flow-b",
+        user: "u-odd"
+      }, a => {
+        if (a.plugin === "Ordering" && a.correlationId === "flow-b") {
+          return a.user === "u-odd";
+        } else {
+          return false;
+        }
+      });
+      let everything = await readAll({}, 100);
+      let middle = everything[(everything.length >> 1)].recordedAt;
+      let newer = await readAll({
+        timeFrom: middle
+      }, 7);
+      globalThis.expect(sorted(newer.map(msgIdOf))).toEqual(sorted(everything.filter(r => r.recordedAt >= middle).map(msgIdOf)));
+      let older = await readAll({
+        timeTo: middle
+      }, 7);
+      globalThis.expect(sorted(older.map(msgIdOf))).toEqual(sorted(everything.filter(r => r.recordedAt <= middle).map(msgIdOf)));
+    }));
+    globalThis.test("each event's log and position, as noted for the tap, are the read's", () => run(async () => {
+      let w = await makeWorld();
+      await w.appendOrder("o-1", "Placed", "tap", "u");
+      await w.appendProduct("p-1", "Added", "tap", "u");
+      let read = await readAll({}, 10);
+      read.forEach(r => {
+        let noted = LocalEventLogRead$ReventlessLocal.take(msgIdOf(r));
+        globalThis.expect(Stdlib_Option.map(noted, param => [
+          param[0],
+          LocalEventLogRead$ReventlessLocal.positionToString(param[1])
+        ])).toEqual([
+          r.log,
+          r.position
+        ]);
+      });
+    }));
+  });
+}
+
+scenario("memory", async () => BackendState$ReventlessLocal.setMemory(), async () => {});
+
+let sqliteDb = {
+  contents: undefined
+};
+
+scenario("SQLite", async () => {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  sqliteDb.contents = Primitive_option.some(db);
+  return BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+}, async () => {
+  BackendState$ReventlessLocal.setMemory();
+  Stdlib_Option.forEach(sqliteDb.contents, SqliteDriver$ReventlessLocal.close);
+  sqliteDb.contents = undefined;
+});
+
+let url = process.env["PG_URL"];
+
+if (url !== undefined) {
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: url
+  });
+  scenario("Postgres", async () => {
+    await PgSchema$ReventlessPostgres.ensureSchema(pool);
+    await PgSchema$ReventlessPostgres.truncateAll(pool);
+    return BackendState$ReventlessLocal.setPostgres(pool);
+  }, async () => BackendState$ReventlessLocal.setMemory());
+  globalThis.describe("the correlation index on Postgres", () => {
+    globalThis.afterAll(() => {
+      PgDriver$ReventlessPostgres.endPool(pool);
+    });
+    globalThis.test("a correlation filter's plan uses the index, on both tables", async () => {
+      await PgSchema$ReventlessPostgres.ensureSchema(pool);
+      let plan = async sql => await PgDriver$ReventlessPostgres.transaction(pool, async client => {
+        await PgDriver$ReventlessPostgres.execOn(client, "SET LOCAL enable_seqscan = off");
+        return (await PgDriver$ReventlessPostgres.queryOn(client, sql, [])).map(row => Object.values(row).map(v => JSON.stringify(v)).join(" ")).join("\n");
+      });
+      let aggregate = await plan("EXPLAIN SELECT global_seq FROM event_log WHERE log_name = 'L' AND (payload->>'correlationId') = 'c' ORDER BY global_seq DESC LIMIT 10");
+      globalThis.expect(aggregate.includes("event_log_correlation")).toBe(true);
+      let dcb = await plan("EXPLAIN SELECT position FROM dcb_event WHERE log_name = 'L' AND (meta->>'correlationId') = 'c' ORDER BY position DESC LIMIT 10");
+      globalThis.expect(dcb.includes("dcb_event_correlation")).toBe(true);
+    });
+  });
+} else {
+  globalThis.test("LocalEventLogRead on Postgres (skipped — set PG_URL to run)", () => {
+    globalThis.expect(true).toBe(true);
+  });
+}
+
+globalThis.describe("the correlation index on SQLite", () => {
+  let planOf = (db, param) => SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, "EXPLAIN QUERY PLAN " + param[0]), param[1]).map(row => Stdlib_Option.getOr(Stdlib_Option.flatMap(row["detail"], Stdlib_JSON.Decode.string), "")).join("\n");
+  globalThis.test("a correlation filter's plan uses the index, on both tables", () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    EventLogStorage_Sqlite$ReventlessLocal.ensureSchema(db);
+    DcbEventLogStorage_Sqlite$ReventlessLocal.ensureSchema(db);
+    let aggregate = planOf(db, EventLogStorage_Sqlite$ReventlessLocal.readBackSql("L", {
+      TAG: "Below",
+      _0: 100
+    }, 10, "c"));
+    globalThis.expect(aggregate.includes("event_log_by_correlation")).toBe(true);
+    let dcb = planOf(db, DcbEventLogStorage_Sqlite$ReventlessLocal.readBackSql("L", {
+      TAG: "Below",
+      _0: 100
+    }, 10, "c"));
+    globalThis.expect(dcb.includes("dcb_event_by_correlation")).toBe(true);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("an existing store gains the indexes when it is opened", () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+    EventLogStorage_Sqlite$ReventlessLocal.ensureSchema(db);
+    let names = Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, "SELECT name FROM sqlite_master WHERE type = 'index'"), []), row => Stdlib_Option.flatMap(row["name"], Stdlib_JSON.Decode.string));
+    globalThis.expect(names.includes("event_log_by_correlation")).toBe(true);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+});
+
+globalThis.describe("the tap line", () => {
+  globalThis.test("carries the event's log and position when its storage noted them", async () => {
+    process.env["REVENTLESS_EVENT_TAP"] = "ndjson";
+    let Bus = LocalBus$ReventlessLocal.MakeSilent({});
+    let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
+    LocalEventLogRead$ReventlessLocal.note(ordersLog, meta.msgId, 42);
+    let printed = [];
+    let original = console.log;
+    console.log = s => {
+      printed.push(s);
+    };
+    await Bus.publishEvent("OrderAggrEventTopic", "Order", meta, JSON.parse(`{"event":{"TAG":"Placed"}}`));
+    let other = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
+    await Bus.publishEvent("Lonely", "svc", other, null);
+    console.log = original;
+    Stdlib_Dict.$$delete(process.env, "REVENTLESS_EVENT_TAP");
+    let lines = printed.filter(l => l.startsWith("@@RVLESS_EVT@@ ")).map(l => Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(JSON.parse(l.slice(15, l.length))), undefined));
+    let field = (d, k) => Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+    let first = lines[0];
+    globalThis.expect(field(first, "log")).toEqual(ordersLog);
+    globalThis.expect(field(first, "position")).toEqual("42");
+    [
+      "event",
+      "seq",
+      "topic",
+      "service",
+      "payload",
+      "ts"
+    ].forEach(k => {
+      globalThis.expect(Stdlib_Option.isSome(first[k])).toBe(true);
+    });
+    let second = lines[1];
+    globalThis.expect(second["log"]).toEqual(undefined);
+    globalThis.expect(second["position"]).toEqual(undefined);
+  });
+});
+
+export {
+  opts,
+  ordersLog,
+  customersLog,
+  catalogLog,
+  resolveOrThrow,
+  makeWorld,
+  seed,
+  msgIdOf,
+  readAll,
+  sorted,
+  scenario,
+  sqliteDb,
+}
+/*  Not a pure module */