@reventlessdev/reventless-core 3.0.0-alpha.238 → 3.0.0-alpha.240

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.240 (2026-08-18)
+
+### Bug Fixes
+
+* **core:** derive the platform's own command defs from its spec ([599d0b6](https://github.com/ReventlessDev/reventless-core/commit/599d0b64e1ab1687841dbff9383f9bda5d2e629b))
+* **core:** give the Plugin lifecycle its transitions back ([1dc2ab2](https://github.com/ReventlessDev/reventless-core/commit/1dc2ab28cf145f2e709359d2a5a67a50b46f5ce4))
+* **core:** let the Plugins view say which field its lifecycle lives in ([45511c5](https://github.com/ReventlessDev/reventless-core/commit/45511c5476e45586b2a6ae8ebac67786360d0d85))
+* **core:** let the Plugins view state its own read rule ([1fe9fcf](https://github.com/ReventlessDev/reventless-core/commit/1fe9fcfb198334923dd8342861315ac53cb78cac))
+* **core:** order union constructors so every one decodes ([39c17ad](https://github.com/ReventlessDev/reventless-core/commit/39c17ad8cedd6f120e92d81b4a05b8c733b4617d)), closes [DZakh/sury#392](https://github.com/DZakh/sury/issues/392)
+* **core:** report the real reason a decode failed ([233c835](https://github.com/ReventlessDev/reventless-core/commit/233c835be47cb83fbd247ab0d8a7073cad622fee)), closes [DZakh/sury#392](https://github.com/DZakh/sury/issues/392)
+* feat(core)!: tell the Monitoring seam where a unit's logs live ([6cbd595](https://github.com/ReventlessDev/reventless-core/commit/6cbd595e2474fce3f87b7720a332e82583899bae))
+* feat(sury)!: migrate to sury 11.0.0-rc.1 ([2cf8969](https://github.com/ReventlessDev/reventless-core/commit/2cf8969a222ce1b775563668a4126cb20611966c))
+### Features
+
+* **core:** let a command declare the edge that creates the row ([a5b6dbd](https://github.com/ReventlessDev/reventless-core/commit/a5b6dbddd3f81ac23117f9ccb9ffdbdd07781dcc))
+* **spec,ppx:** uploadable types that derive their store from the field name ([722b404](https://github.com/ReventlessDev/reventless-core/commit/722b4044a2e8dfb6a34231d6bfb529526de38b20))
+
+### BREAKING CHANGES
+
+* Monitoring.Backend.onProvisioned gained a required
+~logLocator argument. An extension that packs its backend against the
+module type will not compile until onProvisioned accepts it.
+* sury is a direct dependency of the published packages and
+its schema and serialization surface changed; consumers must migrate to
+sury 11.
+
+
+
+# 3.0.0-alpha.239 (2026-08-18)
+
+### Bug Fixes
+
+* **api:** declare the reference door in the SDL every backend is built from ([5c1857e](https://github.com/ReventlessDev/reventless-core/commit/5c1857ea90ff40305a1c44a9e57043528e6a93aa))
+* **api:** make the by-index door answer, and let an elevated caller widen it ([0fe0c6f](https://github.com/ReventlessDev/reventless-core/commit/0fe0c6f8dec6228ecaba39577e28d780b4f79c83))
+* **core:** fail the build on a retired state the field's enum does not declare ([781935b](https://github.com/ReventlessDev/reventless-core/commit/781935bf8f3e9c418d1e7b25e7235717e4812d7c))
+### Features
+
+* **core:** let a reference name a retired row, and let an elevated caller open one ([9e2623a](https://github.com/ReventlessDev/reventless-core/commit/9e2623a4b22487561607fcc0ca19d51726069ee4))
+
+
 # 3.0.0-alpha.238 (2026-08-16)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.238",
+  "version": "3.0.0-alpha.240",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -26,24 +26,24 @@
     }
   },
   "dependencies": {
-    "sury": "11.0.0-alpha.4",
+    "sury": "11.0.0-rc.1",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.7",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.7",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.7",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.31",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.116",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.144"
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.146",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.118",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
   },
   "devDependencies": {
     "rescript": "12.3.0",
-    "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.68"
+    "sury-ppx": "11.0.0-rc.1",
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.71"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Message.res

@@ -76,9 +76,9 @@ let decodeCommand' = (json, idSchema, commandSchema) =>
   json->parseJsonTolerant(toCommandSchema'(idSchema, commandSchema))
 
 let encodeEvent' = (event', idSchema, eventSchema) =>
-  event'->S.reverseConvertToJsonOrThrow(toEventSchema'(idSchema, eventSchema))
+  event'->Reventless.Util_Sury.toJson(toEventSchema'(idSchema, eventSchema))
 let encodeCommand' = (command', idSchema, commandSchema) =>
-  command'->S.reverseConvertToJsonOrThrow(toCommandSchema'(idSchema, commandSchema))
+  command'->Reventless.Util_Sury.toJson(toCommandSchema'(idSchema, commandSchema))
 
 let uuid = Uuid.v4
 
@@ -95,7 +95,7 @@ let toMessageBody = ({id, meta, commandJson}) => {
   let commandMeta: meta = {...meta, msgId: uuid(), time: nowAsISOString()}
   [
     ("id", id->JSON.Encode.string),
-    ("meta", commandMeta->S.reverseConvertToJsonOrThrow(metaSchema)),
+    ("meta", commandMeta->Reventless.Util_Sury.toJson(metaSchema)),
     ("command", commandJson),
   ]
   ->Dict.fromArray
@@ -115,7 +115,7 @@ let serviceNameOfMsg = msgJson =>
     msgObj
     ->Dict.get("meta")
     ->Option.flatMap(meta =>
-      switch meta->S.parseJsonOrThrow(metaSchema) {
+      switch meta->Reventless.Util_Sury.fromJson(metaSchema) {
       | msgMeta => Some(msgMeta.service)
       | exception err =>
         logger.warn(
@@ -252,7 +252,7 @@ let deriveMeta = (~parent: meta, ~service=?) => {
 
 let decomposeMeta = meta =>
   meta
-  ->S.reverseConvertToJsonOrThrow(metaSchema)
+  ->Reventless.Util_Sury.toJson(metaSchema)
   ->JSON.Decode.object
   ->Option.getOrThrow
   ->Dict.toArray
@@ -260,7 +260,7 @@ let decomposeMeta = meta =>
 let composeEventJson' = (id, meta, ~recordedAt, eventJson) =>
   [
     ("id", id->JSON.Encode.string),
-    ("meta", meta->S.reverseConvertToJsonOrThrow(metaSchema)),
+    ("meta", meta->Reventless.Util_Sury.toJson(metaSchema)),
     ("recordedAt", recordedAt->JSON.Encode.string),
     ("event", eventJson),
   ]
@@ -316,7 +316,7 @@ let storedEventToFlatJson = (
   idSchema: S.t<'id>,
 ): JSON.t => {
   let fields = [
-    ("id", stored.id->S.reverseConvertToJsonOrThrow(idSchema)),
+    ("id", stored.id->Reventless.Util_Sury.toJson(idSchema)),
     ("position", JSON.String(stored.position)),
     ("event", JSON.String(stored.event)),
     ("data", stored.data),
@@ -324,7 +324,7 @@ let storedEventToFlatJson = (
   ]
   let withTags = switch stored.tags {
   | Some(tags) =>
-    let tagsJson = tags->S.reverseConvertToJsonOrThrow(S.array(Reventless.DcbTag.tagSchema))
+    let tagsJson = tags->Reventless.Util_Sury.toJson(S.array(Reventless.DcbTag.tagSchema))
     fields->Array.concat([("tags", tagsJson)])
   | None => fields
   }
@@ -337,17 +337,17 @@ let flatJsonToStoredEvent = (
   idSchema: S.t<'id>,
 ): Reventless.StoredEvent.storedEvent<'id> => {
   let dict = json->JSON.Decode.object->Option.getOrThrow
-  let id = dict->Dict.get("id")->Option.getOrThrow->S.parseJsonOrThrow(idSchema)
+  let id = dict->Dict.get("id")->Option.getOrThrow->Reventless.Util_Sury.fromJson(idSchema)
   let position = dict->Dict.get("position")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
   let event = dict->Dict.get("event")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
   let data = dict->Dict.get("data")->Option.getOrThrow
   let recordedAt =
     dict->Dict.get("recordedAt")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
-  let meta = composeMeta(dict)->S.parseJsonOrThrow(metaSchema)
+  let meta = composeMeta(dict)->Reventless.Util_Sury.fromJson(metaSchema)
   let tags =
     dict
     ->Dict.get("tags")
-    ->Option.map(t => t->S.parseJsonOrThrow(S.array(Reventless.DcbTag.tagSchema)))
+    ->Option.map(t => t->Reventless.Util_Sury.fromJson(S.array(Reventless.DcbTag.tagSchema)))
   {id, position, event, data, recordedAt, meta, tags: ?tags}
 }
 

package/src/Message.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Uuid from "uuid";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -8,6 +8,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
 
 let logger = Logger$ReventlessCore.fromEnv();
@@ -28,7 +29,7 @@ function memoizeBySchemaPair(a, b, build) {
 }
 
 function toEventSchema$p(idSchema, eventSchema) {
-  return _rawMemoize(idSchema, eventSchema, (idSchema, eventSchema) => S.object(s => ({
+  return _rawMemoize(idSchema, eventSchema, (idSchema, eventSchema) => Sury.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     event: s.f("event", eventSchema)
@@ -36,7 +37,7 @@ function toEventSchema$p(idSchema, eventSchema) {
 }
 
 function toCommandSchema$p(idSchema, commandSchema) {
-  return _rawMemoize(idSchema, commandSchema, (idSchema, commandSchema) => S.object(s => ({
+  return _rawMemoize(idSchema, commandSchema, (idSchema, commandSchema) => Sury.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     command: s.f("command", commandSchema)
@@ -52,11 +53,11 @@ function decodeCommand$p(json, idSchema, commandSchema) {
 }
 
 function encodeEvent$p(event$p, idSchema, eventSchema) {
-  return S.reverseConvertToJsonOrThrow(event$p, toEventSchema$p(idSchema, eventSchema));
+  return Util_Sury$Reventless.toJson(event$p, toEventSchema$p(idSchema, eventSchema));
 }
 
 function encodeCommand$p(command$p, idSchema, commandSchema) {
-  return S.reverseConvertToJsonOrThrow(command$p, toCommandSchema$p(idSchema, commandSchema));
+  return Util_Sury$Reventless.toJson(command$p, toCommandSchema$p(idSchema, commandSchema));
 }
 
 function uuid(prim) {
@@ -87,7 +88,7 @@ function toMessageBody(param) {
     ],
     [
       "meta",
-      S.reverseConvertToJsonOrThrow(newrecord, Message$Reventless.metaSchema)
+      Util_Sury$Reventless.toJson(newrecord, Message$Reventless.metaSchema)
     ],
     [
       "command",
@@ -102,7 +103,7 @@ function serviceNameOfMsg(msgJson) {
     return Stdlib_Option.flatMap(msgObj["meta"], meta => {
       let msgMeta;
       try {
-        msgMeta = S.parseJsonOrThrow(meta, Message$Reventless.metaSchema);
+        msgMeta = Util_Sury$Reventless.fromJson(meta, Message$Reventless.metaSchema);
       } catch (raw_err) {
         let err = Primitive_exceptions.internalToException(raw_err);
         logger.warn("Message", Stdlib_Option.getOr(JSON.stringify(err), ""), "serviceNameOfMsg: Couldn't parse meta");
@@ -200,7 +201,7 @@ function deriveMeta(parent, service) {
 }
 
 function decomposeMeta(meta) {
-  return Object.entries(Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)), undefined));
+  return Object.entries(Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(Util_Sury$Reventless.toJson(meta, Message$Reventless.metaSchema)), undefined));
 }
 
 function composeEventJson$p(id, meta, recordedAt, eventJson) {
@@ -211,7 +212,7 @@ function composeEventJson$p(id, meta, recordedAt, eventJson) {
     ],
     [
       "meta",
-      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+      Util_Sury$Reventless.toJson(meta, Message$Reventless.metaSchema)
     ],
     [
       "recordedAt",
@@ -275,7 +276,7 @@ function storedEventToFlatJson(stored, idSchema) {
   let fields = [
     [
       "id",
-      S.reverseConvertToJsonOrThrow(stored.id, idSchema)
+      Util_Sury$Reventless.toJson(stored.id, idSchema)
     ],
     [
       "position",
@@ -297,7 +298,7 @@ function storedEventToFlatJson(stored, idSchema) {
   let tags = stored.tags;
   let withTags;
   if (tags !== undefined) {
-    let tagsJson = S.reverseConvertToJsonOrThrow(tags, S.array(DcbTag$Reventless.tagSchema));
+    let tagsJson = Util_Sury$Reventless.toJson(tags, Sury.array(DcbTag$Reventless.tagSchema));
     withTags = fields.concat([[
         "tags",
         tagsJson
@@ -310,13 +311,13 @@ function storedEventToFlatJson(stored, idSchema) {
 
 function flatJsonToStoredEvent(json, idSchema) {
   let dict = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(json), undefined);
-  let id = S.parseJsonOrThrow(Stdlib_Option.getOrThrow(dict["id"], undefined), idSchema);
+  let id = Util_Sury$Reventless.fromJson(Stdlib_Option.getOrThrow(dict["id"], undefined), idSchema);
   let position = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["position"], undefined)), undefined);
   let event = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["event"], undefined)), undefined);
   let data = Stdlib_Option.getOrThrow(dict["data"], undefined);
   let recordedAt = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["recordedAt"], undefined)), undefined);
-  let meta = S.parseJsonOrThrow(composeMeta(dict), Message$Reventless.metaSchema);
-  let tags = Stdlib_Option.map(dict["tags"], t => S.parseJsonOrThrow(t, S.array(DcbTag$Reventless.tagSchema)));
+  let meta = Util_Sury$Reventless.fromJson(composeMeta(dict), Message$Reventless.metaSchema);
+  let tags = Stdlib_Option.map(dict["tags"], t => Util_Sury$Reventless.fromJson(t, Sury.array(DcbTag$Reventless.tagSchema)));
   return {
     id: id,
     position: position,

package/src/Projection.res

@@ -33,13 +33,13 @@ let overlayDisplayName = (
   stateSchema: S.t<'state>,
   spec: Reventless.DisplayName.displayNameSpec,
 ): 'state => {
-  let json = state->S.reverseConvertToJsonOrThrow(stateSchema)
+  let json = state->Reventless.Util_Sury.toJson(stateSchema)
   switch json->JSON.Decode.object {
   | None => state
   | Some(stateDict) =>
     let label = Reventless.DisplayName.computeLabel(spec, stateDict)
     stateDict->Dict.set("displayName", JSON.Encode.string(label))
-    stateDict->JSON.Encode.object->S.parseJsonOrThrow(stateSchema)
+    stateDict->JSON.Encode.object->Reventless.Util_Sury.fromJson(stateSchema)
   }
 }
 

package/src/Projection.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -11,6 +11,7 @@ import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as Message$ReventlessCore from "./Message.res.mjs";
@@ -21,7 +22,7 @@ import * as LogFormat$ReventlessCore from "./util/LogFormat.res.mjs";
 let log = Logger$ReventlessCore.fromEnv();
 
 function MakeGenericSource(Mapping) {
-  let decode$p = json => Message$ReventlessCore.decodeEvent$p(json, S.string, Mapping.sourceEventSchema);
+  let decode$p = json => Message$ReventlessCore.decodeEvent$p(json, Sury.string, Mapping.sourceEventSchema);
   return {
     name: Mapping.sourceName,
     decode$p: decode$p
@@ -37,14 +38,14 @@ function logAction(makeStr) {
 }
 
 function overlayDisplayName(state, stateSchema, spec) {
-  let json = S.reverseConvertToJsonOrThrow(state, stateSchema);
+  let json = Util_Sury$Reventless.toJson(state, stateSchema);
   let stateDict = Stdlib_JSON.Decode.object(json);
   if (stateDict === undefined) {
     return state;
   }
   let label = DisplayName$Reventless.computeLabel(spec, stateDict);
   stateDict["displayName"] = label;
-  return S.parseJsonOrThrow(stateDict, stateSchema);
+  return Util_Sury$Reventless.fromJson(stateDict, stateSchema);
 }
 
 function rewriteAction(action, stateSchema) {

package/src/adapter/Monitoring/Monitoring.res

@@ -64,6 +64,16 @@ same stack, parented naturally.
 `AWS_Tags` uses). Both are `None` for substrate provisioned outside any plugin construct — the
 correct answer for platform-scope resources. A backend that names or routes its monitoring resources
 per plugin needs this: `~name` is only the component, and two plugins can own like-named components.
+
+`~logLocator` is the provider-native address of the unit's logs — an OPAQUE string core assigns no
+further meaning to (a CloudWatch log group name on one runtime, a namespace/selector on another),
+and `None` for a unit with no logs of its own. It exists because an alert is only half of what an
+operator needs: the notification a provider sends names the unit and the metric, never where to
+read what happened. A backend cannot reconstruct the address either — where a unit's logs land can
+depend on stack configuration the runtime backend resolved and did not record, so a derived guess is
+wrong exactly where it differs from the default. Like `~component`'s fields this is an `Output`, so
+it can only be used inside a resolution (a description, an annotation) and never as a synchronous
+logical resource name — which is no limitation for an address a human is meant to follow.
 */
 module type Backend = {
   let onProvisioned: (
@@ -72,12 +82,20 @@ module type Backend = {
     ~component: ReventlessInfra.Adapter.resource,
     ~plugin: option<string>,
     ~platform: option<string>,
+    ~logLocator: option<Pulumi.Output.t<string>>,
   ) => unit
 }
 
 /** Default backend: does nothing. Active unless an extension calls `use`. */
 module Noop: Backend = {
-  let onProvisioned = (~kind as _, ~name as _, ~component as _, ~plugin as _, ~platform as _) => ()
+  let onProvisioned = (
+    ~kind as _,
+    ~name as _,
+    ~component as _,
+    ~plugin as _,
+    ~platform as _,
+    ~logLocator as _,
+  ) => ()
 }
 
 let backend: ref<module(Backend)> = ref(module(Noop: Backend))
@@ -98,11 +116,15 @@ let notify = (
   ~kind: unitKind,
   ~name: string,
   ~component: ReventlessInfra.Adapter.resource,
+  ~logLocator: option<Pulumi.Output.t<string>>=?,
 ) => {
   module B = unpack(backend.contents)
   // The owning plugin/platform come from the ambient context the plugin builder publishes
   // (ResourceAttribution.enter) — populated exactly when this fires, so the call sites need not
   // thread the names. `None` outside a plugin construct (platform substrate).
   let {ResourceAttribution.plugin: plugin, platform} = ResourceAttribution.current.contents
-  B.onProvisioned(~kind, ~name, ~component, ~plugin, ~platform)
+  // `~logLocator`, unlike the owner, is NOT ambient: only the provisioning site knows where it
+  // pointed the unit's logs. So it is passed, and optional — a call site with nothing to say omits
+  // it rather than being forced to invent an address.
+  B.onProvisioned(~kind, ~name, ~component, ~plugin, ~platform, ~logLocator)
 }

package/src/adapter/Monitoring/Monitoring.res.mjs

@@ -2,7 +2,7 @@
 
 import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.res.mjs";
 
-function onProvisioned(param, param$1, param$2, param$3, param$4) {
+function onProvisioned(param, param$1, param$2, param$3, param$4, param$5) {
   
 }
 
@@ -18,10 +18,10 @@ function use(b) {
   backend.contents = b;
 }
 
-function notify(kind, name, component) {
+function notify(kind, name, component, logLocator) {
   let B = backend.contents;
   let match = ResourceAttribution$ReventlessCore.current.contents;
-  B.onProvisioned(kind, name, component, match.plugin, match.platform);
+  B.onProvisioned(kind, name, component, match.plugin, match.platform, logLocator);
 }
 
 export {

package/src/admin/Platform_AdminApi.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../components/Api/GraphQL_Stitcher.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
@@ -10,8 +10,8 @@ import * as Plugin_SubscriptionSchema$ReventlessCore from "../plugin/component/P
 import * as Platform_PluginStructuresApi$ReventlessCore from "./Platform_PluginStructuresApi.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
 
-let cloneArgsSchema = S.schema(s => ({
-  restoreDateTime: s.m(S.option(S.string))
+let cloneArgsSchema = Sury.$schema(s => ({
+  restoreDateTime: s.m(Sury.$option(Sury.string))
 }));
 
 let cloneMutationEntry_fieldNames = [Api_Naming$ReventlessCore.adminField("Clone")];

package/src/admin/Platform_Admin_Structure.res

@@ -7,9 +7,11 @@
 // never seeds them into pluginStructuresStore — so the host shell's Auto UI
 // has no metadata for the admin plugin and renders nothing for it.
 //
-// This module produces an equivalent structure by hand using the same field
-// naming conventions (Api_Naming.adminField) and the mutation arg schemas
-// from PluginBaseFragment.
+// This module assembles the equivalent structure from `PluginSpec` /
+// `PluginsReadModelSpec` directly, through the same module-level extractors
+// `make` uses for every ordinary plugin. It cannot call `make` itself — the
+// platform has no `module(Aggregate.T)` to hand it at structure-assembly time —
+// but the extractors take schemas, which is all this needs.
 
 open Reventless.Plugin
 
@@ -17,86 +19,31 @@ let pluginId = "Platform"
 
 let pluginName = pluginId
 
-let encodeSchema = (schema: S.t<unknown>): string =>
-  schema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify
+let commandSchema = PluginSpec.commandSchema->S.castToUnknown
 
-// Strip the named fields from a derived JSON schema's `properties` map and
-// `required` list. Used so Plugin read model metadata announced via
-// `Platform_ComponentDefinitions` matches the SDL — fields excluded from the GraphQL
-// schema in `PluginBaseFragment` must also disappear from the schema string
-// AutoUI consumes, or list-view queries will reference non-existent fields.
-let encodeSchemaExcluding = (schema: S.t<unknown>, ~excludeFields: array<string>): string => {
-  let derived = schema->SuryToJsonSchema.deriveObjectSchema
-  switch derived->JSON.Decode.object {
-  | None => derived->JSON.stringify
-  | Some(obj) =>
-    switch obj->Dict.get("properties")->Option.flatMap(JSON.Decode.object) {
-    | None => derived->JSON.stringify
-    | Some(props) =>
-      excludeFields->Array.forEach(f => props->Dict.delete(f))
-      obj->Dict.set("properties", props->JSON.Encode.object)
-      switch obj->Dict.get("required")->Option.flatMap(JSON.Decode.array) {
-      | None => ()
-      | Some(req) =>
-        let filtered =
-          req
-          ->Array.filterMap(JSON.Decode.string)
-          ->Array.filter(name => !(excludeFields->Array.includes(name)))
-          ->Array.map(JSON.Encode.string)
-          ->JSON.Encode.array
-        obj->Dict.set("required", filtered)
-      }
-      obj->JSON.Encode.object->JSON.stringify
-    }
-  }
-}
-
-// Args schema for the synthetic Auto UI metadata. Activate/Deactivate are payload-less
-// `PluginSpec.command` variants on the wire — the auto-resolver flow injects `id: ID!`.
-// Keep a local schema here so Auto UI's command-form metadata stays accurate.
-@schema
-type idArgs = {id: @s.matches(Reventless.DcbTag.string) string}
-
-// `aggregateIdField: Some("id")` pre-fills the form's `id` input from the
-// selected list row. The auto-codegen path would emit this for any
-// Instance-level command whose schema has a DCB-tagged id field; the
-// hand-rolled definitions below have to mirror that.
-
-// `allowedStates` mirrors the PluginBehavior accept/reject branches: Activate
-// is meaningful only on Inactive plugins; Deactivate is meaningful on
-// Connected or Disconnected ones. Strings here must match the variant
-// constructor names that PluginsReadModelSpec.status serialises to.
-let activateCommand: commandDef = {
-  name: "Activate",
-  schema: idArgsSchema->S.castToUnknown->encodeSchema,
-  level: Instance,
-  aggregateIdField: Some("id"),
-  mutationField: Api_Naming.adminField(~name="Plugin_Activate"),
-  references: [],
-  allowedStates: Some(["Inactive"]),
-  targetState: None,
-  apiExposed: Some(true),
-  requiredAccess: None,
-  ownerField: None,
-}
-
-let deactivateCommand: commandDef = {
-  name: "Deactivate",
-  schema: idArgsSchema->S.castToUnknown->encodeSchema,
-  level: Instance,
-  aggregateIdField: Some("id"),
-  mutationField: Api_Naming.adminField(~name="Plugin_Deactivate"),
-  references: [],
-  allowedStates: Some(["Connected", "Disconnected"]),
-  targetState: None,
-  apiExposed: Some(true),
-  requiredAccess: None,
-  ownerField: None,
-}
+// Every variant of `PluginSpec.command`, walked by the same `extractCommandDefs`
+// an ordinary aggregate goes through. The hand-written alternative described the
+// arguments with a local `{id}` schema while the generated SDL declared
+// `Platform_Plugin_Activate(_0: String!, id: ID!)`, so AutoUI built a mutation
+// missing a required argument and every admin row action was rejected before it
+// reached the aggregate. Deriving from `commandSchema` — the same schema the SDL
+// is generated from — cannot reproduce that class of fault.
+//
+// `mutationFieldFor` is composed the way `PluginBaseFragment` composes the field
+// it generates, so the two cannot name it differently. The `@noApi` protocol
+// variants come back too, carrying `apiExposed: false` and the empty
+// `mutationField` sentinel: metadata about an edge, not a way to invoke it.
+let pluginCommands: array<commandDef> = Plugin_Structure.extractCommandDefs(
+  ~isAggregate=true,
+  ~mutationFieldFor=variantName =>
+    Api_Naming.adminField(~name=PluginSpec.name ++ "_" ++ variantName),
+  ~commandAuthorization=PluginSpec.commandAuthorization->Obj.magic,
+  commandSchema,
+)
 
 let pluginAggregate: writableDef = {
   name: "Plugin",
-  commands: [activateCommand, deactivateCommand],
+  commands: pluginCommands,
   producedEventTypes: [],
   consumedEventTypes: [],
   linkedViews: ["Plugins"],
@@ -109,39 +56,13 @@ let pluginAggregate: writableDef = {
   chapter: None,
 }
 
-let pluginReadModel: queryableDef = {
-  name: "Plugins",
-  queryField: Api_Naming.adminField(~name="Plugins"),
-  schema: PluginsReadModelSpec.stateSchema
-  ->S.castToUnknown
-  ->encodeSchemaExcluding(~excludeFields=PluginBaseFragment.pluginUIOnlyExcludeFields),
-  consumedEventTypes: [],
-  linkedWriteSide: ["Plugin"],
-  labelField: "name",
-  searchableFields: ["name"],
-  // Hand-rolled rather than resolved, but the rung is the same one
-  // `labelFieldsFromStateSchema` would report for a field literally named `name`.
-  labelFieldSource: Some("convention"),
-  // The published wire name stays `status` — it is what the SDL declares and what
-  // stored rows carry. Only the key naming it moved.
-  lifecycleField: Some("status"),
-  visibility: None,
-  chapter: None,
-  // The admin fragment hand-declares its query names rather than deriving them from
-  // the read-model name, so the singular is taken from the same call
-  // `PluginBaseFragment.queryNames.singleFieldName` makes — not singularised here.
-  singleQueryField: Some(Api_Naming.adminField(~name="Plugin")),
-  // No key field to name: the row id is `name@version` (`Plugin.makeId`), and the
-  // state carries the two halves separately rather than the composed key. `None`
-  // is the honest answer — the same one the resolver ladder reaches for a state
-  // with no `*Id` field.
-  idField: None,
-  idFieldSource: None,
-  requiredAccess: None,
-  ownerField: None,
-  retiredField: None,
-  retiredValues: None,
-}
+let pluginReadModel: queryableDef = Plugin_Structure.queryableDefFromSpec(
+  ~plugin=pluginId,
+  ~name=PluginsReadModelSpec.name,
+  ~stateSchema=PluginsReadModelSpec.stateSchema->S.castToUnknown,
+  ~authorization=PluginsReadModelSpec.authorization,
+  ~linkedWriteSide=["Plugin"],
+)
 
 let structure: pluginStructure = {
   readModels: [pluginReadModel],