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

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs

@@ -16,6 +16,7 @@ import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/compon
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
 import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
+import * as RowChange$ReventlessCore from "@reventlessdev/reventless-core/src/RowChange.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as SortKey_Filter$ReventlessLocal from "./SortKey_Filter.res.mjs";
@@ -749,9 +750,15 @@ function Make(Bus) {
       };
       fieldResolvers[match.resolvedField] = resolver;
     });
-    if (Object.keys(fieldResolvers).length !== 0) {
-      server.registerFieldResolvers(returnTypeName, fieldResolvers);
-    }
+    let changeResolver = async (root, _args, ctx) => {
+      if (OwnerScope$Reventless.isExempt(OwnerScope$Reventless.resolve(extractIdentity(ctx), undefined))) {
+        return Stdlib_Option.getOr(sourceField(root, RowChange$ReventlessCore.key), null);
+      } else {
+        return null;
+      }
+    };
+    fieldResolvers[RowChange$ReventlessCore.key] = changeResolver;
+    server.registerFieldResolvers(returnTypeName, fieldResolvers);
     let allSdl = [byIdSdl].concat(byIdsSdl).concat(refsSdl).concat(match[0]).concat(itemsSdl).concat(indexSdlFields);
     let resolvers = {};
     resolvers[singleQueryName] = byIdResolver;

package/src/adapter/ViewChangeLog/LocalViewChangeLog.res

@@ -0,0 +1,95 @@
+// Every row change the local platform makes, kept and read back by flow, event, view or row:
+// a tool that missed a change live reads it here. In the SQLite store when the platform runs
+// on one, else in memory for as long as it runs (Postgres included, whose store is not
+// this machine's). Each change is the tap's `viewChange` line, so live and stored read alike.
+
+module ViewChange = ReventlessCore.ViewChange
+
+/** A change as a page lists it: the tap's line, and the cursor to read on after it. */
+type node = {item: JSON.t, cursor: string}
+
+type page = {records: array<node>, hasNextPage: bool, endCursor?: string}
+
+let sqliteReady = ref(None)
+
+/** The SQLite store when the platform runs on one, its table made once. */
+let sqlite = () =>
+  switch BackendState.getSqliteDb() {
+  | Some(db) =>
+    if sqliteReady.contents !== Some(db) {
+      ViewChangeLogStorage_Sqlite.ensureSchema(db)
+      sqliteReady := Some(db)
+    }
+    Some(db)
+  | None => None
+  }
+
+let nextSeq = ref(0)
+
+let record = (c: ViewChange.t) => {
+  let item = LocalTapLines.viewChangeLine(c)->JSON.parseOrThrow
+  let entry: ViewChangeLogEntry.t = {
+    seq: 0,
+    flow: ?c.correlationId,
+    view: c.view,
+    key: c.key,
+    msgIds: c.sources->Array.map(s => s.msgId),
+    item,
+  }
+  switch sqlite() {
+  | Some(db) => ViewChangeLogStorage_Sqlite.append(db, entry)
+  | None =>
+    nextSeq := nextSeq.contents + 1
+    ViewChangeLogStorage_InMemory.append({...entry, seq: nextSeq.contents})
+  }
+}
+
+/** A page of the changes matching the filter, newest first; `after` is a page's `endCursor`. */
+let read = (~filter: ViewChangeLogEntry.filter, ~first=100, ~after: option<string>=?): page => {
+  let before = after->Option.flatMap(a => Int.fromString(a))
+  // One more than asked, to know whether there is a next page.
+  let rows = switch sqlite() {
+  | Some(db) => ViewChangeLogStorage_Sqlite.read(db, ~filter, ~before, ~first=first + 1)
+  | None => ViewChangeLogStorage_InMemory.read(~filter, ~before, ~first=first + 1)
+  }
+  let shown = rows->Array.slice(~start=0, ~end=first)
+  let hasNextPage = rows->Array.length > first
+  {
+    records: shown->Array.map(e => {item: e.item, cursor: e.seq->Int.toString}),
+    hasNextPage,
+    endCursor: ?(hasNextPage ? shown->Array.at(-1)->Option.map(e => e.seq->Int.toString) : None),
+  }
+}
+
+let removal: ref<option<unit => unit>> = ref(None)
+
+/** Starts keeping every row change, once per process. A change that cannot be kept is logged
+    and passed over: the row is already written. */
+let install = () =>
+  if removal.contents->Option.isNone {
+    let log = ReventlessCore.Logger.fromEnv()
+    removal :=
+      Some(
+        ViewChange.register(c =>
+          try record(c) catch {
+          | exn =>
+            log.warn(
+              ~comp="ViewChangeLog",
+              `a row change of ${c.view} was not kept: ${exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("unknown")}`,
+            )
+          }
+        ),
+      )
+  }
+
+/** Test seam: stops keeping them and forgets the in-memory ones. */
+let resetForTests = () => {
+  removal.contents->Option.forEach(remove => remove())
+  removal := None
+  ViewChangeLogStorage_InMemory.clear()
+  nextSeq := 0
+  sqliteReady := None
+}

package/src/adapter/ViewChangeLog/LocalViewChangeLog.res.mjs

@@ -0,0 +1,116 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as ViewChange$ReventlessCore from "@reventlessdev/reventless-core/src/ViewChange.res.mjs";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as LocalTapLines$ReventlessLocal from "../LocalTapLines.res.mjs";
+import * as ViewChangeLogStorage_Sqlite$ReventlessLocal from "./ViewChangeLogStorage_Sqlite.res.mjs";
+import * as ViewChangeLogStorage_InMemory$ReventlessLocal from "./ViewChangeLogStorage_InMemory.res.mjs";
+
+let sqliteReady = {
+  contents: undefined
+};
+
+function sqlite() {
+  let db = BackendState$ReventlessLocal.getSqliteDb();
+  if (db === undefined) {
+    return;
+  }
+  let db$1 = Primitive_option.valFromOption(db);
+  if (sqliteReady.contents !== Primitive_option.some(db$1)) {
+    ViewChangeLogStorage_Sqlite$ReventlessLocal.ensureSchema(db$1);
+    sqliteReady.contents = Primitive_option.some(db$1);
+  }
+  return Primitive_option.some(db$1);
+}
+
+let nextSeq = {
+  contents: 0
+};
+
+function record(c) {
+  let item = JSON.parse(LocalTapLines$ReventlessLocal.viewChangeLine(c));
+  let entry_flow = c.correlationId;
+  let entry_view = c.view;
+  let entry_key = c.key;
+  let entry_msgIds = c.sources.map(s => s.msgId);
+  let entry = {
+    seq: 0,
+    flow: entry_flow,
+    view: entry_view,
+    key: entry_key,
+    msgIds: entry_msgIds,
+    item: item
+  };
+  let db = sqlite();
+  if (db !== undefined) {
+    return ViewChangeLogStorage_Sqlite$ReventlessLocal.append(Primitive_option.valFromOption(db), entry);
+  }
+  nextSeq.contents = nextSeq.contents + 1 | 0;
+  let newrecord = {...entry};
+  ViewChangeLogStorage_InMemory$ReventlessLocal.append((newrecord.seq = nextSeq.contents, newrecord));
+}
+
+function read(filter, firstOpt, after) {
+  let first = firstOpt !== undefined ? firstOpt : 100;
+  let before = Stdlib_Option.flatMap(after, a => Stdlib_Int.fromString(a, undefined));
+  let db = sqlite();
+  let rows = db !== undefined ? ViewChangeLogStorage_Sqlite$ReventlessLocal.read(Primitive_option.valFromOption(db), filter, before, first + 1 | 0) : ViewChangeLogStorage_InMemory$ReventlessLocal.read(filter, before, first + 1 | 0);
+  let shown = rows.slice(0, first);
+  let hasNextPage = rows.length > first;
+  return {
+    records: shown.map(e => ({
+      item: e.item,
+      cursor: e.seq.toString()
+    })),
+    hasNextPage: hasNextPage,
+    endCursor: hasNextPage ? Stdlib_Option.map(shown.at(-1), e => e.seq.toString()) : undefined
+  };
+}
+
+let removal = {
+  contents: undefined
+};
+
+function install() {
+  if (!Stdlib_Option.isNone(removal.contents)) {
+    return;
+  }
+  let log = Logger$ReventlessCore.fromEnv();
+  removal.contents = ViewChange$ReventlessCore.register(c => {
+    try {
+      return record(c);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return log.warn("ViewChangeLog", undefined, `a row change of ` + c.view + ` was not kept: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown"));
+    }
+  });
+}
+
+function resetForTests() {
+  Stdlib_Option.forEach(removal.contents, remove => remove());
+  removal.contents = undefined;
+  ViewChangeLogStorage_InMemory$ReventlessLocal.clear();
+  nextSeq.contents = 0;
+  sqliteReady.contents = undefined;
+}
+
+let ViewChange;
+
+export {
+  ViewChange,
+  sqliteReady,
+  sqlite,
+  nextSeq,
+  record,
+  read,
+  removal,
+  install,
+  resetForTests,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/adapter/ViewChangeLog/ViewChangeLogEntry.res

@@ -0,0 +1,33 @@
+// One stored row change: the line the tap sends for it (view, key, kind, fields, sources,
+// flow, the row before and after, redacted), with the columns a read filters by.
+
+type t = {
+  seq: int,
+  flow?: string,
+  view: string,
+  key: string,
+  /** The message ids of the events behind it. */
+  msgIds: array<string>,
+  /** The tap's `viewChange` line, as JSON. */
+  item: JSON.t,
+}
+
+/** What a read asks for: every field narrows, none reads every change. */
+type filter = {
+  correlationId?: string,
+  msgId?: string,
+  view?: string,
+  key?: string,
+}
+
+let matches = (f: filter, e: t) =>
+  f.correlationId->Option.mapOr(true, c => e.flow == Some(c)) &&
+  f.msgId->Option.mapOr(true, m => e.msgIds->Array.includes(m)) &&
+  f.view->Option.mapOr(true, v => e.view == v) &&
+  f.key->Option.mapOr(true, k => e.key == k)
+
+let filterOfJson = (j: option<JSON.t>): filter => {
+  let d = j->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let s = k => d->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  {correlationId: ?s("correlationId"), msgId: ?s("msgId"), view: ?s("view"), key: ?s("key")}
+}

package/src/adapter/ViewChangeLog/ViewChangeLogEntry.res.mjs

@@ -0,0 +1,30 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function matches(f, e) {
+  if (Stdlib_Option.mapOr(f.correlationId, true, c => Primitive_object.equal(e.flow, c)) && Stdlib_Option.mapOr(f.msgId, true, m => e.msgIds.includes(m)) && Stdlib_Option.mapOr(f.view, true, v => e.view === v)) {
+    return Stdlib_Option.mapOr(f.key, true, k => e.key === k);
+  } else {
+    return false;
+  }
+}
+
+function filterOfJson(j) {
+  let d = Stdlib_Option.getOr(Stdlib_Option.flatMap(j, Stdlib_JSON.Decode.object), {});
+  let s = k => Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+  return {
+    correlationId: s("correlationId"),
+    msgId: s("msgId"),
+    view: s("view"),
+    key: s("key")
+  };
+}
+
+export {
+  matches,
+  filterOfJson,
+}
+/* No side effect */

package/src/adapter/ViewChangeLog/ViewChangeLogStorage_InMemory.res

@@ -0,0 +1,28 @@
+// The row changes of an in-memory platform, oldest first, for as long as it runs.
+
+type entry = ViewChangeLogEntry.t
+
+let entries: array<entry> = []
+
+let append = (e: entry) => entries->Array.push(e)
+
+/** Up to `first` entries matching the filter, newest first, below the `before` sequence number. */
+let read = (~filter: ViewChangeLogEntry.filter, ~before: option<int>, ~first: int): array<
+  entry,
+> => {
+  let out = []
+  let i = ref(entries->Array.length - 1)
+  while i.contents >= 0 && out->Array.length < first {
+    let e = entries->Array.getUnsafe(i.contents)
+    if before->Option.mapOr(true, b => e.seq < b) && ViewChangeLogEntry.matches(filter, e) {
+      out->Array.push(e)
+    }
+    i := i.contents - 1
+  }
+  out
+}
+
+let lastSeq = () => entries->Array.at(-1)->Option.mapOr(0, e => e.seq)
+
+/** Test seam. */
+let clear = () => entries->Array.splice(~start=0, ~remove=entries->Array.length, ~insert=[])

package/src/adapter/ViewChangeLog/ViewChangeLogStorage_InMemory.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ViewChangeLogEntry$ReventlessLocal from "./ViewChangeLogEntry.res.mjs";
+
+let entries = [];
+
+function append(e) {
+  entries.push(e);
+}
+
+function read(filter, before, first) {
+  let out = [];
+  let i = entries.length - 1 | 0;
+  while (i >= 0 && out.length < first) {
+    let e = entries[i];
+    if (Stdlib_Option.mapOr(before, true, b => e.seq < b) && ViewChangeLogEntry$ReventlessLocal.matches(filter, e)) {
+      out.push(e);
+    }
+    i = i - 1 | 0;
+  };
+  return out;
+}
+
+function lastSeq() {
+  return Stdlib_Option.mapOr(entries.at(-1), 0, e => e.seq);
+}
+
+function clear() {
+  entries.splice(0, entries.length);
+}
+
+export {
+  entries,
+  append,
+  read,
+  lastSeq,
+  clear,
+}
+/* No side effect */

package/src/adapter/ViewChangeLog/ViewChangeLogStorage_Sqlite.res

@@ -0,0 +1,76 @@
+// The row changes of a SQLite platform, kept in its store across restarts.
+
+type entry = ViewChangeLogEntry.t
+
+let table = "reventless_view_changes"
+
+let ensureSchema = db => {
+  db->SqliteDriver.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (seq INTEGER PRIMARY KEY AUTOINCREMENT, flow TEXT, view TEXT NOT NULL, key TEXT NOT NULL, msg_ids TEXT NOT NULL, item TEXT NOT NULL)`,
+  )
+  db->SqliteDriver.exec(`CREATE INDEX IF NOT EXISTS ${table}_flow ON ${table} (flow, seq)`)
+  db->SqliteDriver.exec(`CREATE INDEX IF NOT EXISTS ${table}_row ON ${table} (view, key, seq)`)
+}
+
+let str = JSON.Encode.string
+
+let append = (db, e: entry) =>
+  db
+  ->SqliteDriver.prepare(
+    `INSERT INTO ${table} (flow, view, key, msg_ids, item) VALUES (?, ?, ?, ?, ?)`,
+  )
+  ->SqliteDriver.run([
+    e.flow->Option.mapOr(JSON.Encode.null, str),
+    str(e.view),
+    str(e.key),
+    str(e.msgIds->Array.join(",")),
+    str(e.item->JSON.stringify),
+  ])
+
+let entryOfRow = (row: dict<JSON.t>): option<entry> => {
+  let s = k => row->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  switch (
+    row->Dict.get("seq")->Option.flatMap(JSON.Decode.float),
+    s("view"),
+    s("key"),
+    s("item")->Option.flatMap(i =>
+      try Some(JSON.parseOrThrow(i)) catch {
+      | _ => None
+      }
+    ),
+  ) {
+  | (Some(seq), Some(view), Some(key), Some(item)) =>
+    Some({
+      seq: seq->Float.toInt,
+      flow: ?s("flow"),
+      view,
+      key,
+      msgIds: s("msg_ids")->Option.mapOr([], m => m == "" ? [] : m->String.split(",")),
+      item,
+    })
+  | _ => None
+  }
+}
+
+/** Up to `first` entries matching the filter, newest first, below the `before` sequence number.
+    The flow, view and key narrow in SQL; a message id is tested on the rows read. */
+let read = (db, ~filter: ViewChangeLogEntry.filter, ~before: option<int>, ~first: int): array<
+  entry,
+> => {
+  let where = []
+  let params = []
+  let add = (clause, value) => {
+    where->Array.push(clause)
+    params->Array.push(value)
+  }
+  filter.correlationId->Option.forEach(c => add("flow = ?", str(c)))
+  filter.view->Option.forEach(v => add("view = ?", str(v)))
+  filter.key->Option.forEach(k => add("key = ?", str(k)))
+  filter.msgId->Option.forEach(m => add("(',' || msg_ids || ',') LIKE ?", str(`%,${m},%`)))
+  before->Option.forEach(b => add("seq < ?", JSON.Encode.int(b)))
+  let sql = `SELECT seq, flow, view, key, msg_ids, item FROM ${table}${where == []
+      ? ""
+      : " WHERE " ++ where->Array.join(" AND ")} ORDER BY seq DESC LIMIT ?`
+  params->Array.push(JSON.Encode.int(first))
+  db->SqliteDriver.prepare(sql)->SqliteDriver.all(params)->Array.filterMap(entryOfRow)
+}

package/src/adapter/ViewChangeLog/ViewChangeLogStorage_Sqlite.res.mjs

@@ -0,0 +1,88 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+
+let table = "reventless_view_changes";
+
+function ensureSchema(db) {
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE TABLE IF NOT EXISTS ` + table + ` (seq INTEGER PRIMARY KEY AUTOINCREMENT, flow TEXT, view TEXT NOT NULL, key TEXT NOT NULL, msg_ids TEXT NOT NULL, item TEXT NOT NULL)`);
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE INDEX IF NOT EXISTS ` + table + `_flow ON ` + table + ` (flow, seq)`);
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE INDEX IF NOT EXISTS ` + table + `_row ON ` + table + ` (view, key, seq)`);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function append(db, e) {
+  SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, `INSERT INTO ` + table + ` (flow, view, key, msg_ids, item) VALUES (?, ?, ?, ?, ?)`), [
+    Stdlib_Option.mapOr(e.flow, null, str),
+    e.view,
+    e.key,
+    e.msgIds.join(","),
+    JSON.stringify(e.item)
+  ]);
+}
+
+function entryOfRow(row) {
+  let s = k => Stdlib_Option.flatMap(row[k], Stdlib_JSON.Decode.string);
+  let match = Stdlib_Option.flatMap(row["seq"], Stdlib_JSON.Decode.float);
+  let match$1 = s("view");
+  let match$2 = s("key");
+  let match$3 = Stdlib_Option.flatMap(s("item"), i => {
+    try {
+      return JSON.parse(i);
+    } catch (exn) {
+      return;
+    }
+  });
+  if (match !== undefined && match$1 !== undefined && match$2 !== undefined && match$3 !== undefined) {
+    return {
+      seq: match | 0,
+      flow: s("flow"),
+      view: match$1,
+      key: match$2,
+      msgIds: Stdlib_Option.mapOr(s("msg_ids"), [], m => {
+        if (m === "") {
+          return [];
+        } else {
+          return m.split(",");
+        }
+      }),
+      item: match$3
+    };
+  }
+}
+
+function read(db, filter, before, first) {
+  let where = [];
+  let params = [];
+  let add = (clause, value) => {
+    where.push(clause);
+    params.push(value);
+  };
+  Stdlib_Option.forEach(filter.correlationId, c => add("flow = ?", c));
+  Stdlib_Option.forEach(filter.view, v => add("view = ?", v));
+  Stdlib_Option.forEach(filter.key, k => add("key = ?", k));
+  Stdlib_Option.forEach(filter.msgId, m => add("(',' || msg_ids || ',') LIKE ?", `%,` + m + `,%`));
+  Stdlib_Option.forEach(before, b => add("seq < ?", b));
+  let sql = `SELECT seq, flow, view, key, msg_ids, item FROM ` + table + (
+    Primitive_object.equal(where, []) ? "" : " WHERE " + where.join(" AND ")
+  ) + ` ORDER BY seq DESC LIMIT ?`;
+  params.push(first);
+  return Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, sql), params), entryOfRow);
+}
+
+export {
+  table,
+  ensureSchema,
+  str,
+  append,
+  entryOfRow,
+  read,
+}
+/* SqliteDriver-ReventlessLocal Not a pure module */

package/src/components/AutomationSlice_Builder.res.mjs

@@ -59,7 +59,7 @@ function Make(Bus) {
         return await ops.tick(key, at);
       });
       Stdlib_Promise.$$catch(TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component)).then(ops => ops.reconcileSchedules()), exn => {
-        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `the schedules could not be reconciled: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown")));
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, undefined, `the schedules could not be reconciled: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown")));
         return Promise.resolve();
       });
       return component;

package/src/components/LocalAutomationSchedules.res.mjs

@@ -18,7 +18,7 @@ function timerName(slice, key) {
 }
 
 function tickFailed(slice, key, message) {
-  Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSchedules", undefined, `tick ` + key + ` of ` + slice + ` failed: ` + message));
+  Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSchedules", undefined, undefined, `tick ` + key + ` of ` + slice + ` failed: ` + message));
 }
 
 function register(slice, tick) {

package/src/components/LocalAutomationSweep.res.mjs

@@ -40,7 +40,7 @@ async function sweepOnce() {
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         let message = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-        return Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSweep", undefined, `sweep of ` + param[0] + ` failed: ` + message));
+        return Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSweep", undefined, undefined, `sweep of ` + param[0] + ` failed: ` + message));
       }
     });
     running.contents = false;

package/tests/LocalPlatformRegistryTest.res

@@ -199,4 +199,21 @@ describe("LocalPlatformRegistry.tapPort", () => {
 
     expect(LocalPlatformRegistry.list(~cwd, ())->Array.map(e => e.tapPort))->toEqual([Some(4100)])
   })
+
+  testSync("names where the platform API is served, and keeps it when a port is published", () => {
+    let cwd = tempRoot()
+    let _ = LocalPlatformRegistry.write(
+      ~port=4000,
+      ~endpoint="http://localhost:4000/graphql",
+      ~loginEndpoint="http://localhost:4000/__inmemory/login",
+      ~store=memoryStore,
+      ~platformEndpoint="http://localhost:4001/graphql",
+      ~cwd,
+    )
+    LocalPlatformRegistry.publishTapPort(~port=4000, ~tapPort=4100, ~cwd)
+
+    expect(
+      LocalPlatformRegistry.list(~cwd, ())->Array.map(e => (e.platformEndpoint, e.tapPort)),
+    )->toEqual([(Some("http://localhost:4001/graphql"), Some(4100))])
+  })
 })

package/tests/LocalPlatformRegistryTest.res.mjs

@@ -24,7 +24,7 @@ let memoryStore = {
 
 function writeAt(cwd, port, store, pidOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
-  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, pid, cwd);
+  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, undefined, pid, cwd);
 }
 
 globalThis.describe("LocalPlatformRegistry", () => {
@@ -173,9 +173,21 @@ globalThis.describe("LocalPlatformRegistry.tapPort", () => {
   globalThis.test("ignores a platform that never published an entry", () => LocalPlatformRegistry$ReventlessLocal.publishTapPort(4000, 1, tempRoot()));
   globalThis.test("round-trips the port a platform serving a tap publishes", () => {
     let cwd = tempRoot();
-    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, 4100, undefined, cwd);
+    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, 4100, undefined, undefined, cwd);
     globalThis.expect(LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined).map(e => e.tapPort)).toEqual([4100]);
   });
+  globalThis.test("names where the platform API is served, and keeps it when a port is published", () => {
+    let cwd = tempRoot();
+    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, undefined, "http://localhost:4001/graphql", undefined, cwd);
+    LocalPlatformRegistry$ReventlessLocal.publishTapPort(4000, 4100, cwd);
+    globalThis.expect(LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined).map(e => [
+      e.platformEndpoint,
+      e.tapPort
+    ])).toEqual([[
+        "http://localhost:4001/graphql",
+        4100
+      ]]);
+  });
 });
 
 let deadPid = 2147483646;

package/tests/LocalPlatformStartTest.res.mjs

@@ -28,7 +28,7 @@ let memoryStore = {
 
 function writeAt(cwd, port, store, pidOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
-  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, pid, cwd);
+  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, undefined, pid, cwd);
 }
 
 function withoutBypass(f) {

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -610,8 +610,9 @@ describe("GraphQL_SchemaInspector", () => {
         // TestState, TestStateEdge, TestStateConnection, TestStateFilter (connection filter)
         // + TestStateRef (the reference door's projection)
         // + CommandResult union + CommandAccepted + CommandRejectionCause + CommandRejected
-        // + CommandPending (auto-injected whenever the fragment emits any mutation field).
-        expect(inspection.types->Array.length)->toBe(10)
+        // + CommandPending (auto-injected whenever the fragment emits any mutation field)
+        // + RowChange (every view row's last change).
+        expect(inspection.types->Array.length)->toBe(11)
         expect(inspection.mutations->Array.length)->toBe(1)
         // single Test_State(id), list Test_States(...), Test_StatesByIds(ids: [String!]!)
         // and Test_StatesRefs(ids: [ID!]!) — the by-ids read projected to a reference.

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -430,7 +430,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
           authorization: undefined
         }]);
       let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
-      globalThis.expect(inspection.types.length).toBe(10);
+      globalThis.expect(inspection.types.length).toBe(11);
       globalThis.expect(inspection.mutations.length).toBe(1);
       globalThis.expect(inspection.queries.length).toBe(4);
       globalThis.expect(inspection.sdlPreview.includes("type TestState")).toBe(true);