@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Task/Task_Builder.res.mjs

@@ -0,0 +1,115 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Task$ReventlessCore from "./Task.res.mjs";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Aggregate$ReventlessCore from "../Aggregate/Aggregate.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as Util_Promise$ReventlessCore from "../../util/Util_Promise.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function pascalCase(s) {
+  return s.split("-").flatMap(p => p.split("_")).filter(p => p.length > 0).map(p => p.slice(0, 1).toUpperCase() + p.slice(1, p.length)).join("");
+}
+
+function Make(Spec) {
+  return RuntimeEnvironment => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (TaskRuntimeBuilder => (TaskBucket => (SpecificSideEffectHandler => {
+    let make = (queryBucketName, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, allAggregates, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Task$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let allCommandTopics = Aggregate$ReventlessCore.allCommandTopics(allAggregates);
+      let publishToAggregatesQueueUrls = Stdlib_Dict.mapValues(allAggregates, agg => Output$Pulumi.flatMap(agg.commandTopic, ct => {
+        let r = ct.resources[0];
+        if (r !== undefined) {
+          return r.id;
+        } else {
+          return Pulumi.output("");
+        }
+      }));
+      let publishCommands = (aggregateName, cmdJsons) => Stdlib_Option.getOrThrow(publishToAggregates[aggregateName], undefined)(cmdJsons);
+      let config = Spec.setup(queryEngine, queryBucketName, opts);
+      let sideEffectHandler = Stdlib_Option.map(config.sideEffects, sideEffects => SpecificSideEffectHandler.make(extra$1, sideEffects, Aggregate$ReventlessCore.allEventTopics(allAggregates), allCommandTopics, undefined, queryEngine, scheduler, resourceNaming, undefined, undefined, opts));
+      let taskActionsHandler = (taskActions, operations) => Util_Promise$ReventlessCore.toUnit(Promise.all(taskActions.map(async taskAction => {
+        switch (taskAction.TAG) {
+          case "PublishCommands" :
+            return await publishCommands(taskAction._0, taskAction._1);
+          case "CreateSchedule" :
+            if (operations !== undefined) {
+              return await operations.createSchedule(taskAction._0);
+            } else {
+              return log.info("Task", undefined, "No SideEffectHandler to create schedule");
+            }
+          case "DeleteSchedule" :
+            if (operations !== undefined) {
+              return await operations.deleteSchedule(taskAction._0);
+            } else {
+              return log.info("Task", undefined, "No SideEffectHandler to delete schedule");
+            }
+        }
+      })));
+      let createHandler = (sideEffectHandler, callback) => {
+        let handler = TaskBucket.makeHandler(callback);
+        if (sideEffectHandler !== undefined) {
+          return Component$ReventlessCore.operations(Primitive_option.valFromOption(sideEffectHandler)).apply(operations => (async (event, context) => {
+            let taskActions = await handler(event, context);
+            return await taskActionsHandler(taskActions, operations);
+          }));
+        } else {
+          return Pulumi.output(async (event, context) => {
+            let taskActions = await handler(event, context);
+            return await taskActionsHandler(taskActions, undefined);
+          });
+        }
+      };
+      let schedulerConfig = Stdlib_Option.flatMap(sideEffectHandler, seh => {
+        let sehOutputs = Component$ReventlessCore.outputs(seh);
+        return Stdlib_Option.map(sehOutputs.eventCollector.resources[0], r => ({
+          schedulerRoleUrn: schedulerRoleUrn,
+          targetUrn: r.urn,
+          targetName: r.name
+        }));
+      });
+      let bucketNames = Stdlib_Option.map(config.buckets, buckets => Object.fromEntries(buckets.map(bucketSpec => {
+        let bucketName = Stdlib_Option.getOr(bucketSpec.bucketName, "Bucket");
+        let bucketStem = Stdlib_Option.mapOr(bucketSpec.bucketName, "", pascalCase);
+        let name = extra$1 + bucketStem + "Bucket";
+        let bucket = TaskBucket.make(name, opts);
+        let opts_parent = bucket.parts;
+        let opts$1 = {
+          parent: opts_parent
+        };
+        Stdlib_Option.forEach(bucketSpec.callback, callback => TaskRuntimeBuilder.forBucketCallback(createHandler(sideEffectHandler, callback), none => TaskBucket.connect(name, bucket, bucketSpec.bucketMode, allCommandTopics, none, opts$1), 4096, 600, bucketStem, Spec.moduleUrl, publishToAggregatesQueueUrls, schedulerConfig, extra));
+        return [
+          bucketName,
+          bucket.resources[0].id
+        ];
+      })));
+      let sideEffectSources = Stdlib_Option.map(config.sideEffects, sideEffect => sideEffect.map(SideEffect => SideEffect.Source.name));
+      return Component$ReventlessCore.setOutputs(extra, {
+        name: extra$1,
+        bucketNames: bucketNames,
+        sideEffectSources: sideEffectSources
+      });
+    }, opts);
+    return {
+      Spec: Spec,
+      make: make,
+      outputs: Component$ReventlessCore.outputs
+    };
+  })))));
+}
+
+export {
+  log,
+  pascalCase,
+  Make,
+}
+/* log Not a pure module */

package/src/plugin/api/PluginBaseFragment.res

@@ -0,0 +1,104 @@
+open ReventlessInfra.Api
+
+let adminAuth: Reventless.ReadModel.authorization = {
+  tableName: "Plugin",
+  group: "Admin",
+}
+
+// Fields present on `PluginsReadModelSpec.state` for projection/storage purposes
+// but intentionally absent from the public GraphQL surface. Shared with
+// `Platform_Admin_Structure` so the schema announced via `Platform_ComponentDefinitions`
+// stays aligned with the SDL — otherwise AutoUI generates list-view queries
+// for fields the server doesn't expose and every Plugin row fails to load.
+let pluginExcludeFields: array<string> = [
+  "eventCollector",
+  "extensionPointNames",
+  "extensionNames",
+]
+
+// Additional fields the SDL exposes but the Plugin list view should NOT
+// surface — they're option-of-nested-object types (e.g. apiSchemaFragment,
+// uiFragments, structure) which AutoUI currently renders as scalar columns
+// and queries without a sub-selection, failing schema validation. Other
+// callers (host-shell's Platform_ComponentDefinitions / Platform_UIFragments)
+// keep querying them via dedicated fields and resolver paths.
+let pluginUIOnlyExcludeFields: array<string> = pluginExcludeFields->Array.concat([
+  "apiSchemaFragment",
+  "uiFragments",
+  "structure",
+])
+
+// Admin read-model query entries are generated from each spec the same way
+// ordinary read models are (Plugin_Builder.res): `subIdField` flows from the
+// spec's `subIdConfig` and `indexQueries` from `config.indexes`, so
+// `GraphQL_FragmentGenerator` emits the matching `<single>Items` (composite key)
+// and `<single>By<Index>` (GSI) fields automatically — in lockstep with the
+// shared resolver layer (`QueryDbResolvers_{AppSync,GraphQL}`). This closes the
+// admin/ordinary parity gap: an admin read model that declares a sub-id or an
+// `@index` now gets the same auto-generated GraphQL surface ordinary read models
+// do, instead of just `single` + `list`.
+let indexQueriesOfConfig = (config: Reventless.ReadModel.config) =>
+  config.indexes->Array.length > 0 ? Some(config.indexes) : None
+
+// The UIFragmentRegistry read model is queried exclusively via the explicit
+// flat `Platform_UIFragments: [Platform_UIFragmentEntry!]!` field declared in
+// `Platform_UIFragmentsApi.res` (and resolved by `Platform_UIFragments_Lambda.res`
+// on AWS / the seeded QueryDb in-memory). Reintroducing an auto-generated
+// connection field here collides with that name on SDL composition.
+let queryEntries: array<querySchemaEntry> = [
+  {
+    // The read-model `Spec.name` is "Plugins" (plural — the read-model cluster
+    // is named after the list, see `PluginsReadModelSpec`), while the GraphQL
+    // return type stays singular as `Platform_Plugin`. `specName` is what
+    // `QueryDbResolvers_{AppSync,GraphQL}.make` looks up in
+    // `queryFieldNamesRegistry`, so it must match `Spec.name`, not the
+    // singular form derived from `returnTypeName`.
+    specName: PluginsReadModelSpec.name,
+    singleFieldName: Api_Naming.adminField(~name="Plugin"),
+    listFieldName: Api_Naming.adminField(~name="Plugins"),
+    returnTypeName: Api_Naming.adminField(~name="Plugin"),
+    stateSchema: PluginsReadModelSpec.stateSchema->S.castToUnknown,
+    authorization: Some(adminAuth),
+    excludeFields: pluginExcludeFields,
+    subIdField: ?PluginsReadModelSpec.subIdConfig->Option.map((c: Reventless.ReadModel.subIdConfig<_>) => c.subIdField),
+    indexQueries: ?indexQueriesOfConfig(PluginsReadModelSpec.config),
+  },
+]
+
+// Plugin aggregate admin mutations — derived statically from PluginSpec.command,
+// so the generated SDL contains one field per non-`@noApi` variant carrying that
+// variant's command fields as args. Since the admin commands are name-keyed and
+// version-scoped (`Activate(version)` / `Deactivate(version)` / `Retire(version)`),
+// the fields are e.g. `Platform_Plugin_Activate(id: ID!, _0: String!): CommandResult!`
+// (`id` = plugin name = aggregate instance; `_0` = target version). `Retire` is
+// API-exposed (manual archive, §2.5). Internal-protocol variants (`Heartbeat`,
+// `Connect`, `Disconnect`, `ReportIncompatibility`) carry `@noApi` and are filtered
+// out by `ApiNoApiHelpers.filterNoApiVariants`. The same `commandSchema`-driven
+// entry feeds the MCP tool generator, so the MCP tools gain the version arg and
+// the `Plugin_Retire` tool automatically.
+//
+// The matching resolver wiring (registry population + `mutationResolverHook` /
+// `mutationBindHook` firing for the in-memory and AWS auto-flow) lives in
+// `Plugin_Helpers.registerAdminAggregateMutations`, invoked from
+// `Platform_Admin.construct` over the `~aggregates` parameter. Both paths derive
+// the same field names so the SDL and the resolvers stay aligned.
+let pluginAggregateMutationEntries: array<mutationSchemaEntry> = {
+  let commandSchema = PluginSpec.commandSchema->S.castToUnknown
+  let constructorNames = Reventless.DcbTag.extractAllVariantNames(PluginSpec.commandSchema)
+  let filteredConstructorNames =
+    ApiNoApiHelpers.filterNoApiVariants(constructorNames, commandSchema)
+  let fieldNames =
+    filteredConstructorNames->Array.map(cname =>
+      Api_Naming.adminField(~name=PluginSpec.name ++ "_" ++ cname)
+    )
+  if fieldNames->Array.length === 0 {
+    []
+  } else {
+    [
+      {
+        ReventlessInfra.Api.fieldNames,
+        commandSchema,
+      },
+    ]
+  }
+}

package/src/plugin/api/PluginBaseFragment.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
+import * as PluginSpec$ReventlessCore from "../lifecycle/PluginSpec.res.mjs";
+import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "../lifecycle/PluginsReadModelSpec.res.mjs";
+
+let adminAuth = {
+  tableName: "Plugin",
+  group: "Admin"
+};
+
+let pluginExcludeFields = [
+  "eventCollector",
+  "extensionPointNames",
+  "extensionNames"
+];
+
+let pluginUIOnlyExcludeFields = pluginExcludeFields.concat([
+  "apiSchemaFragment",
+  "uiFragments",
+  "structure"
+]);
+
+function indexQueriesOfConfig(config) {
+  if (config.indexes.length !== 0) {
+    return config.indexes;
+  }
+}
+
+let queryEntries = [{
+    singleFieldName: Api_Naming$ReventlessCore.adminField("Plugin"),
+    listFieldName: Api_Naming$ReventlessCore.adminField("Plugins"),
+    returnTypeName: Api_Naming$ReventlessCore.adminField("Plugin"),
+    stateSchema: PluginsReadModelSpec$ReventlessCore.stateSchema,
+    specName: PluginsReadModelSpec$ReventlessCore.name,
+    authorization: adminAuth,
+    excludeFields: pluginExcludeFields,
+    subIdField: Stdlib_Option.map(undefined, c => c.subIdField),
+    indexQueries: indexQueriesOfConfig(PluginsReadModelSpec$ReventlessCore.config)
+  }];
+
+let constructorNames = DcbTag$Reventless.extractAllVariantNames(PluginSpec$ReventlessCore.commandSchema);
+
+let filteredConstructorNames = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(constructorNames, PluginSpec$ReventlessCore.commandSchema);
+
+let fieldNames = filteredConstructorNames.map(cname => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + cname));
+
+let pluginAggregateMutationEntries = fieldNames.length === 0 ? [] : [{
+      fieldNames: fieldNames,
+      commandSchema: PluginSpec$ReventlessCore.commandSchema
+    }];
+
+export {
+  adminAuth,
+  pluginExcludeFields,
+  pluginUIOnlyExcludeFields,
+  indexQueriesOfConfig,
+  queryEntries,
+  pluginAggregateMutationEntries,
+}
+/* pluginUIOnlyExcludeFields Not a pure module */

package/src/plugin/component/Plugin.res

@@ -0,0 +1,100 @@
+let componentType = ComponentType.Plugin
+
+type outputs = ReventlessInfra.Plugin.outputs
+
+type t
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  type api
+  type role
+  let make: (
+    ~name: string,
+    ~heartbeatInterval: int,
+    ~extensionPoints: array<module(ReventlessInfra.ExtensionPoint.T)>=?,
+    ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=?,
+    ~aggregates: array<module(ReventlessInfra.Aggregate.T with type api = api)>=?,
+    ~readModels: array<
+      module(ReventlessInfra.ReadModel.T with type api = api and type role = role),
+    >=?,
+    ~tasks: array<module(ReventlessInfra.Task.T)>=?,
+    ~stateChangeSlices: array<module(ReventlessInfra.StateChangeSlice.T)>=?,
+    ~stateViewSlices: array<module(ReventlessInfra.StateViewSlice.T)>=?,
+    ~automationSlices: array<module(ReventlessInfra.AutomationSlice.T)>=?,
+    ~outboundTranslationSlices: array<module(ReventlessInfra.OutboundTranslationSlice.T)>=?,
+    ~inboundTranslationSlices: array<module(ReventlessInfra.InboundTranslationSlice.T)>=?,
+    ~uiFragments: Reventless.Plugin.uiFragmentManifest=?,
+    ~pluginStructure: Reventless.Plugin.pluginStructure=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+  let makeAutoUIManifest: (
+    ~remoteEntryUrl: string,
+    ~name: string,
+    ~pluginStructure: Reventless.Plugin.pluginStructure,
+    ~readModelPositions: array<string>=?,
+    ~aggregatePositions: array<string>=?,
+  ) => Reventless.Plugin.uiFragmentManifest
+  let makePluginDefinition: (
+    ~name: string,
+    ~aggregates: array<module(ReventlessInfra.Aggregate.T with type api = api)>=?,
+    ~readModels: array<module(ReventlessInfra.ReadModel.T with type api = api and type role = role)>=?,
+    ~stateViewSlices: array<module(ReventlessInfra.StateViewSlice.T)>=?,
+    ~stateChangeSlices: array<module(ReventlessInfra.StateChangeSlice.T)>=?,
+    ~automationSlices: array<module(ReventlessInfra.AutomationSlice.T)>=?,
+    ~outboundTranslationSlices: array<module(ReventlessInfra.OutboundTranslationSlice.T)>=?,
+    ~inboundTranslationSlices: array<module(ReventlessInfra.InboundTranslationSlice.T)>=?,
+    ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=?,
+    ~extensionPoints: array<module(ReventlessInfra.ExtensionPointMapping.Mapping)>=?,
+  ) => Reventless.Plugin.pluginStructure
+}
+
+let makeId = (name, version) => `${name}@${version}`
+
+// Inverse of `makeId` for the GraphQL boundary. Internally a plugin id is
+// `name@version` so the in-memory platform's plugin store can key by it, but
+// the platform invariant is one version per plugin at a time — so anything
+// crossing into the UI (routes, federation remote name, subscription
+// payloads) gets the bare name. If the input has no `@`, returns it as-is.
+let name = (id: string): string =>
+  id->String.split("@")->Array.get(0)->Option.getOr(id)
+
+// Version segment of a plugin id (`name@version`). Empty string when the id
+// carries no `@` (e.g. the synthetic admin plugin id).
+let version = (id: string): string =>
+  id->String.split("@")->Array.get(1)->Option.getOr("")
+
+// Compare two plugin version strings (e.g. "0.10.0-alpha.73"), newest-first:
+// returns 1 when `a` is newer than `b`, -1 when older, 0 when equal. Separators
+// (`.`, `-`, `+`) are normalised, then segments compare numerically when both
+// sides are numeric and lexically otherwise — enough to pick the latest among
+// the monotonically-increasing lerna versions this platform produces. Used by
+// the admin manifest resolvers to enforce the one-version-per-plugin invariant
+// when more than one version lingers in `Connected` state.
+let compareVersions = (a: string, b: string): int => {
+  let parts = s => s->String.replaceRegExp(%re("/[-+]/g"), ".")->String.split(".")
+  let pa = parts(a)
+  let pb = parts(b)
+  let len = pa->Array.length > pb->Array.length ? pa->Array.length : pb->Array.length
+  let result = ref(0)
+  let i = ref(0)
+  while result.contents == 0 && i.contents < len {
+    let sa = pa->Array.get(i.contents)->Option.getOr("")
+    let sb = pb->Array.get(i.contents)->Option.getOr("")
+    switch (Int.fromString(sa), Int.fromString(sb)) {
+    | (Some(na), Some(nb)) =>
+      if na > nb {
+        result := 1
+      } else if na < nb {
+        result := -1
+      }
+    | _ =>
+      if sa > sb {
+        result := 1
+      } else if sa < sb {
+        result := -1
+      }
+    }
+    i := i.contents + 1
+  }
+  result.contents
+}

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

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function makeId(name, version) {
+  return name + `@` + version;
+}
+
+function name(id) {
+  return Stdlib_Option.getOr(id.split("@")[0], id);
+}
+
+function version(id) {
+  return Stdlib_Option.getOr(id.split("@")[1], "");
+}
+
+function compareVersions(a, b) {
+  let parts = s => s.replace(/[-+]/g, ".").split(".");
+  let pa = parts(a);
+  let pb = parts(b);
+  let len = pa.length > pb.length ? pa.length : pb.length;
+  let result = 0;
+  let i = 0;
+  while (result === 0 && i < len) {
+    let sa = Stdlib_Option.getOr(pa[i], "");
+    let sb = Stdlib_Option.getOr(pb[i], "");
+    let match = Stdlib_Int.fromString(sa, undefined);
+    let match$1 = Stdlib_Int.fromString(sb, undefined);
+    let exit = 0;
+    if (match !== undefined && match$1 !== undefined) {
+      if (match > match$1) {
+        result = 1;
+      } else if (match < match$1) {
+        result = -1;
+      }
+    } else {
+      exit = 1;
+    }
+    if (exit === 1) {
+      if (sa > sb) {
+        result = 1;
+      } else if (sa < sb) {
+        result = -1;
+      }
+    }
+    i = i + 1 | 0;
+  };
+  return result;
+}
+
+let componentType = "Plugin";
+
+export {
+  componentType,
+  makeId,
+  name,
+  version,
+  compareVersions,
+}
+/* No side effect */