@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/EventLog/EventPublish_Callback.res

@@ -0,0 +1,29 @@
+type publishedEvent = {
+  componentName: string,
+  entityId: string,
+  eventCount: int,
+  eventsJson: array<JSON.t>,
+  meta: Reventless.Message.meta,
+}
+
+type beforePublishHook = publishedEvent => promise<publishedEvent>
+type afterPublishHook = publishedEvent => promise<unit>
+
+/** Module-level hook called before events are published to EventTopic. None = passthrough (default). */
+let beforePublishHook: ref<option<beforePublishHook>> = ref(None)
+
+/** Module-level hook called after events are published to EventTopic. None = no-op (default). */
+let afterPublishHook: ref<option<afterPublishHook>> = ref(None)
+
+let registerBeforePublish = (hook: beforePublishHook) => {
+  beforePublishHook.contents = Some(hook)
+}
+
+let registerAfterPublish = (hook: afterPublishHook) => {
+  afterPublishHook.contents = Some(hook)
+}
+
+let clearPublishHooks = () => {
+  beforePublishHook.contents = None
+  afterPublishHook.contents = None
+}

package/src/components/EventLog/EventPublish_Callback.res.mjs

@@ -0,0 +1,32 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let beforePublishHook = {
+  contents: undefined
+};
+
+let afterPublishHook = {
+  contents: undefined
+};
+
+function registerBeforePublish(hook) {
+  beforePublishHook.contents = hook;
+}
+
+function registerAfterPublish(hook) {
+  afterPublishHook.contents = hook;
+}
+
+function clearPublishHooks() {
+  beforePublishHook.contents = undefined;
+  afterPublishHook.contents = undefined;
+}
+
+export {
+  beforePublishHook,
+  afterPublishHook,
+  registerBeforePublish,
+  registerAfterPublish,
+  clearPublishHooks,
+}
+/* No side effect */

package/src/components/EventMapper/EventMapper.res

@@ -0,0 +1,72 @@
+module ReventlessEventCollector = EventCollector
+
+let componentType = ComponentType.EventMapper
+
+type outputs = ReventlessInfra.EventMapper.outputs
+
+type t
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  let make: (
+    ~name: string,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~publishJsons: CommandTopic.publishJsons,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~memorySize: int=?,
+    ~timeout: int=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.EventMapper.resolvedOutputs> => {
+  let eventCollectorOutput =
+    outputs.eventCollector->Pulumi.Output.flatMap((ec: ReventlessEventCollector.outputs) =>
+      ec.resources
+      ->Adapter.resourcesToInterop
+      ->Pulumi.Output.apply(resources => {
+        let resolved: ReventlessInterop.EventCollector.resolvedOutputs = {
+          name: ec.name,
+          resources: resources,
+        }
+        resolved
+      })
+    )
+  let counterOutput = switch outputs.counter {
+  | Some(counter) =>
+    (
+      counter.referencesDb.resources->Adapter.resourcesToInterop,
+      counter.countsDb.resources->Adapter.resourcesToInterop,
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((referencesDbResources, countsDbResources)) =>
+      Some({
+        ReventlessInterop.Counter.referencesDb: {resources: referencesDbResources},
+        countsDb: {resources: countsDbResources},
+      })
+    )
+  | None => Pulumi.Output.make(None)
+  }
+  (eventCollectorOutput, counterOutput)
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((eventCollector, counter)) =>
+    switch counter {
+    | Some(counter) => {
+        ReventlessInterop.EventMapper.name: outputs.name,
+        eventCollector,
+        counter,
+      }
+    | None => {name: outputs.name, eventCollector}
+    }
+  )
+}
+
+module type Mappings = {
+  module Target: Reventless.EventMapping.Target
+  module type Mapping = Reventless.EventMapping.T with module Target := Target
+  let mappings: array<module(Mapping)>
+  let counter: option<module(Counter.T)>
+}

package/src/components/EventMapper/EventMapper.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  let eventCollectorOutput = Output$Pulumi.flatMap(outputs.eventCollector, ec => Adapter$ReventlessCore.resourcesToInterop(ec.resources).apply(resources => ({
+    name: ec.name,
+    resources: resources
+  })));
+  let counter = outputs.counter;
+  let counterOutput = counter !== undefined ? Pulumi.all([
+      Adapter$ReventlessCore.resourcesToInterop(counter.referencesDb.resources),
+      Adapter$ReventlessCore.resourcesToInterop(counter.countsDb.resources)
+    ]).apply(param => ({
+      referencesDb: {
+        resources: param[0]
+      },
+      countsDb: {
+        resources: param[1]
+      }
+    })) : Pulumi.output(undefined);
+  return Pulumi.all([
+    eventCollectorOutput,
+    counterOutput
+  ]).apply(param => {
+    let counter = param[1];
+    let eventCollector = param[0];
+    if (counter !== undefined) {
+      return {
+        name: outputs.name,
+        eventCollector: eventCollector,
+        counter: counter
+      };
+    } else {
+      return {
+        name: outputs.name,
+        eventCollector: eventCollector
+      };
+    }
+  });
+}
+
+let ReventlessEventCollector;
+
+let componentType = "EventMapper";
+
+export {
+  ReventlessEventCollector,
+  componentType,
+  toResolvedOutputs,
+}
+/* Output-Pulumi Not a pure module */

package/src/components/EventMapper/EventMapper_Builder.res

@@ -0,0 +1,128 @@
+let log = Logger.fromEnv()
+
+module Make = (
+  Target: Reventless.EventMapping.Target,
+  SpecificEventCollector: EventCollector.T,
+  Mappings: EventMapper.Mappings with module Target := Target,
+  AggregateRuntimeBuilder: AggregateRuntime_Builder.T
+    with type EventCollectorChannel.callbackEvent := SpecificEventCollector.callbackEvent,
+): EventMapper.T => {
+  module Target = Target
+
+  let construct = (
+    ~allEventTopics,
+    ~queryEngine,
+    ~publishJsons,
+    ~resources,
+    ~memorySize,
+    ~timeout,
+    self,
+    name,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let name = name->ComponentType.name(EventMapper.componentType)
+
+    module CounterHandler = EventMapper_Callback.MakeCounterHandler(
+      Target,
+      Mappings,
+      {
+        let publishJsons = publishJsons
+        let queryEngine = queryEngine
+      },
+    )
+
+    let (counterOperations, counterOutputs) = Mappings.counter->Option.mapOr(
+      (
+        Pulumi.Output.make({
+          let ops: Counter.operations = {
+            count: async _items =>
+              log.warn(~comp="EventMapper", "No counter deployed, but trying to use count"),
+            addToCounterTarget: async _target =>
+              log.warn(~comp="EventMapper", "No counter deployed, but trying to use addToCounterTarget"),
+          }
+          ops
+        }),
+        None,
+      ),
+      (module(Counter: Counter.T)) => {
+        let counter = Counter.make(
+          ~name,
+          ~jsonEventsHandler=CounterHandler.handleCounterEvents,
+          ~opts,
+        )
+        (Counter.operations(counter), Counter.outputs(counter)->Some)
+      },
+    )
+
+    module Set = Belt.Set.String
+    let aggregateNames =
+      Mappings.mappings
+      ->Array.filterMap((module(Mapping: Mappings.Mapping)) =>
+        if Mapping.Source.name != Counter.Source.name {
+          Some(Mapping.Source.name)
+        } else {
+          None
+        }
+      )
+      ->Set.fromArray
+
+    let eventCollector = counterOperations->Pulumi.Output.apply(({count, addToCounterTarget}) =>
+      {
+        let eventTopics = allEventTopics->EventTopic.filter(aggregateNames)
+        let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+
+        module EventCollectorHandler = EventMapper_Callback.MakeEventCollectorHandler({
+          let publishJsons = publishJsons
+          let count = count
+          let addToCounterTarget = addToCounterTarget
+          let commonEventsHandler = CounterHandler.commonEventsHandler
+        })
+        let handler = SpecificEventCollector.makeHandler(
+          ~eventCollector,
+          ~jsonEventsHandler=EventCollectorHandler.handleJsonEvents,
+        )
+        eventCollector->AggregateRuntimeBuilder.forEventCollector(
+          ~handler,
+          ~eventTopics,
+          ~resources,
+          ~memorySize,
+          ~timeout,
+        )
+
+        eventCollector
+      }->Component.outputs
+    )
+
+    let outputs: EventMapper.outputs = {
+      name,
+      eventCollector,
+      counter: ?counterOutputs,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (
+    ~name,
+    ~allEventTopics,
+    ~queryEngine,
+    ~publishJsons,
+    ~resources,
+    ~memorySize=2048,
+    ~timeout=180,
+    ~opts=?,
+  ) =>
+    Component.make(
+      ~componentType=EventMapper.componentType->ComponentType.toString,
+      ~name,
+      ~construct=construct(
+        ~allEventTopics,
+        ~queryEngine,
+        ~publishJsons,
+        ~resources,
+        ~memorySize,
+        ~timeout,
+        ...
+      ),
+      ~opts,
+    )
+}

package/src/components/EventMapper/EventMapper_Builder.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Counter$ReventlessCore from "../Counter/Counter.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
+import * as EventMapper$ReventlessCore from "./EventMapper.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventMapper_Callback$ReventlessCore from "./EventMapper_Callback.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function Make(Target) {
+  return SpecificEventCollector => (Mappings => (AggregateRuntimeBuilder => {
+    let make = (name, allEventTopics, queryEngine, publishJsons, resources, memorySizeOpt, timeoutOpt, opts) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 2048;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 180;
+      return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(EventMapper$ReventlessCore.componentType), name, (extra, extra$1) => {
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let name = ComponentType$ReventlessCore.name(extra$1, EventMapper$ReventlessCore.componentType);
+        let CounterHandler = EventMapper_Callback$ReventlessCore.MakeCounterHandler(Target)(Mappings)({
+          publishJsons: publishJsons,
+          queryEngine: queryEngine
+        });
+        let match = Stdlib_Option.mapOr(Mappings.counter, [
+          Pulumi.output({
+            count: async _items => log.warn("EventMapper", undefined, "No counter deployed, but trying to use count"),
+            addToCounterTarget: async _target => log.warn("EventMapper", undefined, "No counter deployed, but trying to use addToCounterTarget")
+          }),
+          undefined
+        ], Counter => {
+          let counter = Counter.make(name, CounterHandler.handleCounterEvents, undefined, undefined, undefined, undefined, opts);
+          return [
+            Counter.operations(counter),
+            Counter.outputs(counter)
+          ];
+        });
+        let aggregateNames = Belt_SetString.fromArray(Stdlib_Array.filterMap(Mappings.mappings, Mapping => {
+          if (Mapping.Source.name !== Counter$ReventlessCore.Source.name) {
+            return Mapping.Source.name;
+          }
+        }));
+        let eventCollector = match[0].apply(param => {
+          let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, aggregateNames);
+          let eventCollector = SpecificEventCollector.make(name, eventTopics, opts);
+          let EventCollectorHandler = EventMapper_Callback$ReventlessCore.MakeEventCollectorHandler({
+            publishJsons: publishJsons,
+            count: param.count,
+            addToCounterTarget: param.addToCounterTarget,
+            commonEventsHandler: CounterHandler.commonEventsHandler
+          });
+          let handler = SpecificEventCollector.makeHandler(eventCollector, EventCollectorHandler.handleJsonEvents);
+          return Component$ReventlessCore.outputs((AggregateRuntimeBuilder.forEventCollector(handler, eventTopics, resources, memorySize, timeout, eventCollector), eventCollector));
+        });
+        let outputs_counter = match[1];
+        let outputs = {
+          name: name,
+          eventCollector: eventCollector,
+          counter: outputs_counter
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+    };
+    return {
+      make: make
+    };
+  }));
+}
+
+export {
+  log,
+  Make,
+}
+/* log Not a pure module */