@reventlessdev/reventless-core 3.0.0-alpha.212 → 3.0.0-alpha.214

package/src/plugin/component/Plugin_Helpers.res

@@ -788,9 +788,10 @@ let clearOnPluginDeployed = () => {
 // ---------------------------------------------------------------------------
 // Deploy-time offload hook — content-addresses a large pluginDefinition field
 // to an object store and returns the reference. Set by a provider that can
-// write objects (AWS creates a BucketObject); unset on the local platform, so
-// the fields stay Inline. `bytes` is the already-serialized JSON of the value;
-// the provider hashes it, stores it at `sha256/<hash>`, and returns the ref.
+// write objects (AWS creates a BucketObject, local writes to its process-local
+// object store); when unset the fields stay Inline. `bytes` is the
+// already-serialized JSON of the value; the provider hashes it, stores it at
+// `sha256/<hash>`, and returns the ref.
 // Fired synchronously at graph-construction time (the value is concrete and a
 // resource cannot be created inside a Pulumi.Output.apply).
 // ---------------------------------------------------------------------------
@@ -806,6 +807,23 @@ let clearOffload = () => {
   offloadHook.contents = None
 }
 
+/**
+Carry a large `pluginDefinition` field by reference when a provider registered an
+offload hook, inline otherwise.
+
+One implementation for both construction sites — `Plugin_Builder`'s deploy-time
+definition and the local platform's synthetic one — so a provider that offloads
+cannot end up offloading through one path and inlining through the other.
+*/
+let offloadPayload = (value: 'a, ~schema: S.t<'a>, ~store: string): Reventless.Offload.payload<'a> =>
+  switch offloadHook.contents {
+  | Some(hook) =>
+    Reventless.Offload.Offloaded(
+      hook(~store, ~bytes=value->S.reverseConvertToJsonStringOrThrow(schema)),
+    )
+  | None => Reventless.Offload.Inline(value)
+  }
+
 // ---------------------------------------------------------------------------
 // Platform-deployed hook — fires after deployPlatform / makePlatform
 // completes, providing platform-level metadata with resolved values.

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

@@ -430,6 +430,21 @@ function clearOffload() {
   offloadHook.contents = undefined;
 }
 
+function offloadPayload(value, schema, store) {
+  let hook = offloadHook.contents;
+  if (hook !== undefined) {
+    return {
+      TAG: "Offloaded",
+      _0: hook(store, S.reverseConvertToJsonStringOrThrow(value, schema, undefined))
+    };
+  } else {
+    return {
+      TAG: "Inline",
+      _0: value
+    };
+  }
+}
+
 let onPlatformDeployedHook = {
   contents: undefined
 };
@@ -1030,6 +1045,7 @@ export {
   offloadHook,
   registerOffload,
   clearOffload,
+  offloadPayload,
   onPlatformDeployedHook,
   lastPlatformDeployedInfo,
   registerOnPlatformDeployed,

package/src/util/LogFormat.res

@@ -28,6 +28,41 @@
 // styling primitive through `LogFormat.bold` rather than the spec namespace.
 let bold = Reventless.AnsiStyle.bold
 
+// ─── Value truncation ────────────────────────────────────────────────────────
+
+@val external logEnv: dict<string> = "process.env"
+
+/**
+Per-value character budget for rendered payloads, before the rest is elided.
+
+A detail line exists to say *which* command or event this is, not to reproduce
+it: a single field can be arbitrarily large (a plugin structure, a pasted
+document, an inline offload payload), and one of those turns a log into
+something no one reads. Truncation is per value rather than per line so a large
+field costs its neighbours nothing — the small fields that identify the message
+stay visible next to it.
+
+`REVENTLESS_LOG_MAX_VALUE` overrides the budget; `0` disables truncation for a
+session that genuinely needs the whole payload.
+*/
+let maxValueChars =
+  logEnv
+  ->Dict.get("REVENTLESS_LOG_MAX_VALUE")
+  ->Option.flatMap(v => Int.fromString(v))
+  ->Option.getOr(512)
+
+/** `s` capped at `maxValueChars`, with what was dropped named rather than
+    silently missing — a truncated line must not read like a complete one. */
+let truncate = (s: string): string => {
+  let len = s->String.length
+  if maxValueChars <= 0 || len <= maxValueChars {
+    s
+  } else {
+    `${s->String.slice(~start=0, ~end=maxValueChars)}…(+${(len - maxValueChars)
+      ->Int.toString} chars)`
+  }
+}
+
 // ─── Commands ────────────────────────────────────────────────────────────────
 
 // "Add"  (bold)
@@ -46,6 +81,16 @@ let cmdSummary = (msg: Message.commandJson): string =>
 let cmdSummaries = (msgs: array<Message.commandJson>): string =>
   `[${msgs->Array.map(cmdSummary)->Array.join(",")}]`
 
+/**
+`JSON.stringify` is typed as total but returns `undefined` — not a string — for
+the one value `JSON.t` cannot represent: the `undefined` a ReScript record's
+*absent* optional field leaves behind as an own property of the JS object. Read
+the result as nullable so an absent field is dropped instead of reaching a
+string function as `undefined`. An explicit `null` still stringifies to `"null"`
+and keeps printing.
+*/
+external stringifiedOrAbsent: string => Nullable.t<string> = "%identity"
+
 // Strip TAG from a variant JSON, return remaining fields as a compact string.
 // {"TAG":"Add","name":"Cat 1"} → {name:"Cat 1"}
 // "Add" (bare string variant) → ""
@@ -56,7 +101,13 @@ let variantFields = (json: JSON.t): string =>
       dict
       ->Dict.toArray
       ->Array.filter(((k, _)) => k != "TAG")
-      ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
+      ->Array.filterMap(((k, v)) =>
+        v
+        ->JSON.stringify
+        ->stringifiedOrAbsent
+        ->Nullable.toOption
+        ->Option.map(s => `${k}:${s->truncate}`)
+      )
       ->Array.join(",")
     fields == "" ? "" : `, {${fields}}`
   | _ => ""

package/src/util/LogFormat.res.mjs

@@ -1,11 +1,25 @@
 // 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_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 AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
 import * as Message$ReventlessCore from "../Message.res.mjs";
 
+let maxValueChars = Stdlib_Option.getOr(Stdlib_Option.flatMap(process.env["REVENTLESS_LOG_MAX_VALUE"], v => Stdlib_Int.fromString(v, undefined)), 512);
+
+function truncate(s) {
+  let len = s.length;
+  if (maxValueChars <= 0 || len <= maxValueChars) {
+    return s;
+  } else {
+    return s.slice(0, maxValueChars) + `…(+` + (len - maxValueChars | 0).toString() + ` chars)`;
+  }
+}
+
 function cmdName(msg) {
   return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(msg.commandJson));
 }
@@ -26,7 +40,10 @@ function variantFields(json) {
   if (typeof json !== "object" || json === null || Array.isArray(json)) {
     return "";
   }
-  let fields = Object.entries(json).filter(param => param[0] !== "TAG").map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
+  let fields = Stdlib_Array.filterMap(Object.entries(json).filter(param => param[0] !== "TAG"), param => {
+    let k = param[0];
+    return Stdlib_Option.map(Primitive_option.fromNullable(JSON.stringify(param[1])), s => k + `:` + truncate(s));
+  }).join(",");
   if (fields === "") {
     return "";
   } else {
@@ -220,6 +237,8 @@ let fmtActions = actionNames;
 
 export {
   bold,
+  maxValueChars,
+  truncate,
   cmdName,
   cmdNames,
   cmdSummary,
@@ -254,4 +273,4 @@ export {
   fmtAction,
   fmtActions,
 }
-/* Stdlib_JsExn Not a pure module */
+/* maxValueChars Not a pure module */

package/src/util/StoreLayout.res

@@ -0,0 +1,38 @@
+// Where a declared object store's keys are rooted.
+//
+// Lives in core beside StorePrefixCollision, and for the same reason: the rule
+// is about a namespace, not about a cloud. The deployed platform roots an S3
+// store's keys here, the local platform roots its filesystem store's keys here,
+// and a reset attributes an object to the plugin that declared its store by
+// reading the prefix back off the key. Three readers of one rule — so it is one
+// function, not three strings that happen to agree today.
+//
+// Qualifying by plugin is what makes the prefix an identity rather than a label:
+// two plugins may both declare a store called `images`, and only the qualified
+// form keeps their objects apart (which is the collision StorePrefixCollision
+// refuses when it cannot).
+
+/** The prefix a store's object keys are rooted at: `{plugin}/{store}`.
+
+    A stored ref is independent of whether the store got its own bucket or a
+    prefix inside a shared one — refs live in an append-only log, so one that
+    encoded its physical layout would be unrewritable and environment-specific. */
+let keyPrefixFor = (~plugin: string, ~store: string): string => `${plugin}/${store}`
+
+/** The same prefix from the qualified `{plugin}.{store}` key that a
+    `pluginStructure.requiredStores` entry carries and that the `Upload_Presign`
+    mutation's `store` argument names.
+
+    Splits on the FIRST `.` — a store name may contain dots, a plugin name may
+    not. An unqualified key (no `.`) is returned as-is rather than guessed at:
+    it is not a `{plugin}.{store}` and inventing a plugin for it would attribute
+    objects to a plugin that never declared them. */
+let prefixOfQualified = (qualified: string): string =>
+  switch qualified->String.indexOfOpt(".") {
+  | Some(i) =>
+    keyPrefixFor(
+      ~plugin=qualified->String.slice(~start=0, ~end=i),
+      ~store=qualified->String.slice(~start=i + 1, ~end=qualified->String.length),
+    )
+  | None => qualified
+  }

package/src/util/StoreLayout.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+
+function keyPrefixFor(plugin, store) {
+  return plugin + `/` + store;
+}
+
+function prefixOfQualified(qualified) {
+  let i = Stdlib_String.indexOfOpt(qualified, ".");
+  if (i !== undefined) {
+    return keyPrefixFor(qualified.slice(0, i), qualified.slice(i + 1 | 0, qualified.length));
+  } else {
+    return qualified;
+  }
+}
+
+export {
+  keyPrefixFor,
+  prefixOfQualified,
+}
+/* No side effect */

package/tests/adapter/EventLogProvisioningTest.res

@@ -0,0 +1,207 @@
+open JestGlobals
+
+// The registry only forwards `~resources` and `~opts`; it never reads their
+// fields. A structural stand-in keeps @pulumi/pulumi (whose Output.make would
+// build a real resource) out of the Jest run — its ESM entry can't be imported
+// under Jest. Same reason as MonitoringTest's stub.
+let stubResource: ReventlessInfra.Adapter.resource = %raw(`{}`)
+let noOpts: Pulumi.CustomResourceOptions.t = {}
+
+let classicOwner: ResourceAttribution.owner = {kind: ComponentType.Aggregate, name: "Product"}
+let dcbOwner: ResourceAttribution.owner = {kind: ComponentType.Plugin, name: "Catalog"}
+
+describe("EventLogProvisioning", () => {
+  testSync("Noop default: notify is silent and does not throw", () => {
+    // No backend registered — the default Noop backend swallows the call.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    expect(true)->toBe(true)
+  })
+
+  testSync("use registers a backend that receives every notify, style and name", () => {
+    let recorded: array<(EventLogProvisioning.logStyle, string)> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => recorded->Array.push((logStyle, name))
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(recorded)->toEqual([
+      (EventLogProvisioning.Classic, "ProductEventLog"),
+      (EventLogProvisioning.Dcb, "CatalogDcbEventLog"),
+    ])
+
+    // Restore the default so registry state doesn't leak to other cases.
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen: ref<
+      option<(option<ResourceAttribution.owner>, array<ReventlessInfra.Adapter.resource>)>,
+    > = ref(None)
+    module Capture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) => seen := Some((owner, resources))
+    }
+    EventLogProvisioning.use(module(Capture: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[stubResource],
+      ~opts=noOpts,
+    )
+    switch seen.contents {
+    | Some((owner, resources)) =>
+      expect(owner)->toEqual(Some(classicOwner))
+      expect(resources)->toHaveLength(1)
+    | None => expect("no notify received")->toBe("a notify")
+    }
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    // Postgres and in-memory adapters return `resources: []`. Backends that only
+    // implement a DynamoDB arm ignore those; the seam does not filter for them.
+    let styles: array<EventLogProvisioning.logStyle> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) =>
+        if resources->Array.length == 0 {
+          styles->Array.push(logStyle)
+        }
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(styles)->toEqual([EventLogProvisioning.Dcb])
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen: array<(option<string>, option<string>)> = []
+    module OwnerCapture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin,
+        ~platform,
+        ~resources as _,
+        ~opts as _,
+      ) => seen->Array.push((plugin, platform))
+    }
+    EventLogProvisioning.use(module(OwnerCapture: EventLogProvisioning.Backend))
+
+    // Outside any plugin construct: both None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    // Inside a construct scope (what Plugin_Builder.construct establishes): both delivered.
+    let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Catalog")
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    ResourceAttribution.restore(prev)
+
+    // After restore: back to None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="OrderEventLog",
+      ~owner=None,
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(seen)->toEqual([(None, None), (Some("Catalog"), Some("online-shop")), (None, None)])
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("use is single-slot: a second registration throws rather than silently winning", () => {
+    module First: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => ()
+    }
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+
+    let threw = try {
+      EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+
+    // reset clears the slot, so a later registration succeeds again.
+    EventLogProvisioning.reset()
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+    EventLogProvisioning.reset()
+  })
+})

package/tests/adapter/EventLogProvisioningTest.res.mjs

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ResourceAttribution$ReventlessCore from "../../src/ResourceAttribution.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "../../src/adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
+
+let stubResource = {};
+
+let noOpts = {};
+
+let classicOwner = {
+  kind: "Aggregate",
+  name: "Product"
+};
+
+let dcbOwner = {
+  kind: "Plugin",
+  name: "Catalog"
+};
+
+globalThis.describe("EventLogProvisioning", () => {
+  globalThis.test("Noop default: notify is silent and does not throw", () => {
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("use registers a backend that receives every notify, style and name", () => {
+    let recorded = [];
+    let onProvisioned = (logStyle, name, param, param$1, param$2, param$3, param$4) => {
+      recorded.push([
+        logStyle,
+        name
+      ]);
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(recorded).toEqual([
+      [
+        "Classic",
+        "ProductEventLog"
+      ],
+      [
+        "Dcb",
+        "CatalogDcbEventLog"
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen = {
+      contents: undefined
+    };
+    let onProvisioned = (param, param$1, owner, param$2, param$3, resources, param$4) => {
+      seen.contents = [
+        owner,
+        resources
+      ];
+    };
+    let Capture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Capture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [stubResource], noOpts);
+    let match = seen.contents;
+    if (match !== undefined) {
+      globalThis.expect(match[0]).toEqual(classicOwner);
+      globalThis.expect(match[1]).toHaveLength(1);
+    } else {
+      globalThis.expect("no notify received").toBe("a notify");
+    }
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    let styles = [];
+    let onProvisioned = (logStyle, param, param$1, param$2, param$3, resources, param$4) => {
+      if (resources.length === 0) {
+        styles.push(logStyle);
+        return;
+      }
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(styles).toEqual(["Dcb"]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen = [];
+    let onProvisioned = (param, param$1, param$2, plugin, platform, param$3, param$4) => {
+      seen.push([
+        plugin,
+        platform
+      ]);
+    };
+    let OwnerCapture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(OwnerCapture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    let prev = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    ResourceAttribution$ReventlessCore.restore(prev);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "OrderEventLog", undefined, [], noOpts);
+    globalThis.expect(seen).toEqual([
+      [
+        undefined,
+        undefined
+      ],
+      [
+        "Catalog",
+        "online-shop"
+      ],
+      [
+        undefined,
+        undefined
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("use is single-slot: a second registration throws rather than silently winning", () => {
+    let onProvisioned = (param, param$1, param$2, param$3, param$4, param$5, param$6) => {};
+    let First = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(First);
+    let threw;
+    try {
+      EventLogProvisioning$ReventlessCore.use(First);
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    EventLogProvisioning$ReventlessCore.reset();
+    EventLogProvisioning$ReventlessCore.use(First);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+});
+
+export {
+  stubResource,
+  noOpts,
+  classicOwner,
+  dcbOwner,
+}
+/*  Not a pure module */

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -47,3 +47,43 @@ describe("GraphQL_FragmentGenerator.generate mutation id injection", () => {
     expect(field->String.includes("id: ID!, orderId"))->toBe(true)
   })
 })
+
+// A slice TODO row stores its work item as `JSON.t`, which the IR can only call
+// `Unknown` — and `Unknown` renders as `String!`. Serving a stored object
+// through a String field fails at execution ("String cannot represent value:
+// { … }") as soon as a client selects it, so `Dcb_Builder` describes the row
+// with `todoRowSchemaFor` and the item's own schema instead.
+module GeocodeItem = {
+  @schema
+  type outboundItem = {customerId: string, address: string}
+}
+
+let typeDefFor = (fragment, needle) =>
+  GraphQL_Stitcher.decode(fragment).types->Array.find(t => t->String.includes(needle))
+
+describe("GraphQL_FragmentGenerator slice TODO rows", () => {
+  testSync("item carries the slice's item type, not String", () => {
+    let fragment = GraphQL_FragmentGenerator.generate(
+      ~mutationEntries=[],
+      ~queryEntries=[
+        {
+          ReventlessInfra.Api.singleFieldName: "Ordering_GeocodeCustomerAddressTodo",
+          listFieldName: "Ordering_GeocodeCustomerAddressTodos",
+          returnTypeName: "Ordering_GeocodeCustomerAddressTodo",
+          stateSchema: OutboundTranslationSlice_Callback.todoRowSchemaFor(
+            GeocodeItem.outboundItemSchema,
+          )->S.castToUnknown,
+          authorization: None,
+          connectionSpec: true,
+        },
+      ],
+    )
+    let row = typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodo ")->Option.getOr("")
+    expect(row->String.includes("item: Ordering_GeocodeCustomerAddressTodoItem!"))->toBe(true)
+
+    let item =
+      typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodoItem ")->Option.getOr("")
+    expect(item->String.includes("customerId: ID!"))->toBe(true)
+    expect(item->String.includes("address: String!"))->toBe(true)
+  })
+})