@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/admin/Platform_Admin.res.mjs

@@ -0,0 +1,250 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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 Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Cloner$ReventlessCore from "../components/Cloner.res.mjs";
+import * as AdminApi$ReventlessCore from "./AdminApi.res.mjs";
+import * as Aggregate$ReventlessCore from "../components/Aggregate/Aggregate.res.mjs";
+import * as Component$ReventlessCore from "../components/Component.res.mjs";
+import * as ReadModel$ReventlessCore from "../components/ReadModel/ReadModel.res.mjs";
+import * as Dcb_Builder$ReventlessCore from "../components/Dcb/Dcb_Builder.res.mjs";
+import * as Admin_Callback$ReventlessCore from "./Admin_Callback.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "../plugin/component/Plugin_Helpers.res.mjs";
+import * as Builder_Helpers$ReventlessCore from "../components/Builder_Helpers.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "../components/Api/GraphQL_Stitcher.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../plugin/component/Plugin_Structure.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../components/EventCollector/EventCollector_Builder.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return EventCollectorChannel => (QueryEngineAdapter => (ClonerRunner => (AdminRuntimeBuilder => (DcbEventLogStorage => (DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (Config => {
+    let MakeEventCollectorHelper = RE => (ECC => (RB => {
+      let AdminEventCollector = EventCollector_Builder$ReventlessCore.Make(RE)(ECC);
+      let make = (name, eventTopics, opts) => {
+        let eventCollector = AdminEventCollector.make(name, eventTopics, opts);
+        let eventCollectorOutputs = Component$ReventlessCore.outputs(eventCollector);
+        return [
+          eventCollector,
+          eventCollectorOutputs
+        ];
+      };
+      let connect = (eventCollector, eventTopics, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers) => {
+        let resources = Pulumi.all(extensionPointsOutputs.map(extensionPoint => extensionPoint.eventTopic)).apply(eventTopics => eventTopics.map(eventTopic => eventTopic.resources).flat());
+        return resources.apply(resources => {
+          let fakePluginDefinition = {
+            id: "Admin@INTERNAL",
+            name: "Admin",
+            version: "INTERNAL",
+            extensionPoints: [],
+            extensions: [],
+            eventCollector: "NOT-SET",
+            extensionProtocols: [],
+            apiSchemaFragment: undefined,
+            apiTarget: undefined,
+            uiFragments: undefined,
+            structure: undefined,
+            dcbEventLog: undefined
+          };
+          let Callback = Admin_Callback$ReventlessCore.Make({
+            pluginDefinition: fakePluginDefinition,
+            outgoingExtensionPointJsonEventsHandlers: extensionPointsOutgoingJsonEventsHandlers
+          });
+          let handler = AdminEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+          RB.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
+        });
+      };
+      return {
+        AdminEventCollector: AdminEventCollector,
+        make: make,
+        connect: connect
+      };
+    }));
+    let construct = (param, extensionPoints, aggregates, readModels, scheduler, resourceNaming, api, apiRole, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices) => {
+      let name = "Admin";
+      let opts = {};
+      let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(AdminRuntimeBuilder)({
+        hooks: Config.hooks
+      });
+      let aggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, opts);
+      let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
+      Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
+      let dcbResult = DcbBuilder.construct(name, name, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, opts);
+      let adminMutationEntries = AdminApi$ReventlessCore.mutationEntries(Config.cloner);
+      let allMutationEntries = adminMutationEntries.concat(dcbResult.mutationEntries);
+      let allQueryEntries = AdminApi$ReventlessCore.queryEntries.concat(dcbResult.queryEntries);
+      let adminFragment = GraphQL_FragmentGenerator$ReventlessCore.generate(allMutationEntries, allQueryEntries);
+      if (dcbResult.mutationEntries.length !== 0 || dcbResult.queryEntries.length !== 0) {
+        let registerTypes = Config.hooks.schemaTypeRegistrationHook;
+        if (registerTypes !== undefined) {
+          let parts = GraphQL_Stitcher$ReventlessCore.decode(adminFragment);
+          registerTypes(parts.types);
+        }
+        let registerMcp = Config.hooks.mcpSchemaRegistrationHook;
+        if (registerMcp !== undefined) {
+          registerMcp({
+            pluginName: "Admin",
+            mutationEntries: allMutationEntries,
+            queryEntries: allQueryEntries,
+            eventLogEntries: dcbResult.eventLogEntries,
+            subscriptionFields: GraphQL_Stitcher$ReventlessCore.decode(adminFragment).subscriptions
+          });
+        }
+      }
+      let dcbOutputs = dcbResult.dcbEventLogOutputs;
+      if (dcbOutputs !== undefined) {
+        aggregateEventTopics[name + "DcbEventLog"] = dcbOutputs.eventTopic;
+      }
+      AdminApi$ReventlessCore.queryEntries.forEach(entry => {
+        let prefix = "Platform_";
+        let entityName = entry.returnTypeName.startsWith(prefix) ? entry.returnTypeName.slice(prefix.length, entry.returnTypeName.length) : entry.returnTypeName;
+        let registryKey = Stdlib_Option.getOr(entry.specName, entityName);
+        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, entry.stateSchema);
+        let qn_singleFieldName = entry.singleFieldName;
+        let qn_listFieldName = entry.listFieldName;
+        let qn_returnTypeName = entry.returnTypeName;
+        let qn_pluralTypeName = entry.listFieldName;
+        let qn_connectionFilterTypeName = entry.returnTypeName + "Filter";
+        let qn_labelField = match[0];
+        let qn_includeIdParam = Stdlib_Option.getOr(entry.includeIdParam, true);
+        let qn_connectionSpec = Stdlib_Option.getOr(entry.connectionSpec, true);
+        let qn = {
+          singleFieldName: qn_singleFieldName,
+          listFieldName: qn_listFieldName,
+          returnTypeName: qn_returnTypeName,
+          pluralTypeName: qn_pluralTypeName,
+          connectionFilterTypeName: qn_connectionFilterTypeName,
+          labelField: qn_labelField,
+          includeIdParam: qn_includeIdParam,
+          connectionSpec: qn_connectionSpec
+        };
+        Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[registryKey] = qn;
+        Plugin_Helpers$ReventlessCore.stateSchemaRegistry[registryKey] = entry.stateSchema;
+      });
+      let readModelsOutputs = Builder_Helpers$ReventlessCore.createReadModels(readModels, api, apiRole, aggregateEventTopics, opts);
+      let allQueryDbs = ReadModel$ReventlessCore.allQueryDbs(readModelsOutputs);
+      Object.entries(dcbResult.stateViewSlicesOutputs).forEach(param => {
+        allQueryDbs[param[0]] = param[1].queryDb;
+      });
+      Object.entries(dcbResult.inboundTranslationSlicesOutputs).forEach(param => {
+        allQueryDbs[param[0]] = param[1].queryDb;
+      });
+      let eventLogEntriesFromAggregates = aggregates.map(M => ({
+        busKey: M.Spec.name + "AggrEventLog",
+        displayName: M.Spec.name,
+        eventSchema: M.Spec.eventSchema
+      }));
+      let eventLogEntries = eventLogEntriesFromAggregates.concat(dcbResult.eventLogEntries);
+      Stdlib_Option.forEach(Config.hooks.subscriptionInfraHook, hook => hook({
+        allQueryDbs: allQueryDbs,
+        allEventTopics: aggregateEventTopics,
+        eventLogEntries: eventLogEntries,
+        opts: opts
+      }));
+      let queryEngine = QueryEngineAdapter.make(allQueryDbs);
+      let resourceNames = Object.values(readModelsOutputs).flatMap(rm => rm.queryDb.resources.map(r => r.name));
+      let dataSourceNames = Object.values(readModelsOutputs).map(rm => rm.queryDb.dataSourceName);
+      let adminBarrier = Pulumi.all(resourceNames.concat(dataSourceNames)).apply(param => {});
+      let push = Config.hooks.preAdminResolversSchemaHook;
+      let adminSchemaPushed = push !== undefined ? push(adminBarrier) : Pulumi.output();
+      adminSchemaPushed.apply(() => Builder_Helpers$ReventlessCore.createResolvers(allQueryDbs));
+      let extensionPointsOutputs = Pulumi.all([
+        Pulumi.all(Builder_Helpers$ReventlessCore.aggregateResources),
+        Pulumi.all(Builder_Helpers$ReventlessCore.publishToAggregates),
+        queryEngine,
+        scheduler
+      ]).apply(param => {
+        let queryEngine = param[2];
+        Builder_Helpers$ReventlessCore.addEventMappers(aggregateEventTopics, queryEngine);
+        let match = Builder_Helpers$ReventlessCore.createExtensionPoints(extensionPoints, param[0], param[1], param[3], queryEngine, resourceNaming, opts);
+        let extensionPointsOutputs = match[0];
+        let aggregateNames = Stdlib_Array.reduce(extensionPointsOutputs.map(extensionPointOutputs => Belt_SetString.fromArray(extensionPointOutputs.aggregateNames)), undefined, Belt_SetString.union);
+        let aggregatesOutputs = Builder_Helpers$ReventlessCore.addEventMappers(aggregateEventTopics, queryEngine);
+        let eventTopics = Aggregate$ReventlessCore.filterEventTopics(aggregatesOutputs, aggregateNames);
+        let AdminEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+        let make = (name, eventTopics, opts) => {
+          let eventCollector = AdminEventCollector.make(name, eventTopics, opts);
+          let eventCollectorOutputs = Component$ReventlessCore.outputs(eventCollector);
+          return [
+            eventCollector,
+            eventCollectorOutputs
+          ];
+        };
+        let connect = (eventCollector, eventTopics, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers) => {
+          let resources = Pulumi.all(extensionPointsOutputs.map(extensionPoint => extensionPoint.eventTopic)).apply(eventTopics => eventTopics.map(eventTopic => eventTopic.resources).flat());
+          return resources.apply(resources => {
+            let fakePluginDefinition = {
+              id: "Admin@INTERNAL",
+              name: "Admin",
+              version: "INTERNAL",
+              extensionPoints: [],
+              extensions: [],
+              eventCollector: "NOT-SET",
+              extensionProtocols: [],
+              apiSchemaFragment: undefined,
+              apiTarget: undefined,
+              uiFragments: undefined,
+              structure: undefined,
+              dcbEventLog: undefined
+            };
+            let Callback = Admin_Callback$ReventlessCore.Make({
+              pluginDefinition: fakePluginDefinition,
+              outgoingExtensionPointJsonEventsHandlers: extensionPointsOutgoingJsonEventsHandlers
+            });
+            let handler = AdminEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+            AdminRuntimeBuilder.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
+          });
+        };
+        let match$1 = make(name, eventTopics, opts);
+        let eventCollector = match$1[0];
+        Output$Pulumi.flatMap(Pulumi.all(match[1]), extensionPointsOutgoingJsonEventsHandlers => connect(eventCollector, eventTopics, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers));
+        Stdlib_Option.forEach(dcbResult.dcbRuntimeSetup, dcbRuntimeSetup => dcbRuntimeSetup());
+        return extensionPointsOutputs;
+      });
+      if (Config.cloner) {
+        let Cloner = Cloner$ReventlessCore.Make(ClonerRunner);
+        Cloner.make(api, opts);
+      }
+      return {
+        adminFragment: adminFragment,
+        dcbMutationEntries: dcbResult.mutationEntries,
+        dcbQueryEntries: dcbResult.queryEntries,
+        dcbEventLogEntries: dcbResult.eventLogEntries,
+        extensionPointsOutputs: extensionPointsOutputs,
+        aggregatesOutputs: aggregatesWithoutEventMappers,
+        readModelsOutputs: readModelsOutputs,
+        dcbEventLogOutputs: dcbResult.dcbEventLogOutputs,
+        stateChangeSlicesOutputs: dcbResult.stateChangeSlicesOutputs,
+        stateViewSlicesOutputs: dcbResult.stateViewSlicesOutputs,
+        automationSlicesOutputs: dcbResult.automationSlicesOutputs,
+        outboundTranslationSlicesOutputs: dcbResult.outboundTranslationSlicesOutputs,
+        inboundTranslationSlicesOutputs: dcbResult.inboundTranslationSlicesOutputs
+      };
+    };
+    return {
+      addEventMapperFns: Builder_Helpers$ReventlessCore.addEventMapperFns,
+      aggregateResources: Builder_Helpers$ReventlessCore.aggregateResources,
+      publishToAggregates: Builder_Helpers$ReventlessCore.publishToAggregates,
+      aggregateFinishFns: Builder_Helpers$ReventlessCore.aggregateFinishFns,
+      createAggregatesWithoutEventMappers: Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers,
+      finishAggregates: Builder_Helpers$ReventlessCore.finishAggregates,
+      addEventMappers: Builder_Helpers$ReventlessCore.addEventMappers,
+      readModelNamesForSourceName: Builder_Helpers$ReventlessCore.readModelNamesForSourceName,
+      publishToReadModels: Builder_Helpers$ReventlessCore.publishToReadModels,
+      finishReadModels: Builder_Helpers$ReventlessCore.finishReadModels,
+      extractReadModelsOutputs: Builder_Helpers$ReventlessCore.extractReadModelsOutputs,
+      createReadModels: Builder_Helpers$ReventlessCore.createReadModels,
+      createExtensionPoints: Builder_Helpers$ReventlessCore.createExtensionPoints,
+      createResolvers: Builder_Helpers$ReventlessCore.createResolvers,
+      MakeEventCollectorHelper: MakeEventCollectorHelper,
+      construct: construct
+    };
+  }))))))));
+}
+
+export {
+  Make,
+}
+/* Output-Pulumi Not a pure module */

package/src/admin/Platform_Admin_Structure.res

@@ -0,0 +1,125 @@
+// Synthetic pluginStructure for the built-in Platform_Admin plugin.
+//
+// The admin's Plugin aggregate + Plugin read model are
+// wired into the GraphQL schema via PluginBaseFragment, not through the
+// regular ~aggregates / ~readModels arrays passed to Admin.construct. As a
+// result, Plugin_Structure.make never sees them, and the in-memory Platform
+// 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.
+
+open Reventless.Plugin
+
+let pluginId = "Platform"
+
+let pluginName = pluginId
+
+let encodeSchema = (schema: S.t<unknown>): string =>
+  schema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify
+
+// 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"]),
+  apiExposed: Some(true),
+}
+
+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"]),
+  apiExposed: Some(true),
+}
+
+let pluginAggregate: writableDef = {
+  name: "Plugin",
+  commands: [activateCommand, deactivateCommand],
+  producedEventTypes: [],
+  consumedEventTypes: [],
+  linkedViews: ["Plugins"],
+  consistencyRead: None,
+  events: [],
+}
+
+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"],
+  statusField: Some("status"),
+  visibility: None,
+}
+
+let structure: pluginStructure = {
+  readModels: [pluginReadModel],
+  stateViewSlices: [],
+  stateChangeSlices: [],
+  aggregates: [pluginAggregate],
+  automationSlices: [],
+  outboundTranslationSlices: [],
+  inboundTranslationSlices: [],
+  extensions: [],
+  extensionPoints: None,
+}

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -0,0 +1,182 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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 SuryToJsonSchema$ReventlessCore from "../components/Api/SuryToJsonSchema.res.mjs";
+import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/PluginsReadModelSpec.res.mjs";
+
+let pluginId = "Platform";
+
+function encodeSchema(schema) {
+  return JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema));
+}
+
+function encodeSchemaExcluding(schema, excludeFields) {
+  let derived = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema);
+  let obj = Stdlib_JSON.Decode.object(derived);
+  if (obj === undefined) {
+    return JSON.stringify(derived);
+  }
+  let props = Stdlib_Option.flatMap(obj["properties"], Stdlib_JSON.Decode.object);
+  if (props === undefined) {
+    return JSON.stringify(derived);
+  }
+  excludeFields.forEach(f => Stdlib_Dict.$$delete(props, f));
+  obj["properties"] = props;
+  let req = Stdlib_Option.flatMap(obj["required"], Stdlib_JSON.Decode.array);
+  if (req !== undefined) {
+    let filtered = Stdlib_Array.filterMap(req, Stdlib_JSON.Decode.string).filter(name => !excludeFields.includes(name)).map(prim => prim);
+    obj["required"] = filtered;
+  }
+  return JSON.stringify(obj);
+}
+
+let idArgsSchema = S.schema(s => ({
+  id: s.m(DcbTag$Reventless.string)
+}));
+
+let activateCommand_schema = encodeSchema(idArgsSchema);
+
+let activateCommand_aggregateIdField = "id";
+
+let activateCommand_mutationField = Api_Naming$ReventlessCore.adminField("Plugin_Activate");
+
+let activateCommand_references = [];
+
+let activateCommand_allowedStates = ["Inactive"];
+
+let activateCommand_apiExposed = true;
+
+let activateCommand = {
+  name: "Activate",
+  schema: activateCommand_schema,
+  level: "Instance",
+  aggregateIdField: activateCommand_aggregateIdField,
+  mutationField: activateCommand_mutationField,
+  references: activateCommand_references,
+  allowedStates: activateCommand_allowedStates,
+  apiExposed: activateCommand_apiExposed
+};
+
+let deactivateCommand_schema = encodeSchema(idArgsSchema);
+
+let deactivateCommand_aggregateIdField = "id";
+
+let deactivateCommand_mutationField = Api_Naming$ReventlessCore.adminField("Plugin_Deactivate");
+
+let deactivateCommand_references = [];
+
+let deactivateCommand_allowedStates = [
+  "Connected",
+  "Disconnected"
+];
+
+let deactivateCommand_apiExposed = true;
+
+let deactivateCommand = {
+  name: "Deactivate",
+  schema: deactivateCommand_schema,
+  level: "Instance",
+  aggregateIdField: deactivateCommand_aggregateIdField,
+  mutationField: deactivateCommand_mutationField,
+  references: deactivateCommand_references,
+  allowedStates: deactivateCommand_allowedStates,
+  apiExposed: deactivateCommand_apiExposed
+};
+
+let pluginAggregate_commands = [
+  activateCommand,
+  deactivateCommand
+];
+
+let pluginAggregate_producedEventTypes = [];
+
+let pluginAggregate_consumedEventTypes = [];
+
+let pluginAggregate_linkedViews = ["Plugins"];
+
+let pluginAggregate_events = [];
+
+let pluginAggregate = {
+  name: "Plugin",
+  commands: pluginAggregate_commands,
+  producedEventTypes: pluginAggregate_producedEventTypes,
+  consumedEventTypes: pluginAggregate_consumedEventTypes,
+  linkedViews: pluginAggregate_linkedViews,
+  consistencyRead: undefined,
+  events: pluginAggregate_events
+};
+
+let pluginReadModel_queryField = Api_Naming$ReventlessCore.adminField("Plugins");
+
+let pluginReadModel_schema = encodeSchemaExcluding(PluginsReadModelSpec$ReventlessCore.stateSchema, PluginBaseFragment$ReventlessCore.pluginUIOnlyExcludeFields);
+
+let pluginReadModel_consumedEventTypes = [];
+
+let pluginReadModel_linkedWriteSide = ["Plugin"];
+
+let pluginReadModel_searchableFields = ["name"];
+
+let pluginReadModel_statusField = "status";
+
+let pluginReadModel = {
+  name: "Plugins",
+  queryField: pluginReadModel_queryField,
+  schema: pluginReadModel_schema,
+  consumedEventTypes: pluginReadModel_consumedEventTypes,
+  linkedWriteSide: pluginReadModel_linkedWriteSide,
+  labelField: "name",
+  searchableFields: pluginReadModel_searchableFields,
+  statusField: pluginReadModel_statusField,
+  visibility: undefined
+};
+
+let structure_readModels = [pluginReadModel];
+
+let structure_stateViewSlices = [];
+
+let structure_stateChangeSlices = [];
+
+let structure_aggregates = [pluginAggregate];
+
+let structure_automationSlices = [];
+
+let structure_outboundTranslationSlices = [];
+
+let structure_inboundTranslationSlices = [];
+
+let structure_extensions = [];
+
+let structure = {
+  readModels: structure_readModels,
+  stateViewSlices: structure_stateViewSlices,
+  stateChangeSlices: structure_stateChangeSlices,
+  aggregates: structure_aggregates,
+  automationSlices: structure_automationSlices,
+  outboundTranslationSlices: structure_outboundTranslationSlices,
+  inboundTranslationSlices: structure_inboundTranslationSlices,
+  extensions: structure_extensions,
+  extensionPoints: undefined
+};
+
+let pluginName = pluginId;
+
+export {
+  pluginId,
+  pluginName,
+  encodeSchema,
+  encodeSchemaExcluding,
+  idArgsSchema,
+  activateCommand,
+  deactivateCommand,
+  pluginAggregate,
+  pluginReadModel,
+  structure,
+}
+/* idArgsSchema Not a pure module */