@reventlessdev/reventless-core 3.0.0-alpha.245 → 3.0.0-alpha.247

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Sury from "sury";
 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_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -17,7 +18,8 @@ let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
   Sury.literal("Processing"),
   Sury.literal("Completed"),
-  Sury.literal("Failed")
+  Sury.literal("Failed"),
+  Sury.literal("Abandoned")
 ]);
 
 let todoRowSchema = Sury.$schema(s => ({
@@ -26,7 +28,8 @@ let todoRowSchema = Sury.$schema(s => ({
   createdAt: s.m(Sury.string),
   processedAt: s.m(Sury.$option(Sury.string)),
   completedAt: s.m(Sury.$option(Sury.string)),
-  retryCount: s.m(Sury.int)
+  retryCount: s.m(Sury.int),
+  maxRetries: s.m(Sury.$option(Sury.int))
 }));
 
 function todoRowSchemaFor(itemSchema) {
@@ -36,7 +39,8 @@ function todoRowSchemaFor(itemSchema) {
     createdAt: s.m(Sury.string),
     processedAt: s.m(Sury.$option(Sury.string)),
     completedAt: s.m(Sury.$option(Sury.string)),
-    retryCount: s.m(Sury.int)
+    retryCount: s.m(Sury.int),
+    maxRetries: s.m(Sury.$option(Sury.int))
   }));
 }
 
@@ -44,6 +48,13 @@ function Make(Spec) {
   return Automation => {
     let todoItems = {};
     let makeMeta = () => Message$ReventlessCore.generateMeta(Spec.targetName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let afterFailedAttempt = row => {
+      let retryCount = row.retryCount + 1 | 0;
+      let newrecord = {...row};
+      newrecord.retryCount = retryCount;
+      newrecord.status = retryCount >= Spec.maxRetries ? "Abandoned" : "Failed";
+      return newrecord;
+    };
     let dispatches = Automation.mappings.map(M => {
       let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
       let handle = (json, ctx) => {
@@ -61,11 +72,13 @@ function Make(Spec) {
           }
           let row_item = Util_Sury$Reventless.toJson(param[1], Spec.todoItemSchema);
           let row_createdAt = new Date().toISOString();
+          let row_maxRetries = Spec.maxRetries;
           let row = {
             item: row_item,
             status: "Pending",
             createdAt: row_createdAt,
-            retryCount: 0
+            retryCount: 0,
+            maxRetries: row_maxRetries
           };
           todoItems[id] = row;
         });
@@ -98,6 +111,18 @@ function Make(Spec) {
       });
     };
     let phase2 = async publishJsons => {
+      let newlyAbandoned = [];
+      Object.entries(todoItems).forEach(param => {
+        let row = param[1];
+        if (!(row.status === "Failed" && row.retryCount >= Spec.maxRetries)) {
+          return;
+        }
+        let id = param[0];
+        let newrecord = {...row};
+        newrecord.status = "Abandoned";
+        todoItems[id] = newrecord;
+        newlyAbandoned.push(id);
+      });
       let pending = Object.entries(todoItems).filter(param => {
         let row = param[1];
         if (row.status === "Pending") {
@@ -138,10 +163,11 @@ function Make(Spec) {
             let exn = Primitive_exceptions.internalToException(raw_exn);
             let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
             Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to encode command: ` + errMsg));
-            let newrecord$1 = {...row};
-            newrecord$1.retryCount = row.retryCount + 1 | 0;
-            newrecord$1.status = "Failed";
-            todoItems[id] = newrecord$1;
+            let updated = afterFailedAttempt(row);
+            todoItems[id] = updated;
+            if (updated.status === "Abandoned") {
+              newlyAbandoned.push(id);
+            }
             commandJson = undefined;
           }
           Stdlib_Option.forEach(commandJson, commandJson => {
@@ -155,32 +181,64 @@ function Make(Spec) {
           });
         });
       });
-      if (commands.length === 0) {
-        return;
+      if (commands.length !== 0) {
+        try {
+          await publishJsons(commands);
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish commands: ` + errMsg));
+          pending.forEach(param => {
+            let id = param[0];
+            let current = todoItems[id];
+            if (current === undefined) {
+              return;
+            }
+            if (current.status !== "Processing") {
+              return;
+            }
+            let updated = afterFailedAttempt(param[1]);
+            todoItems[id] = updated;
+            if (updated.status === "Abandoned") {
+              newlyAbandoned.push(id);
+              return;
+            }
+          });
+        }
       }
-      try {
-        return await publishJsons(commands);
-      } catch (raw_exn) {
-        let exn = Primitive_exceptions.internalToException(raw_exn);
-        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish commands: ` + errMsg));
-        pending.forEach(param => {
-          let row = param[1];
-          let id = param[0];
-          let current = todoItems[id];
-          if (current === undefined) {
-            return;
-          }
-          if (current.status !== "Processing") {
+      let abandonmentCommands = Stdlib_Array.filterMap(newlyAbandoned, id => Stdlib_Option.flatMap(todoItems[id], row => {
+        let item;
+        try {
+          item = Util_Sury$Reventless.fromJson(row.item, Spec.todoItemSchema);
+        } catch (exn) {
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and its item could not be decoded to announce it`));
+          return;
+        }
+        return Stdlib_Option.flatMap(Automation.onExhausted(id, item), param => {
+          let commandJson;
+          try {
+            commandJson = Util_Sury$Reventless.toJson(param[1], Spec.commandSchema);
+          } catch (exn) {
+            Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and the abandonment command could not be encoded`));
             return;
           }
-          let newrecord = {...row};
-          newrecord.retryCount = row.retryCount + 1 | 0;
-          newrecord.status = "Failed";
-          todoItems[id] = newrecord;
+          return {
+            id: param[0],
+            meta: makeMeta(),
+            commandJson: commandJson
+          };
         });
+      }));
+      if (abandonmentCommands.length === 0) {
         return;
       }
+      try {
+        return await publishJsons(abandonmentCommands);
+      } catch (raw_exn$1) {
+        let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+        let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish abandonment commands: ` + errMsg$1));
+      }
     };
     return {
       Spec: Spec,

package/src/components/Dcb/Dcb_Builder.res

@@ -1095,6 +1095,8 @@ module Make = (
           let subIdField = V.Spec.subIdConfig->Option.map(c => c.subIdField)
           let indexes = V.Spec.config.indexes
           let indexQueries = if indexes->Array.length > 0 {Some(indexes)} else {None}
+          let resolved = Api_Naming.resolvedFieldsOfConfig(~plugin=name, V.Spec.config)
+          let resolvedFields = if resolved->Array.length > 0 {Some(resolved)} else {None}
           {
             ReventlessInfra.Api.singleFieldName: qn.singleFieldName,
             listFieldName: qn.listFieldName,
@@ -1107,6 +1109,7 @@ module Make = (
             connectionSpec: true,
             subIdField: ?subIdField,
             indexQueries: ?indexQueries,
+            resolvedFields: ?resolvedFields,
           }
         })
 

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -603,6 +603,8 @@ function Make(DcbEventLogStorage) {
         let subIdField = Stdlib_Option.map(V.Spec.subIdConfig, c => c.subIdField);
         let indexes = V.Spec.config.indexes;
         let indexQueries = indexes.length !== 0 ? indexes : undefined;
+        let resolved = Api_Naming$ReventlessCore.resolvedFieldsOfConfig(name, V.Spec.config);
+        let resolvedFields = resolved.length !== 0 ? resolved : undefined;
         return {
           singleFieldName: qn.singleFieldName,
           listFieldName: qn.listFieldName,
@@ -614,7 +616,8 @@ function Make(DcbEventLogStorage) {
           includeIdParam: qn.includeIdParam,
           connectionSpec: true,
           subIdField: subIdField,
-          indexQueries: indexQueries
+          indexQueries: indexQueries,
+          resolvedFields: resolvedFields
         };
       });
       let automationEntries = automationSlices.map(A => {

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -8,7 +8,12 @@ type todoStatus =
   | Pending
   | Processing
   | Completed
+  /** Failed and will be tried again. */
   | Failed
+  /** Failed for the last time — the retry budget is spent and no pass will pick
+      this row up again. Distinct from `Failed` because the two are opposite
+      instructions to whoever is reading: wait, or intervene. */
+  | Abandoned
 
 @schema
 type todoRow = {
@@ -18,6 +23,11 @@ type todoRow = {
   processedAt?: string,
   completedAt?: string,
   retryCount: int,
+  /** The ceiling `retryCount` is racing, copied from the Spec when the row is
+      created. Optional because rows written before this field existed are
+      rehydrated through `S.parseOrThrow`, and a required field would fail that
+      decode — silently, since the restore swallows it per row. */
+  maxRetries?: int,
   lastError?: string,
 }
 
@@ -50,6 +60,7 @@ let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
     processedAt: ?s.matches(S.option(S.string)),
     completedAt: ?s.matches(S.option(S.string)),
     retryCount: s.matches(S.int),
+    maxRetries: ?s.matches(S.option(S.int)),
     lastError: ?s.matches(S.option(S.string)),
   })
 
@@ -135,6 +146,61 @@ module Make = (
       ~service=Spec.targetName->Option.getOr(`OutboundTranslationSlice:${Spec.name}`),
     )
 
+  /** Record a failed attempt. The row is marked `Abandoned` at the moment the
+      budget runs out rather than being left to fall out of the next pass's
+      filter, so a reader never has to compare `retryCount` against a constant
+      that lives only in this Spec. */
+  let afterFailedAttempt = (row: todoRow, ~lastError: option<string>=?): todoRow => {
+    let retryCount = row.retryCount + 1
+    {
+      ...row,
+      status: retryCount >= Spec.maxRetries ? Abandoned : Failed,
+      retryCount,
+      lastError: ?switch lastError {
+      | Some(_) as given => given
+      | None => row.lastError
+      },
+    }
+  }
+
+  /** Ask the slice whether abandonment is worth telling the domain about, and
+      publish what it says. Failing to publish here cannot mark the row for retry
+      — the budget is what ran out — so the loss is logged and the row stays
+      `Abandoned`. */
+  let announceAbandonment = async (
+    ~id: string,
+    ~row: todoRow,
+    ~publishJsons: ReventlessInfra.CommandTopic.publishJsons,
+  ) =>
+    switch row.item->Reventless.Util_Sury.fromJson(Spec.outboundItemSchema) {
+    | item =>
+      switch Translation.onExhausted(id, item, ~lastError=row.lastError) {
+      | None => ()
+      | Some((targetId, cmd)) =>
+        try {
+          let msg: Reventless.Message.commandJson = {
+            id: targetId,
+            meta: makeMeta(),
+            commandJson: cmd->Reventless.Util_Sury.toJson(Spec.inboundCommandSchema),
+          }
+          await publishJsons([msg])
+        } catch {
+        | exn =>
+          let errMsg =
+            exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+          EffectLogger.logError(
+            ~comp=`OutboundTranslationSlice(${Spec.name})`,
+            `retries exhausted for ${id}, and the abandonment command could not be published: ${errMsg}`,
+          )->Effect.runSync
+        }
+      }
+    | exception _ =>
+      EffectLogger.logError(
+        ~comp=`OutboundTranslationSlice(${Spec.name})`,
+        `retries exhausted for ${id}, and its item could not be decoded to announce it`,
+      )->Effect.runSync
+    }
+
   let phase1 = (events: array<(string, Spec.consumedEvent)>) => {
     events->Array.forEach(((sourceId, event)) => {
       // Collect new outbound items
@@ -147,6 +213,7 @@ module Make = (
             status: Pending,
             createdAt: now(),
             retryCount: 0,
+            maxRetries: Spec.maxRetries,
           }
           todoItems->Dict.set(id, row)
         }
@@ -158,6 +225,23 @@ module Make = (
     publishJsons: ReventlessInfra.CommandTopic.publishJsons,
     ~capabilities: Reventless.Capabilities.t,
   ) => {
+    // Ids that ran out of budget during this pass, announced once at the end so
+    // one item's abandonment cannot interleave with another's attempt.
+    let newlyAbandoned: array<string> = []
+
+    // A `Failed` row at or past the ceiling is one an older build left stranded,
+    // or one whose Spec lowered `maxRetries` under it. Either way it is abandoned
+    // in fact, so say so rather than letting it sit in a status that promises a
+    // retry no pass will make.
+    todoItems
+    ->Dict.toArray
+    ->Array.forEach(((id, row)) =>
+      if row.status == Failed && row.retryCount >= Spec.maxRetries {
+        todoItems->Dict.set(id, {...row, status: Abandoned})
+        newlyAbandoned->Array.push(id)
+      }
+    )
+
     let pending =
       todoItems
       ->Dict.toArray
@@ -229,16 +313,18 @@ module Make = (
                 ~comp=`OutboundTranslationSlice(${Spec.name})`,
                 `failed to publish command: ${errMsg}`,
               )->Effect.runSync
-              todoItems->Dict.set(
-                id,
-                {...row, status: Failed, retryCount: row.retryCount + 1},
-              )
+              let updated = row->afterFailedAttempt(~lastError=errMsg)
+              todoItems->Dict.set(id, updated)
+              if updated.status == Abandoned {
+                newlyAbandoned->Array.push(id)
+              }
             }
           | None =>
-            todoItems->Dict.set(
-              id,
-              {...row, status: Failed, retryCount: row.retryCount + 1},
-            )
+            let updated = row->afterFailedAttempt
+            todoItems->Dict.set(id, updated)
+            if updated.status == Abandoned {
+              newlyAbandoned->Array.push(id)
+            }
           }
 
         | Ok(None) =>
@@ -246,12 +332,22 @@ module Make = (
           todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
 
         | Error(msg) =>
-          todoItems->Dict.set(
-            id,
-            {...row, status: Failed, retryCount: row.retryCount + 1, lastError: msg},
-          )
+          let updated = row->afterFailedAttempt(~lastError=msg)
+          todoItems->Dict.set(id, updated)
+          if updated.status == Abandoned {
+            newlyAbandoned->Array.push(id)
+          }
         }
       }
     })
+
+    // The row is already `Abandoned`; this only asks whether the domain hears.
+    let _ = await newlyAbandoned->Array.reduce(Promise.resolve(), async (prev, id) => {
+      let _ = await prev
+      switch todoItems->Dict.get(id) {
+      | Some(row) => await announceAbandonment(~id, ~row, ~publishJsons)
+      | None => ()
+      }
+    })
   }
 }

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -15,7 +15,8 @@ let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
   Sury.literal("Processing"),
   Sury.literal("Completed"),
-  Sury.literal("Failed")
+  Sury.literal("Failed"),
+  Sury.literal("Abandoned")
 ]);
 
 let todoRowSchema = Sury.$schema(s => ({
@@ -25,6 +26,7 @@ let todoRowSchema = Sury.$schema(s => ({
   processedAt: s.m(Sury.$option(Sury.string)),
   completedAt: s.m(Sury.$option(Sury.string)),
   retryCount: s.m(Sury.int),
+  maxRetries: s.m(Sury.$option(Sury.int)),
   lastError: s.m(Sury.$option(Sury.string))
 }));
 
@@ -36,6 +38,7 @@ function todoRowSchemaFor(itemSchema) {
     processedAt: s.m(Sury.$option(Sury.string)),
     completedAt: s.m(Sury.$option(Sury.string)),
     retryCount: s.m(Sury.int),
+    maxRetries: s.m(Sury.$option(Sury.int)),
     lastError: s.m(Sury.$option(Sury.string))
   }));
 }
@@ -44,6 +47,41 @@ function Make(Spec) {
   return Translation => {
     let todoItems = {};
     let makeMeta = () => Message$ReventlessCore.generateMeta(Stdlib_Option.getOr(Spec.targetName, `OutboundTranslationSlice:` + Spec.name), undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let afterFailedAttempt = (row, lastError) => {
+      let retryCount = row.retryCount + 1 | 0;
+      let newrecord = {...row};
+      newrecord.lastError = lastError !== undefined ? lastError : row.lastError;
+      newrecord.retryCount = retryCount;
+      newrecord.status = retryCount >= Spec.maxRetries ? "Abandoned" : "Failed";
+      return newrecord;
+    };
+    let announceAbandonment = async (id, row, publishJsons) => {
+      let item;
+      try {
+        item = Util_Sury$Reventless.fromJson(row.item, Spec.outboundItemSchema);
+      } catch (exn) {
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and its item could not be decoded to announce it`));
+      }
+      let match = Translation.onExhausted(id, item, row.lastError);
+      if (match === undefined) {
+        return;
+      }
+      try {
+        let msg_id = match[0];
+        let msg_meta = makeMeta();
+        let msg_commandJson = Util_Sury$Reventless.toJson(match[1], Spec.inboundCommandSchema);
+        let msg = {
+          id: msg_id,
+          meta: msg_meta,
+          commandJson: msg_commandJson
+        };
+        return await publishJsons([msg]);
+      } catch (raw_exn) {
+        let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and the abandonment command could not be published: ` + errMsg));
+      }
+    };
     let phase1 = events => {
       events.forEach(param => {
         Translation.collect(param[1], param[0]).forEach(param => {
@@ -54,17 +92,31 @@ function Make(Spec) {
           }
           let row_item = Util_Sury$Reventless.toJson(param[1], Spec.outboundItemSchema);
           let row_createdAt = new Date().toISOString();
+          let row_maxRetries = Spec.maxRetries;
           let row = {
             item: row_item,
             status: "Pending",
             createdAt: row_createdAt,
-            retryCount: 0
+            retryCount: 0,
+            maxRetries: row_maxRetries
           };
           todoItems[id] = row;
         });
       });
     };
     let phase2 = async (publishJsons, capabilities) => {
+      let newlyAbandoned = [];
+      Object.entries(todoItems).forEach(param => {
+        let row = param[1];
+        if (!(row.status === "Failed" && row.retryCount >= Spec.maxRetries)) {
+          return;
+        }
+        let id = param[0];
+        let newrecord = {...row};
+        newrecord.status = "Abandoned";
+        todoItems[id] = newrecord;
+        newlyAbandoned.push(id);
+      });
       let pending = Object.entries(todoItems).filter(param => {
         let row = param[1];
         if (row.status === "Pending") {
@@ -137,33 +189,48 @@ function Make(Spec) {
                 let exn$3 = Primitive_exceptions.internalToException(raw_exn$3);
                 let errMsg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$3), Stdlib_JsExn.message), "unknown");
                 Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to publish command: ` + errMsg$2));
-                let newrecord$2 = {...row};
-                newrecord$2.retryCount = row.retryCount + 1 | 0;
-                newrecord$2.status = "Failed";
-                todoItems[id] = newrecord$2;
-                return;
+                let updated = afterFailedAttempt(row, errMsg$2);
+                todoItems[id] = updated;
+                if (updated.status === "Abandoned") {
+                  newlyAbandoned.push(id);
+                  return;
+                } else {
+                  return;
+                }
               }
             } else {
-              let newrecord$3 = {...row};
-              newrecord$3.retryCount = row.retryCount + 1 | 0;
-              newrecord$3.status = "Failed";
-              todoItems[id] = newrecord$3;
-              return;
+              let updated$1 = afterFailedAttempt(row, undefined);
+              todoItems[id] = updated$1;
+              if (updated$1.status === "Abandoned") {
+                newlyAbandoned.push(id);
+                return;
+              } else {
+                return;
+              }
             }
           } else {
-            let newrecord$4 = {...row};
-            newrecord$4.completedAt = new Date().toISOString();
-            newrecord$4.status = "Completed";
-            todoItems[id] = newrecord$4;
+            let newrecord$2 = {...row};
+            newrecord$2.completedAt = new Date().toISOString();
+            newrecord$2.status = "Completed";
+            todoItems[id] = newrecord$2;
             return;
           }
         } else {
-          let newrecord$5 = {...row};
-          newrecord$5.lastError = result._0;
-          newrecord$5.retryCount = row.retryCount + 1 | 0;
-          newrecord$5.status = "Failed";
-          todoItems[id] = newrecord$5;
-          return;
+          let updated$2 = afterFailedAttempt(row, result._0);
+          todoItems[id] = updated$2;
+          if (updated$2.status === "Abandoned") {
+            newlyAbandoned.push(id);
+            return;
+          } else {
+            return;
+          }
+        }
+      });
+      await Stdlib_Array.reduce(newlyAbandoned, Promise.resolve(), async (prev, id) => {
+        await prev;
+        let row = todoItems[id];
+        if (row !== undefined) {
+          return await announceAbandonment(id, row, publishJsons);
         }
       });
     };

package/src/plugin/component/Plugin_Builder.res

@@ -255,6 +255,7 @@ module Make = (
         // its SDL did not declare. The DCB and admin entries have populated this
         // all along; the omission here was the asymmetry, not the rule.
         let indexes = R.Spec.config.indexes
+        let resolvedFields = Api_Naming.resolvedFieldsOfConfig(~plugin=name, R.Spec.config)
         {
           ReventlessInfra.Api.singleFieldName: qn.singleFieldName,
           listFieldName: qn.listFieldName,
@@ -265,6 +266,7 @@ module Make = (
           connectionSpec: true,
           subIdField: ?subIdField,
           indexQueries: ?(indexes->Array.length > 0 ? Some(indexes) : None),
+          resolvedFields: ?(resolvedFields->Array.length > 0 ? Some(resolvedFields) : None),
         }
       })
 

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -196,6 +196,7 @@ function Make(Spec) {
           let qn = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(extra$1, R.Spec.name, undefined);
           let subIdField = Stdlib_Option.map(R.Spec.subIdConfig, c => c.subIdField);
           let indexes = R.Spec.config.indexes;
+          let resolvedFields = Api_Naming$ReventlessCore.resolvedFieldsOfConfig(extra$1, R.Spec.config);
           return {
             singleFieldName: qn.singleFieldName,
             listFieldName: qn.listFieldName,
@@ -205,7 +206,8 @@ function Make(Spec) {
             permission: R.Spec.authorization,
             connectionSpec: true,
             subIdField: subIdField,
-            indexQueries: indexes.length !== 0 ? indexes : undefined
+            indexQueries: indexes.length !== 0 ? indexes : undefined,
+            resolvedFields: resolvedFields.length !== 0 ? resolvedFields : undefined
           };
         });
         let queryEntries = queryEntriesFromReadModels.concat(dcbResult.queryEntries);