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

package/src/adapter/LocalPlatformObserve.res

@@ -1,9 +1,11 @@
 // What the platform API and the platform MCP server offer a tool that watches
-// this platform: every event of every log newest first (`Platform_EventLog`),
+// this platform: every event of every log newest first (`Platform_EventLog`), every row
+// change and command outcome kept (`Platform_ViewChanges`, `Platform_CommandOutcomes`),
 // the log level while running (`Platform_LogLevels`, `Platform_SetLogLevel`),
 // the log feed and the event tap as subscriptions (`Platform_LogAppended`,
-// `Platform_EventAppended`), and the MCP resources `platform/logs/recent` and
-// `platform/events`.
+// `Platform_EventAppended`), the metrics counted since start (`Platform_Metrics`),
+// and the MCP resources `platform/logs/recent`, `platform/events` and
+// `platform/metrics`.
 //
 // Every field here is admin-checked, also when the platform serves one API for
 // both, where nothing else would check it.
@@ -76,6 +78,19 @@ let logLevelTypes = [
 }`,
 ]
 
+let metricTypes = [
+  `type Platform_MetricCount {
+  metric: String!
+  plugin: String!
+  slice: String!
+  unit: String!
+  count: Int!
+  sum: Float!
+  lastAt: String!
+  perMinute: [Int!]!
+}`,
+]
+
 let feedTypes = [
   `input Platform_FeedFilter {
   plugins: [String!]
@@ -87,12 +102,51 @@ let feedTypes = [
 ]
 
 let eventLogField = "Platform_EventLog"
+let viewChangesField = "Platform_ViewChanges"
+let commandOutcomesField = "Platform_CommandOutcomes"
+
+// Every row change kept since the store began, newest first; each node is the tap's
+// `viewChange` line as JSON.
+let viewChangeTypes = [
+  `input Platform_ViewChangeFilter {
+  correlationId: String
+  msgId: String
+  view: String
+  key: String
+}`,
+  `type Platform_ViewChangeEdge {
+  node: AWSJSON!
+  cursor: String!
+}`,
+  `type Platform_ViewChangeConnection {
+  edges: [Platform_ViewChangeEdge!]!
+  pageInfo: Platform_EventLogPageInfo!
+}`,
+  // Every command outcome kept, newest first; each node is the tap's `commandOutcome` line.
+  `input Platform_CommandOutcomeFilter {
+  correlationId: String
+  msgId: String
+  startsFlow: Boolean
+}`,
+  `type Platform_CommandOutcomeEdge {
+  node: AWSJSON!
+  cursor: String!
+}`,
+  `type Platform_CommandOutcomeConnection {
+  edges: [Platform_CommandOutcomeEdge!]!
+  pageInfo: Platform_EventLogPageInfo!
+}`,
+]
 let logLevelsField = "Platform_LogLevels"
 let setLogLevelField = "Platform_SetLogLevel"
+let metricsField = "Platform_Metrics"
 
 let queryFields = [
   `  ${eventLogField}(filter: Platform_EventLogFilter, first: Int, after: String): Platform_EventLogConnection!`,
+  `  ${viewChangesField}(filter: Platform_ViewChangeFilter, first: Int, after: String): Platform_ViewChangeConnection!`,
+  `  ${commandOutcomesField}(filter: Platform_CommandOutcomeFilter, first: Int, after: String): Platform_CommandOutcomeConnection!`,
   `  ${logLevelsField}: Platform_LogLevels!`,
+  `  ${metricsField}(plugins: [String!]): [Platform_MetricCount!]!`,
 ]
 
 let logAppendedField = "Platform_LogAppended"
@@ -145,6 +199,43 @@ let eventLog: GQL.resolverFn = async (_root, args, _ctx) => {
   pageJson(page)
 }
 
+/** A page of kept lines as a connection: each node the tap's line, each cursor its place. */
+let keptPageJson = (page: LocalViewChangeLog.page): JSON.t =>
+  Dict.fromArray([
+    (
+      "edges",
+      page.records
+      ->Array.map(({item, cursor}) =>
+        Dict.fromArray([("node", item), ("cursor", JSON.Encode.string(cursor))])->JSON.Encode.object
+      )
+      ->JSON.Encode.array,
+    ),
+    (
+      "pageInfo",
+      Dict.fromArray([
+        ("hasNextPage", JSON.Encode.bool(page.hasNextPage)),
+        ("endCursor", page.endCursor->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+      ])->JSON.Encode.object,
+    ),
+  ])->JSON.Encode.object
+
+let firstOf = args => arg(args, "first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+let afterOf = args => arg(args, "after")->Option.flatMap(JSON.Decode.string)
+
+let viewChanges: GQL.resolverFn = async (_root, args, _ctx) =>
+  LocalViewChangeLog.read(
+    ~filter=ViewChangeLogEntry.filterOfJson(arg(args, "filter")),
+    ~first=?firstOf(args),
+    ~after=?afterOf(args),
+  )->keptPageJson
+
+let commandOutcomes: GQL.resolverFn = async (_root, args, _ctx) =>
+  LocalCommandOutcomeLog.read(
+    ~filter=CommandOutcomeLogEntry.filterOfJson(arg(args, "filter")),
+    ~first=?firstOf(args),
+    ~after=?afterOf(args),
+  )->keptPageJson
+
 let levelOfWire = (s: string): option<Logger.level> =>
   switch s {
   | "DEBUG" => Some(Debug)
@@ -309,6 +400,15 @@ let feedField = (feed: LocalFeed.t): GQL.resolverFn =>
     resolve: payload => payload,
   })
 
+/** The metrics counted since the platform started, of the given plugins or of every one:
+    per metric and slice, how often, the sum of their values, and the last 60 minutes. */
+let metrics: GQL.resolverFn = async (_root, args, _ctx) =>
+  LocalMetrics.read(
+    ~plugins=?arg(args, "plugins")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.map(a => a->Array.filterMap(JSON.Decode.string)),
+  )
+
 let adminOnly = (resolvers: array<(string, GQL.resolverFn)>): dict<GQL.resolverFn> =>
   resolvers
   ->Array.map(((name, resolver)) => (
@@ -320,11 +420,21 @@ let adminOnly = (resolvers: array<(string, GQL.resolverFn)>): dict<GQL.resolverF
 /** Registers the fields on the platform API. */
 let registerGraphQL = (server: GQL.t) => {
   server.registerTypes(
-    ~sdlTypes=eventLogTypes->Array.concat(logLevelTypes)->Array.concat(feedTypes),
+    ~sdlTypes=eventLogTypes
+    ->Array.concat(viewChangeTypes)
+    ->Array.concat(logLevelTypes)
+    ->Array.concat(metricTypes)
+    ->Array.concat(feedTypes),
   )
   server.registerQueries(
     ~sdlFields=queryFields,
-    ~resolvers=adminOnly([(eventLogField, eventLog), (logLevelsField, logLevels)]),
+    ~resolvers=adminOnly([
+      (eventLogField, eventLog),
+      (viewChangesField, viewChanges),
+      (commandOutcomesField, commandOutcomes),
+      (logLevelsField, logLevels),
+      (metricsField, metrics),
+    ]),
   )
   server.registerMutations(
     ~sdlFields=mutationFields,
@@ -343,6 +453,7 @@ let registerGraphQL = (server: GQL.t) => {
 
 let recentLogsUri = "platform/logs/recent"
 let eventsUri = "platform/events"
+let metricsUri = "platform/metrics"
 
 @val external decodeURIComponent: string => string = "decodeURIComponent"
 
@@ -431,6 +542,10 @@ let events: MCP_ServerInstance.resourceHandler = async uri => {
   resourceResult(~uri, pageJson(page))
 }
 
+/** `platform/metrics?plugins=a,b`: the metrics counted since the platform started. */
+let metricsResource: MCP_ServerInstance.resourceHandler = async uri =>
+  resourceResult(~uri, LocalMetrics.read(~plugins=?listOf(queryOf(uri), "plugins")))
+
 /** Registers the resources on the platform MCP server. */
 let registerMcp = (server: MCP_ServerInstance.t) => {
   server.registerResource(
@@ -453,4 +568,14 @@ let registerMcp = (server: MCP_ServerInstance.t) => {
     },
     ~handler=events,
   )
+  server.registerResource(
+    ~name=metricsUri,
+    ~definition={
+      uriTemplate: metricsUri,
+      name: metricsUri,
+      description: "The metrics counted since the platform started, per metric, plugin and slice: count, sum of values, last time, and counts of the last 60 minutes. Query parameter: plugins (narrow).",
+      mimeType: "application/json",
+    },
+    ~handler=metricsResource,
+  )
 }

package/src/adapter/LocalPlatformObserve.res.mjs

@@ -8,9 +8,14 @@ import * as Role$Reventless from "@reventlessdev/reventless-spec/src/types/Role.
 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 LocalMetrics$ReventlessLocal from "./LocalMetrics.res.mjs";
 import * as LocalEventTap$ReventlessLocal from "./LocalEventTap.res.mjs";
 import * as LocalEventLogRead$ReventlessLocal from "./LocalEventLogRead.res.mjs";
+import * as LocalViewChangeLog$ReventlessLocal from "./ViewChangeLog/LocalViewChangeLog.res.mjs";
+import * as ViewChangeLogEntry$ReventlessLocal from "./ViewChangeLog/ViewChangeLogEntry.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
+import * as CommandOutcomeLogEntry$ReventlessLocal from "./CommandOutcomeLog/CommandOutcomeLogEntry.res.mjs";
+import * as LocalCommandOutcomeLog$ReventlessLocal from "./CommandOutcomeLog/LocalCommandOutcomeLog.res.mjs";
 
 let eventLogTypes = [
   "scalar AWSJSON",
@@ -75,6 +80,17 @@ let logLevelTypes = [
 }`
 ];
 
+let metricTypes = [`type Platform_MetricCount {
+  metric: String!
+  plugin: String!
+  slice: String!
+  unit: String!
+  count: Int!
+  sum: Float!
+  lastAt: String!
+  perMinute: [Int!]!
+}`];
+
 let feedTypes = [`input Platform_FeedFilter {
   plugins: [String!]
   level: Platform_LogLevel
@@ -85,13 +101,52 @@ let feedTypes = [`input Platform_FeedFilter {
 
 let eventLogField = "Platform_EventLog";
 
+let viewChangesField = "Platform_ViewChanges";
+
+let commandOutcomesField = "Platform_CommandOutcomes";
+
+let viewChangeTypes = [
+  `input Platform_ViewChangeFilter {
+  correlationId: String
+  msgId: String
+  view: String
+  key: String
+}`,
+  `type Platform_ViewChangeEdge {
+  node: AWSJSON!
+  cursor: String!
+}`,
+  `type Platform_ViewChangeConnection {
+  edges: [Platform_ViewChangeEdge!]!
+  pageInfo: Platform_EventLogPageInfo!
+}`,
+  `input Platform_CommandOutcomeFilter {
+  correlationId: String
+  msgId: String
+  startsFlow: Boolean
+}`,
+  `type Platform_CommandOutcomeEdge {
+  node: AWSJSON!
+  cursor: String!
+}`,
+  `type Platform_CommandOutcomeConnection {
+  edges: [Platform_CommandOutcomeEdge!]!
+  pageInfo: Platform_EventLogPageInfo!
+}`
+];
+
 let logLevelsField = "Platform_LogLevels";
 
 let setLogLevelField = "Platform_SetLogLevel";
 
+let metricsField = "Platform_Metrics";
+
 let queryFields = [
   `  ` + eventLogField + `(filter: Platform_EventLogFilter, first: Int, after: String): Platform_EventLogConnection!`,
-  `  ` + logLevelsField + `: Platform_LogLevels!`
+  `  ` + viewChangesField + `(filter: Platform_ViewChangeFilter, first: Int, after: String): Platform_ViewChangeConnection!`,
+  `  ` + commandOutcomesField + `(filter: Platform_CommandOutcomeFilter, first: Int, after: String): Platform_CommandOutcomeConnection!`,
+  `  ` + logLevelsField + `: Platform_LogLevels!`,
+  `  ` + metricsField + `(plugins: [String!]): [Platform_MetricCount!]!`
 ];
 
 let logAppendedField = "Platform_LogAppended";
@@ -144,6 +199,53 @@ 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 keptPageJson(page) {
+  return Object.fromEntries([
+    [
+      "edges",
+      page.records.map(param => Object.fromEntries([
+        [
+          "node",
+          param.item
+        ],
+        [
+          "cursor",
+          param.cursor
+        ]
+      ]))
+    ],
+    [
+      "pageInfo",
+      Object.fromEntries([
+        [
+          "hasNextPage",
+          page.hasNextPage
+        ],
+        [
+          "endCursor",
+          Stdlib_Option.mapOr(page.endCursor, null, prim => prim)
+        ]
+      ])
+    ]
+  ]);
+}
+
+function firstOf(args) {
+  return Stdlib_Option.map(Stdlib_Option.flatMap(arg(args, "first"), Stdlib_JSON.Decode.float), prim => prim | 0);
+}
+
+function afterOf(args) {
+  return Stdlib_Option.flatMap(arg(args, "after"), Stdlib_JSON.Decode.string);
+}
+
+async function viewChanges(_root, args, _ctx) {
+  return keptPageJson(LocalViewChangeLog$ReventlessLocal.read(ViewChangeLogEntry$ReventlessLocal.filterOfJson(arg(args, "filter")), firstOf(args), afterOf(args)));
+}
+
+async function commandOutcomes(_root, args, _ctx) {
+  return keptPageJson(LocalCommandOutcomeLog$ReventlessLocal.read(CommandOutcomeLogEntry$ReventlessLocal.filterOfJson(arg(args, "filter")), firstOf(args), afterOf(args)));
+}
+
 function levelOfWire(s) {
   switch (s) {
     case "DEBUG" :
@@ -311,6 +413,10 @@ function feedField(feed) {
   };
 }
 
+async function metrics(_root, args, _ctx) {
+  return LocalMetrics$ReventlessLocal.read(Stdlib_Option.map(Stdlib_Option.flatMap(arg(args, "plugins"), Stdlib_JSON.Decode.array), a => Stdlib_Array.filterMap(a, Stdlib_JSON.Decode.string)));
+}
+
 function adminOnly(resolvers) {
   return Object.fromEntries(resolvers.map(param => [
     param[0],
@@ -319,15 +425,27 @@ function adminOnly(resolvers) {
 }
 
 function registerGraphQL(server) {
-  server.registerTypes(eventLogTypes.concat(logLevelTypes).concat(feedTypes));
+  server.registerTypes(eventLogTypes.concat(viewChangeTypes).concat(logLevelTypes).concat(metricTypes).concat(feedTypes));
   server.registerQueries(queryFields, adminOnly([
     [
       eventLogField,
       eventLog
     ],
+    [
+      viewChangesField,
+      viewChanges
+    ],
+    [
+      commandOutcomesField,
+      commandOutcomes
+    ],
     [
       logLevelsField,
       logLevels
+    ],
+    [
+      metricsField,
+      metrics
     ]
   ]));
   server.registerMutations(mutationFields, adminOnly([[
@@ -350,6 +468,8 @@ let recentLogsUri = "platform/logs/recent";
 
 let eventsUri = "platform/events";
 
+let metricsUri = "platform/metrics";
+
 function queryOf(uri) {
   let params = {};
   let qs = uri.split("?")[1];
@@ -440,6 +560,10 @@ async function events(uri) {
   return resourceResult(uri, pageJson(page));
 }
 
+async function metricsResource(uri) {
+  return resourceResult(uri, LocalMetrics$ReventlessLocal.read(listOf(queryOf(uri), "plugins")));
+}
+
 function registerMcp(server) {
   server.registerResource(recentLogsUri, {
     uriTemplate: recentLogsUri,
@@ -453,6 +577,12 @@ function registerMcp(server) {
     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);
+  server.registerResource(metricsUri, {
+    uriTemplate: metricsUri,
+    name: metricsUri,
+    description: "The metrics counted since the platform started, per metric, plugin and slice: count, sum of values, last time, and counts of the last 60 minutes. Query parameter: plugins (narrow).",
+    mimeType: "application/json"
+  }, metricsResource);
 }
 
 let Logger;
@@ -466,10 +596,15 @@ export {
   GQL,
   eventLogTypes,
   logLevelTypes,
+  metricTypes,
   feedTypes,
   eventLogField,
+  viewChangesField,
+  commandOutcomesField,
+  viewChangeTypes,
   logLevelsField,
   setLogLevelField,
+  metricsField,
   queryFields,
   logAppendedField,
   eventAppendedField,
@@ -478,6 +613,11 @@ export {
   arg,
   pageJson,
   eventLog,
+  keptPageJson,
+  firstOf,
+  afterOf,
+  viewChanges,
+  commandOutcomes,
   levelOfWire,
   levelsJson,
   logLevels,
@@ -490,16 +630,19 @@ export {
   lineToJson,
   feedSubscription,
   feedField,
+  metrics,
   adminOnly,
   registerGraphQL,
   recentLogsUri,
   eventsUri,
+  metricsUri,
   queryOf,
   listOf,
   intOf,
   resourceResult,
   recentLogs,
   events,
+  metricsResource,
   registerMcp,
 }
 /* log Not a pure module */

package/src/adapter/LocalRequestLog.res

@@ -0,0 +1,62 @@
+// One log line per GraphQL operation the app's API answers: a query or a subscription at debug, a
+// mutation at info, one that answered with errors at warn, so it shows among the problems.
+
+module YG = GraphqlYoga
+module L = ReventlessCore.Logger
+
+type line = {level: L.level, message: string, data: JSON.t}
+
+let lineOf = (r: YG.requestReport): line => {
+  let name = switch (r.operationName, r.fields) {
+  | (Some(n), _) => n
+  | (None, []) => "(anonymous)"
+  | (None, fields) => fields->Array.join(", ")
+  }
+  let who = r.user->Option.mapOr("", u => ` by ${u}`)
+  let took = r.kind == "subscription" ? "" : ` in ${r.ms->Float.toString} ms`
+  let message = switch r.errors->Array.get(0) {
+  | None => `${r.kind} ${name}${who}${took}`
+  | Some(first) =>
+    let more = r.errors->Array.length - 1
+    `${r.kind} ${name}${who} failed${took}: ${first}${more > 0
+        ? ` (and ${more->Int.toString} more)`
+        : ""}`
+  }
+  let level: L.level = if r.errors != [] {
+    Warn
+  } else if r.kind == "mutation" {
+    Info
+  } else {
+    Debug
+  }
+  let data = JSON.Encode.object(
+    Dict.fromArray(
+      [
+        ("operation", JSON.Encode.string(r.kind)),
+        ("fields", JSON.Encode.array(r.fields->Array.map(JSON.Encode.string))),
+        ("ms", JSON.Encode.float(r.ms)),
+      ]
+      ->Array.concat(
+        r.operationName->Option.mapOr([], n => [("operationName", JSON.Encode.string(n))]),
+      )
+      ->Array.concat(r.user->Option.mapOr([], u => [("user", JSON.Encode.string(u))]))
+      ->Array.concat(
+        r.errors == []
+          ? []
+          : [("errors", JSON.Encode.array(r.errors->Array.map(JSON.Encode.string)))],
+      ),
+    ),
+  )
+  {level, message, data}
+}
+
+/** The plugin that writes the line under the API's component, its fields as the line's detail
+    rather than in its words. */
+let plugin = (): YG.plugin =>
+  YG.requestLog(r => {
+    let {level, message, data} = lineOf(r)
+    let comp = "GraphQL:Domain"
+    if L.shouldLog(level, ~comp, ()) {
+      L.emit(~level, ~comp, ~detail=data, message)
+    }
+  })

package/src/adapter/LocalRequestLog.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as GraphqlYoga from "@reventlessdev/rescript-graphql-yoga/src/GraphqlYoga.res.mjs";
+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 Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+
+function lineOf(r) {
+  let match = r.operationName;
+  let match$1 = r.fields;
+  let name = match !== undefined ? match : (
+      match$1.length !== 0 ? match$1.join(", ") : "(anonymous)"
+    );
+  let who = Stdlib_Option.mapOr(r.user, "", u => ` by ` + u);
+  let took = r.kind === "subscription" ? "" : ` in ` + r.ms.toString() + ` ms`;
+  let first = r.errors[0];
+  let message;
+  if (first !== undefined) {
+    let more = r.errors.length - 1 | 0;
+    message = r.kind + ` ` + name + who + ` failed` + took + `: ` + first + (
+      more > 0 ? ` (and ` + more.toString() + ` more)` : ""
+    );
+  } else {
+    message = r.kind + ` ` + name + who + took;
+  }
+  let level = Primitive_object.notequal(r.errors, []) ? "Warn" : (
+      r.kind === "mutation" ? "Info" : "Debug"
+    );
+  let data = Object.fromEntries([
+    [
+      "operation",
+      r.kind
+    ],
+    [
+      "fields",
+      r.fields.map(prim => prim)
+    ],
+    [
+      "ms",
+      r.ms
+    ]
+  ].concat(Stdlib_Option.mapOr(r.operationName, [], n => [[
+      "operationName",
+      n
+    ]])).concat(Stdlib_Option.mapOr(r.user, [], u => [[
+      "user",
+      u
+    ]])).concat(Primitive_object.equal(r.errors, []) ? [] : [[
+        "errors",
+        r.errors.map(prim => prim)
+      ]]));
+  return {
+    level: level,
+    message: message,
+    data: data
+  };
+}
+
+function plugin() {
+  return GraphqlYoga.requestLog(r => {
+    let match = lineOf(r);
+    let level = match.level;
+    let comp = "GraphQL:Domain";
+    if (Logger$ReventlessCore.shouldLog(level, undefined, comp, undefined)) {
+      return Logger$ReventlessCore.emit(level, comp, undefined, match.data, undefined, match.message);
+    }
+  });
+}
+
+let YG;
+
+let L;
+
+export {
+  YG,
+  L,
+  lineOf,
+  plugin,
+}
+/* GraphqlYoga Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res

@@ -1221,9 +1221,17 @@ module Make = (Bus: LocalBus.T) => {
       fieldResolvers->Dict.set(resolvedField, resolver)
     })
 
-    if fieldResolvers->Dict.keysToArray->Array.length > 0 {
-      server.registerFieldResolvers(~typeName=returnTypeName, ~resolvers=fieldResolvers)
-    }
+    // A row's last change is read by an elevated caller only; anyone else reads null.
+    let changeResolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+      root,
+      _args,
+      ctx,
+    ) =>
+      extractIdentity(ctx)->Reventless.OwnerScope.resolve->Reventless.OwnerScope.isExempt
+        ? root->sourceField(ReventlessCore.RowChange.key)->Option.getOr(JSON.Encode.null)
+        : JSON.Encode.null
+    fieldResolvers->Dict.set(ReventlessCore.RowChange.key, changeResolver)
+    server.registerFieldResolvers(~typeName=returnTypeName, ~resolvers=fieldResolvers)
 
     // -- Register all fields --------------------------------------------------
     let allSdl =

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;