@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/src/adapter/LocalPlatformObserve.res.mjs

@@ -0,0 +1,505 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.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 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 LocalFeed$ReventlessLocal from "./LocalFeed.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "./LocalLogFeed.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "./LocalEventTap.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "./LocalEventLogRead.res.mjs";
+import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
+
+let eventLogTypes = [
+  "scalar AWSJSON",
+  `input Platform_EventLogFilter {
+  plugins: [String!]
+  logs: [String!]
+  eventTypes: [String!]
+  entityId: String
+  tagKey: String
+  tagValue: String
+  msgId: String
+  correlationId: String
+  causationId: String
+  user: String
+  timeFrom: String
+  timeTo: String
+}`,
+  `type Platform_EventLogTag {
+  key: String!
+  value: String!
+}`,
+  `type Platform_EventLogRecord {
+  plugin: String
+  log: String!
+  position: String!
+  eventType: String!
+  entityId: String
+  tags: [Platform_EventLogTag!]!
+  payload: AWSJSON!
+  meta: AWSJSON!
+  recordedAt: String!
+}`,
+  `type Platform_EventLogEdge {
+  node: Platform_EventLogRecord!
+  cursor: String!
+}`,
+  `type Platform_EventLogPageInfo {
+  hasNextPage: Boolean!
+  endCursor: String
+}`,
+  `type Platform_EventLogConnection {
+  edges: [Platform_EventLogEdge!]!
+  pageInfo: Platform_EventLogPageInfo!
+}`
+];
+
+let logLevelTypes = [
+  `enum Platform_LogLevel {
+  DEBUG
+  INFO
+  WARN
+  ERROR
+}`,
+  `type Platform_LogLevelSetting {
+  plugin: String
+  comp: String
+  level: Platform_LogLevel!
+}`,
+  `type Platform_LogLevels {
+  base: Platform_LogLevel
+  settings: [Platform_LogLevelSetting!]!
+}`
+];
+
+let feedTypes = [`input Platform_FeedFilter {
+  plugins: [String!]
+  level: Platform_LogLevel
+  components: [String!]
+  eventTypes: [String!]
+  correlationId: String
+}`];
+
+let eventLogField = "Platform_EventLog";
+
+let logLevelsField = "Platform_LogLevels";
+
+let setLogLevelField = "Platform_SetLogLevel";
+
+let queryFields = [
+  `  ` + eventLogField + `(filter: Platform_EventLogFilter, first: Int, after: String): Platform_EventLogConnection!`,
+  `  ` + logLevelsField + `: Platform_LogLevels!`
+];
+
+let logAppendedField = "Platform_LogAppended";
+
+let eventAppendedField = "Platform_EventAppended";
+
+let subscriptionFields = [
+  `  ` + logAppendedField + `(filter: Platform_FeedFilter): AWSJSON!`,
+  `  ` + eventAppendedField + `(filter: Platform_FeedFilter): AWSJSON!`
+];
+
+let mutationFields = [`  ` + setLogLevelField + `(plugin: String, comp: String, level: Platform_LogLevel): Platform_LogLevels!`];
+
+function arg(args, key) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[key]);
+}
+
+function pageJson(page) {
+  return Object.fromEntries([
+    [
+      "edges",
+      page.edges.map(param => Object.fromEntries([
+        [
+          "node",
+          LocalEventLogRead$ReventlessLocal.recordToJson(param[0])
+        ],
+        [
+          "cursor",
+          param[1]
+        ]
+      ]))
+    ],
+    [
+      "pageInfo",
+      Object.fromEntries([
+        [
+          "hasNextPage",
+          page.hasNextPage
+        ],
+        [
+          "endCursor",
+          Stdlib_Option.mapOr(page.endCursor, null, prim => prim)
+        ]
+      ])
+    ]
+  ]);
+}
+
+async function eventLog(_root, args, _ctx) {
+  return pageJson(await LocalEventLogRead$ReventlessLocal.read(LocalEventLogRead$ReventlessLocal.filterOfJson(arg(args, "filter")), Stdlib_Option.map(Stdlib_Option.flatMap(arg(args, "first"), Stdlib_JSON.Decode.float), prim => prim | 0), Stdlib_Option.flatMap(arg(args, "after"), Stdlib_JSON.Decode.string)));
+}
+
+function levelOfWire(s) {
+  switch (s) {
+    case "DEBUG" :
+      return "Debug";
+    case "ERROR" :
+      return "Error";
+    case "INFO" :
+      return "Info";
+    case "WARN" :
+      return "Warn";
+    default:
+      return;
+  }
+}
+
+function levelsJson() {
+  return Object.fromEntries([
+    [
+      "base",
+      Stdlib_Option.mapOr(Logger$ReventlessCore.effectiveMin(), null, Logger$ReventlessCore.levelLabel)
+    ],
+    [
+      "settings",
+      Logger$ReventlessCore.levelSettings().map(s => Object.fromEntries([[
+          "level",
+          Logger$ReventlessCore.levelLabel(s.level)
+        ]].concat(Stdlib_Option.mapOr(s.plugin, [], p => [[
+          "plugin",
+          p
+        ]])).concat(Stdlib_Option.mapOr(s.comp, [], c => [[
+          "comp",
+          c
+        ]]))))
+    ]
+  ]);
+}
+
+async function logLevels(_root, _args, _ctx) {
+  return levelsJson();
+}
+
+let log = Logger$ReventlessCore.fromEnv();
+
+async function setLogLevel(_root, args, _ctx) {
+  let plugin = Stdlib_Option.flatMap(arg(args, "plugin"), Stdlib_JSON.Decode.string);
+  let comp = Stdlib_Option.flatMap(arg(args, "comp"), Stdlib_JSON.Decode.string);
+  let level = Stdlib_Option.flatMap(Stdlib_Option.flatMap(arg(args, "level"), Stdlib_JSON.Decode.string), levelOfWire);
+  Logger$ReventlessCore.setLevel(plugin, comp, level);
+  let scope = plugin !== undefined ? (
+      comp !== undefined ? comp + ` of ` + plugin : plugin
+    ) : (
+      comp !== undefined ? comp : "every line"
+    );
+  log.info("Platform", undefined, level !== undefined ? `log level for ` + scope + ` set to ` + Logger$ReventlessCore.levelLabel(level) : `log level for ` + scope + ` cleared`);
+  return levelsJson();
+}
+
+function feedFilterOf(json) {
+  let d = Stdlib_Option.getOr(Stdlib_Option.flatMap(json, Stdlib_JSON.Decode.object), {});
+  let a = k => Stdlib_Option.map(Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.array), items => Stdlib_Array.filterMap(items, Stdlib_JSON.Decode.string));
+  return {
+    plugins: a("plugins"),
+    level: Stdlib_Option.flatMap(Stdlib_Option.flatMap(d["level"], Stdlib_JSON.Decode.string), levelOfWire),
+    components: a("components"),
+    eventTypes: a("eventTypes"),
+    correlationId: Stdlib_Option.flatMap(d["correlationId"], Stdlib_JSON.Decode.string)
+  };
+}
+
+let makeAsyncIterable = (function (next, ret) {
+  return { next, return: ret, [Symbol.asyncIterator]() { return this } }
+});
+
+let tapSentinel = "@@RVLESS_EVT@@ ";
+
+function lineToJson(line) {
+  let body = line.startsWith(tapSentinel) ? line.slice(tapSentinel.length, line.length) : line;
+  try {
+    return JSON.parse(body);
+  } catch (exn) {
+    return line;
+  }
+}
+
+function feedSubscription(feed, filter) {
+  let pending = [];
+  let waiting = {
+    contents: undefined
+  };
+  let drainers = {
+    contents: []
+  };
+  let closed = {
+    contents: false
+  };
+  let sink_write = line => {
+    let value = lineToJson(line);
+    let resolve = waiting.contents;
+    if (resolve !== undefined) {
+      waiting.contents = undefined;
+      resolve({
+        done: false,
+        value: value
+      });
+    } else {
+      pending.push(value);
+    }
+    return pending.length < 256;
+  };
+  let sink_onceDrain = f => {
+    drainers.contents = drainers.contents.concat([f]);
+  };
+  let sink_buffered = () => Stdlib_Array.reduce(pending, 0, (sum, v) => sum + JSON.stringify(v).length | 0);
+  let sink_close = () => {
+    closed.contents = true;
+  };
+  let sink = {
+    write: sink_write,
+    onceDrain: sink_onceDrain,
+    buffered: sink_buffered,
+    close: sink_close
+  };
+  let unsubscribe = LocalFeed$ReventlessLocal.subscribe(feed, filter, sink);
+  let next = () => {
+    let value = pending.shift();
+    if (value === undefined) {
+      if (closed.contents) {
+        return Promise.resolve({
+          done: true
+        });
+      } else {
+        return new Promise((resolve, param) => {
+          waiting.contents = resolve;
+        });
+      }
+    }
+    if (pending.length < 128) {
+      let toCall = drainers.contents;
+      drainers.contents = [];
+      toCall.forEach(f => f());
+    }
+    return Promise.resolve({
+      done: false,
+      value: value
+    });
+  };
+  let $$return = () => {
+    closed.contents = true;
+    unsubscribe();
+    Stdlib_Option.forEach(waiting.contents, resolve => resolve({
+      done: true
+    }));
+    waiting.contents = undefined;
+    return Promise.resolve({
+      done: true
+    });
+  };
+  return makeAsyncIterable(next, $$return);
+}
+
+function feedField(feed) {
+  return {
+    subscribe: Auth_GraphqlContext$ReventlessLocal.requireGroup(Role$Reventless.adminGroup(), async (_root, args, _ctx) => feedSubscription(feed, feedFilterOf(arg(args, "filter")))),
+    resolve: payload => payload
+  };
+}
+
+function adminOnly(resolvers) {
+  return Object.fromEntries(resolvers.map(param => [
+    param[0],
+    Auth_GraphqlContext$ReventlessLocal.requireGroup(Role$Reventless.adminGroup(), param[1])
+  ]));
+}
+
+function registerGraphQL(server) {
+  server.registerTypes(eventLogTypes.concat(logLevelTypes).concat(feedTypes));
+  server.registerQueries(queryFields, adminOnly([
+    [
+      eventLogField,
+      eventLog
+    ],
+    [
+      logLevelsField,
+      logLevels
+    ]
+  ]));
+  server.registerMutations(mutationFields, adminOnly([[
+      setLogLevelField,
+      setLogLevel
+    ]]));
+  server.registerSubscriptions(subscriptionFields, Object.fromEntries([
+    [
+      logAppendedField,
+      feedField(LocalLogFeed$ReventlessLocal.feed)
+    ],
+    [
+      eventAppendedField,
+      feedField(LocalEventTap$ReventlessLocal.feed)
+    ]
+  ]));
+}
+
+let recentLogsUri = "platform/logs/recent";
+
+let eventsUri = "platform/events";
+
+function queryOf(uri) {
+  let params = {};
+  let qs = uri.split("?")[1];
+  if (qs !== undefined) {
+    qs.split("&").forEach(pair => {
+      let decode = s => {
+        try {
+          return decodeURIComponent(s.replaceAll("+", " "));
+        } catch (exn) {
+          return s;
+        }
+      };
+      let i = pair.indexOf("=");
+      if (i !== -1) {
+        params[decode(pair.slice(0, i))] = decode(pair.slice(i + 1 | 0, pair.length));
+        return;
+      }
+    });
+  }
+  return params;
+}
+
+function listOf(q, key) {
+  return Stdlib_Option.map(q[key], v => v.split(",").map(prim => prim.trim()).filter(s => s !== ""));
+}
+
+function intOf(q, key) {
+  return Stdlib_Option.flatMap(q[key], v => Stdlib_Int.fromString(v, undefined));
+}
+
+function resourceResult(uri, json) {
+  return {
+    contents: [{
+        uri: uri,
+        text: JSON.stringify(json)
+      }]
+  };
+}
+
+async function recentLogs(uri) {
+  let q = queryOf(uri);
+  let filter_plugins = listOf(q, "plugins");
+  let filter_level = Stdlib_Option.flatMap(q["level"], LocalFeed$ReventlessLocal.levelOfString);
+  let filter_components = listOf(q, "components");
+  let filter_correlationId = q["correlationId"];
+  let filter = {
+    plugins: filter_plugins,
+    level: filter_level,
+    components: filter_components,
+    correlationId: filter_correlationId
+  };
+  let records = LocalLogFeed$ReventlessLocal.recentRecords(filter, Stdlib_Option.getOr(intOf(q, "limit"), 200));
+  return resourceResult(uri, Object.fromEntries([[
+      "records",
+      records.map(Logger$ReventlessCore.recordToJson)
+    ]]));
+}
+
+async function events(uri) {
+  let q = queryOf(uri);
+  let filter_plugins = listOf(q, "plugins");
+  let filter_logs = listOf(q, "logs");
+  let filter_eventTypes = listOf(q, "eventTypes");
+  let filter_entityId = q["entityId"];
+  let filter_tagKey = q["tagKey"];
+  let filter_tagValue = q["tagValue"];
+  let filter_msgId = q["msgId"];
+  let filter_correlationId = q["correlationId"];
+  let filter_causationId = q["causationId"];
+  let filter_user = q["user"];
+  let filter_timeFrom = q["timeFrom"];
+  let filter_timeTo = q["timeTo"];
+  let filter = {
+    plugins: filter_plugins,
+    logs: filter_logs,
+    eventTypes: filter_eventTypes,
+    entityId: filter_entityId,
+    tagKey: filter_tagKey,
+    tagValue: filter_tagValue,
+    msgId: filter_msgId,
+    correlationId: filter_correlationId,
+    causationId: filter_causationId,
+    user: filter_user,
+    timeFrom: filter_timeFrom,
+    timeTo: filter_timeTo
+  };
+  let page = await LocalEventLogRead$ReventlessLocal.read(filter, intOf(q, "first"), q["after"]);
+  return resourceResult(uri, pageJson(page));
+}
+
+function registerMcp(server) {
+  server.registerResource(recentLogsUri, {
+    uriTemplate: recentLogsUri,
+    name: recentLogsUri,
+    description: "The platform's recent log records, oldest first. Query parameters: plugins, level, components, correlationId (narrow), limit (default 200).",
+    mimeType: "application/json"
+  }, recentLogs);
+  server.registerResource(eventsUri, {
+    uriTemplate: eventsUri,
+    name: eventsUri,
+    description: "Every event of every log, newest first, one page at a time. Query parameters: plugins, logs, eventTypes, entityId, tagKey, tagValue, msgId, correlationId, causationId, user, timeFrom, timeTo, first, after (the page's endCursor).",
+    mimeType: "application/json"
+  }, events);
+}
+
+let Logger;
+
+let GQL;
+
+let subscriptionWindow = 256;
+
+export {
+  Logger,
+  GQL,
+  eventLogTypes,
+  logLevelTypes,
+  feedTypes,
+  eventLogField,
+  logLevelsField,
+  setLogLevelField,
+  queryFields,
+  logAppendedField,
+  eventAppendedField,
+  subscriptionFields,
+  mutationFields,
+  arg,
+  pageJson,
+  eventLog,
+  levelOfWire,
+  levelsJson,
+  logLevels,
+  log,
+  setLogLevel,
+  feedFilterOf,
+  makeAsyncIterable,
+  subscriptionWindow,
+  tapSentinel,
+  lineToJson,
+  feedSubscription,
+  feedField,
+  adminOnly,
+  registerGraphQL,
+  recentLogsUri,
+  eventsUri,
+  queryOf,
+  listOf,
+  intOf,
+  resourceResult,
+  recentLogs,
+  events,
+  registerMcp,
+}
+/* log Not a pure module */

package/src/adapter/LocalTapLines.res

@@ -0,0 +1,149 @@
+// The lines the event tap carries besides events: what became of each command,
+// and each row a projection changed. Both go to the tap's listeners only; a
+// rejected command is also kept in the log feed's problem ring.
+//
+// They are sent without the tap's sentinel prefix, as the `skipped` line is, and
+// each carries a `kind`, so a reader that picks event lines by the prefix passes
+// over them.
+
+module Logger = ReventlessCore.Logger
+module Outcome = ReventlessCore.CommandTopic_Helpers
+module ViewChange = ReventlessCore.ViewChange
+
+let str = JSON.Encode.string
+let now = () => Date.make()->Date.toISOString
+
+let lineOf = (fields: array<(string, JSON.t)>): string =>
+  fields->Dict.fromArray->JSON.Encode.object->JSON.stringify
+
+let optional = (name: string, value: option<string>): array<(string, JSON.t)> =>
+  value->Option.mapOr([], v => [(name, str(v))])
+
+// ─── Command outcomes ────────────────────────────────────────────────────────
+
+/** The component a report names, as the log lines of its handler name it. */
+let compOf = (r: Outcome.commandOutcomeReport) => `CommandTopic(${r.component})`
+
+let pluginOf = (r: Outcome.commandOutcomeReport) => Logger.resolvePlugin(~comp=compOf(r), ())
+
+/** The tap line for one outcome. */
+let outcomeLine = (r: Outcome.commandOutcomeReport): string => {
+  let plugin = pluginOf(r)
+  let head =
+    [("kind", str("commandOutcome")), ("component", str(r.component))]
+    ->Array.concat(optional("plugin", plugin))
+    ->Array.concat([("msgId", str(r.reference))])
+    ->Array.concat(optional("correlationId", r.correlationId))
+    ->Array.concat(optional("causationId", r.causationId))
+  let body = switch r.outcome {
+  | OutcomeAccepted({entityId, eventCount}) =>
+    [("outcome", str("accepted"))]
+    ->Array.concat(optional("entityId", entityId))
+    ->Array.concat([("eventCount", JSON.Encode.int(eventCount))])
+  | OutcomeRejected({errorCode, cause}) => [
+      ("outcome", str("rejected")),
+      ("errorCode", str(errorCode)),
+      ("cause", str(Outcome.refusalCauseToGraphQL(cause))),
+    ]
+  }
+  lineOf(head->Array.concat(body)->Array.concat([("ts", str(now()))]))
+}
+
+/** A rejection as a log record: an error when the platform failed, a warning
+    when the model or the caller's access refused. The detail is redacted as a
+    logged detail is. */
+let rejectionRecord = (r: Outcome.commandOutcomeReport): option<Logger.record> =>
+  switch r.outcome {
+  | OutcomeAccepted(_) => None
+  | OutcomeRejected({errorCode, errorDetail, cause}) =>
+    let level: Logger.level = switch cause {
+    | InfrastructureFailure => Error
+    | DomainRejection | AccessRefusal => Warn
+    }
+    let detailJson = switch errorDetail {
+    | "" => []
+    | text =>
+      let parsed = try JSON.parseOrThrow(text) catch {
+      | _ => str(text)
+      }
+      [("errorDetail", parsed->Reventless.LogRedaction.redactJson->Logger.truncateDetail)]
+    }
+    let annotations = Dict.fromArray([("msgId", r.reference)])
+    r.correlationId->Option.forEach(id => annotations->Dict.set("correlationId", id))
+    r.causationId->Option.forEach(id => annotations->Dict.set("causationId", id))
+    Some({
+      time: now(),
+      level,
+      message: "command rejected",
+      service: ?Logger.serviceName(),
+      plugin: ?pluginOf(r),
+      comp: compOf(r),
+      annotations,
+      detail: [
+        ("component", str(r.component)),
+        ("errorCode", str(errorCode)),
+        ("cause", str(Outcome.refusalCauseToGraphQL(cause))),
+      ]
+      ->Array.concat(detailJson)
+      ->Dict.fromArray
+      ->JSON.Encode.object,
+    })
+  }
+
+let onOutcome = (r: Outcome.commandOutcomeReport) => {
+  rejectionRecord(r)->Option.forEach(LocalLogFeed.keepProblem)
+  if LocalEventTap.hasReaders() {
+    LocalEventTap.publish({
+      line: outcomeLine(r),
+      facets: {plugin: ?pluginOf(r), correlationId: ?r.correlationId},
+    })
+  }
+}
+
+// ─── View changes ────────────────────────────────────────────────────────────
+
+/** The tap line for one row change: the summary the log line carries, with the
+    row before and after, redacted. */
+let viewChangeLine = (c: ViewChange.t): string => {
+  let side = (name, value: option<JSON.t>) =>
+    value->Option.mapOr([], v => [
+      (name, v->Reventless.LogRedaction.redactJson->Logger.truncateDetail),
+    ])
+  lineOf(
+    [("kind", str("viewChange"))]
+    ->Array.concat(c->ViewChange.summaryFields)
+    ->Array.concat(optional("correlationId", c.correlationId))
+    ->Array.concat(side("before", c.before))
+    ->Array.concat(side("after", c.after))
+    ->Array.concat([("ts", str(now()))]),
+  )
+}
+
+let onViewChange = (c: ViewChange.t) =>
+  if LocalEventTap.hasReaders() {
+    LocalEventTap.publish({
+      line: viewChangeLine(c),
+      facets: {
+        // The plugin is looked up by the view's name, as a log line's is by the
+        // name inside its component.
+        plugin: ?Logger.resolvePlugin(~comp=`View(${c.view})`, ()),
+        correlationId: ?c.correlationId,
+      },
+    })
+  }
+
+// ─── Registration ────────────────────────────────────────────────────────────
+
+let removals: ref<array<unit => unit>> = ref([])
+
+/** Starts sending both lines, once per process. */
+let install = () =>
+  if removals.contents == [] {
+    removals := [Outcome.registerCommandOutcome(onOutcome), ViewChange.register(onViewChange)]
+  }
+
+/** Test seam: stops sending them. */
+let resetForTests = () => {
+  removals.contents->Array.forEach(remove => remove())
+  removals := []
+}