@reventlessdev/reventless-core 3.0.0-alpha.256 → 3.0.0-alpha.258

package/src/components/Api/SuryToJsonSchema.res

@@ -176,33 +176,72 @@ let rec isNullableType = (st: SchemaType.schemaType): bool =>
   | _ => false
   }
 
-let rec fromSchemaType = (st: SchemaType.schemaType): JSON.t =>
+// The GraphQL **input** type name an object is declared under, written onto the
+// object's own JSON Schema wherever it occurs.
+//
+// A client that assembles a mutation must name its variables' types, and for a
+// *top-level* argument `x-reventless-graphql-type` already publishes the rendered
+// reference (`[Ordering_PlaceOrderLineItems!]!`, wrappers and all). That one is
+// keyed by argument name and so stops at the first level; this one travels with
+// the object, which is what a reader reaching an element schema inside a list has.
+//
+// The name is taken from the `ObjectRef` the SDL emitter names the type from, so
+// there is one source and the two cannot drift — but only when the caller rooted
+// the walk at the same prefix the emitter uses. That is what `inputNames` gates:
+// a schema walked from an unknown root would publish a name the SDL never
+// declares, and a plausible wrong name is worse than none.
+let withGraphqlInput = (schema: JSON.t, name: string): JSON.t =>
+  switch schema->JSON.Decode.object {
+  | None => schema
+  | Some(obj) =>
+    obj->Dict.set("x-reventless-graphql-input", str(name))
+    JSON.Encode.object(obj)
+  }
+
+let rec fromSchemaType = (~inputNames: bool=false, st: SchemaType.schemaType): JSON.t =>
   switch st {
   | ScalarString => jsonObject([("type", str("string"))])
   | ScalarNumber => jsonObject([("type", str("number"))])
+  | ScalarInt => jsonObject([("type", str("integer"))])
   | ScalarBoolean => jsonObject([("type", str("boolean"))])
   | ScalarBigInt => jsonObject([("type", str("integer"))])
   | EntityId => jsonObject([("type", str("string")), ("format", str("uuid"))])
   | DateTime => jsonObject([("type", str("string")), ("format", str("date-time"))])
   | Nullable(inner) =>
-    let innerSchema = fromSchemaType(inner)
+    let innerSchema = fromSchemaType(~inputNames, inner)
     jsonObject([("oneOf", JSON.Encode.array([innerSchema, jsonObject([("type", str("null"))])]))])
   | ArrayOf(item) =>
-    jsonObject([("type", str("array")), ("items", fromSchemaType(item))])
-  | ObjectRef(_, fields) => objectRefToJsonSchema(fields)
+    jsonObject([("type", str("array")), ("items", fromSchemaType(~inputNames, item))])
+  | ObjectRef(name, fields) =>
+    let base = objectRefToJsonSchema(~inputNames, fields)
+    inputNames ? base->withGraphqlInput(name) : base
   | Enum(_, values) =>
     jsonObject([
       ("type", str("string")),
       ("enum", JSON.Encode.array(values->Array.map(JSON.Encode.string))),
     ])
-  | Semantic(sem, inner) => fromSchemaType(inner)->withSemantic(sem)
+  // A semantic composite is one named type wherever it appears, and GraphQL
+  // forbids one name serving as both an object and an input — so in input
+  // position it is the `Input`-suffixed name that exists in the SDL, which is
+  // the one a client can paste into a variable declaration. Positionally-named
+  // objects take no suffix, so the `ObjectRef` branch above already published
+  // the right string for them.
+  | Semantic(sem, inner) =>
+    let base = fromSchemaType(~inputNames, inner)
+    let base = switch (inputNames, SchemaType.canonicalName(sem.id), inner) {
+    | (true, Some(name), ObjectRef(_, _)) => base->withGraphqlInput(name ++ "Input")
+    | _ => base
+    }
+    base->withSemantic(sem)
+  // A union has no input form — see the fragment generator, which emits `String`
+  // and says so — hence no name to publish on either arm.
   // A union is `oneOf` its arms, each an object carrying the `TAG` const it is
   // discriminated by. The discriminator is what tells a union apart from a
   // nullable object, which is also a `oneOf` of objects — a reader that misses
   // it selects one arm's fields as though they were the field's own and produces
   // a query that looks plausible and is invalid.
   | TaggedUnion(name, arms) =>
-    let members = arms->Array.map(((tag, armType)) => armToJsonSchema(~tag, armType))
+    let members = arms->Array.map(((tag, armType)) => armToJsonSchema(~inputNames, ~tag, armType))
     jsonObject([("oneOf", JSON.Encode.array(members)), ("x-reventless-union", str(name))])
   | Unknown => jsonObject([("type", str("string"))])
   }
@@ -212,10 +251,14 @@ let rec fromSchemaType = (st: SchemaType.schemaType): JSON.t =>
 // the payload that says which arm this is. The GraphQL member type name rides
 // alongside so a reader mapping a raw payload to a selection does not have to
 // re-derive the naming rule in a second repo.
-and armToJsonSchema = (~tag: string, armType: SchemaType.schemaType): JSON.t =>
+and armToJsonSchema = (
+  ~inputNames: bool=false,
+  ~tag: string,
+  armType: SchemaType.schemaType,
+): JSON.t =>
   switch armType {
   | ObjectRef(memberName, fields) =>
-    let base = objectRefToJsonSchema(fields)
+    let base = objectRefToJsonSchema(~inputNames, fields)
     switch base->JSON.Decode.object {
     | Some(obj) =>
       switch obj->Dict.get("properties")->Option.flatMap(JSON.Decode.object) {
@@ -232,7 +275,7 @@ and armToJsonSchema = (~tag: string, armType: SchemaType.schemaType): JSON.t =>
       JSON.Encode.object(obj)
     | None => base
     }
-  | other => fromSchemaType(other)
+  | other => fromSchemaType(~inputNames, other)
   }
 
 // Attach a type-carried semantic to a field's JSON Schema.
@@ -313,11 +356,17 @@ and withSemantic = (fieldSchema: JSON.t, sem: Reventless.Semantic.t): JSON.t =>
 // way — off the sury schema by the caller. What it marks is a field whose value
 // must not be rendered into content somebody receives, which is a property of
 // the domain model rather than of the field's shape.
+// `inputNames` says which side of the wire this schema describes. It changes only
+// the name a semantic composite is published under — `MoneyInput` where a command
+// takes one, `Money` where a view returns one — because GraphQL forbids one name
+// serving as both. Emitting the input name on a view would name a type that need
+// not exist in the SDL at all.
 and objectRefToJsonSchema = (
   ~annotations: option<Reventless.StateAnnotations.stateAnnotationSpec>=?,
   ~optional: array<string>=[],
   ~owners: array<string>=[],
   ~sensitive: array<string>=[],
+  ~inputNames: bool=false,
   fields: dict<SchemaType.schemaType>,
 ): JSON.t => {
   let props = Dict.make()
@@ -336,7 +385,7 @@ and objectRefToJsonSchema = (
   ->Dict.toArray
   ->Array.filter(((fieldName, _)) => !(internal->Array.includes(fieldName)))
   ->Array.forEach(((fieldName, fieldType)) => {
-    let baseSchema = fromSchemaType(fieldType)
+    let baseSchema = fromSchemaType(~inputNames, fieldType)
     let withAnnotations = switch annotations {
     | Some(spec) => mergeAnnotations(baseSchema, fieldName, spec)
     | None => baseSchema
@@ -394,8 +443,16 @@ and objectRefToJsonSchema = (
 
 // ── Public API (sury → JSON Schema via SchemaType) ───────────────────────
 
-let deriveObjectSchema = (schema: S.t<unknown>): JSON.t =>
-  switch SchemaType.fromSuryObject(~typeName="", schema) {
+// `typeName` roots the walk where the SDL emitter roots its own — the mutation
+// field name for a command — so the nested type names this publishes are the
+// ones the SDL declares. It is only consulted when `inputNames` asks for those
+// names; every other caller leaves both alone and gets today's schema exactly.
+let deriveObjectSchema = (
+  ~inputNames: bool=false,
+  ~typeName: string="",
+  schema: S.t<unknown>,
+): JSON.t =>
+  switch SchemaType.fromSuryObject(~typeName, schema) {
   | Some(fields) =>
     let annotations = Reventless.StateAnnotations.getSpec(schema)
     let objSchema = objectRefToJsonSchema(
@@ -403,6 +460,7 @@ let deriveObjectSchema = (schema: S.t<unknown>): JSON.t =>
       ~optional=SchemaType.optionalFieldNames(schema),
       ~owners=Reventless.Owner.fieldNames(schema),
       ~sensitive=Reventless.Sensitive.fieldNames(schema),
+      ~inputNames,
       fields,
     )
     // Surface component-level hints on the top-level object schema.

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

@@ -160,7 +160,18 @@ function isNullableType(_st) {
   };
 }
 
-function fromSchemaType(st) {
+function withGraphqlInput(schema, name) {
+  let obj = Stdlib_JSON.Decode.object(schema);
+  if (obj !== undefined) {
+    obj["x-reventless-graphql-input"] = name;
+    return obj;
+  } else {
+    return schema;
+  }
+}
+
+function fromSchemaType(inputNamesOpt, st) {
+  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
   if (typeof st !== "object") {
     switch (st) {
       case "ScalarNumber" :
@@ -173,6 +184,7 @@ function fromSchemaType(st) {
             "type",
             "boolean"
           ]]);
+      case "ScalarInt" :
       case "ScalarBigInt" :
         return Object.fromEntries([[
             "type",
@@ -210,7 +222,7 @@ function fromSchemaType(st) {
   } else {
     switch (st.TAG) {
       case "Nullable" :
-        let innerSchema = fromSchemaType(st._0);
+        let innerSchema = fromSchemaType(inputNames, st._0);
         return Object.fromEntries([[
             "oneOf",
             [
@@ -229,11 +241,16 @@ function fromSchemaType(st) {
           ],
           [
             "items",
-            fromSchemaType(st._0)
+            fromSchemaType(inputNames, st._0)
           ]
         ]);
       case "ObjectRef" :
-        return objectRefToJsonSchema(undefined, undefined, undefined, undefined, st._1);
+        let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, st._1);
+        if (inputNames) {
+          return withGraphqlInput(base, st._0);
+        } else {
+          return base;
+        }
       case "Enum" :
         return Object.fromEntries([
           [
@@ -246,9 +263,14 @@ function fromSchemaType(st) {
           ]
         ]);
       case "Semantic" :
-        return withSemantic(fromSchemaType(st._1), st._0);
+        let inner = st._1;
+        let sem = st._0;
+        let base$1 = fromSchemaType(inputNames, inner);
+        let match = SchemaType$ReventlessCore.canonicalName(sem.id);
+        let base$2 = inputNames && match !== undefined && typeof inner === "object" && inner.TAG === "ObjectRef" ? withGraphqlInput(base$1, match + "Input") : base$1;
+        return withSemantic(base$2, sem);
       case "TaggedUnion" :
-        let members = st._1.map(param => armToJsonSchema(param[0], param[1]));
+        let members = st._1.map(param => armToJsonSchema(inputNames, param[0], param[1]));
         return Object.fromEntries([
           [
             "oneOf",
@@ -263,14 +285,15 @@ function fromSchemaType(st) {
   }
 }
 
-function armToJsonSchema(tag, armType) {
+function armToJsonSchema(inputNamesOpt, tag, armType) {
+  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
   if (typeof armType !== "object") {
-    return fromSchemaType(armType);
+    return fromSchemaType(inputNames, armType);
   }
   if (armType.TAG !== "ObjectRef") {
-    return fromSchemaType(armType);
+    return fromSchemaType(inputNames, armType);
   }
-  let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, armType._1);
+  let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, armType._1);
   let obj = Stdlib_JSON.Decode.object(base);
   if (obj === undefined) {
     return base;
@@ -341,17 +364,18 @@ function withSemantic(fieldSchema, sem) {
   return obj;
 }
 
-function objectRefToJsonSchema(annotations, optionalOpt, ownersOpt, sensitiveOpt, fields) {
+function objectRefToJsonSchema(annotations, optionalOpt, ownersOpt, sensitiveOpt, inputNamesOpt, fields) {
   let optional = optionalOpt !== undefined ? optionalOpt : [];
   let owners = ownersOpt !== undefined ? ownersOpt : [];
   let sensitive = sensitiveOpt !== undefined ? sensitiveOpt : [];
+  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
   let props = {};
   let required = [];
   let internal = Stdlib_Option.getOr(Stdlib_Option.flatMap(annotations, spec => spec.internal), []);
   Object.entries(fields).filter(param => !internal.includes(param[0])).forEach(param => {
     let fieldType = param[1];
     let fieldName = param[0];
-    let baseSchema = fromSchemaType(fieldType);
+    let baseSchema = fromSchemaType(inputNames, fieldType);
     let withAnnotations = annotations !== undefined ? mergeAnnotations(baseSchema, fieldName, annotations) : baseSchema;
     let withAnnotations$1;
     if (owners.includes(fieldName)) {
@@ -401,8 +425,10 @@ function objectRefToJsonSchema(annotations, optionalOpt, ownersOpt, sensitiveOpt
   return Object.fromEntries(entries);
 }
 
-function deriveObjectSchema(schema) {
-  let fields = SchemaType$ReventlessCore.fromSuryObject("", schema);
+function deriveObjectSchema(inputNamesOpt, typeNameOpt, schema) {
+  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
+  let typeName = typeNameOpt !== undefined ? typeNameOpt : "";
+  let fields = SchemaType$ReventlessCore.fromSuryObject(typeName, schema);
   if (fields === undefined) {
     return Object.fromEntries([[
         "type",
@@ -410,7 +436,7 @@ function deriveObjectSchema(schema) {
       ]]);
   }
   let annotations = StateAnnotations$Reventless.getSpec(schema);
-  let objSchema = objectRefToJsonSchema(annotations, SchemaType$ReventlessCore.optionalFieldNames(schema), Owner$Reventless.fieldNames(schema), Sensitive$Reventless.fieldNames(schema), fields);
+  let objSchema = objectRefToJsonSchema(annotations, SchemaType$ReventlessCore.optionalFieldNames(schema), Owner$Reventless.fieldNames(schema), Sensitive$Reventless.fieldNames(schema), inputNames, fields);
   if (annotations === undefined) {
     return objSchema;
   }
@@ -434,7 +460,7 @@ function deriveObjectSchema(schema) {
 }
 
 function toJsonSchema(schema) {
-  return fromSchemaType(SchemaType$ReventlessCore.fromSury("", "", schema));
+  return fromSchemaType(undefined, SchemaType$ReventlessCore.fromSury("", "", schema));
 }
 
 export {
@@ -444,6 +470,7 @@ export {
   withOptionalPlugin,
   mergeAnnotations,
   isNullableType,
+  withGraphqlInput,
   fromSchemaType,
   armToJsonSchema,
   withSemantic,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -313,9 +313,14 @@ module Make = (
         )
       })
       ->Effect.flatMap(((state, headPosition, _)) =>
+        // Identity, not content: the decision model folds the whole matched
+        // history, so serialising it here makes the line's size a function of
+        // how long the entity has been in use.
         EffectLogger.logDebug(
           ~comp,
-          `deciding on state: ${state->JSON.stringifyAny->Option.getOr("<unserializable>")}`,
+          `deciding: id=${entityId->Option.getOr("-")} head=${headPosition->Option.getOr(
+              "-",
+            )} cmd=${cmdJson->LogFormat.cmdName}`,
         )->Effect.flatMap(_ =>
           switch Behavior.decide(state, command'.command) {
           | Ok(newEvents) if newEvents->Array.length == 0 =>

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -164,7 +164,7 @@ function Make(Spec) {
         }), param => {
           let headPosition = param[1];
           let state = param[0];
-          return Effect.flatMap(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding on state: ` + Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>")), () => {
+          return Effect.flatMap(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding: id=` + Stdlib_Option.getOr(entityId, "-") + ` head=` + Stdlib_Option.getOr(headPosition, "-") + ` cmd=` + LogFormat$ReventlessCore.cmdName(cmdJson)), () => {
             let newEvents = Behavior.decide(state, command$p.command);
             if (newEvents.TAG === "Ok") {
               let newEvents$1 = newEvents._0;

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -154,11 +154,16 @@ module Make = (
               })
               ->Array.flat
               ->Array.reduce(Effect.succeed(), (acc, action) =>
-                acc->Effect.flatMap(_ =>
+                acc->Effect.flatMap(_ => {
+                  // A slice's state carries the same synthetic `displayName` the
+                  // ppx injects for a read model's, so it is composed on the same
+                  // terms — without this the column stays null and every surface
+                  // names the row by its id.
+                  let action = FrameworkProjection.rewriteAction(action, Spec.stateSchema)
                   Effect.promise(() =>
                     FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
                   )->Effect.map(_ => ())
-                )
+                })
               )
             })
 

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -121,7 +121,10 @@ function Make(RuntimeEnvironment) {
               let fieldsStr = f === "" ? "" : `({` + f + `})`;
               Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, dataDict, `handling event ` + idxStr + `/` + total + `: ` + LogFormat$ReventlessCore.bold(eventType) + fieldsStr + ` ` + actionsStr));
               return actions;
-            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, projectionOps, Spec.subIdConfig)), param => {})));
+            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
+              let action$1 = Projection$ReventlessCore.rewriteAction(action, Spec.stateSchema);
+              return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, projectionOps, Spec.subIdConfig)), param => {});
+            }));
           });
           let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
           let resources = Component$ReventlessCore.outputs(queryDb).resources;

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -47,7 +47,9 @@ module Make = (
           ~detail=raw.data,
           `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(raw.eventType)}(${id}) ${actionsStr}`,
         )->Effect.runSync
-        allActions->Array.pushMany(actions)
+        allActions->Array.pushMany(
+          actions->Array.map(FrameworkProjection.rewriteAction(_, Spec.stateSchema)),
+        )
         Some(event)
       | None => None
       }

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -35,7 +35,7 @@ function Make(Spec) {
         });
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
-        allActions.push(...actions);
+        allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, Spec.stateSchema)));
         return Primitive_option.some(event);
       });
       let skipped = rawEvents.length - events.length | 0;

package/src/plugin/component/Plugin.res

@@ -52,6 +52,7 @@ module type T = {
     ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=?,
     ~extensionPoints: array<module(ReventlessInfra.ExtensionPointMapping.Mapping)>=?,
     ~componentChapters: dict<string>=?,
+    ~lifecycleModel: array<Reventless.Plugin.derivedEdge>=?,
   ) => Reventless.Plugin.pluginStructure
 }
 

package/src/plugin/component/Plugin_Builder.res

@@ -1104,6 +1104,7 @@ module Make = (
     ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=[],
     ~extensionPoints: array<module(ReventlessInfra.ExtensionPointMapping.Mapping)>=[],
     ~componentChapters: dict<string>=Dict.make(),
+    ~lifecycleModel: array<Reventless.Plugin.derivedEdge>=[],
   ): Reventless.Plugin.pluginStructure =>
     Plugin_Structure.make(
       ~name,
@@ -1117,6 +1118,7 @@ module Make = (
       ~extensions,
       ~extensionPoints,
       ~componentChapters,
+      ~lifecycleModel,
     )
 
   let make = (

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

@@ -95,7 +95,7 @@ function Make(Spec) {
         pages: pages
       };
     };
-    let makePluginDefinition = (name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) => {
+    let makePluginDefinition = (name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt, lifecycleModelOpt) => {
       let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
       let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
       let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
@@ -106,7 +106,8 @@ function Make(Spec) {
       let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
       let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
       let componentChapters = componentChaptersOpt !== undefined ? componentChaptersOpt : ({});
-      return Plugin_Structure$ReventlessCore.make(name, aggregates, readModels, stateViewSlices, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints, componentChapters);
+      let lifecycleModel = lifecycleModelOpt !== undefined ? lifecycleModelOpt : [];
+      return Plugin_Structure$ReventlessCore.make(name, aggregates, readModels, stateViewSlices, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints, componentChapters, lifecycleModel);
     };
     let make = (name, heartbeatInterval, extensionPointsOpt, extensionsOpt, aggregatesOpt, readModelsOpt, tasksOpt, stateChangeSlicesOpt, stateViewSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, systemCallableComponentsOpt, componentRuntimeOpt, uiFragments, pluginStructure, opts) => {
       let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];