@reventlessdev/reventless-core 3.0.0-alpha.211 → 3.0.0-alpha.213

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -22,6 +22,38 @@ type todoRow = {
   lastError?: string,
 }
 
+/** The item schema seen through the `JSON.t` the row actually stores.
+
+    `item` holds `Spec.outboundItemSchema`-encoded JSON, so the item schema
+    already describes the stored value exactly — only the ReScript types
+    disagree. */
+external itemAsJson: S.t<'item> => S.t<JSON.t> = "%identity"
+
+/**
+The row schema as the API describes it: `item` carried by the slice's own item
+schema instead of as opaque JSON.
+
+`todoRowSchema` types `item` as `JSON.t`, which the schema→GraphQL IR can only
+classify as `Unknown` — and `Unknown` renders as `String!`. The field then
+serves a stored object through a String, which fails at execution ("String
+cannot represent value: { … }") the moment a client selects it. Describing the
+item shape gives the field a real object type instead.
+
+Shape only: never encode or parse a row with this. The runtime field is `JSON.t`
+and the identity cast above would have `S.parseOrThrow` hand back an item where
+the row's own code expects JSON.
+*/
+let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
+  S.schema(s => {
+    item: s.matches(itemSchema->itemAsJson),
+    status: s.matches(todoStatusSchema),
+    createdAt: s.matches(S.string),
+    processedAt: ?s.matches(S.option(S.string)),
+    completedAt: ?s.matches(S.option(S.string)),
+    retryCount: s.matches(S.int),
+    lastError: ?s.matches(S.option(S.string)),
+  })
+
 /**
 The runtime protocol between a built callback and whoever drives it.
 

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

@@ -29,6 +29,18 @@ let todoRowSchema = S.schema(s => ({
   lastError: s.m(S.option(S.string))
 }));
 
+function todoRowSchemaFor(itemSchema) {
+  return S.schema(s => ({
+    item: s.m(itemSchema),
+    status: s.m(todoStatusSchema),
+    createdAt: s.m(S.string),
+    processedAt: s.m(S.option(S.string)),
+    completedAt: s.m(S.option(S.string)),
+    retryCount: s.m(S.int),
+    lastError: s.m(S.option(S.string))
+  }));
+}
+
 function Make(Spec) {
   return Translation => {
     let todoItems = {};
@@ -168,6 +180,7 @@ function Make(Spec) {
 export {
   todoStatusSchema,
   todoRowSchema,
+  todoRowSchemaFor,
   Make,
 }
 /*  Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -621,20 +621,13 @@ module Make = (
 
       // Offload the two large pluginDefinition fields at deploy time when a
       // provider offers an object store (AWS writes a content-addressed object
-      // and returns a reference); unset locally, so they stay Inline. Computed
-      // HERE, at graph-construction time — both values are concrete and the hook
-      // (which creates the object resource) MUST run outside the Pulumi.Output.apply
-      // below: a resource cannot be created inside .apply, and an apply callback is
-      // skipped entirely on `pulumi preview` when its inputs are still unknown.
+      // and returns a reference). Computed HERE, at graph-construction time —
+      // both values are concrete and the hook (which creates the object resource)
+      // MUST run outside the Pulumi.Output.apply below: a resource cannot be
+      // created inside .apply, and an apply callback is skipped entirely on
+      // `pulumi preview` when its inputs are still unknown.
       // Unconditional: these fields are always large enough to be worth offloading.
-      let toPayload = (value, ~schema, ~store) =>
-        switch Plugin_Helpers.offloadHook.contents {
-        | Some(hook) =>
-          Reventless.Offload.Offloaded(
-            hook(~store, ~bytes=value->S.reverseConvertToJsonStringOrThrow(schema)),
-          )
-        | None => Reventless.Offload.Inline(value)
-        }
+      let toPayload = Plugin_Helpers.offloadPayload
       let apiSchemaFragmentPayload = toPayload(
         apiSchemaFragment,
         ~schema=Reventless.Plugin.apiSchemaFragmentSchema,

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

@@ -425,22 +425,8 @@ function Make(Spec) {
         });
         let pushSchema = Spec.hooks.preResolversSchemaHook;
         let schemaPushed = pushSchema !== undefined ? pushSchema(extra$1, version, apiSchemaFragment) : Pulumi.output();
-        let toPayload = (value, schema, store) => {
-          let hook = Plugin_Helpers$ReventlessCore.offloadHook.contents;
-          if (hook !== undefined) {
-            return {
-              TAG: "Offloaded",
-              _0: hook(store, S.reverseConvertToJsonStringOrThrow(value, schema, undefined))
-            };
-          } else {
-            return {
-              TAG: "Inline",
-              _0: value
-            };
-          }
-        };
-        let apiSchemaFragmentPayload = toPayload(apiSchemaFragment, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments");
-        let structurePayload = Stdlib_Option.map(pluginStructure, s => toPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures"));
+        let apiSchemaFragmentPayload = Plugin_Helpers$ReventlessCore.offloadPayload(apiSchemaFragment, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments");
+        let structurePayload = Stdlib_Option.map(pluginStructure, s => Plugin_Helpers$ReventlessCore.offloadPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures"));
         let builderOutputs = Pulumi.all([
           Pulumi.all([
             interstackAdminExtensionPoints,

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/admin/Platform_ComponentDefinitionsApiTest.res

@@ -163,17 +163,22 @@ describe("encodePluginStructureEntry", () => {
   )
 
   // Translation-slice externalSystem: absent on the fixture above (both None), so it
-  // must serialize as null — the "no external box" case.
+  // must serialize as null — the "no external box" case. The leading field keeps the
+  // two directions apart; `targetName` sits between them and is pinned here too.
   testSync("encodes None outbound externalSystem as null", () =>
-    expect(json->String.includes("\"inboundCommandTypes\":[\"Ship\"],\"externalSystem\":null"))->toEqual(
-      true,
-    )
+    expect(
+      json->String.includes(
+        "\"inboundCommandTypes\":[\"Ship\"],\"targetName\":null,\"externalSystem\":null",
+      ),
+    )->toEqual(true)
   )
 
   testSync("encodes None inbound externalSystem as null", () =>
-    expect(json->String.includes("\"commandTypes\":[\"RecordPayment\"],\"externalSystem\":null"))->toEqual(
-      true,
-    )
+    expect(
+      json->String.includes(
+        "\"commandTypes\":[\"RecordPayment\"],\"targetName\":\"Order\",\"externalSystem\":null",
+      ),
+    )->toEqual(true)
   )
 })
 

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -183,10 +183,10 @@ globalThis.describe("encodePluginStructureEntry", () => {
     globalThis.expect(json.includes("\"events\":[{\"name\":\"ProductAdded\"")).toEqual(true);
   });
   globalThis.test("encodes None outbound externalSystem as null", () => {
-    globalThis.expect(json.includes("\"inboundCommandTypes\":[\"Ship\"],\"externalSystem\":null")).toEqual(true);
+    globalThis.expect(json.includes("\"inboundCommandTypes\":[\"Ship\"],\"targetName\":null,\"externalSystem\":null")).toEqual(true);
   });
   globalThis.test("encodes None inbound externalSystem as null", () => {
-    globalThis.expect(json.includes("\"commandTypes\":[\"RecordPayment\"],\"externalSystem\":null")).toEqual(true);
+    globalThis.expect(json.includes("\"commandTypes\":[\"RecordPayment\"],\"targetName\":\"Order\",\"externalSystem\":null")).toEqual(true);
   });
 });
 

package/tests/admin/Platform_PluginStructuresApiTest.res

@@ -0,0 +1,144 @@
+// Asserts what makes `Platform_PluginStructures` different from
+// `Platform_ComponentDefinitions`: nothing is filtered out, and the structure-level
+// collections the AutoUI entry does not carry are present. A developer tool draws
+// its graph from this response, so a component or a bridge missing here is a graph
+// that silently disagrees with the source.
+
+open JestGlobals
+open Reventless.Plugin
+
+let publicRm: queryableDef = {
+  name: "Products",
+  queryField: "Catalog_Products",
+  schema: "{}",
+  consumedEventTypes: ["ProductAdded"],
+  linkedWriteSide: ["Product"],
+  labelField: "displayName",
+  searchableFields: ["displayName"],
+  labelFieldSource: Some("annotation"),
+  statusField: None,
+  visibility: None,
+  chapter: Some("Inventory"),
+}
+
+// The component `Platform_ComponentDefinitions` drops and this query must keep.
+let internalRm: queryableDef = {
+  ...publicRm,
+  name: "ProductAudit",
+  queryField: "Catalog_ProductAudit",
+  visibility: Some("Internal"),
+}
+
+let structure: pluginStructure = {
+  readModels: [publicRm, internalRm],
+  stateViewSlices: [internalRm],
+  stateChangeSlices: [],
+  aggregates: [],
+  automationSlices: [],
+  outboundTranslationSlices: [],
+  inboundTranslationSlices: [],
+  extensions: [],
+  extensionPoints: Some([
+    {
+      name: "Catalog.Products",
+      delegateNames: ["onAdded"],
+      sourceEventTypes: ["Catalog.ProductAdded"],
+      commandTypes: None,
+    },
+  ]),
+  requiredStores: Some(["Catalog.images"]),
+  requiredStoreDeclarations: Some([
+    {store: "Catalog.images", component: "Product", field: "image", annotation: Some("images")},
+  ]),
+}
+
+let encoded = Platform_PluginStructuresApi.encodePluginStructureEntry(
+  ~pluginId="Catalog",
+  structure,
+)
+let json = encoded->JSON.stringify
+
+let namesOf = (key): array<string> =>
+  encoded
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(key))
+  ->Option.flatMap(JSON.Decode.array)
+  ->Option.getOr([])
+  ->Array.filterMap(v =>
+    v->JSON.Decode.object->Option.flatMap(o => o->Dict.get("name"))->Option.flatMap(JSON.Decode.string)
+  )
+
+describe("Platform_PluginStructures entry", () => {
+  testSync("carries the structure-level keys the AutoUI entry omits", () => {
+    let dict = encoded->JSON.Decode.object->Option.getOr(Dict.make())
+    let keys = dict->Dict.keysToArray->Array.toSorted(String.compare)
+    expect(keys)->toEqual([
+      "aggregates",
+      "automationSlices",
+      "extensionPoints",
+      "extensions",
+      "inboundTranslationSlices",
+      "outboundTranslationSlices",
+      "pluginId",
+      "readModels",
+      "requiredStoreDeclarations",
+      "requiredStores",
+      "stateChangeSlices",
+      "stateViewSlices",
+    ])
+  })
+
+  // The whole reason this query exists as a separate field.
+  testSync("keeps Internal read models", () =>
+    expect(namesOf("readModels"))->toEqual(["Products", "ProductAudit"])
+  )
+
+  testSync("keeps Internal state-view slices", () =>
+    expect(namesOf("stateViewSlices"))->toEqual(["ProductAudit"])
+  )
+
+  testSync("carries visibility so a consumer can tell which are Internal", () =>
+    expect(json->String.includes("\"visibility\":\"Internal\""))->toEqual(true)
+  )
+
+  testSync("encodes the chapter band", () =>
+    expect(json->String.includes("\"chapter\":\"Inventory\""))->toEqual(true)
+  )
+
+  testSync("encodes extension points with their source event types", () =>
+    expect(
+      json->String.includes(
+        "\"extensionPoints\":[{\"name\":\"Catalog.Products\",\"delegateNames\":[\"onAdded\"],\"sourceEventTypes\":[\"Catalog.ProductAdded\"],\"commandTypes\":null}]",
+      ),
+    )->toEqual(true)
+  )
+
+  testSync("encodes required stores with their provenance", () =>
+    expect(json->String.includes("\"requiredStores\":[\"Catalog.images\"]"))->toEqual(true)
+  )
+})
+
+// A structure persisted before these fields existed decodes as None, and null is the
+// honest wire value — an empty list would claim the plugin has no extension points
+// when the truth is that the deployment cannot say.
+describe("absent optional collections", () => {
+  let bare: pluginStructure = {
+    ...structure,
+    extensionPoints: None,
+    requiredStores: None,
+    requiredStoreDeclarations: None,
+  }
+  let bareJson =
+    Platform_PluginStructuresApi.encodePluginStructureEntry(
+      ~pluginId="Catalog",
+      bare,
+    )->JSON.stringify
+
+  testSync("encodes absent extensionPoints as null", () =>
+    expect(bareJson->String.includes("\"extensionPoints\":null"))->toEqual(true)
+  )
+
+  testSync("encodes absent requiredStores as null", () =>
+    expect(bareJson->String.includes("\"requiredStores\":null"))->toEqual(true)
+  )
+})