@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/components/DataCleaner.res

@@ -0,0 +1,170 @@
+/* let mode = #production // opposed to `debug
+open PulumiAws.Lambda
+open ReventlessInfra.Adapter
+
+type tableConfig = {name: string, id: string, sort: option<string>}
+type event = {tables: nullable<array<tableConfig>>}
+
+let promiseToResult: promise<'a> => promise<result<'a, 'b>> = async p =>
+  switch await p {
+  | res => Ok(res)
+  | exception err => Error(err)
+  }
+
+let handleDeleteResult = result => {
+  if mode == #debug {
+    Console.log("Handle delete result")
+  }
+  // Belt.Result removed — Ok/Error are global in RescriptCore
+  switch result {
+  | Error(err) =>
+    Console.log2("Couldn't delete item:", err)
+    Error("Couldn't delete item.")
+  | Ok(_x) => Ok()
+  }
+}
+
+let deleteAllItems = async (items: array<dict<string>>, tableConfig: tableConfig): unit =>
+  switch await items
+  ->Array.map(async (item: dict<string>) => {
+    let id = item->Dict.get(tableConfig.id)
+    let sort = tableConfig.sort->Option.flatMap(sortField => item->Dict.get(sortField))
+    switch (id, sort) {
+    | (Some(id), Some(sort)) =>
+      switch await AwsSdk.DynamoDb.DocumentClient.deleteByIdSort(
+        ~tableName=tableConfig.name,
+        ~id,
+        ~sortField=tableConfig.sort->Option.getExn,
+        ~sortKey=sort,
+      )->promiseToResult {
+      | res => res->handleDeleteResult
+      }
+    | (Some(id), None) =>
+      switch await AwsSdk.DynamoDb.DocumentClient.deleteById(
+        ~tableName=tableConfig.name,
+        ~id,
+      )->promiseToResult {
+      | res => res->handleDeleteResult
+      }
+    //Promise.handlePromise(handeDeleteResult)
+    | _ => Error("No valid Config found!")
+    }
+  })
+  ->Promise.all {
+  | result =>
+    result
+    ->Array.reduce(0, (state, item) =>
+      switch item {
+      | Ok(_) => state + 1
+      | Error(_) => state
+      }
+    )
+    ->Console.log3(
+      "Deleted",
+      _,
+      "of " ++
+      (result->Array.length->Int.toString ++
+      (" items in table " ++ tableConfig.name)),
+    )
+  }
+
+let handleScanResult = async (
+  tableConfig: tableConfig,
+  scanResult: result<AwsSdk.DynamoDb.DocumentClient.QueryCommand.output, 'a>,
+): result<int, 'a> => {
+  if mode == #debug {
+    Console.log("Clean table " ++ tableConfig.name)
+  }
+  switch scanResult {
+  | Ok(scanResult) =>
+    if mode == #debug {
+      Console.log2("Items in scan-result:", scanResult.items->Array.length)
+    }
+    let _ = await scanResult.items->deleteAllItems(tableConfig)
+    Ok(-1)
+  | Error(error) =>
+    if mode == #debug {
+      Console.log2("Couldn't scan table " ++ (tableConfig.name ++ ":"), error)
+    }
+    Error(error)
+  }
+}
+
+let scanTableAndClean = async (tableConfig: tableConfig): promise<
+  result<string, string>,
+> => {
+  if mode == #debug {
+    Console.log("Scan " ++ tableConfig.name)
+  }
+
+  let idKey = tableConfig.id
+  let (projectionExpression, expressionAttributeNames) = switch tableConfig.sort {
+  | Some(sortKey) => (
+      "#" ++ (idKey ++ (",#" ++ sortKey)),
+      [("#" ++ idKey, idKey), ("#" ++ sortKey, sortKey)]->Dict.fromArray,
+    )
+  | None => ("#" ++ idKey, [("#" ++ idKey, idKey)]->Dict.fromArray)
+  }
+
+  switch await AwsSdk.DynamoDb.DocumentClient.scan(
+    ~params=AwsSdk.DynamoDb.DocumentClient.ScanInput.make(
+      ~_TableName=tableConfig.name,
+      ~_ProjectionExpression=projectionExpression,
+      ~_ExpressionAttributeNames=expressionAttributeNames,
+      (),
+    ),
+  )->promiseToResult {
+  | res => {
+      let scanResult = await handleScanResult(tableConfig, res)
+      let deletedItemsCount = switch scanResult {
+      | Ok(deletedItemsCount) =>
+        Ok(tableConfig.name ++ (" [" ++ (Int.toString(deletedItemsCount) ++ "]")))
+      | Error(_err) => Error(tableConfig.name ++ " [ERROR]")
+      }
+      deletedItemsCount->Promise.resolve
+    }
+  }
+}
+
+let toTableConfig: resource => tableConfig = resource => {
+  let name = resource.name->Pulumi.Output.get
+  let (id, sort) = resource->Util_DynamoDb_Runtime.keysFromResource
+
+  {name, id, sort}
+}
+
+let cleanerFn = async (tablesToClean, _event, _context) =>
+  switch tablesToClean->Array.map(toTableConfig) {
+  | tableConfigs if tableConfigs->Array.length == 0 => "No tables to clean."
+  | tableConfigs =>
+    switch await tableConfigs->Array.map(scanTableAndClean)->Promise.all {
+    | results => {
+        let summary = results->Array.reduce(Promise.resolve(""), async (state, result) =>
+          (await state) ++
+          (" | " ++
+          switch await result {
+          | Ok(successMsg) => successMsg
+          | Error(errorMsg) => errorMsg
+          })
+        )
+        "Cleaned tables " ++ (await summary)
+      }
+    }
+  }
+
+let stackName = prefix =>
+  switch prefix {
+  | Some(prefix) => prefix->String.replace("_", "-") ++ "-"
+  | None => ""
+  } ++
+  (Pulumi.Pulumi.getProjectName() ++
+  ("-" ++ Pulumi.Pulumi.getStackName()))
+
+let make = (~prefix: option<string>, ~tablesToClean: array<resource>) => {
+  open CallbackFunction
+  make(
+    ~name="DataCleaner-" ++ stackName(prefix),
+    ~args=Args.make(~callback=cleanerFn(tablesToClean, ...), ~memorySize=1024->Pulumi.Input.make),
+  )
+}
+*/

package/src/components/DataCleaner.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/DcbEventLog_Builder.res

@@ -0,0 +1,8 @@
+// AWS DcbEventLog builder — no longer used directly.
+// The DcbEventLog is created internally by Dcb_Builder via ReventlessCore.DcbEventLog_Builder.
+// This module is retained for potential future use.
+
+include ReventlessCore.DcbEventLog_Builder.Make(
+  DcbEventLogStorage.DynamoDb,
+  EventTopicPublisher.DynamoDbStream,
+)

package/src/components/DcbEventLog_Builder.res.mjs

@@ -0,0 +1,14 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DcbEventLog_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Builder.res.mjs";
+import * as DcbEventLogStorage_DynamoDb$ReventlessAws from "../adapter/DcbEventLog/DcbEventLogStorage_DynamoDb.res.mjs";
+import * as EventTopicPublisher_DynamoDbStream$ReventlessAws from "../adapter/EventTopic/EventTopicPublisher_DynamoDbStream.res.mjs";
+
+let include = DcbEventLog_Builder$ReventlessCore.Make(DcbEventLogStorage_DynamoDb$ReventlessAws)(EventTopicPublisher_DynamoDbStream$ReventlessAws);
+
+let make = include.make;
+
+export {
+  make,
+}
+/* include Not a pure module */

package/src/components/ExtensionPoint_Builder.res

@@ -0,0 +1,16 @@
+module CommandTopicChannel = CommandTopicChannel.SQS_Sync
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+module ExtensionPointRuntimeBuilder = ExtensionPointRuntime_Builder_PerExtensionPoint
+
+module Make = (
+  Spec: ReventlessInfra.ExtensionPointMapping.Spec,
+  Mappings: ReventlessInfra.ExtensionPoint.Mappings with module Spec := Spec,
+): ReventlessInfra.ExtensionPoint.T =>
+  ReventlessCore.ExtensionPoint_Builder.Make(
+    Spec,
+    Mappings,
+    RuntimeEnvironment,
+    CommandTopicChannel,
+    EventTopicPublisher.SNS,
+    ExtensionPointRuntimeBuilder,
+  )

package/src/components/ExtensionPoint_Builder.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as EventTopicPublisher_SNS$ReventlessAws from "../adapter/EventTopic/EventTopicPublisher_SNS.res.mjs";
+import * as ExtensionPoint_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/ExtensionPoint/ExtensionPoint_Builder.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "../adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
+import * as ExtensionPointRuntime_Builder_PerExtensionPoint$ReventlessAws from "../adapter/Runtime/ExtensionPointRuntime_Builder_PerExtensionPoint.res.mjs";
+
+function Make(Spec) {
+  return Mappings => ExtensionPoint_Builder$ReventlessCore.Make(Spec)(Mappings)({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: CommandTopicChannel_SQS_Sync$ReventlessAws.make
+  })({
+    make: EventTopicPublisher_SNS$ReventlessAws.make
+  })({
+    forCommandTopic: ExtensionPointRuntime_Builder_PerExtensionPoint$ReventlessAws.forCommandTopic
+  });
+}
+
+let CommandTopicChannel;
+
+let RuntimeEnvironment;
+
+let ExtensionPointRuntimeBuilder;
+
+export {
+  CommandTopicChannel,
+  RuntimeEnvironment,
+  ExtensionPointRuntimeBuilder,
+  Make,
+}
+/* EventTopicPublisher_SNS-ReventlessAws Not a pure module */

package/src/components/ForeignReadModel_Builder.res

@@ -0,0 +1,19 @@
+module EventCollectorChannel = EventCollectorChannel.SQS
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+module EventCollectorRuntimeBuilder = ReventlessCore.EventCollectorRuntime_Builder_PerEventCollector.Make(
+  RuntimeEnvironment,
+  EventCollectorChannel,
+)
+
+module Make = (
+  Spec: Reventless.ReadModel.Spec,
+  Mappings: Reventless.Projection.Mappings with module Target := Spec,
+) => ReventlessCore.ReadModel_Builder.Make(
+  Spec,
+  Mappings,
+  RuntimeEnvironment,
+  QueryDbStorage.DynamoDb,
+  QueryDbResolvers.AppSync,
+  EventCollectorChannel,
+  EventCollectorRuntimeBuilder,
+)

package/src/components/ForeignReadModel_Builder.res.mjs

@@ -0,0 +1,48 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ReadModel_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel_Builder.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as EventCollectorChannel_SQS$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_SQS.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as EventCollectorRuntime_Builder_PerEventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/EventCollectorRuntime_Builder_PerEventCollector.res.mjs";
+
+let EventCollectorRuntimeBuilder = EventCollectorRuntime_Builder_PerEventCollector$ReventlessCore.Make({
+  make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+  groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+  extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+  asEventHandler: prim => prim,
+  asEffectHandler: prim => prim
+})({
+  make: EventCollectorChannel_SQS$ReventlessAws.make,
+  connect: EventCollectorChannel_SQS$ReventlessAws.connect
+});
+
+function Make(Spec) {
+  return Mappings => ReadModel_Builder$ReventlessCore.Make(Spec)(Mappings)({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })({
+    make: EventCollectorChannel_SQS$ReventlessAws.make,
+    connect: EventCollectorChannel_SQS$ReventlessAws.connect
+  })(EventCollectorRuntimeBuilder);
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  EventCollectorRuntimeBuilder,
+  Make,
+}
+/* EventCollectorRuntimeBuilder Not a pure module */

package/src/components/InboundTranslationSlice_Builder.res

@@ -0,0 +1,25 @@
+// InboundTranslationSlice_Builder (AWS)
+// Wires AWS adapters and delegates to the core ReventlessCore.InboundTranslationSlice_Builder.
+
+module Make = (Api: {
+  let api: unit => Types.AppSync.api
+  let apiRole: unit => Types.AppSync.role
+}) => {
+  module Inner = ReventlessCore.InboundTranslationSlice_Builder.Make(
+    QueryDbStorage.DynamoDb,
+    QueryDbResolvers.AppSync,
+    Api,
+  )
+
+  module Make = (
+    Spec: Reventless.InboundTranslationSlice.Spec,
+    Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+  ): (ReventlessCore.InboundTranslationSlice.T with module Spec = Spec) => {
+    module InnerMake = Inner.Make(Spec, Translation)
+    module Spec = Spec
+    module Translation = Translation
+    type component = InnerMake.component
+    let queryDbName = InnerMake.queryDbName
+    let make = InnerMake.make
+  }
+}

package/src/components/InboundTranslationSlice_Builder.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as InboundTranslationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res.mjs";
+
+function Make(Api) {
+  let Inner = InboundTranslationSlice_Builder$ReventlessCore.Make({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })(Api);
+  let Make$1 = Spec => (Translation => {
+    let InnerMake = Inner.Make(Spec)(Translation);
+    return {
+      Spec: Spec,
+      Translation: Translation,
+      queryDbName: InnerMake.queryDbName,
+      make: InnerMake.make
+    };
+  });
+  return {
+    Inner: Inner,
+    Make: Make$1
+  };
+}
+
+export {
+  Make,
+}
+/* QueryDbStorage_DynamoDb-ReventlessAws Not a pure module */

package/src/components/OutboundTranslationSlice_Builder.res

@@ -0,0 +1,60 @@
+// OutboundTranslationSlice_Builder (AWS)
+// Wires AWS adapters and delegates to the core ReventlessCore.OutboundTranslationSlice_Builder.
+
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+module EventCollectorRuntimeBuilder = {
+  module Inner = AutomationSliceRuntime_Builder_Single
+  type context = Inner.context
+  type runtimeParts = Inner.runtimeParts
+  module EventCollectorChannel = Inner.EventCollectorChannel
+
+  let forEventCollector = Inner.forEventCollector
+  let finish = Inner.finish
+}
+
+module Make = (Api: {
+  let api: unit => Types.AppSync.api
+  let apiRole: unit => Types.AppSync.role
+}) => {
+  module Inner = ReventlessCore.OutboundTranslationSlice_Builder.Make(
+    RuntimeEnvironment,
+    QueryDbStorage.DynamoDb,
+    QueryDbResolvers.AppSync,
+    EventCollectorChannel,
+    EventCollectorRuntimeBuilder,
+    Api,
+  )
+
+  module Make = (
+    Spec: Reventless.OutboundTranslationSlice.Spec,
+    Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+  ): (ReventlessCore.OutboundTranslationSlice.T with module Spec = Spec) => {
+    module InnerMake = Inner.Make(Spec, Translation)
+
+    module Spec = Spec
+    module Translation = Translation
+    type component = InnerMake.component
+    let queryDbName = InnerMake.queryDbName
+
+    let make = (~dcbEventLog, ~publishJsons, ~opts=?): component => {
+      let ots = InnerMake.make(~dcbEventLog, ~publishJsons, ~opts?)
+
+      let queryDbOutputs = (ots->ReventlessCore.Component.outputs).queryDb
+      let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
+      let queryDbTableName = tableResource.name
+
+      AutomationSliceRuntime_Builder_Single.registerAutomationSlice(
+        ~name=Spec.name,
+        ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
+        ~callbackType="outbound",
+        ~queryDbTableName,
+      )
+
+      ots
+    }
+  }
+
+  let finish = () => EventCollectorRuntimeBuilder.finish()
+}

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as OutboundTranslationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+import * as AutomationSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs";
+
+let EventCollectorRuntimeBuilder = {
+  Inner: undefined,
+  EventCollectorChannel: undefined,
+  forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+  finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+};
+
+function Make(Api) {
+  let Inner = OutboundTranslationSlice_Builder$ReventlessCore.Make({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })({
+    make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+    connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+  })({
+    EventCollectorChannel: {
+      make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+      connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+    },
+    forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+    finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+  })(Api);
+  let Make$1 = Spec => (Translation => {
+    let InnerMake = Inner.Make(Spec)(Translation);
+    let make = (dcbEventLog, publishJsons, opts) => {
+      let ots = InnerMake.make(dcbEventLog, publishJsons, opts);
+      let queryDbOutputs = Component$ReventlessCore.outputs(ots).queryDb;
+      let tableResource = queryDbOutputs.resources[0];
+      let queryDbTableName = tableResource.name;
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), "outbound", queryDbTableName);
+      return ots;
+    };
+    return {
+      Spec: Spec,
+      Translation: Translation,
+      queryDbName: InnerMake.queryDbName,
+      make: make
+    };
+  });
+  let finish = () => AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+  return {
+    Inner: Inner,
+    Make: Make$1,
+    finish: finish
+  };
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  EventCollectorRuntimeBuilder,
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/OutboundTranslationSlice_Builder_Bundled.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as OutboundTranslationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+import * as AutomationSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs";
+
+let EventCollectorRuntimeBuilder = {
+  Inner: undefined,
+  EventCollectorChannel: undefined,
+  forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+  finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+};
+
+function Make(Api) {
+  let Inner = OutboundTranslationSlice_Builder$ReventlessCore.Make({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })({
+    make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+    connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+  })({
+    EventCollectorChannel: {
+      make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+      connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+    },
+    forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+    finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+  })(Api);
+  let Make$1 = Spec => {
+    let InnerMake = Inner.Make(Spec);
+    let make = (dcbEventLog, publishJsons, opts) => {
+      let ots = InnerMake.make(dcbEventLog, publishJsons, opts);
+      let queryDbOutputs = Component$ReventlessCore.outputs(ots).queryDb;
+      let tableResource = queryDbOutputs.resources[0];
+      let queryDbTableName = tableResource.name;
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(InnerMake.Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(InnerMake.Spec.moduleUrl), "outbound", queryDbTableName);
+      return ots;
+    };
+    return {
+      Spec: InnerMake.Spec,
+      queryDbName: InnerMake.queryDbName,
+      make: make
+    };
+  };
+  let finish = () => AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+  return {
+    Inner: Inner,
+    Make: Make$1,
+    finish: finish
+  };
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  EventCollectorRuntimeBuilder,
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/Plugin.res

@@ -0,0 +1,29 @@
+module EventCollectorChannel = EventCollectorChannel.SQS
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+module Make = (HooksConfig: ReventlessCore.Plugin_Helpers.HooksConfig) => {
+  include ReventlessCore.Plugin_Builder.Make(
+    {
+      let runtimeOps = PluginRuntimeOperations.operations
+      let resourceNaming = Util_ResourceNaming.operations
+      let environment = PulumiAws.Lambda.environment->Option.getOr("unknown")
+      let platformName = Pulumi.Pulumi.getProjectName()
+      let hooks = HooksConfig.hooks
+    },
+    {
+      type api = Types.AppSync.api
+      type role = Types.AppSync.role
+    },
+    AppSync_Adapter,
+    RuntimeEnvironment,
+    EventCollectorChannel,
+    QueryEngine.DynamoDb,
+    CommandTopicRemoteChannel.SQS,
+    HeartbeatRunner.CloudwatchEvents,
+    PluginRuntime_Builder.Make(EventCollectorChannel),
+    DcbEventLogStorage.DynamoDb,
+    EventTopicPublisher.DynamoDbStream,
+    CommandTopicChannel.SQS_Sync,
+    CommandTopicChannel.SQS_Async,
+  )
+}