@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/ExtensionPoint/ExtensionPoint_Callback.res.mjs

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
+import * as ScheduleOps$ReventlessCore from "../../util/ScheduleOps.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function Make(Spec) {
+  return MappingSpec => (Mappings => {
+    let mapIncomingCommands = (topicItems, mappings, scheduler, queryEngine, resourceNaming, queue) => mappings.map(Mapping => Mapping.mapIncomingCommands(topicItems, ScheduleOps$ReventlessCore.create(scheduler, queue, resourceNaming), ScheduleOps$ReventlessCore.$$delete(scheduler, queue, resourceNaming), queryEngine)).flat();
+    let applyCommandAction = action => {
+      if (action.TAG === "AbstractPublishCommand") {
+        let cmdJson = action._2;
+        let reference = action._1;
+        let aggregateName = action._0;
+        return Effect$1.catchAll(Effect.trySync(err => {
+          let errMsg = Util_Error$ReventlessCore.messageFromUnknown(err, "unknown");
+          return [
+            {
+              TAG: "Error",
+              _0: reference
+            },
+            `ExtensionPoint: Error on publish command: ` + errMsg
+          ];
+        }, () => {
+          let result = Stdlib_Option.mapOr(Stdlib_Option.map(Spec.publishToAggregates[aggregateName], publishJsons => publishJsons([cmdJson])), () => Stdlib_JsError.throwWithMessage(`ExtensionPoint.applyCommandAction: Aggregate ` + aggregateName + ` doesn't exist`), x => (() => x));
+          result();
+          return {
+            TAG: "Ok",
+            _0: reference
+          };
+        }), param => {
+          let errorResult = param[0];
+          return Effect$1.map(EffectLogger$ReventlessCore.logError("ExtensionPoint", undefined, param[1]), () => errorResult);
+        });
+      }
+      let handler = action._1;
+      let reference$1 = action._0;
+      return Effect$1.catchAll(Effect$1.map(Effect.tryPromise(err => {
+        let errMsg = Util_Error$ReventlessCore.messageFromUnknown(err, "unknown");
+        return [
+          {
+            TAG: "Error",
+            _0: reference$1
+          },
+          `ExtensionPoint: Error on handling directive: ` + errMsg
+        ];
+      }, () => handler()), () => ({
+        TAG: "Ok",
+        _0: reference$1
+      })), param => {
+        let errorResult = param[0];
+        return Effect$1.map(EffectLogger$ReventlessCore.logError("ExtensionPoint", undefined, param[1]), () => errorResult);
+      });
+    };
+    let handleIncomingCommands = stream => Effect$1.flatMap(Stream.runCollect(stream), topicItems => {
+      let commandActions = mapIncomingCommands(topicItems, Mappings.mappings, Spec.scheduler, Spec.queryEngine, Spec.resourceNaming, Spec.commandTopicResources);
+      return Effect$1.all(commandActions.map(applyCommandAction), {
+        concurrency: "unbounded"
+      });
+    });
+    return {
+      MappingSpec: MappingSpec,
+      handleIncomingCommands: handleIncomingCommands
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Effect Not a pure module */

package/src/components/ExtensionPoint/ExtensionPoint_Operations.res

@@ -0,0 +1,146 @@
+module type Mappings = {
+  module Spec: ReventlessInfra.ExtensionPointMapping.Spec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := Spec
+  let mappings: array<module(Mapping)>
+}
+
+module type Ops = {
+  let publishToEventTopic: EventTopic.publishJson
+  let commandTopicResources: array<Adapter.resolvedResource>
+  let scheduler: Scheduler.operations
+  let queryEngine: Reventless.QueryEngine.operations
+  let resourceNaming: ReventlessInfra.ResourceNaming.operations
+}
+
+module Make = (
+  MappingSpec: ReventlessInfra.ExtensionPointMapping.Spec,
+  Mappings: Mappings with module Spec := MappingSpec,
+  Ops: Ops,
+) => {
+  let findOutgoingMapping = (delegateNameOpt, mappings) =>
+    delegateNameOpt->Option.flatMap(delegateName =>
+      mappings->Array.find((module(Mapping: Mappings.Mapping)) =>
+        Mapping.delegateName == delegateName
+      )
+    ) // TODO: handle multiple mappings for same Target name
+
+  let mapOutgoingEvent = (eventJson', mappings, scheduler, queue, queryEngine, resourceNaming) =>
+    switch eventJson'->Message.serviceNameOfMsg->findOutgoingMapping(mappings) {
+    | Some(module(Mapping)) =>
+      switch Mapping.mapOutgoingEvent {
+      | Some(mapOutgoingEvent) =>
+        mapOutgoingEvent(
+          eventJson',
+          ScheduleOps.create(~scheduler, ~channelResources=queue, ~resourceNaming),
+          ScheduleOps.delete(~scheduler, ~channelResources=queue, ~resourceNaming),
+          queryEngine,
+        )
+      | None =>
+        EffectLogger.logError(
+          ~comp=`ExtensionPoint(${MappingSpec.name})`,
+          "mapOutgoingEvent: shouldn't be called, because Plugin EventCollector shouldn't subscribe to EventLog stream not having mapOutgoingEvent() !",
+        )->Effect.runSync
+        []
+      }
+    | None =>
+      JsError.throwWithMessage(
+        "ExtensionPoint.Mapping: Missing mapping for " ++ eventJson'->JSON.stringify,
+      )
+    }
+
+  let publishWithHooks = async (id, meta, eventJson) => {
+    // Run beforePublish hook — if it throws, log the error and publish original event.
+    let finalEventJson = switch EventPublish_Callback.beforePublishHook.contents {
+    | None => eventJson
+    | Some(hook) =>
+      let published: EventPublish_Callback.publishedEvent = {
+        componentName: MappingSpec.name,
+        entityId: id,
+        eventCount: 1,
+        eventsJson: [eventJson],
+        meta,
+      }
+      try {
+        let result = await hook(published)
+        result.eventsJson->Array.getUnsafe(0)
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`ExtensionPoint(${MappingSpec.name})`,
+          `beforePublishHook error: ${errMsg}`,
+        )->Effect.runSync
+        eventJson
+      }
+    }
+
+    try await Ops.publishToEventTopic(id, meta, finalEventJson) catch {
+    | err =>
+      let errMsg =
+        err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      EffectLogger.logError(
+        ~comp=`ExtensionPoint(${MappingSpec.name})`,
+        `Error on publishToEventTopic command: ${errMsg}`,
+      )->Effect.runSync
+    }
+
+    // Run afterPublish hook — fire-and-forget, errors are caught and logged.
+    switch EventPublish_Callback.afterPublishHook.contents {
+    | None => ()
+    | Some(hook) =>
+      try {
+        let published: EventPublish_Callback.publishedEvent = {
+          componentName: MappingSpec.name,
+          entityId: id,
+          eventCount: 1,
+          eventsJson: [finalEventJson],
+          meta,
+        }
+        let _ = await hook(published)
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`ExtensionPoint(${MappingSpec.name})`,
+          `afterPublishHook error: ${errMsg}`,
+        )->Effect.runSync
+      }
+    }
+  }
+
+  let applyEventAction = async action =>
+    switch action {
+    | ReventlessInfra.ExtensionPointMapping.AbstractPublishEvent(id, meta, eventJson) =>
+      EffectLogger.logInfo(~comp=`ExtensionPoint(${MappingSpec.name})`, `applying event: ${LogFormat.eventSummary(eventJson)}`)->Effect.runSync
+      await publishWithHooks(id, meta, eventJson)
+    | ReventlessInfra.ExtensionPointMapping.AbstractPublishEventAsync(promise) =>
+      let (id, meta, eventJson) = await promise
+      await publishWithHooks(id, meta, eventJson)
+    | AbstractHandleDirective(handler) =>
+      try await handler() catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(~comp=`ExtensionPoint(${MappingSpec.name})`, `Error on handling directive: ${errMsg}`)->Effect.runSync
+      }
+    }
+
+  let outgoingJsonEventsHandler = async (eventJson', _pluginDef) => {
+    EffectLogger.logInfo(~comp=`ExtensionPoint(${MappingSpec.name})`, `outgoing event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    let eventActions = mapOutgoingEvent(
+      eventJson',
+      Mappings.mappings,
+      Ops.scheduler,
+      Ops.commandTopicResources,
+      Ops.queryEngine,
+      Ops.resourceNaming,
+    )
+
+    await eventActions
+    ->Array.map(applyEventAction)
+    ->Promise.all
+    ->Util.Promise.toUnit
+  }
+}

package/src/components/ExtensionPoint/ExtensionPoint_Operations.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as ScheduleOps$ReventlessCore from "../../util/ScheduleOps.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as Util_Promise$ReventlessCore from "../../util/Util_Promise.res.mjs";
+import * as EventPublish_Callback$ReventlessCore from "../EventLog/EventPublish_Callback.res.mjs";
+
+function Make(MappingSpec) {
+  return Mappings => (Ops => {
+    let findOutgoingMapping = (delegateNameOpt, mappings) => Stdlib_Option.flatMap(delegateNameOpt, delegateName => mappings.find(Mapping => Mapping.delegateName === delegateName));
+    let mapOutgoingEvent = (eventJson$p, mappings, scheduler, queue, queryEngine, resourceNaming) => {
+      let Mapping = findOutgoingMapping(Message$ReventlessCore.serviceNameOfMsg(eventJson$p), mappings);
+      if (Mapping === undefined) {
+        return Stdlib_JsError.throwWithMessage("ExtensionPoint.Mapping: Missing mapping for " + JSON.stringify(eventJson$p));
+      }
+      let mapOutgoingEvent$1 = Mapping.mapOutgoingEvent;
+      if (mapOutgoingEvent$1 !== undefined) {
+        return mapOutgoingEvent$1(eventJson$p, ScheduleOps$ReventlessCore.create(scheduler, queue, resourceNaming), ScheduleOps$ReventlessCore.$$delete(scheduler, queue, resourceNaming), queryEngine);
+      } else {
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, "mapOutgoingEvent: shouldn't be called, because Plugin EventCollector shouldn't subscribe to EventLog stream not having mapOutgoingEvent() !"));
+        return [];
+      }
+    };
+    let publishWithHooks = async (id, meta, eventJson) => {
+      let hook = EventPublish_Callback$ReventlessCore.beforePublishHook.contents;
+      let finalEventJson;
+      if (hook !== undefined) {
+        let published_componentName = MappingSpec.name;
+        let published_eventsJson = [eventJson];
+        let published = {
+          componentName: published_componentName,
+          entityId: id,
+          eventCount: 1,
+          eventsJson: published_eventsJson,
+          meta: meta
+        };
+        try {
+          let result = await hook(published);
+          finalEventJson = result.eventsJson[0];
+        } catch (raw_err) {
+          let err = Primitive_exceptions.internalToException(raw_err);
+          let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `beforePublishHook error: ` + errMsg));
+          finalEventJson = eventJson;
+        }
+      } else {
+        finalEventJson = eventJson;
+      }
+      try {
+        await Ops.publishToEventTopic(id, meta, finalEventJson);
+      } catch (raw_err$1) {
+        let err$1 = Primitive_exceptions.internalToException(raw_err$1);
+        let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err$1), Stdlib_JsExn.message), "unknown");
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `Error on publishToEventTopic command: ` + errMsg$1));
+      }
+      let hook$1 = EventPublish_Callback$ReventlessCore.afterPublishHook.contents;
+      if (hook$1 === undefined) {
+        return;
+      }
+      try {
+        let published_componentName$1 = MappingSpec.name;
+        let published_eventsJson$1 = [finalEventJson];
+        let published$1 = {
+          componentName: published_componentName$1,
+          entityId: id,
+          eventCount: 1,
+          eventsJson: published_eventsJson$1,
+          meta: meta
+        };
+        await hook$1(published$1);
+        return;
+      } catch (raw_err$2) {
+        let err$2 = Primitive_exceptions.internalToException(raw_err$2);
+        let errMsg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err$2), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `afterPublishHook error: ` + errMsg$2));
+      }
+    };
+    let applyEventAction = async action => {
+      switch (action.TAG) {
+        case "AbstractPublishEvent" :
+          let eventJson = action._2;
+          Effect.runSync(EffectLogger$ReventlessCore.logInfo(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `applying event: ` + LogFormat$ReventlessCore.eventSummary(eventJson)));
+          return await publishWithHooks(action._0, action._1, eventJson);
+        case "AbstractPublishEventAsync" :
+          let match = await action._0;
+          return await publishWithHooks(match[0], match[1], match[2]);
+        case "AbstractHandleDirective" :
+          try {
+            return await action._0();
+          } catch (raw_err) {
+            let err = Primitive_exceptions.internalToException(raw_err);
+            let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+            return Effect.runSync(EffectLogger$ReventlessCore.logError(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `Error on handling directive: ` + errMsg));
+          }
+      }
+    };
+    let outgoingJsonEventsHandler = async (eventJson$p, _pluginDef) => {
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(`ExtensionPoint(` + MappingSpec.name + `)`, undefined, `outgoing event: ` + LogFormat$ReventlessCore.eventSummary(eventJson$p)));
+      let eventActions = mapOutgoingEvent(eventJson$p, Mappings.mappings, Ops.scheduler, Ops.commandTopicResources, Ops.queryEngine, Ops.resourceNaming);
+      return await Util_Promise$ReventlessCore.toUnit(Promise.all(eventActions.map(applyEventAction)));
+    };
+    return {
+      findOutgoingMapping: findOutgoingMapping,
+      mapOutgoingEvent: mapOutgoingEvent,
+      publishWithHooks: publishWithHooks,
+      applyEventAction: applyEventAction,
+      outgoingJsonEventsHandler: outgoingJsonEventsHandler
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/components/Heartbeat/Heartbeat.res

@@ -0,0 +1,25 @@
+let componentType = ComponentType.Heartbeat
+
+type outputs = ReventlessInfra.Heartbeat.outputs
+
+type t
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  type runtimeParts
+
+  let connect: (
+    ~runtime: Runtime.environment<runtimeParts>,
+    ~remoteChannel: CommandTopic_Adapter.remoteChannel,
+    ~timeout: int=?,
+    component,
+  ) => unit
+
+  let makeHandler: (
+    ~id: string,
+    ~timeout: int=?,
+    ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
+  ) => Pulumi.Output.t<Runtime.eventHandler<unit, 'context, unit>>
+
+  let make: (~name: string, ~opts: Pulumi.ComponentResource.options=?) => component
+}

package/src/components/Heartbeat/Heartbeat.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let componentType = "Heartbeat";
+
+export {
+  componentType,
+}
+/* No side effect */

package/src/components/Heartbeat/Heartbeat_Adapter.res

@@ -0,0 +1,14 @@
+type runner = {resources: array<ReventlessInfra.Adapter.resource>}
+
+type runnerMaker<'runtimeParts> = (
+  ~name: string,
+  ~remoteChannel: CommandTopic_Adapter.remoteChannel,
+  ~timeout: int,
+  ~runtime: Runtime.environment<'runtimeParts>,
+  ~opts: Pulumi.ComponentResource.options,
+) => runner
+
+module type Runner = {
+  type runtimeParts
+  let make: runnerMaker<runtimeParts>
+}

package/src/components/Heartbeat/Heartbeat_Adapter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/Heartbeat/Heartbeat_Builder.res

@@ -0,0 +1,43 @@
+module Make = (Runner: Heartbeat_Adapter.Runner): (
+  Heartbeat.T with type runtimeParts = Runner.runtimeParts
+) => {
+  type runtimeParts = Runner.runtimeParts
+
+  let construct = (_self, _name) => ()
+
+  let connect = (~runtime, ~remoteChannel, ~timeout=10, heartbeat) => {
+    let heartbeatResource = heartbeat->Component.toPulumiResource
+    let name =
+      heartbeatResource.name
+      ->Option.getOr("Unnamed")
+      ->ComponentType.name(Heartbeat.componentType)
+    let opts = {Pulumi.ComponentResource.parent: heartbeatResource}
+
+    let runnerResources = {
+      Runner.make(~name, ~remoteChannel, ~timeout, ~runtime, ~opts).resources
+    }
+
+    let outputs: Heartbeat.outputs = {
+      name,
+      resources: runnerResources,
+    }
+    let _ = heartbeat->Component.setOutputs(outputs)
+  }
+
+  let makeHandler = (~id, ~timeout=10, ~publishToPluginExtensionPoint) => {
+    module Callback = Heartbeat_Callback.Make({
+      let publishToPluginExtensionPoint = publishToPluginExtensionPoint
+      let id = id
+      let timeout = timeout
+    })
+    Callback.heartbeat->Pulumi.Output.make
+  }
+
+  let make = (~name, ~opts=?): Heartbeat.component =>
+    Component.make(
+      ~componentType=Heartbeat.componentType->ComponentType.toString,
+      ~name,
+      ~construct,
+      ~opts,
+    )
+}

package/src/components/Heartbeat/Heartbeat_Builder.res.mjs

@@ -0,0 +1,47 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as Heartbeat$ReventlessCore from "./Heartbeat.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as Heartbeat_Callback$ReventlessCore from "./Heartbeat_Callback.res.mjs";
+
+function Make(Runner) {
+  let construct = (_self, _name) => {};
+  let connect = (runtime, remoteChannel, timeoutOpt, heartbeat) => {
+    let timeout = timeoutOpt !== undefined ? timeoutOpt : 10;
+    let heartbeatResource = Component$ReventlessCore.toPulumiResource(heartbeat);
+    let name = ComponentType$ReventlessCore.name(Stdlib_Option.getOr(heartbeatResource.__name, "Unnamed"), Heartbeat$ReventlessCore.componentType);
+    let opts_parent = heartbeatResource;
+    let opts = {
+      parent: opts_parent
+    };
+    let runnerResources = Runner.make(name, remoteChannel, timeout, runtime, opts).resources;
+    let outputs = {
+      name: name,
+      resources: runnerResources
+    };
+    Component$ReventlessCore.setOutputs(heartbeat, outputs);
+  };
+  let makeHandler = (id, timeoutOpt, publishToPluginExtensionPoint) => {
+    let timeout = timeoutOpt !== undefined ? timeoutOpt : 10;
+    let Callback = Heartbeat_Callback$ReventlessCore.Make({
+      publishToPluginExtensionPoint: publishToPluginExtensionPoint,
+      id: id,
+      timeout: timeout
+    });
+    return Pulumi.output(Callback.heartbeat);
+  };
+  let make = (name, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Heartbeat$ReventlessCore.componentType), name, construct, opts);
+  return {
+    connect: connect,
+    makeHandler: makeHandler,
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/Heartbeat/Heartbeat_Callback.res

@@ -0,0 +1,32 @@
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+
+module type Spec = {
+  let publishToPluginExtensionPoint: CommandTopic.publishJsons
+  let id: string
+  let timeout: int
+}
+
+module Make = (Spec: Spec) => {
+  let log = Logger.fromEnv()
+
+  let heartbeat = (_, _) => {
+    let msgId = Message.uuid()
+    log.info(~comp="Heartbeat", `id=${Spec.id} timeout=${Spec.timeout->Int.toString}s`)
+    Spec.publishToPluginExtensionPoint([
+      {
+        Message.id: Spec.id,
+        meta: {
+          service: PluginExtensionPointSpec.name,
+          time: Message.nowAsISOString(),
+          ip: "",
+          user: "Heartbeat",
+          msgId,
+          correlationId: msgId,
+        },
+        commandJson: PluginExtensionPointSpec.Heartbeat(
+          Spec.timeout,
+        )->Message.encode(PluginExtensionPointSpec.commandSchema),
+      },
+    ])
+  }
+}

package/src/components/Heartbeat/Heartbeat_Callback.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+function Make(Spec) {
+  let log = Logger$ReventlessCore.fromEnv();
+  let heartbeat = (param, param$1) => {
+    let msgId = Message$ReventlessCore.uuid();
+    log.info("Heartbeat", undefined, `id=` + Spec.id + ` timeout=` + Spec.timeout.toString() + `s`);
+    return Spec.publishToPluginExtensionPoint([{
+        id: Spec.id,
+        meta: {
+          service: PluginExtensionPointSpec$ReventlessInfra.name,
+          time: Message$ReventlessCore.nowAsISOString(),
+          ip: "",
+          user: "Heartbeat",
+          msgId: msgId,
+          correlationId: msgId
+        },
+        commandJson: Message$ReventlessCore.encode({
+          TAG: "Heartbeat",
+          _0: Spec.timeout
+        }, PluginExtensionPointSpec$ReventlessInfra.commandSchema)
+      }]);
+  };
+  return {
+    log: log,
+    heartbeat: heartbeat
+  };
+}
+
+let PluginExtensionPointSpec;
+
+export {
+  PluginExtensionPointSpec,
+  Make,
+}
+/* Logger-ReventlessCore Not a pure module */

package/src/components/InboundTranslationSlice/InboundTranslationSlice.res

@@ -0,0 +1,34 @@
+let componentType = ComponentType.InboundTranslationSlice
+
+type t = ReventlessInfra.InboundTranslationSlice.t
+type outputs = ReventlessInfra.InboundTranslationSlice.outputs
+type operations = ReventlessInfra.InboundTranslationSlice.operations
+type component = Component.t<t, outputs, operations>
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.InboundTranslationSlice.resolvedOutputs> =>
+  (
+    outputs.resources->Adapter.resourcesToInterop,
+    outputs.queryDb.resources->Adapter.resourcesToInterop,
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((resources, queryDbResources)) => {
+    let resolved: ReventlessInterop.InboundTranslationSlice.resolvedOutputs = {
+      resources: resources,
+      queryDb: {resources: queryDbResources},
+    }
+    resolved
+  })
+
+module type T = {
+  module Spec: Reventless.InboundTranslationSlice.Spec
+  module Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+
+  let make: (
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/InboundTranslationSlice/InboundTranslationSlice.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 = "InboundTranslationSlice";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */