@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Api/SuryToJsonSchema.res

@@ -0,0 +1,142 @@
+// Shared utility: convert sury S.t<'a> schemas to JSON Schema objects.
+// Uses SchemaType as the shared intermediate representation.
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+let str = JSON.Encode.string
+
+let jsonObject = (entries: array<(string, JSON.t)>): JSON.t =>
+  JSON.Encode.object(Dict.fromArray(entries))
+
+// Merge x-reventless-* extension properties from a Reventless.StateAnnotations.stateAnnotationSpec
+// into a property schema (a JSON Schema object). Returns the schema unchanged when the field
+// has no annotations or when the schema is not a JSON object.
+let mergeAnnotations = (
+  fieldSchema: JSON.t,
+  fieldName: string,
+  spec: Reventless.StateAnnotations.stateAnnotationSpec,
+): JSON.t =>
+  switch fieldSchema->JSON.Decode.object {
+  | None => fieldSchema
+  | Some(obj) =>
+    if spec.ids->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-id", JSON.Encode.bool(true))
+    }
+    if spec.compositeIds->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-compositeId", JSON.Encode.bool(true))
+    }
+    if spec.subIds->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-subId", JSON.Encode.bool(true))
+    }
+    if spec.compositeSubIds->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-compositeSubId", JSON.Encode.bool(true))
+    }
+    switch spec.indexes->Array.find(((field, _)) => field === fieldName) {
+    | Some((_, indexName)) =>
+      let value =
+        indexName === "" ? JSON.Encode.bool(true) : JSON.Encode.string(indexName)
+      obj->Dict.set("x-reventless-index", value)
+    | None => ()
+    }
+    if spec.hidden->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-hidden", JSON.Encode.bool(true))
+    }
+    if spec.summary->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-summary", JSON.Encode.bool(true))
+    }
+    switch spec.drillTargets->Array.find(((field, _)) => field === fieldName) {
+    | Some((_, sliceName)) =>
+      obj->Dict.set("x-reventless-drillTarget", JSON.Encode.string(sliceName))
+    | None => ()
+    }
+    switch spec.drillTargetKeys->Array.find(((field, _)) => field === fieldName) {
+    | Some((_, keyPath)) =>
+      obj->Dict.set("x-reventless-drillTargetKey", JSON.Encode.string(keyPath))
+    | None => ()
+    }
+    if spec.collapsed->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-collapsed", JSON.Encode.bool(true))
+    }
+    if spec.scan->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-scan", JSON.Encode.bool(true))
+    }
+    if spec.scanSort->Array.includes(fieldName) {
+      obj->Dict.set("x-reventless-scanSort", JSON.Encode.bool(true))
+    }
+    JSON.Encode.object(obj)
+  }
+
+// ── SchemaType → JSON Schema ─────────────────────────────────────────────
+
+let rec fromSchemaType = (st: SchemaType.schemaType): JSON.t =>
+  switch st {
+  | ScalarString => jsonObject([("type", str("string"))])
+  | ScalarNumber => jsonObject([("type", str("number"))])
+  | ScalarBoolean => jsonObject([("type", str("boolean"))])
+  | ScalarBigInt => jsonObject([("type", str("integer"))])
+  | EntityId => jsonObject([("type", str("string")), ("format", str("uuid"))])
+  | Nullable(inner) =>
+    let innerSchema = fromSchemaType(inner)
+    jsonObject([("oneOf", JSON.Encode.array([innerSchema, jsonObject([("type", str("null"))])]))])
+  | ArrayOf(item) =>
+    jsonObject([("type", str("array")), ("items", fromSchemaType(item))])
+  | ObjectRef(_, fields) => objectRefToJsonSchema(fields)
+  | Enum(_, values) =>
+    jsonObject([
+      ("type", str("string")),
+      ("enum", JSON.Encode.array(values->Array.map(JSON.Encode.string))),
+    ])
+  | Unknown => jsonObject([("type", str("string"))])
+  }
+
+and objectRefToJsonSchema = (
+  ~annotations: option<Reventless.StateAnnotations.stateAnnotationSpec>=?,
+  fields: dict<SchemaType.schemaType>,
+): JSON.t => {
+  let props = Dict.make()
+  let required: array<string> = []
+  fields
+  ->Dict.toArray
+  ->Array.forEach(((fieldName, fieldType)) => {
+    let baseSchema = fromSchemaType(fieldType)
+    let withAnnotations = switch annotations {
+    | Some(spec) => mergeAnnotations(baseSchema, fieldName, spec)
+    | None => baseSchema
+    }
+    props->Dict.set(fieldName, withAnnotations)
+    required->Array.push(fieldName)
+  })
+  let entries: array<(string, JSON.t)> = [
+    ("type", str("object")),
+    ("properties", JSON.Encode.object(props)),
+  ]
+  if required->Array.length > 0 {
+    entries->Array.push(("required", JSON.Encode.array(required->Array.map(JSON.Encode.string))))
+  }
+  jsonObject(entries)
+}
+
+// ── Public API (sury → JSON Schema via SchemaType) ───────────────────────
+
+let deriveObjectSchema = (schema: S.t<unknown>): JSON.t =>
+  switch SchemaType.fromSuryObject(~typeName="", schema) {
+  | Some(fields) =>
+    let annotations = Reventless.StateAnnotations.getSpec(schema)
+    let objSchema = objectRefToJsonSchema(~annotations?, fields)
+    // Surface component-level visibility on the top-level object schema.
+    // Omitted entirely for the default `Public` (None) so schemas stay compact.
+    switch annotations {
+    | Some({visibility: Some(name)}) =>
+      switch objSchema->JSON.Decode.object {
+      | Some(obj) =>
+        obj->Dict.set("x-reventless-visibility", JSON.Encode.string(name))
+        JSON.Encode.object(obj)
+      | None => objSchema
+      }
+    | _ => objSchema
+    }
+  | None => jsonObject([("type", str("object"))])
+  }
+
+let toJsonSchema = (schema: S.t<unknown>): JSON.t =>
+  fromSchemaType(SchemaType.fromSury(~parentName="", ~fieldName="", schema))

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

@@ -0,0 +1,210 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as SchemaType$ReventlessCore from "./SchemaType.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function jsonObject(entries) {
+  return Object.fromEntries(entries);
+}
+
+function mergeAnnotations(fieldSchema, fieldName, spec) {
+  let obj = Stdlib_JSON.Decode.object(fieldSchema);
+  if (obj === undefined) {
+    return fieldSchema;
+  }
+  if (spec.ids.includes(fieldName)) {
+    obj["x-reventless-id"] = true;
+  }
+  if (spec.compositeIds.includes(fieldName)) {
+    obj["x-reventless-compositeId"] = true;
+  }
+  if (spec.subIds.includes(fieldName)) {
+    obj["x-reventless-subId"] = true;
+  }
+  if (spec.compositeSubIds.includes(fieldName)) {
+    obj["x-reventless-compositeSubId"] = true;
+  }
+  let match = spec.indexes.find(param => param[0] === fieldName);
+  if (match !== undefined) {
+    let indexName = match[1];
+    let value = indexName === "" ? true : indexName;
+    obj["x-reventless-index"] = value;
+  }
+  if (spec.hidden.includes(fieldName)) {
+    obj["x-reventless-hidden"] = true;
+  }
+  if (spec.summary.includes(fieldName)) {
+    obj["x-reventless-summary"] = true;
+  }
+  let match$1 = spec.drillTargets.find(param => param[0] === fieldName);
+  if (match$1 !== undefined) {
+    obj["x-reventless-drillTarget"] = match$1[1];
+  }
+  let match$2 = spec.drillTargetKeys.find(param => param[0] === fieldName);
+  if (match$2 !== undefined) {
+    obj["x-reventless-drillTargetKey"] = match$2[1];
+  }
+  if (spec.collapsed.includes(fieldName)) {
+    obj["x-reventless-collapsed"] = true;
+  }
+  if (spec.scan.includes(fieldName)) {
+    obj["x-reventless-scan"] = true;
+  }
+  if (spec.scanSort.includes(fieldName)) {
+    obj["x-reventless-scanSort"] = true;
+  }
+  return obj;
+}
+
+function fromSchemaType(st) {
+  if (typeof st !== "object") {
+    switch (st) {
+      case "ScalarNumber" :
+        return Object.fromEntries([[
+            "type",
+            "number"
+          ]]);
+      case "ScalarBoolean" :
+        return Object.fromEntries([[
+            "type",
+            "boolean"
+          ]]);
+      case "ScalarBigInt" :
+        return Object.fromEntries([[
+            "type",
+            "integer"
+          ]]);
+      case "EntityId" :
+        return Object.fromEntries([
+          [
+            "type",
+            "string"
+          ],
+          [
+            "format",
+            "uuid"
+          ]
+        ]);
+      case "ScalarString" :
+      case "Unknown" :
+        return Object.fromEntries([[
+            "type",
+            "string"
+          ]]);
+    }
+  } else {
+    switch (st.TAG) {
+      case "Nullable" :
+        let innerSchema = fromSchemaType(st._0);
+        return Object.fromEntries([[
+            "oneOf",
+            [
+              innerSchema,
+              Object.fromEntries([[
+                  "type",
+                  "null"
+                ]])
+            ]
+          ]]);
+      case "ArrayOf" :
+        return Object.fromEntries([
+          [
+            "type",
+            "array"
+          ],
+          [
+            "items",
+            fromSchemaType(st._0)
+          ]
+        ]);
+      case "ObjectRef" :
+        return objectRefToJsonSchema(undefined, st._1);
+      case "Enum" :
+        return Object.fromEntries([
+          [
+            "type",
+            "string"
+          ],
+          [
+            "enum",
+            st._1.map(prim => prim)
+          ]
+        ]);
+    }
+  }
+}
+
+function objectRefToJsonSchema(annotations, fields) {
+  let props = {};
+  let required = [];
+  Object.entries(fields).forEach(param => {
+    let fieldName = param[0];
+    let baseSchema = fromSchemaType(param[1]);
+    let withAnnotations = annotations !== undefined ? mergeAnnotations(baseSchema, fieldName, annotations) : baseSchema;
+    props[fieldName] = withAnnotations;
+    required.push(fieldName);
+  });
+  let entries = [
+    [
+      "type",
+      "object"
+    ],
+    [
+      "properties",
+      props
+    ]
+  ];
+  if (required.length !== 0) {
+    entries.push([
+      "required",
+      required.map(prim => prim)
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+
+function deriveObjectSchema(schema) {
+  let fields = SchemaType$ReventlessCore.fromSuryObject("", schema);
+  if (fields === undefined) {
+    return Object.fromEntries([[
+        "type",
+        "object"
+      ]]);
+  }
+  let annotations = StateAnnotations$Reventless.getSpec(schema);
+  let objSchema = objectRefToJsonSchema(annotations, fields);
+  if (annotations === undefined) {
+    return objSchema;
+  }
+  let name = annotations.visibility;
+  if (name === undefined) {
+    return objSchema;
+  }
+  let obj = Stdlib_JSON.Decode.object(objSchema);
+  if (obj !== undefined) {
+    obj["x-reventless-visibility"] = name;
+    return obj;
+  } else {
+    return objSchema;
+  }
+}
+
+function toJsonSchema(schema) {
+  return fromSchemaType(SchemaType$ReventlessCore.fromSury("", "", schema));
+}
+
+export {
+  str,
+  jsonObject,
+  mergeAnnotations,
+  fromSchemaType,
+  objectRefToJsonSchema,
+  deriveObjectSchema,
+  toJsonSchema,
+}
+/* SchemaType-ReventlessCore Not a pure module */

package/src/components/AutomationSlice/AutomationSlice.res

@@ -0,0 +1,39 @@
+let componentType = ComponentType.AutomationSlice
+
+type t = ReventlessInfra.AutomationSlice.t
+type outputs = ReventlessInfra.AutomationSlice.outputs
+type operations = ReventlessInfra.AutomationSlice.operations
+type component = Component.t<t, outputs, operations>
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.AutomationSlice.resolvedOutputs> =>
+  (
+    outputs.resources->Adapter.resourcesToInterop,
+    outputs.queryDb.resources->Adapter.resourcesToInterop,
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((resources, queryDbResources)) => {
+    let resolved: ReventlessInterop.AutomationSlice.resolvedOutputs = {
+      resources: resources,
+      queryDb: {resources: queryDbResources},
+    }
+    resolved
+  })
+
+module type T = {
+  module Spec: Reventless.AutomationSlice.Spec
+  module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+  /** Names of all sources this slice consumes (deduplicated). Used by
+      `Plugin_Builder` for the source-name fail-fast assembly check. */
+  let sourceNames: array<string>
+
+  let make: (
+    ~allEventTopics: EventTopic.allOutputs,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~context: Reventless.AutomationSlice.context,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/AutomationSlice/AutomationSlice.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Pulumi.all([
+    Adapter$ReventlessCore.resourcesToInterop(outputs.resources),
+    Adapter$ReventlessCore.resourcesToInterop(outputs.queryDb.resources)
+  ]).apply(param => ({
+    resources: param[0],
+    queryDb: {
+      resources: param[1]
+    }
+  }));
+}
+
+let componentType = "AutomationSlice";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/AutomationSlice/AutomationSlice_Builder.res

@@ -0,0 +1,207 @@
+// AutomationSlice builder — creates the TODO list QueryDb, EventCollector,
+// and wires the event handler (Phase 1 + Phase 2) plus exposes processPending.
+//
+// Plan 04: subscribes to events from any combination of Aggregate EventTopics
+// and DCB EventLog topics declared by the slice's `Mappings.mappings`. The
+// caller passes `~allEventTopics` (the plugin-wide topic dict) — the slice
+// filters down to topics matching its mappings' source names.
+//
+// Follows the StateViewSlice_Builder pattern for adapter injection.
+
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  QueryDbResolvers: QueryDb_Adapter.Resolvers
+    with type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+  Api: {
+    let api: unit => QueryDbStorage.api
+    let apiRole: unit => QueryDbStorage.role
+  },
+) => {
+  let finish = EventCollectorRuntimeBuilder.finish
+  module Make = (
+    Spec: Reventless.AutomationSlice.Spec,
+    Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+  ): (AutomationSlice.T with module Spec = Spec) => {
+    module Spec = Spec
+    module Automation = Automation
+    type component = AutomationSlice.component
+
+    module Callback = AutomationSlice_Callback.Make(Spec, Automation)
+
+    let queryDbName = Spec.name ++ "Todo"
+
+    // Names of all sources this slice subscribes to (deduplicated). Multiple
+    // mappings can share a source name (e.g., two mappings reading the same
+    // Aggregate's events for different reasons).
+    let sourceNames =
+      Automation.mappings
+      ->Array.map((module(M: Automation.Mapping)) => M.sourceName)
+      ->Belt.Set.String.fromArray
+      ->Belt.Set.String.toArray
+
+    // QueryDb for TODO list — stores todoRow keyed by string ID
+    module TodoQueryDbSpec = {
+      module Id = Reventless.Id.String
+      let name = queryDbName
+      let moduleUrl: string = %raw(`import.meta.url`)
+      type state = AutomationSlice_Callback.todoRow
+      let stateSchema = AutomationSlice_Callback.todoRowSchema
+      let config = Reventless.ReadModel.config()
+      let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>> = None
+      let authorization: Reventless.Authorization.permission = AllowAuthenticated
+      let visibility: Reventless.Visibility.t = Public
+    }
+
+    module SpecificQueryDb = QueryDb_Builder.Make(TodoQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+    module SpecificEventCollector = EventCollector_Builder.Make(
+      RuntimeEnvironment,
+      EventCollectorChannel,
+    )
+
+    let syncToQueryDb = async (queryDbOps: SpecificQueryDb.operations) => {
+      let items = Callback.todoItems->Dict.toArray
+      let _ = await items->Array.reduce(Promise.resolve(), async (prev, (id, row)) => {
+        let _ = await prev
+        let _ = await queryDbOps.save(
+          id->Reventless.Id.String.makeFromString,
+          row,
+          QueryDb.Overwrite,
+          None,
+        )
+      })
+    }
+
+    let construct = (
+      ~allEventTopics: EventTopic.allOutputs,
+      ~publishJsons,
+      ~context: Reventless.AutomationSlice.context,
+      self,
+      _name,
+    ) => {
+      let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+
+      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+
+      // Fail-fast: every Mapping.sourceName must resolve to a topic in
+      // `allEventTopics`. Catches Aggregate-name typos and DCB-source-name
+      // typos (e.g. "FooDcb" instead of "FooDcbEventLog"). Without this check
+      // `EventTopic.filter` silently drops the unknown source, the
+      // EventCollector subscribes to nothing, and the slice runs on no events
+      // — which surfaces as "TODO list never populates" much later.
+      sourceNames->Array.forEach(sourceName =>
+        if !(allEventTopics->Dict.has(sourceName)) {
+          let availableNames =
+            allEventTopics->Dict.keysToArray->Array.toSorted(String.compare)->Array.join(", ")
+          JsError.throwWithMessage(
+            `AutomationSlice "${Spec.name}" has a Mapping with sourceName "${sourceName}", ` ++
+            `but no EventTopic with that key exists in allEventTopics. ` ++
+            `Available source names: [${availableNames}]. ` ++
+            `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB ` ++
+            `source name (typically "<pluginName>DcbEventLog").`,
+          )
+        }
+      )
+
+      // Filter to only the topics this slice consumes from.
+      let sourceSet = sourceNames->Belt.Set.String.fromArray
+      let eventTopics = allEventTopics->EventTopic.filter(sourceSet)
+
+      // Build the EventCollector inside an Output.all2 so both `queryDbOps`
+      // and `publishJsonsFn` are captured in the same closure. The
+      // jsonEventsHandler then has direct access to `publishJsonsFn` —
+      // avoids racing a side-effect-only `publishJsons.apply` against the
+      // first event arrival (which silently dropped Phase 2 in the previous
+      // shape).
+      let eventCollector =
+        (queryDb->Component.operations, publishJsons)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn)) => {
+          let ec = SpecificEventCollector.make(~name=Spec.name, ~eventTopics, ~opts)
+
+          let jsonEventsHandler: EventCollector.jsonEventsHandler = stream =>
+            stream
+            ->Stream.runCollect
+            ->Effect.flatMap(jsons =>
+              Effect.promise(
+                async () => {
+                  // Phase 1: per-source decode + collect/resolve, threaded with context
+                  Callback.phase1(jsons, context)
+                  // Sync the post-phase-1 TODO state so consumers awaiting the
+                  // originating publishEvent observe Pending rows immediately.
+                  await syncToQueryDb(queryDbOps)
+                  // Phase 2 must NOT be awaited here. Phase 2 publishes commands
+                  // whose downstream events get fanned out by the bus to all
+                  // subscribers of this same topic — including this very fiber.
+                  // Awaiting would self-deadlock: the bus's allDone for the
+                  // inner event needs this fiber to dequeue it, but the fiber
+                  // is still inside this handler. Detaching mirrors the
+                  // fire-and-forget shape LocalBus already uses for
+                  // cross-plugin EP→Extension routing.
+                  let _ =
+                    Callback.phase2(publishJsonsFn)
+                    ->Promise.then(() => syncToQueryDb(queryDbOps))
+                    ->Promise.catch(exn => {
+                      let errMsg =
+                        exn
+                        ->JsExn.fromException
+                        ->Option.flatMap(JsExn.message)
+                        ->Option.getOr("unknown")
+                      EffectLogger.logError(
+                        ~comp=`AutomationSlice(${Spec.name})`,
+                        `detached phase 2 error: ${errMsg}`,
+                      )->Effect.runSync
+                      Promise.resolve()
+                    })
+                },
+              )
+            )
+
+          let handler = SpecificEventCollector.makeHandler(~eventCollector=ec, ~jsonEventsHandler)
+          let resources = (queryDb->Component.outputs).resources
+          ec->EventCollectorRuntimeBuilder.forEventCollector(
+            ~handler,
+            ~eventTopics,
+            ~resources,
+          )
+          ec
+        })
+
+      self->Component.setOperations(
+        (eventCollector->Pulumi.Output.flatMap(ec => ec->Component.operations), publishJsons)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((ecOps, publishJsonsFn)) => {
+          let ops: AutomationSlice.operations = {
+            enqueueEvent: ecOps.enqueueEvent,
+            processPending: async () => await Callback.phase2(publishJsonsFn),
+          }
+          ops
+        }),
+      )
+
+      // Outputs.resources are aggregated from all subscribed event topics.
+      let aggregatedResources =
+        eventTopics
+        ->Dict.valuesToArray
+        ->Array.flatMap((t: EventTopic.outputs) => t.resources)
+      let outputs: AutomationSlice.outputs = {
+        resources: aggregatedResources,
+        queryDb: queryDb->Component.outputs,
+      }
+      self->Component.setOutputs(outputs)
+    }
+
+    let make = (~allEventTopics, ~publishJsons, ~context, ~opts=?): AutomationSlice.component =>
+      Component.make(
+        ~componentType=AutomationSlice.componentType->ComponentType.toString,
+        ~name=Spec.name,
+        ~construct=construct(~allEventTopics, ~publishJsons, ~context, ...),
+        ~opts,
+      )
+  }
+}