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

package/tests/adapter/LocalEvents_ServerTest.res

@@ -32,6 +32,17 @@ let descriptor = (~id: string): JSON.t =>
 describe("LocalEvents_Server", () => {
   beforeEach(() => LocalEvents_Server.resetConnections())
 
+  testSync("a subscription is told by its channel and who subscribed", () => {
+    let conn = LocalEvents_Server.addConnection(~send=_ => (), ~user="alice")
+    expect(
+      LocalEvents_Server.subscriptionLine(conn, ~verb="subscribe", ~channel="/default/orders/*"),
+    )->toBe("subscribe /default/orders/* by alice")
+    let anonymous = LocalEvents_Server.addConnection(~send=_ => ())
+    expect(
+      LocalEvents_Server.subscriptionLine(anonymous, ~verb="unsubscribe", ~channel="/default/x"),
+    )->toBe("unsubscribe /default/x")
+  })
+
   describe("channelMatches", () => {
     testSync(
       "exact match",

package/tests/adapter/LocalEvents_ServerTest.res.mjs

@@ -17,7 +17,7 @@ function makeConn() {
   sentFrames.contents = [];
   return LocalEvents_Server$ReventlessLocal.addConnection(f => {
     sentFrames.contents.push(f);
-  });
+  }, undefined);
 }
 
 function parseFrame(s) {
@@ -47,6 +47,12 @@ function descriptor(id) {
 
 globalThis.describe("LocalEvents_Server", () => {
   globalThis.beforeEach(() => LocalEvents_Server$ReventlessLocal.resetConnections());
+  globalThis.test("a subscription is told by its channel and who subscribed", () => {
+    let conn = LocalEvents_Server$ReventlessLocal.addConnection(param => {}, "alice");
+    globalThis.expect(LocalEvents_Server$ReventlessLocal.subscriptionLine(conn, "subscribe", "/default/orders/*")).toBe("subscribe /default/orders/* by alice");
+    let anonymous = LocalEvents_Server$ReventlessLocal.addConnection(param => {}, undefined);
+    globalThis.expect(LocalEvents_Server$ReventlessLocal.subscriptionLine(anonymous, "unsubscribe", "/default/x")).toBe("unsubscribe /default/x");
+  });
   globalThis.describe("channelMatches", () => {
     globalThis.test("exact match", () => {
       globalThis.expect(LocalEvents_Server$ReventlessLocal.channelMatches("/default/Product/p-1", "/default/Product/p-1")).toBe(true);

package/tests/adapter/LocalIdleExitTest.res

@@ -0,0 +1,57 @@
+// A platform left running for an editor stops once nothing has watched it for its grace, and keeps
+// running while something does.
+
+open JestGlobals
+
+let wait = ms =>
+  Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), ms)
+  })
+
+describe("LocalIdleExit", () => {
+  let stopped = ref(0)
+  beforeEach(() => {
+    LocalIdleExit.reset()
+    stopped := 0
+    LocalIdleExit.onIdle := (() => stopped := stopped.contents + 1)
+  })
+  afterEach(() => LocalIdleExit.reset())
+
+  testSync("reads its grace in seconds, and nothing else turns it on", () => {
+    expect(LocalIdleExit.graceOf(Some("60")))->toEqual(Some(60_000))
+    expect(LocalIdleExit.graceOf(Some("0")))->toEqual(None)
+    expect(LocalIdleExit.graceOf(Some("soon")))->toEqual(None)
+    expect(LocalIdleExit.graceOf(None))->toEqual(None)
+  })
+
+  testPromise("stops when nothing connects within its grace", async () => {
+    LocalIdleExit.start(~env=dict{"REVENTLESS_IDLE_EXIT": "1"})
+    await wait(1200)
+    expect(stopped.contents)->toBe(1)
+  })
+
+  testPromise(
+    "keeps running while watched, and a watcher back in time keeps it running",
+    async () => {
+      LocalIdleExit.start(~env=dict{"REVENTLESS_IDLE_EXIT": "1"})
+      LocalIdleExit.connected()
+      await wait(1200)
+      expect(stopped.contents)->toBe(0)
+      // A reload: the watcher goes and comes back within the grace.
+      LocalIdleExit.disconnected()
+      await wait(500)
+      LocalIdleExit.connected()
+      await wait(800)
+      expect(stopped.contents)->toBe(0)
+      LocalIdleExit.disconnected()
+      await wait(1200)
+      expect(stopped.contents)->toBe(1)
+    },
+  )
+
+  testPromise("does nothing without the variable", async () => {
+    LocalIdleExit.start(~env=dict{})
+    await wait(1200)
+    expect(stopped.contents)->toBe(0)
+  })
+})

package/tests/adapter/LocalIdleExitTest.res.mjs

@@ -0,0 +1,62 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalIdleExit$ReventlessLocal from "../../src/adapter/LocalIdleExit.res.mjs";
+
+function wait(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+globalThis.describe("LocalIdleExit", () => {
+  let stopped = {
+    contents: 0
+  };
+  globalThis.beforeEach(() => {
+    LocalIdleExit$ReventlessLocal.reset();
+    stopped.contents = 0;
+    LocalIdleExit$ReventlessLocal.onIdle.contents = () => {
+      stopped.contents = stopped.contents + 1 | 0;
+    };
+  });
+  globalThis.afterEach(() => LocalIdleExit$ReventlessLocal.reset());
+  globalThis.test("reads its grace in seconds, and nothing else turns it on", () => {
+    globalThis.expect(LocalIdleExit$ReventlessLocal.graceOf("60")).toEqual(60000);
+    globalThis.expect(LocalIdleExit$ReventlessLocal.graceOf("0")).toEqual(undefined);
+    globalThis.expect(LocalIdleExit$ReventlessLocal.graceOf("soon")).toEqual(undefined);
+    globalThis.expect(LocalIdleExit$ReventlessLocal.graceOf(undefined)).toEqual(undefined);
+  });
+  globalThis.test("stops when nothing connects within its grace", async () => {
+    LocalIdleExit$ReventlessLocal.start({
+      REVENTLESS_IDLE_EXIT: "1"
+    });
+    await wait(1200);
+    globalThis.expect(stopped.contents).toBe(1);
+  });
+  globalThis.test("keeps running while watched, and a watcher back in time keeps it running", async () => {
+    LocalIdleExit$ReventlessLocal.start({
+      REVENTLESS_IDLE_EXIT: "1"
+    });
+    LocalIdleExit$ReventlessLocal.connected();
+    await wait(1200);
+    globalThis.expect(stopped.contents).toBe(0);
+    LocalIdleExit$ReventlessLocal.disconnected();
+    await wait(500);
+    LocalIdleExit$ReventlessLocal.connected();
+    await wait(800);
+    globalThis.expect(stopped.contents).toBe(0);
+    LocalIdleExit$ReventlessLocal.disconnected();
+    await wait(1200);
+    globalThis.expect(stopped.contents).toBe(1);
+  });
+  globalThis.test("does nothing without the variable", async () => {
+    LocalIdleExit$ReventlessLocal.start({});
+    await wait(1200);
+    globalThis.expect(stopped.contents).toBe(0);
+  });
+});
+
+export {
+  wait,
+}
+/*  Not a pure module */

package/tests/adapter/LocalPlatformObserveTest.res

@@ -123,8 +123,11 @@ describe("the platform API's watching fields", () => {
       }
     }
     expect(await refused(s.getQueryResolver(LocalPlatformObserve.eventLogField)))->toBe(true)
+    expect(await refused(s.getQueryResolver(LocalPlatformObserve.viewChangesField)))->toBe(true)
+    expect(await refused(s.getQueryResolver(LocalPlatformObserve.commandOutcomesField)))->toBe(true)
     expect(await refused(s.getQueryResolver(LocalPlatformObserve.logLevelsField)))->toBe(true)
     expect(await refused(s.getMutationResolver(LocalPlatformObserve.setLogLevelField)))->toBe(true)
+    expect(await refused(s.getQueryResolver(LocalPlatformObserve.metricsField)))->toBe(true)
   })
 
   testPromise("set and list the log levels for an admin", async () => {
@@ -156,6 +159,186 @@ describe("the platform API's watching fields", () => {
     expect(answer->field("pageInfo")->field("hasNextPage"))->toEqual(JSON.Encode.bool(false))
   })
 
+  // Two flows: two changes in one, one in the other.
+  let keepChanges = () => {
+    let change = (~view, ~key, ~flow, msgId): ReventlessCore.ViewChange.t => {
+      view,
+      key,
+      kind: Changed,
+      fields: ["status"],
+      after: JSON.parseOrThrow(`{"status":"shipped"}`),
+      sources: [{msgId, correlationId: flow}],
+      correlationId: flow,
+    }
+    LocalViewChangeLog.record(change(~view="Orders", ~key="o-1", ~flow="k-1", "m-1"))
+    LocalViewChangeLog.record(change(~view="Customers", ~key="c-1", ~flow="k-2", "m-2"))
+    LocalViewChangeLog.record(change(~view="Customers", ~key="c-1", ~flow="k-1", "m-3"))
+  }
+
+  let readChanges = async (args: string) => {
+    let s = server()
+    let read = s.getQueryResolver(LocalPlatformObserve.viewChangesField)->Option.getOrThrow
+    await read(JSON.Encode.null, JSON.parseOrThrow(args), admin())
+  }
+
+  let views = (answer: JSON.t) =>
+    answer
+    ->field("edges")
+    ->JSON.Decode.array
+    ->Option.getOr([])
+    ->Array.map(e => e->field("node")->field("view")->JSON.Decode.string->Option.getOr(""))
+
+  let readsBack = async () => {
+    keepChanges()
+    let flow = await readChanges(`{"filter":{"correlationId":"k-1"}}`)
+    let byEvent = await readChanges(`{"filter":{"msgId":"m-2"}}`)
+    let firstPage = await readChanges(`{"filter":{"correlationId":"k-1"},"first":1}`)
+    let cursor = firstPage->field("pageInfo")->field("endCursor")->JSON.Decode.string
+    let secondPage = await readChanges(
+      `{"filter":{"correlationId":"k-1"},"first":1,"after":"${cursor->Option.getOr("")}"}`,
+    )
+    (
+      views(flow),
+      views(byEvent),
+      views(firstPage),
+      firstPage->field("pageInfo")->field("hasNextPage"),
+      views(secondPage),
+      secondPage->field("pageInfo")->field("hasNextPage"),
+    )
+  }
+
+  let expected = (
+    ["Customers", "Orders"],
+    ["Customers"],
+    ["Customers"],
+    JSON.Encode.bool(true),
+    ["Orders"],
+    JSON.Encode.bool(false),
+  )
+
+  testPromise(
+    "the view changes answer an admin by flow and event, newest first, in pages",
+    async () => {
+      BackendState.setMemory()
+      LocalViewChangeLog.resetForTests()
+      expect(await readsBack())->toEqual(expected)
+      LocalViewChangeLog.resetForTests()
+    },
+  )
+
+  testPromise("the view changes are kept in a SQLite store alike", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    BackendState.setSqlite(~db, ~path=":memory:")
+    LocalViewChangeLog.resetForTests()
+    expect(await readsBack())->toEqual(expected)
+    LocalViewChangeLog.resetForTests()
+    BackendState.setMemory()
+    SqliteDriver.close(db)
+  })
+
+  // Three commands: two in one flow, one rejected.
+  let keepOutcomes = () => {
+    let report = (
+      ~flow,
+      ~outcome,
+      msgId,
+    ): ReventlessCore.CommandTopic_Helpers.commandOutcomeReport => {
+      component: "Order",
+      reference: msgId,
+      correlationId: flow,
+      outcome,
+    }
+    let accepted = ReventlessCore.CommandTopic_Helpers.OutcomeAccepted({
+      entityId: Some("o-1"),
+      eventCount: 1,
+    })
+    LocalCommandOutcomeLog.record(report(~flow="k-1", ~outcome=accepted, "c-1"))
+    LocalCommandOutcomeLog.record(report(~flow="k-2", ~outcome=accepted, "c-2"))
+    LocalCommandOutcomeLog.record(
+      report(
+        ~flow="k-1",
+        ~outcome=OutcomeRejected({
+          errorCode: "AlreadyShipped",
+          errorDetail: "",
+          cause: ReventlessCore.CommandTopic_Helpers.DomainRejection,
+        }),
+        "c-3",
+      ),
+    )
+  }
+
+  let outcomesRead = async () => {
+    keepOutcomes()
+    let s = server()
+    let read = s.getQueryResolver(LocalPlatformObserve.commandOutcomesField)->Option.getOrThrow
+    let ask = async args => {
+      let answer = await read(JSON.Encode.null, JSON.parseOrThrow(args), admin())
+      answer
+      ->field("edges")
+      ->JSON.Decode.array
+      ->Option.getOr([])
+      ->Array.map(e => {
+        let node = e->field("node")
+        (
+          node->field("msgId")->JSON.Decode.string->Option.getOr(""),
+          node->field("outcome")->JSON.Decode.string->Option.getOr(""),
+        )
+      })
+    }
+    (await ask(`{"filter":{"correlationId":"k-1"}}`), await ask(`{"filter":{"msgId":"c-2"}}`))
+  }
+
+  let outcomesExpected = ([("c-3", "rejected"), ("c-1", "accepted")], [("c-2", "accepted")])
+
+  testPromise(
+    "the command outcomes answer an admin by flow and by command, newest first",
+    async () => {
+      BackendState.setMemory()
+      LocalCommandOutcomeLog.resetForTests()
+      expect(await outcomesRead())->toEqual(outcomesExpected)
+      LocalCommandOutcomeLog.resetForTests()
+    },
+  )
+
+  testPromise("the command outcomes are kept in a SQLite store alike", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    BackendState.setSqlite(~db, ~path=":memory:")
+    LocalCommandOutcomeLog.resetForTests()
+    expect(await outcomesRead())->toEqual(outcomesExpected)
+    LocalCommandOutcomeLog.resetForTests()
+    BackendState.setMemory()
+    SqliteDriver.close(db)
+  })
+
+  testPromise("the metrics answer an admin with the counts, narrowed by plugin", async () => {
+    let counts = LocalMetrics.counts
+    ReventlessCore.Metrics.Counts.clear(counts)
+    let sample = (~metric, ~plugin, ~value=1): ReventlessCore.Metrics.sample => {
+      metric,
+      slice: "PlaceOrder",
+      plugin,
+      value,
+      unit: "Count",
+      at: Date.now(),
+    }
+    counts->ReventlessCore.Metrics.Counts.add(sample(~metric="AppendRetry", ~plugin="Ordering"))
+    counts->ReventlessCore.Metrics.Counts.add(sample(~metric="AppendRetry", ~plugin="Ordering"))
+    counts->ReventlessCore.Metrics.Counts.add(sample(~metric="AppendRetry", ~plugin="Catalog"))
+    let s = server()
+    let read = s.getQueryResolver(LocalPlatformObserve.metricsField)->Option.getOrThrow
+    let answer = await read(
+      JSON.Encode.null,
+      JSON.parseOrThrow(`{"plugins":["Ordering"]}`),
+      admin(),
+    )
+    let rows = answer->JSON.Decode.array->Option.getOr([])
+    expect(rows->Array.length)->toBe(1)
+    let row = rows->Array.getUnsafe(0)
+    expect(row->field("plugin"))->toEqual(JSON.Encode.string("Ordering"))
+    expect(row->field("count"))->toEqual(JSON.Encode.int(2))
+    ReventlessCore.Metrics.Counts.clear(counts)
+  })
+
   testSync("the SDL builds into a schema", () => {
     let s = server()
     let sdl = s.buildSdl()

package/tests/adapter/LocalPlatformObserveTest.res.mjs

@@ -7,12 +7,17 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Role$Reventless from "@reventlessdev/reventless-spec/src/types/Role.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Metrics$ReventlessCore from "@reventlessdev/reventless-core/src/util/Metrics.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 LocalLogFeed$ReventlessLocal from "../../src/adapter/LocalLogFeed.res.mjs";
+import * as LocalMetrics$ReventlessLocal from "../../src/adapter/LocalMetrics.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
 import * as LocalEventLogRead$ReventlessLocal from "../../src/adapter/LocalEventLogRead.res.mjs";
+import * as LocalViewChangeLog$ReventlessLocal from "../../src/adapter/ViewChangeLog/LocalViewChangeLog.res.mjs";
 import * as LocalPlatformObserve$ReventlessLocal from "../../src/adapter/LocalPlatformObserve.res.mjs";
+import * as LocalCommandOutcomeLog$ReventlessLocal from "../../src/adapter/CommandOutcomeLog/LocalCommandOutcomeLog.res.mjs";
 import * as LocalDcbEventLogStorage$ReventlessLocal from "../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
 import * as GraphQL_ServerInstance$ReventlessGraphqlServer from "@reventlessdev/reventless-graphql-server/src/GraphQL_ServerInstance.res.mjs";
 
@@ -135,8 +140,11 @@ globalThis.describe("the platform API's watching fields", () => {
       }
     };
     globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.eventLogField))).toBe(true);
+    globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.viewChangesField))).toBe(true);
+    globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.commandOutcomesField))).toBe(true);
     globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.logLevelsField))).toBe(true);
     globalThis.expect(await refused(s.getMutationResolver(LocalPlatformObserve$ReventlessLocal.setLogLevelField))).toBe(true);
+    globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.metricsField))).toBe(true);
   });
   globalThis.test("set and list the log levels for an admin", async () => {
     let s = server();
@@ -157,6 +165,179 @@ globalThis.describe("the platform API's watching fields", () => {
     globalThis.expect(field(answer, "edges")).toEqual([]);
     globalThis.expect(field(field(answer, "pageInfo"), "hasNextPage")).toEqual(false);
   });
+  let keepChanges = () => {
+    let change = (view, key, flow, msgId) => ({
+      view: view,
+      key: key,
+      kind: "Changed",
+      fields: ["status"],
+      after: JSON.parse(`{"status":"shipped"}`),
+      sources: [{
+          msgId: msgId,
+          correlationId: flow
+        }],
+      correlationId: flow
+    });
+    LocalViewChangeLog$ReventlessLocal.record(change("Orders", "o-1", "k-1", "m-1"));
+    LocalViewChangeLog$ReventlessLocal.record(change("Customers", "c-1", "k-2", "m-2"));
+    LocalViewChangeLog$ReventlessLocal.record(change("Customers", "c-1", "k-1", "m-3"));
+  };
+  let readChanges = async args => {
+    let s = server();
+    let read = Stdlib_Option.getOrThrow(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.viewChangesField), undefined);
+    return await read(null, JSON.parse(args), context([Role$Reventless.adminGroup()]));
+  };
+  let views = answer => Stdlib_Option.getOr(Stdlib_JSON.Decode.array(field(answer, "edges")), []).map(e => Stdlib_Option.getOr(Stdlib_JSON.Decode.string(field(field(e, "node"), "view")), ""));
+  let readsBack = async () => {
+    keepChanges();
+    let flow = await readChanges(`{"filter":{"correlationId":"k-1"}}`);
+    let byEvent = await readChanges(`{"filter":{"msgId":"m-2"}}`);
+    let firstPage = await readChanges(`{"filter":{"correlationId":"k-1"},"first":1}`);
+    let cursor = Stdlib_JSON.Decode.string(field(field(firstPage, "pageInfo"), "endCursor"));
+    let secondPage = await readChanges(`{"filter":{"correlationId":"k-1"},"first":1,"after":"` + Stdlib_Option.getOr(cursor, "") + `"}`);
+    return [
+      views(flow),
+      views(byEvent),
+      views(firstPage),
+      field(field(firstPage, "pageInfo"), "hasNextPage"),
+      views(secondPage),
+      field(field(secondPage, "pageInfo"), "hasNextPage")
+    ];
+  };
+  let expected_0 = [
+    "Customers",
+    "Orders"
+  ];
+  let expected_1 = ["Customers"];
+  let expected_2 = ["Customers"];
+  let expected_4 = ["Orders"];
+  let expected = [
+    expected_0,
+    expected_1,
+    expected_2,
+    true,
+    expected_4,
+    false
+  ];
+  globalThis.test("the view changes answer an admin by flow and event, newest first, in pages", async () => {
+    BackendState$ReventlessLocal.setMemory();
+    LocalViewChangeLog$ReventlessLocal.resetForTests();
+    globalThis.expect(await readsBack()).toEqual(expected);
+    return LocalViewChangeLog$ReventlessLocal.resetForTests();
+  });
+  globalThis.test("the view changes are kept in a SQLite store alike", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+    LocalViewChangeLog$ReventlessLocal.resetForTests();
+    globalThis.expect(await readsBack()).toEqual(expected);
+    LocalViewChangeLog$ReventlessLocal.resetForTests();
+    BackendState$ReventlessLocal.setMemory();
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  let keepOutcomes = () => {
+    let report = (flow, outcome, msgId) => ({
+      component: "Order",
+      reference: msgId,
+      correlationId: flow,
+      outcome: outcome
+    });
+    let accepted = {
+      TAG: "OutcomeAccepted",
+      entityId: "o-1",
+      eventCount: 1
+    };
+    LocalCommandOutcomeLog$ReventlessLocal.record(report("k-1", accepted, "c-1"));
+    LocalCommandOutcomeLog$ReventlessLocal.record(report("k-2", accepted, "c-2"));
+    LocalCommandOutcomeLog$ReventlessLocal.record({
+      component: "Order",
+      reference: "c-3",
+      correlationId: "k-1",
+      outcome: {
+        TAG: "OutcomeRejected",
+        errorCode: "AlreadyShipped",
+        errorDetail: "",
+        cause: "DomainRejection"
+      }
+    });
+  };
+  let outcomesRead = async () => {
+    keepOutcomes();
+    let s = server();
+    let read = Stdlib_Option.getOrThrow(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.commandOutcomesField), undefined);
+    let ask = async args => {
+      let answer = await read(null, JSON.parse(args), context([Role$Reventless.adminGroup()]));
+      return Stdlib_Option.getOr(Stdlib_JSON.Decode.array(field(answer, "edges")), []).map(e => {
+        let node = field(e, "node");
+        return [
+          Stdlib_Option.getOr(Stdlib_JSON.Decode.string(field(node, "msgId")), ""),
+          Stdlib_Option.getOr(Stdlib_JSON.Decode.string(field(node, "outcome")), "")
+        ];
+      });
+    };
+    return [
+      await ask(`{"filter":{"correlationId":"k-1"}}`),
+      await ask(`{"filter":{"msgId":"c-2"}}`)
+    ];
+  };
+  let outcomesExpected_0 = [
+    [
+      "c-3",
+      "rejected"
+    ],
+    [
+      "c-1",
+      "accepted"
+    ]
+  ];
+  let outcomesExpected_1 = [[
+      "c-2",
+      "accepted"
+    ]];
+  let outcomesExpected = [
+    outcomesExpected_0,
+    outcomesExpected_1
+  ];
+  globalThis.test("the command outcomes answer an admin by flow and by command, newest first", async () => {
+    BackendState$ReventlessLocal.setMemory();
+    LocalCommandOutcomeLog$ReventlessLocal.resetForTests();
+    globalThis.expect(await outcomesRead()).toEqual(outcomesExpected);
+    return LocalCommandOutcomeLog$ReventlessLocal.resetForTests();
+  });
+  globalThis.test("the command outcomes are kept in a SQLite store alike", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+    LocalCommandOutcomeLog$ReventlessLocal.resetForTests();
+    globalThis.expect(await outcomesRead()).toEqual(outcomesExpected);
+    LocalCommandOutcomeLog$ReventlessLocal.resetForTests();
+    BackendState$ReventlessLocal.setMemory();
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("the metrics answer an admin with the counts, narrowed by plugin", async () => {
+    Metrics$ReventlessCore.Counts.clear(LocalMetrics$ReventlessLocal.counts);
+    let sample = (metric, plugin, valueOpt) => {
+      let value = valueOpt !== undefined ? valueOpt : 1;
+      return {
+        metric: metric,
+        slice: "PlaceOrder",
+        plugin: plugin,
+        value: value,
+        unit: "Count",
+        at: Date.now()
+      };
+    };
+    Metrics$ReventlessCore.Counts.add(LocalMetrics$ReventlessLocal.counts, sample("AppendRetry", "Ordering", undefined));
+    Metrics$ReventlessCore.Counts.add(LocalMetrics$ReventlessLocal.counts, sample("AppendRetry", "Ordering", undefined));
+    Metrics$ReventlessCore.Counts.add(LocalMetrics$ReventlessLocal.counts, sample("AppendRetry", "Catalog", undefined));
+    let s = server();
+    let read = Stdlib_Option.getOrThrow(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.metricsField), undefined);
+    let answer = await read(null, JSON.parse(`{"plugins":["Ordering"]}`), context([Role$Reventless.adminGroup()]));
+    let rows = Stdlib_Option.getOr(Stdlib_JSON.Decode.array(answer), []);
+    globalThis.expect(rows.length).toBe(1);
+    let row = rows[0];
+    globalThis.expect(field(row, "plugin")).toEqual("Ordering");
+    globalThis.expect(field(row, "count")).toEqual(2);
+    return Metrics$ReventlessCore.Counts.clear(LocalMetrics$ReventlessLocal.counts);
+  });
   globalThis.test("the SDL builds into a schema", () => {
     let s = server();
     let sdl = s.buildSdl();

package/tests/adapter/LocalRequestLogTest.res

@@ -0,0 +1,46 @@
+// The line the app's API writes for each GraphQL operation: how it reads, and at which level.
+
+open JestGlobals
+
+let report = (
+  ~kind="query",
+  ~operationName=?,
+  ~fields=["Catalog_Products"],
+  ~user=?,
+  ~ms=12.,
+  ~errors=[],
+  (),
+): GraphqlYoga.requestReport => {kind, ?operationName, fields, ?user, ms, errors}
+
+let line = r => LocalRequestLog.lineOf(r)
+
+testSync("a query is a debug line naming it, who asked and how long it took", () => {
+  let l = line(report(~operationName="Products", ~user="alice", ()))
+  expect(l.message)->toBe("query Products by alice in 12 ms")
+  expect(l.level == Debug)->toBe(true)
+})
+
+testSync("an operation without a name goes by its root fields", () => {
+  let l = line(report(~fields=["Catalog_Products", "Catalog_Categories"], ()))
+  expect(l.message)->toBe("query Catalog_Products, Catalog_Categories in 12 ms")
+})
+
+testSync("a mutation is an info line", () => {
+  let l = line(report(~kind="mutation", ~fields=["Catalog_AddProduct"], ~user="bob", ~ms=40., ()))
+  expect(l.message)->toBe("mutation Catalog_AddProduct by bob in 40 ms")
+  expect(l.level == Info)->toBe(true)
+})
+
+testSync("an operation that answered with errors is a warning with the first of them", () => {
+  let l = line(
+    report(~kind="mutation", ~fields=["Catalog_AddProduct"], ~errors=["Forbidden", "Other"], ()),
+  )
+  expect(l.message)->toBe("mutation Catalog_AddProduct failed in 12 ms: Forbidden (and 1 more)")
+  expect(l.level == Warn)->toBe(true)
+})
+
+testSync("a subscription is said when it starts, with no time", () => {
+  let l = line(report(~kind="subscription", ~fields=["onOrderChanged"], ~ms=0., ()))
+  expect(l.message)->toBe("subscription onOrderChanged")
+  expect(l.level == Debug)->toBe(true)
+})

package/tests/adapter/LocalRequestLogTest.res.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalRequestLog$ReventlessLocal from "../../src/adapter/LocalRequestLog.res.mjs";
+
+function report(kindOpt, operationName, fieldsOpt, user, msOpt, errorsOpt, param) {
+  let kind = kindOpt !== undefined ? kindOpt : "query";
+  let fields = fieldsOpt !== undefined ? fieldsOpt : ["Catalog_Products"];
+  let ms = msOpt !== undefined ? msOpt : 12;
+  let errors = errorsOpt !== undefined ? errorsOpt : [];
+  return {
+    kind: kind,
+    operationName: operationName,
+    fields: fields,
+    user: user,
+    ms: ms,
+    errors: errors
+  };
+}
+
+let line = LocalRequestLog$ReventlessLocal.lineOf;
+
+globalThis.test("a query is a debug line naming it, who asked and how long it took", () => {
+  let l = LocalRequestLog$ReventlessLocal.lineOf(report(undefined, "Products", undefined, "alice", undefined, undefined, undefined));
+  globalThis.expect(l.message).toBe("query Products by alice in 12 ms");
+  globalThis.expect(l.level === "Debug").toBe(true);
+});
+
+globalThis.test("an operation without a name goes by its root fields", () => {
+  let l = LocalRequestLog$ReventlessLocal.lineOf(report(undefined, undefined, [
+    "Catalog_Products",
+    "Catalog_Categories"
+  ], undefined, undefined, undefined, undefined));
+  globalThis.expect(l.message).toBe("query Catalog_Products, Catalog_Categories in 12 ms");
+});
+
+globalThis.test("a mutation is an info line", () => {
+  let l = LocalRequestLog$ReventlessLocal.lineOf(report("mutation", undefined, ["Catalog_AddProduct"], "bob", 40, undefined, undefined));
+  globalThis.expect(l.message).toBe("mutation Catalog_AddProduct by bob in 40 ms");
+  globalThis.expect(l.level === "Info").toBe(true);
+});
+
+globalThis.test("an operation that answered with errors is a warning with the first of them", () => {
+  let l = LocalRequestLog$ReventlessLocal.lineOf(report("mutation", undefined, ["Catalog_AddProduct"], undefined, undefined, [
+    "Forbidden",
+    "Other"
+  ], undefined));
+  globalThis.expect(l.message).toBe("mutation Catalog_AddProduct failed in 12 ms: Forbidden (and 1 more)");
+  globalThis.expect(l.level === "Warn").toBe(true);
+});
+
+globalThis.test("a subscription is said when it starts, with no time", () => {
+  let l = LocalRequestLog$ReventlessLocal.lineOf(report("subscription", undefined, ["onOrderChanged"], undefined, 0, undefined, undefined));
+  globalThis.expect(l.message).toBe("subscription onOrderChanged");
+  globalThis.expect(l.level === "Debug").toBe(true);
+});
+
+export {
+  report,
+  line,
+}
+/*  Not a pure module */