@reventlessdev/reventless-core 3.0.0-alpha.156 → 3.0.0-alpha.157

package/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function evolve(_state, event) {
+  switch (event.TAG) {
+    case "UiFragmentRegistered" :
+      return event.manifest;
+    case "UiFragmentUpdated" :
+      return event.newManifest;
+    case "UiFragmentDeregistered" :
+      return;
+  }
+}
+
+function decide(state, command) {
+  if (command.TAG !== "RegisterUiFragment") {
+    if (state !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "UiFragmentDeregistered",
+            pluginId: command.pluginId
+          }]
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  }
+  let at = command.at;
+  let manifest = command.manifest;
+  let pluginId = command.pluginId;
+  if (state !== undefined) {
+    if (Primitive_object.equal(state, manifest)) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "UiFragmentUpdated",
+            pluginId: pluginId,
+            previousManifest: state,
+            newManifest: manifest,
+            at: at
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "UiFragmentRegistered",
+          pluginId: pluginId,
+          manifest: manifest,
+          at: at
+        }]
+    };
+  }
+}
+
+let Spec;
+
+let initialState;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res

@@ -0,0 +1,33 @@
+// UiFragments StateViewSlice — the read side of the platform UI-fragment registry,
+// replacing UIFragmentRegistryReadModelSpec + UIFragmentRegistryProjection. Projects the
+// UiFragmentRegistry slice's events (from the shared admin DcbEventLog) into the
+// manifest-per-plugin table that backs the Platform_UIFragments query. The wire shape is
+// owned by Platform_UIFragmentsApi.res (SDL + encoder), pinned by the golden test
+// Platform_UIFragmentsApiTest.res — `state` here matches that encoder byte-for-byte.
+@@reventless.spec
+
+open Reventless.Plugin
+
+@schema
+type state = {
+  pluginId: string,
+  remoteEntryUrl: string,
+  panels: array<panelManifestEntry>,
+  pages: array<pageManifestEntry>,
+  registeredAt: string,
+  updatedAt: string,
+}
+
+// Consumes the UiFragmentRegistry slice's events (from the shared admin DcbEventLog). Inline
+// records with the same constructors/fields as the producer's `event` — decodes byte-identically
+// and the ppx auto-tags `pluginId`.
+@schema
+type consumedEvent =
+  | UiFragmentRegistered({pluginId: string, manifest: uiFragmentManifest, at: string})
+  | UiFragmentUpdated({
+      pluginId: string,
+      previousManifest: uiFragmentManifest,
+      newManifest: uiFragmentManifest,
+      at: string,
+    })
+  | UiFragmentDeregistered({pluginId: string})

package/src/admin/{UIFragmentRegistryReadModelSpec.res.mjs → UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs}

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 
@@ -13,15 +14,35 @@ let stateSchema = S.schema(s => ({
   updatedAt: s.m(S.string)
 }));
 
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "UiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
 let config = ReadModel$Reventless.config(undefined, undefined, undefined);
 
-let name = "UIFragmentRegistry";
+let name = "UiFragments";
 
 let Id;
 
 let subIdConfig;
 
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/UIFragmentRegistryReadModelSpec.res.mjs";
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs";
 
 let authorization = "AllowAuthenticated";
 
@@ -31,6 +52,7 @@ export {
   name,
   Id,
   stateSchema,
+  consumedEventSchema,
   config,
   subIdConfig,
   moduleUrl,

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res

@@ -0,0 +1,34 @@
+@@reventless.projection
+
+// No `open Reventless.Plugin`: it would shadow the state labels (panels/pages/...) brought in
+// by the projection's spec open. `manifest.<field>` resolves type-directed from the event's
+// uiFragmentManifest payload.
+let project = event =>
+  switch event {
+  | UiFragmentRegistered({pluginId, manifest, at}) => [
+      Set(
+        pluginId,
+        {
+          pluginId,
+          remoteEntryUrl: manifest.remoteEntryUrl,
+          panels: manifest.panels,
+          pages: manifest.pages,
+          registeredAt: at,
+          updatedAt: at,
+        },
+      ),
+    ]
+  | UiFragmentUpdated({pluginId, newManifest, at}) => [
+      Update(
+        pluginId,
+        state => {
+          ...state,
+          remoteEntryUrl: newManifest.remoteEntryUrl,
+          panels: newManifest.panels,
+          pages: newManifest.pages,
+          updatedAt: at,
+        },
+      ),
+    ]
+  | UiFragmentDeregistered({pluginId}) => [Delete(pluginId)]
+  }

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function project(event) {
+  switch (event.TAG) {
+    case "UiFragmentRegistered" :
+      let at = event.at;
+      let manifest = event.manifest;
+      let pluginId = event.pluginId;
+      return [{
+          TAG: "Set",
+          _0: pluginId,
+          _1: {
+            pluginId: pluginId,
+            remoteEntryUrl: manifest.remoteEntryUrl,
+            panels: manifest.panels,
+            pages: manifest.pages,
+            registeredAt: at,
+            updatedAt: at
+          }
+        }];
+    case "UiFragmentUpdated" :
+      let at$1 = event.at;
+      let newManifest = event.newManifest;
+      return [{
+          TAG: "Update",
+          _0: event.pluginId,
+          _1: state => ({
+            pluginId: state.pluginId,
+            remoteEntryUrl: newManifest.remoteEntryUrl,
+            panels: newManifest.panels,
+            pages: newManifest.pages,
+            registeredAt: state.registeredAt,
+            updatedAt: at$1
+          })
+        }];
+    case "UiFragmentDeregistered" :
+      return [{
+          TAG: "Delete",
+          _0: event.pluginId
+        }];
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs";
+
+export {
+  Spec,
+  project,
+  moduleUrl,
+}
+/* No side effect */

package/src/components/Api/Api_Naming.res

@@ -49,7 +49,7 @@ let sliceMutationField = (~plugin: string, ~slice: string) => `${plugin}_${slice
 let dcbCommandMutationField = (~plugin: string, ~command: string) => `${plugin}_${command}`
 
 // AppSync hard limit: subscription field names may be at most 50 chars. Each mutation
-// field `f` produces a `@aws_subscribe` subscription `on${f}` (see
+// field `f` produces a mutation-sourced subscription `on${f}` (see
 // Plugin_SubscriptionSchema.sourceCFields), so the real cap on a mutation field is 48.
 // Fail at build with an actionable message rather than letting AppSync reject the
 // schema push at deploy time with an opaque 500.

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -598,15 +598,11 @@ let generate = (
     commandResultSdlTypes->Array.forEach(t => types->Array.push(t))
   }
 
-  let encoded =
-    JSON.Encode.object(
-      Dict.fromArray([
-        ("types", JSON.Encode.array(types->Array.map(JSON.Encode.string))),
-        ("mutations", JSON.Encode.array(mutations->Array.map(JSON.Encode.string))),
-        ("queries", JSON.Encode.array(queries->Array.map(JSON.Encode.string))),
-        ("subscriptions", JSON.Encode.array([])),
-      ]),
-    )->JSON.stringify
-
-  {Reventless.Plugin.encoded, protocol: "graphql"}
+  GraphQL_Stitcher.encode({
+    types,
+    mutations,
+    queries,
+    subscriptions: [],
+    subscriptionSources: [],
+  })
 }

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as SchemaType$ReventlessCore from "./SchemaType.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
 
 let commandResultSdlTypes = [
   `union CommandResult = CommandAccepted | CommandRejected | CommandPending`,
@@ -453,28 +454,13 @@ function generate(mutationEntries, queryEntries) {
       types.push(t);
     });
   }
-  let encoded = JSON.stringify(Object.fromEntries([
-    [
-      "types",
-      types.map(prim => prim)
-    ],
-    [
-      "mutations",
-      mutations.map(prim => prim)
-    ],
-    [
-      "queries",
-      queries.map(prim => prim)
-    ],
-    [
-      "subscriptions",
-      []
-    ]
-  ]));
-  return {
-    encoded: encoded,
-    protocol: "graphql"
-  };
+  return GraphQL_Stitcher$ReventlessCore.encode({
+    types: types,
+    mutations: mutations,
+    queries: queries,
+    subscriptions: [],
+    subscriptionSources: []
+  });
 }
 
 export {

package/src/components/Api/GraphQL_PushPlanner.res

@@ -0,0 +1,65 @@
+// Generic, provider-neutral push planner for the event-sourced API-schema fragment registry.
+//
+// Given the fragments currently in the ApiFragmentRegistry (each tagged with the API it belongs to)
+// it groups them by target and produces one stitched-SDL push plan per API, honouring split vs.
+// unified mode. It encodes the SAME base-selection rules the deploy-time push
+// (`reventless-aws Platform.preResolversSchemaHook`) applies, so the reactive single writer stays
+// consistent with the deploy path:
+//   - split mode: the Platform API carries the admin base + Platform-target fragments; the Domain
+//     API carries an EMPTY base + Domain-target fragments (admin lives only on the Platform API).
+//   - unified mode: a single API carries the admin base + ALL fragments regardless of target.
+//
+// Neutral SDL only — the AWS adapter injects @aws_subscribe per plan and pushes each to the
+// matching AppSync API id; the local platform (scope 2) will consume the same plans in-process.
+
+open Reventless.Plugin
+
+type targetedFragment = {
+  fragment: apiSchemaFragment,
+  target: apiTarget,
+}
+
+// The destination API of a push plan. In unified mode every fragment collapses onto `DomainApi`
+// (the single shared API); the AWS adapter maps `PlatformApi` → the Platform AppSync id and
+// `DomainApi` → the Domain AppSync id.
+@schema
+type planTarget = DomainApi | PlatformApi
+
+type pushPlan = {
+  api: planTarget,
+  // Stitched neutral SDL for that API (admin/empty base + the target's fragments).
+  sdl: string,
+}
+
+// An empty base fragment — the Domain API's base in split mode (admin is on the Platform API).
+let emptyBase: apiSchemaFragment = GraphQL_Stitcher.encode({
+  types: [],
+  queries: [],
+  mutations: [],
+  subscriptions: [],
+  subscriptionSources: [],
+})
+
+let planPushes = (
+  ~adminBase: apiSchemaFragment,
+  ~fragments: array<targetedFragment>,
+  ~splitApi: bool,
+): array<pushPlan> =>
+  if splitApi {
+    let platformFrags =
+      fragments->Array.filter(f => f.target == Platform)->Array.map(f => f.fragment)
+    let domainFrags = fragments->Array.filter(f => f.target == Domain)->Array.map(f => f.fragment)
+    [
+      {
+        api: PlatformApi,
+        sdl: GraphQL_Stitcher.stitch(~baseFragment=adminBase, ~pluginFragments=platformFrags),
+      },
+      {
+        api: DomainApi,
+        sdl: GraphQL_Stitcher.stitch(~baseFragment=emptyBase, ~pluginFragments=domainFrags),
+      },
+    ]
+  } else {
+    let allFrags = fragments->Array.map(f => f.fragment)
+    [{api: DomainApi, sdl: GraphQL_Stitcher.stitch(~baseFragment=adminBase, ~pluginFragments=allFrags)}]
+  }

package/src/components/Api/GraphQL_PushPlanner.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
+
+let planTargetSchema = S.union([
+  S.literal("DomainApi"),
+  S.literal("PlatformApi")
+]);
+
+let emptyBase = GraphQL_Stitcher$ReventlessCore.encode({
+  types: [],
+  mutations: [],
+  queries: [],
+  subscriptions: [],
+  subscriptionSources: []
+});
+
+function planPushes(adminBase, fragments, splitApi) {
+  if (splitApi) {
+    let platformFrags = fragments.filter(f => f.target === "Platform").map(f => f.fragment);
+    let domainFrags = fragments.filter(f => f.target === "Domain").map(f => f.fragment);
+    return [
+      {
+        api: "PlatformApi",
+        sdl: GraphQL_Stitcher$ReventlessCore.stitch(adminBase, platformFrags)
+      },
+      {
+        api: "DomainApi",
+        sdl: GraphQL_Stitcher$ReventlessCore.stitch(emptyBase, domainFrags)
+      }
+    ];
+  }
+  let allFrags = fragments.map(f => f.fragment);
+  return [{
+      api: "DomainApi",
+      sdl: GraphQL_Stitcher$ReventlessCore.stitch(adminBase, allFrags)
+    }];
+}
+
+export {
+  planTargetSchema,
+  emptyBase,
+  planPushes,
+}
+/* planTargetSchema Not a pure module */

package/src/components/Api/GraphQL_Stitcher.res

@@ -4,13 +4,33 @@
 
 let log = Logger.fromEnv()
 
+// Neutral subscription→mutation source mapping. Core emits provider-free
+// subscription SDL; this record carries which mutation(s) feed a subscription
+// field so each provider can wire its own dialect (AppSync appends
+// `@aws_subscribe(mutations: [...])` at push time; the local platform routes
+// its PubSub bridge from the same mapping). Supports many-mutations-to-one
+// fan-in (e.g. onUIFragmentChange ← three Platform_UIFragment* mutations).
+type subscriptionSource = {
+  field: string,
+  mutations: array<string>,
+}
+
 type fragmentParts = {
   types: array<string>,
   mutations: array<string>,
   queries: array<string>,
   subscriptions: array<string>,
+  subscriptionSources: array<subscriptionSource>,
 }
 
+let encodeSubscriptionSource = (source: subscriptionSource): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("field", JSON.Encode.string(source.field)),
+      ("mutations", JSON.Encode.array(source.mutations->Array.map(JSON.Encode.string))),
+    ]),
+  )
+
 let encode = (parts: fragmentParts): Reventless.Plugin.apiSchemaFragment => {
   let encoded =
     JSON.Encode.object(
@@ -19,6 +39,10 @@ let encode = (parts: fragmentParts): Reventless.Plugin.apiSchemaFragment => {
         ("mutations", JSON.Encode.array(parts.mutations->Array.map(JSON.Encode.string))),
         ("queries", JSON.Encode.array(parts.queries->Array.map(JSON.Encode.string))),
         ("subscriptions", JSON.Encode.array(parts.subscriptions->Array.map(JSON.Encode.string))),
+        (
+          "subscriptionSources",
+          JSON.Encode.array(parts.subscriptionSources->Array.map(encodeSubscriptionSource)),
+        ),
       ]),
     )->JSON.stringify
   {Reventless.Plugin.encoded, protocol: "graphql"}
@@ -26,7 +50,7 @@ let encode = (parts: fragmentParts): Reventless.Plugin.apiSchemaFragment => {
 
 let decode = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentParts => {
   switch fragment.encoded->JSON.parseOrThrow->JSON.Decode.object {
-  | None => {types: [], mutations: [], queries: [], subscriptions: []}
+  | None => {types: [], mutations: [], queries: [], subscriptions: [], subscriptionSources: []}
   | Some(dict) =>
     let getString = (key): array<string> =>
       switch dict->Dict.get(key) {
@@ -39,15 +63,62 @@ let decode = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentParts => {
         )
       | _ => []
       }
+    // Tolerant of fragments encoded before the field existed — default [].
+    let subscriptionSources = switch dict->Dict.get("subscriptionSources") {
+    | Some(JSON.Array(arr)) =>
+      arr->Array.filterMap(j =>
+        j
+        ->JSON.Decode.object
+        ->Option.flatMap(obj => {
+          let field = obj->Dict.get("field")->Option.flatMap(JSON.Decode.string)
+          let mutations = switch obj->Dict.get("mutations") {
+          | Some(JSON.Array(ms)) =>
+            ms->Array.filterMap(m =>
+              switch m {
+              | JSON.String(s) => Some(s)
+              | _ => None
+              }
+            )
+          | _ => []
+          }
+          field->Option.map(field => {field, mutations})
+        })
+      )
+    | _ => []
+    }
     {
       types: getString("types"),
       mutations: getString("mutations"),
       queries: getString("queries"),
       subscriptions: getString("subscriptions"),
+      subscriptionSources,
     }
   }
 }
 
+/**
+Union of the subscription→mutation source mappings across a base fragment and
+all plugin fragments, deduped by subscription field name (first wins — matching
+`stitch`'s first-wins field dedupe). Providers use this to decorate or wire the
+STITCHED schema's subscription fields.
+*/
+let collectSubscriptionSources = (
+  ~baseFragment: Reventless.Plugin.apiSchemaFragment,
+  ~pluginFragments: array<Reventless.Plugin.apiSchemaFragment>,
+): array<subscriptionSource> => {
+  let seen: Set.t<string> = Set.make()
+  Array.concat([baseFragment], pluginFragments)
+  ->Array.flatMap(fragment => decode(fragment).subscriptionSources)
+  ->Array.filter(source =>
+    if seen->Set.has(source.field) {
+      false
+    } else {
+      seen->Set.add(source.field)
+      true
+    }
+  )
+}
+
 // Extract the first identifier from a SDL field/type string.
 // e.g. "  fieldName(args): Type" → "fieldName"
 //      "type TypeName {" → "TypeName"

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -8,6 +8,19 @@ import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
+function encodeSubscriptionSource(source) {
+  return Object.fromEntries([
+    [
+      "field",
+      source.field
+    ],
+    [
+      "mutations",
+      source.mutations.map(prim => prim)
+    ]
+  ]);
+}
+
 function encode(parts) {
   let encoded = JSON.stringify(Object.fromEntries([
     [
@@ -25,6 +38,10 @@ function encode(parts) {
     [
       "subscriptions",
       parts.subscriptions.map(prim => prim)
+    ],
+    [
+      "subscriptionSources",
+      parts.subscriptionSources.map(encodeSubscriptionSource)
     ]
   ]));
   return {
@@ -40,7 +57,8 @@ function decode(fragment) {
       types: [],
       mutations: [],
       queries: [],
-      subscriptions: []
+      subscriptions: [],
+      subscriptionSources: []
     };
   }
   let getString = key => {
@@ -59,14 +77,45 @@ function decode(fragment) {
       return [];
     }
   };
+  let match = dict["subscriptionSources"];
+  let subscriptionSources = match !== undefined ? (
+      Array.isArray(match) ? Stdlib_Array.filterMap(match, j => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), obj => {
+          let field = Stdlib_Option.flatMap(obj["field"], Stdlib_JSON.Decode.string);
+          let match = obj["mutations"];
+          let mutations = match !== undefined ? (
+              Array.isArray(match) ? Stdlib_Array.filterMap(match, m => {
+                  if (typeof m === "string") {
+                    return m;
+                  }
+                }) : []
+            ) : [];
+          return Stdlib_Option.map(field, field => ({
+            field: field,
+            mutations: mutations
+          }));
+        })) : []
+    ) : [];
   return {
     types: getString("types"),
     mutations: getString("mutations"),
     queries: getString("queries"),
-    subscriptions: getString("subscriptions")
+    subscriptions: getString("subscriptions"),
+    subscriptionSources: subscriptionSources
   };
 }
 
+function collectSubscriptionSources(baseFragment, pluginFragments) {
+  let seen = new Set();
+  return [baseFragment].concat(pluginFragments).flatMap(fragment => decode(fragment).subscriptionSources).filter(source => {
+    if (seen.has(source.field)) {
+      return false;
+    } else {
+      seen.add(source.field);
+      return true;
+    }
+  });
+}
+
 function extractLeadingName(str) {
   let trimmed = str.trim();
   let afterType = trimmed.startsWith("type ") || trimmed.startsWith("enum ") ? trimmed.slice(5, trimmed.length).trim() : (
@@ -252,8 +301,10 @@ function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
 
 export {
   log,
+  encodeSubscriptionSource,
   encode,
   decode,
+  collectSubscriptionSources,
   extractLeadingName,
   relayBaseTypes,
   relayBaseQueries,