@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/component/SchemaWalker.res

@@ -0,0 +1,164 @@
+// SchemaWalker — runtime sury schema introspection for Plugin_BuiltHook.
+//
+// Walks an S.t<unknown> schema and produces a Plugin_BuiltHook.typeSchema
+// describing its fields, constructors, and a stable structural hash.
+//
+// Follows the same Union/Object/Number/Boolean constructor names used by
+// SchemaType.res (which are the real sury constructors, not Float/Bool/Int).
+
+open Plugin_BuiltHook
+
+// ---------------------------------------------------------------------------
+// Type description — maps a sury schema node to a human-readable string.
+// Optional fields in sury are Union({anyOf}) containing Null or Undefined.
+// ---------------------------------------------------------------------------
+let rec describeSchema = (schema: S.t<unknown>): string =>
+  switch schema {
+  | String({const: ?Some(_)}) => "string"
+  | String(_) => "string"
+  | Number(_) => "number"
+  | Boolean(_) => "bool"
+  | BigInt(_) => "bigint"
+  | Null(_) => "null"
+  | Union({anyOf}) =>
+    // Nullable/optional field: Union of Null/Undefined + one real type.
+    let nonNull = anyOf->Array.filter(v =>
+      switch v {
+      | Null(_) | Undefined(_) => false
+      | _ => true
+      }
+    )
+    switch nonNull->Array.get(0) {
+    | Some(inner) => "option<" ++ describeSchema(inner) ++ ">"
+    | None => "unknown"
+    }
+  | Array({additionalItems}) =>
+    let itemDesc = switch additionalItems {
+    | Schema(s) => describeSchema(s)
+    | _ => "unknown"
+    }
+    "array<" ++ itemDesc ++ ">"
+  | Object(_) => "object"
+  | _ => "unknown"
+  }
+
+// Returns true if the schema represents an optional field
+// (Union containing Null or Undefined).
+let isOptionalSchema = (schema: S.t<unknown>): bool =>
+  switch schema {
+  | Union({anyOf}) =>
+    anyOf->Array.some(v =>
+      switch v {
+      | Null(_) | Undefined(_) => true
+      | _ => false
+      }
+    )
+  | _ => false
+  }
+
+// ---------------------------------------------------------------------------
+// Field extraction from an Object({properties}) schema.
+// ---------------------------------------------------------------------------
+let extractFields = (properties: dict<S.t<unknown>>): array<fieldSchema> =>
+  properties
+  ->Dict.toArray
+  ->Array.filterMap(((name, fieldSch)) =>
+    // Skip the TAG discriminator — it's an internal sury marker.
+    if name == "TAG" {
+      None
+    } else {
+      let isRequired = !isOptionalSchema(fieldSch)
+      Some({
+        name,
+        typeDescription: describeSchema(fieldSch),
+        isRequired,
+      })
+    }
+  )
+  ->Array.toSorted((a, b) => String.compare(a.name, b.name))
+
+// ---------------------------------------------------------------------------
+// Hash computation — SHA256 over sorted "name:type:required" tuples.
+// ---------------------------------------------------------------------------
+let hashFields = (fields: array<fieldSchema>): string => {
+  let dict =
+    fields
+    ->Array.map(f => (f.name, f.typeDescription ++ ":" ++ (f.isRequired ? "1" : "0")))
+    ->Dict.fromArray
+  HashObj.hashDict(~dict, ~options={algorithm: SHA256})
+}
+
+let hashConstructors = (ctors: array<constructorSchema>): string => {
+  let dict =
+    ctors
+    ->Array.toSorted((a, b) => String.compare(a.name, b.name))
+    ->Array.map(c => (c.name, hashFields(c.fields)))
+    ->Dict.fromArray
+  HashObj.hashDict(~dict, ~options={algorithm: SHA256})
+}
+
+// ---------------------------------------------------------------------------
+// TAG item helper — extracts the const string value from a TAG schema item.
+// ---------------------------------------------------------------------------
+let tagConstOf = (items: array<S.item>): option<string> =>
+  items
+  ->Array.find(item => item.location == "TAG")
+  ->Option.flatMap(item =>
+    switch item.schema {
+    | String({const: ?Some(v)}) => Some(v)
+    | _ => None
+    }
+  )
+
+// ---------------------------------------------------------------------------
+// Main walker — converts an S.t<unknown> to a typeSchema.
+// ---------------------------------------------------------------------------
+let walkSchema = (typeName: string, schema: S.t<unknown>): typeSchema =>
+  switch schema {
+  | Object({properties}) =>
+    let fields = extractFields(properties)
+    {
+      typeName,
+      kind: "record",
+      fields,
+      structuralHash: hashFields(fields),
+    }
+  | Union({anyOf}) =>
+    // Check if this is a nullable scalar vs. a true variant union.
+    let hasNullLike = anyOf->Array.some(v =>
+      switch v {
+      | Null(_) | Undefined(_) => true
+      | _ => false
+      }
+    )
+    if hasNullLike {
+      // It's an optional/nullable scalar at the top level, treat as unknown.
+      {typeName, kind: "unknown", fields: [], structuralHash: ""}
+    } else {
+      let constructors =
+        anyOf->Array.filterMap(variantSchema =>
+          switch variantSchema {
+          | Object({items, properties}) =>
+            tagConstOf(items)->Option.map(name => {
+              name,
+              fields: extractFields(properties),
+            })
+          | _ => None
+          }
+        )
+      {
+        typeName,
+        kind: "variant",
+        fields: [],
+        constructors: constructors,
+        structuralHash: hashConstructors(constructors),
+      }
+    }
+  | _ => {typeName, kind: "unknown", fields: [], structuralHash: ""}
+  }
+
+// ---------------------------------------------------------------------------
+// Convenience: walk a typed schema (casts to unknown internally).
+// ---------------------------------------------------------------------------
+let walk = (typeName: string, schema: S.t<'a>): typeSchema =>
+  walkSchema(typeName, schema->S.castToUnknown)

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

@@ -0,0 +1,183 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import HashObject from "hash-object";
+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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function describeSchema(schema) {
+  switch (schema.type) {
+    case "string" :
+      return "string";
+    case "number" :
+      return "number";
+    case "bigint" :
+      return "bigint";
+    case "boolean" :
+      return "bool";
+    case "null" :
+      return "null";
+    case "array" :
+      let additionalItems = schema.additionalItems;
+      let itemDesc;
+      itemDesc = additionalItems === "strip" || additionalItems === "strict" ? "unknown" : describeSchema(additionalItems);
+      return "array<" + itemDesc + ">";
+    case "object" :
+      return "object";
+    case "union" :
+      let nonNull = schema.anyOf.filter(v => {
+        switch (v.type) {
+          case "null" :
+          case "undefined" :
+            return false;
+          default:
+            return true;
+        }
+      });
+      let inner = nonNull[0];
+      if (inner !== undefined) {
+        return "option<" + describeSchema(inner) + ">";
+      } else {
+        return "unknown";
+      }
+    default:
+      return "unknown";
+  }
+}
+
+function isOptionalSchema(schema) {
+  if (schema.type === "union") {
+    return schema.anyOf.some(v => {
+      switch (v.type) {
+        case "null" :
+        case "undefined" :
+          return true;
+        default:
+          return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
+function extractFields(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let name = param[0];
+    if (name === "TAG") {
+      return;
+    }
+    let fieldSch = param[1];
+    let isRequired = !isOptionalSchema(fieldSch);
+    return {
+      name: name,
+      typeDescription: describeSchema(fieldSch),
+      isRequired: isRequired
+    };
+  }).toSorted((a, b) => Primitive_string.compare(a.name, b.name));
+}
+
+function hashFields(fields) {
+  let dict = Object.fromEntries(fields.map(f => [
+    f.name,
+    f.typeDescription + ":" + (
+      f.isRequired ? "1" : "0"
+    )
+  ]));
+  return HashObject(dict, {
+    algorithm: "sha256"
+  });
+}
+
+function hashConstructors(ctors) {
+  let dict = Object.fromEntries(ctors.toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(c => [
+    c.name,
+    hashFields(c.fields)
+  ]));
+  return HashObject(dict, {
+    algorithm: "sha256"
+  });
+}
+
+function tagConstOf(items) {
+  return Stdlib_Option.flatMap(items.find(item => item.location === "TAG"), item => {
+    let match = item.schema;
+    if (match.type !== "string") {
+      return;
+    }
+    let v = match.const;
+    if (v !== undefined) {
+      return v;
+    }
+  });
+}
+
+function walkSchema(typeName, schema) {
+  switch (schema.type) {
+    case "object" :
+      let fields = extractFields(schema.properties);
+      return {
+        typeName: typeName,
+        kind: "record",
+        fields: fields,
+        structuralHash: hashFields(fields)
+      };
+    case "union" :
+      let anyOf = schema.anyOf;
+      let hasNullLike = anyOf.some(v => {
+        switch (v.type) {
+          case "null" :
+          case "undefined" :
+            return true;
+          default:
+            return false;
+        }
+      });
+      if (hasNullLike) {
+        return {
+          typeName: typeName,
+          kind: "unknown",
+          fields: [],
+          structuralHash: ""
+        };
+      }
+      let constructors = Stdlib_Array.filterMap(anyOf, variantSchema => {
+        if (variantSchema.type !== "object") {
+          return;
+        }
+        let properties = variantSchema.properties;
+        return Stdlib_Option.map(tagConstOf(variantSchema.items), name => ({
+          name: name,
+          fields: extractFields(properties)
+        }));
+      });
+      return {
+        typeName: typeName,
+        kind: "variant",
+        fields: [],
+        constructors: constructors,
+        structuralHash: hashConstructors(constructors)
+      };
+    default:
+      return {
+        typeName: typeName,
+        kind: "unknown",
+        fields: [],
+        structuralHash: ""
+      };
+  }
+}
+
+let walk = walkSchema;
+
+export {
+  describeSchema,
+  isOptionalSchema,
+  extractFields,
+  hashFields,
+  hashConstructors,
+  tagConstOf,
+  walkSchema,
+  walk,
+}
+/* hash-object Not a pure module */

package/src/plugin/connect/PluginConnectExtension_Builder.res

@@ -0,0 +1,14 @@
+// Deploy-time Extension component for PluginConnectExtension. Pulls Pulumi via
+// `include Extension_Builder.Make(...)`; layer-builder filters this file out of
+// the Lambda layer (`**/*_Builder*.res.mjs` glob). The runtime-relevant
+// mapping logic lives in PluginConnectExtension_Mapping.res so the
+// EventCollector entry point can dynamic-import it at cold start.
+
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+
+module type Spec = PluginConnectExtension_Mapping.Spec
+
+module Make = (Spec: Spec) => {
+  include PluginConnectExtension_Mapping.Make(Spec)
+  include Extension_Builder.Make(PluginExtensionPointSpec, ConnectPluginMappings)
+}

package/src/plugin/connect/PluginConnectExtension_Builder.res.mjs

@@ -0,0 +1,36 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Extension_Builder$ReventlessCore from "../../components/Extension/Extension_Builder.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as PluginConnectExtension_Mapping$ReventlessCore from "./PluginConnectExtension_Mapping.res.mjs";
+
+function Make(Spec) {
+  let include = PluginConnectExtension_Mapping$ReventlessCore.Make(Spec);
+  let ConnectPluginMappings = include.ConnectPluginMappings;
+  let include$1 = Extension_Builder$ReventlessCore.Make({
+    name: PluginExtensionPointSpec$ReventlessInfra.name,
+    moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+    commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+    eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+    directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+  })({
+    name: ConnectPluginMappings.name,
+    moduleUrl: ConnectPluginMappings.moduleUrl,
+    mappings: ConnectPluginMappings.mappings
+  });
+  return {
+    ConnectPluginMapping: include.ConnectPluginMapping,
+    ConnectPluginMappings: ConnectPluginMappings,
+    make: include$1.make,
+    outputs: include$1.outputs,
+    operations: include$1.operations
+  };
+}
+
+let PluginExtensionPointSpec;
+
+export {
+  PluginExtensionPointSpec,
+  Make,
+}
+/* Extension_Builder-ReventlessCore Not a pure module */

package/src/plugin/connect/PluginConnectExtension_Mapping.res

@@ -0,0 +1,76 @@
+// Runtime-safe ConnectPlugin mapping — split out of PluginConnectExtension_Builder
+// so the EventCollector Lambda entry point can dynamic-import it from the layer.
+// PluginConnectExtension_Builder.res still pulls Pulumi via `include
+// Extension_Builder.Make(...)` and is filtered out of the layer by the
+// `**/*_Builder*.res.mjs` rimraf in DependencyBundler_PostProcess; this module
+// contains only what runs in a Lambda.
+//
+// After Phase 3 of the plugin-eventcollector-runtime-rewire plans, cross-plugin
+// SNS subscription management lives on the admin side (admin's EventCollector
+// runs manageSubscriptions on every PluginConnected / Reconnected / Deactivated
+// event). This mapping retains a single responsibility: the bootstrap step
+// where a plugin emits a ConnectPlugin command to admin after admin posts an
+// UnknownPluginDetected event referencing this plugin's id. No subscribe /
+// unsubscribe directives are emitted any more.
+
+@@reventless.spec
+
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+module ExtensionMapping = ReventlessInfra.ExtensionMapping
+
+module type Spec = {
+  let pluginDefinition: Reventless.Plugin.pluginDefinition
+}
+
+module Make = (Spec: Spec) => {
+  module ConnectPluginMapping = ExtensionMapping.Make(
+    {
+      module ExtensionPoint = PluginExtensionPointSpec
+      module Delegate = ReventlessInfra.ExtensionMapping.NoDelegate
+
+      // Unused by ExtensionMapping.Make (it reads Delegate.moduleUrl, not the
+      // arg's); present only to satisfy the input module type. The actually
+      // dynamic-imported specifier is the file-level `moduleUrl` (@@reventless.spec
+      // injected, move-safe) referenced from Plugin_Helpers.
+      let moduleUrl = PluginExtensionPointSpec.moduleUrl
+
+      let delegateModuleUrl = Delegate.moduleUrl
+
+      let mapIncomingEvent: ReventlessInfra.ExtensionMapping.mapIncomingEvent<
+        PluginExtensionPointSpec.event,
+        Delegate.command,
+        PluginExtensionPointSpec.command,
+        PluginExtensionPointSpec.directive,
+      > = (pluginId, event, _meta, _pluginDef, _queryEngine) => {
+        let pluginDefinition = Spec.pluginDefinition
+        let id = pluginDefinition.id
+
+        switch event {
+        | PluginExtensionPointSpec.UnknownPluginDetected if pluginId == id => [
+            PublishExtensionPointCommand(
+              id,
+              PluginExtensionPointSpec.ConnectPlugin(pluginDefinition),
+            ),
+          ]
+        // PluginConnected / PluginReconnected / PluginDeactivated for peer
+        // plugins used to call DoConnectPlugin / DoDisconnectPlugin here so
+        // each plugin's EC Lambda could subscribe / unsubscribe its own
+        // queue to peer EP topics. Admin owns that work now
+        // (manageSubscriptions in AdminEventCollectorEntryPoint.mjs) — these
+        // cases drop to no-ops.
+        | _ => []
+        }
+      }
+
+      let mapOutgoingEvent = None
+    },
+  )
+
+  module ConnectPluginMappings = {
+    module Spec = PluginExtensionPointSpec
+    module type Mapping = ExtensionMapping.T with module ExtensionPoint := Spec
+    let name = "Connect"
+    let moduleUrl: string = %raw(`import.meta.url`)
+    let mappings: array<module(Mapping)> = [module(ConnectPluginMapping)]
+  }
+}

package/src/plugin/connect/PluginConnectExtension_Mapping.res.mjs

@@ -0,0 +1,89 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+function Make(Spec) {
+  let delegateModuleUrl = ExtensionMapping$ReventlessInfra.NoDelegate.moduleUrl;
+  let mapIncomingEvent = (pluginId, event, _meta, _pluginDef, _queryEngine) => {
+    let pluginDefinition = Spec.pluginDefinition;
+    let id = pluginDefinition.id;
+    if (typeof event !== "object") {
+      if (pluginId === id) {
+        return [{
+            TAG: "PublishExtensionPointCommand",
+            _0: id,
+            _1: {
+              TAG: "ConnectPlugin",
+              _0: pluginDefinition
+            }
+          }];
+      } else {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  };
+  let $$let = ExtensionMapping$ReventlessInfra.NoDelegate.Id;
+  let ConnectPluginMapping = ExtensionMapping$ReventlessInfra.Make({
+    ExtensionPoint: {
+      name: PluginExtensionPointSpec$ReventlessInfra.name,
+      moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+      commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+      eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+      directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+    },
+    Delegate: {
+      Id: {
+        schema: $$let.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: $$let.cmp
+      },
+      name: ExtensionMapping$ReventlessInfra.NoDelegate.name,
+      eventSchema: ExtensionMapping$ReventlessInfra.NoDelegate.eventSchema,
+      errorSchema: ExtensionMapping$ReventlessInfra.NoDelegate.errorSchema,
+      commandSchema: ExtensionMapping$ReventlessInfra.NoDelegate.commandSchema,
+      moduleUrl: ExtensionMapping$ReventlessInfra.NoDelegate.moduleUrl,
+      commandAuthorization: ExtensionMapping$ReventlessInfra.NoDelegate.commandAuthorization
+    },
+    moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+    delegateModuleUrl: delegateModuleUrl,
+    mapIncomingEvent: mapIncomingEvent,
+    mapOutgoingEvent: undefined
+  });
+  let moduleUrl = import.meta.url;
+  let mappings = [ConnectPluginMapping];
+  let ConnectPluginMappings = {
+    Spec: undefined,
+    name: "Connect",
+    moduleUrl: moduleUrl,
+    mappings: mappings
+  };
+  return {
+    ConnectPluginMapping: ConnectPluginMapping,
+    ConnectPluginMappings: ConnectPluginMappings
+  };
+}
+
+let name = "PluginConnectExtension_Mapping";
+
+let Id;
+
+let PluginExtensionPointSpec;
+
+let ExtensionMapping;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/connect/PluginConnectExtension_Mapping.res.mjs";
+
+export {
+  name,
+  Id,
+  PluginExtensionPointSpec,
+  ExtensionMapping,
+  Make,
+  moduleUrl,
+}
+/* ExtensionMapping-ReventlessInfra Not a pure module */

package/src/plugin/connect/PluginExtensionPoint_Builder.res

@@ -0,0 +1,39 @@
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+
+module type Spec = {
+  let runtimeOps: PluginRuntimeOperations.operations
+  let environment: string
+  let updateApiSchema: option<Reventless.QueryEngine.operations => promise<unit>>
+  let manageSubscriptions: option<
+    (Reventless.Plugin.pluginDefinition, [#connect | #disconnect]) => promise<unit>,
+  >
+}
+
+module Make = (
+  Spec: Spec,
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventTopicAdapter: EventTopic_Adapter.Publisher,
+  ExtensionPointRuntimeBuilder: ExtensionPointRuntime_Builder.T
+    with module CommandTopicChannel := CommandTopicChannel,
+): ExtensionPoint.T => {
+  module PluginMappingInstance = PluginExtensionPoint_Plugin.Make(Spec)
+
+  module Mappings = {
+    module type Mapping = ReventlessInfra.ExtensionPointMapping.T
+      with module ExtensionPoint := PluginExtensionPointSpec
+
+    let name = PluginMappingInstance.Mapping.delegateName
+    let moduleUrl = PluginExtensionPointSpec.moduleUrl
+    let mappings: array<module(Mapping)> = [module(PluginMappingInstance.Mapping)]
+  }
+  include ExtensionPoint_Builder.Make(
+    PluginExtensionPointSpec,
+    Mappings,
+    RuntimeEnvironment,
+    CommandTopicChannel,
+    EventTopicAdapter,
+    ExtensionPointRuntimeBuilder,
+  )
+}

package/src/plugin/connect/PluginExtensionPoint_Builder.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ExtensionPoint_Builder$ReventlessCore from "../../components/ExtensionPoint/ExtensionPoint_Builder.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as PluginExtensionPoint_Plugin$ReventlessCore from "./PluginExtensionPoint_Plugin.res.mjs";
+
+function Make(Spec) {
+  return RuntimeEnvironment => (CommandTopicChannel => (EventTopicAdapter => (ExtensionPointRuntimeBuilder => {
+    let PluginMappingInstance = PluginExtensionPoint_Plugin$ReventlessCore.Make(Spec);
+    let name = PluginMappingInstance.Mapping.delegateName;
+    let mappings = [PluginMappingInstance.Mapping];
+    let Mappings = {
+      name: name,
+      moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+      mappings: mappings
+    };
+    return ExtensionPoint_Builder$ReventlessCore.Make({
+      name: PluginExtensionPointSpec$ReventlessInfra.name,
+      moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+      commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+      eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+      directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+    })(Mappings)(RuntimeEnvironment)(CommandTopicChannel)(EventTopicAdapter)(ExtensionPointRuntimeBuilder);
+  })));
+}
+
+let PluginExtensionPointSpec;
+
+export {
+  PluginExtensionPointSpec,
+  Make,
+}
+/* ExtensionPoint_Builder-ReventlessCore Not a pure module */