@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/CommandTopic/CommandTopic_Helpers.res.mjs

@@ -0,0 +1,195 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+
+let acceptedResultChannel = {
+  contents: undefined
+};
+
+let rejectedResultChannel = {
+  contents: undefined
+};
+
+function reportAccepted(reference, result) {
+  Stdlib_Option.forEach(acceptedResultChannel.contents, cb => cb(reference, result));
+}
+
+function reportRejected(reference, result) {
+  Stdlib_Option.forEach(rejectedResultChannel.contents, cb => cb(reference, result));
+}
+
+function commandOutcomeToJson(outcome) {
+  switch (outcome.TAG) {
+    case "Accepted" :
+      return Object.fromEntries([
+        [
+          "__typename",
+          "CommandAccepted"
+        ],
+        [
+          "msgId",
+          outcome.msgId
+        ],
+        [
+          "entityId",
+          Stdlib_Option.getOr(Stdlib_Option.map(outcome.entityId, id => (id)), null)
+        ],
+        [
+          "eventCount",
+          outcome.eventCount
+        ]
+      ]);
+    case "Rejected" :
+      return Object.fromEntries([
+        [
+          "__typename",
+          "CommandRejected"
+        ],
+        [
+          "msgId",
+          outcome.msgId
+        ],
+        [
+          "errorCode",
+          outcome.errorCode
+        ],
+        [
+          "errorDetail",
+          Stdlib_Option.getOr(Stdlib_Option.map(outcome.errorDetail, s => (s)), null)
+        ]
+      ]);
+    case "Pending" :
+      return Object.fromEntries([
+        [
+          "__typename",
+          "CommandPending"
+        ],
+        [
+          "msgId",
+          outcome.msgId
+        ]
+      ]);
+  }
+}
+
+function encodeCommandJson(cmdJson) {
+  return Object.fromEntries([
+    [
+      "id",
+      cmdJson.id
+    ],
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(cmdJson.meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "command",
+      cmdJson.commandJson
+    ]
+  ]);
+}
+
+async function runInlineAndCollect(jsons, handleCmds) {
+  let items = jsons.map(cmdJson => {
+    let reference = cmdJson.meta.msgId;
+    return {
+      command: encodeCommandJson(cmdJson),
+      reference: reference
+    };
+  });
+  let acceptedResults = {};
+  let rejectedResults = {};
+  acceptedResultChannel.contents = (reference, result) => {
+    acceptedResults[reference] = result;
+  };
+  rejectedResultChannel.contents = (reference, result) => {
+    rejectedResults[reference] = result;
+  };
+  let results = await Effect.runPromise(handleCmds(Stream.fromIterable(items)));
+  acceptedResultChannel.contents = undefined;
+  rejectedResultChannel.contents = undefined;
+  return jsons.map((cmdJson, i) => {
+    let msgId = cmdJson.meta.msgId;
+    let match = rejectedResults[msgId];
+    if (match !== undefined) {
+      let errorDetail = match.errorDetail;
+      let detail = errorDetail === "" ? undefined : errorDetail;
+      return {
+        TAG: "Rejected",
+        msgId: msgId,
+        errorCode: match.errorCode,
+        errorDetail: detail
+      };
+    }
+    let match$1 = results[i];
+    if (match$1 !== undefined && match$1.TAG !== "Ok") {
+      return {
+        TAG: "Rejected",
+        msgId: msgId,
+        errorCode: "Conflict",
+        errorDetail: match$1._0
+      };
+    }
+    let ar = Stdlib_Option.getOr(acceptedResults[msgId], {
+      eventCount: 0
+    });
+    let entityId = ar.entityId;
+    if (entityId !== undefined) {
+      return {
+        TAG: "Accepted",
+        msgId: msgId,
+        entityId: entityId,
+        eventCount: ar.eventCount
+      };
+    } else {
+      return {
+        TAG: "Accepted",
+        msgId: msgId,
+        eventCount: ar.eventCount
+      };
+    }
+  });
+}
+
+function callHandlerWithArray(handler, items) {
+  return Effect.runPromise(handler(Stream.fromIterable(items)));
+}
+
+let extractTypeNamesFromSchema = DcbTag$Reventless.extractAllVariantNames;
+
+let globalRegistry = {};
+
+function registerHandler(schema, handler, typeNames) {
+  typeNames.forEach(typeName => {
+    let existing = Stdlib_Option.getOr(globalRegistry[typeName], []);
+    globalRegistry[typeName] = existing.concat([{
+        schema: schema,
+        handler: handler
+      }]);
+  });
+}
+
+function getHandlers(typeName) {
+  return Stdlib_Option.getOr(globalRegistry[typeName], []);
+}
+
+export {
+  acceptedResultChannel,
+  rejectedResultChannel,
+  reportAccepted,
+  reportRejected,
+  commandOutcomeToJson,
+  encodeCommandJson,
+  runInlineAndCollect,
+  callHandlerWithArray,
+  extractTypeNamesFromSchema,
+  globalRegistry,
+  registerHandler,
+  getHandlers,
+}
+/* S Not a pure module */

package/src/components/CommandTopic/CommandTopic_Operations.res

@@ -0,0 +1,40 @@
+module type Ops = {
+  let publishJsons: CommandTopic.publishJsons
+}
+
+module Make = (Spec: ReventlessInfra.CommandTopic.T, Ops: Ops) => {
+  let comp = `CommandTopic(${Spec.name})`
+
+  let publishJsons = async cmdJsons => {
+    let count = cmdJsons->Array.length->Int.toString
+    cmdJsons->Array.forEachWithIndex((cmdJson, idx) => {
+      let idxStr = (idx + 1)->Int.toString
+      EffectLogger.logInfo(
+        ~comp,
+        ~detail=cmdJson.Message.commandJson,
+        `publishing command ${idxStr}/${count}: ${LogFormat.cmdDetailNoId(cmdJson)}`,
+      )->Effect.runSync
+    })
+    try {await Ops.publishJsons(cmdJsons)} catch {
+    | exn =>
+      cmdJsons->Array.forEachWithIndex((cmdJson, idx) => {
+        let idxStr = (idx + 1)->Int.toString
+        EffectLogger.logError(
+          ~comp,
+          ~detail=cmdJson.Message.commandJson,
+          `publish failed ${idxStr}/${count}: ${LogFormat.cmdDetailNoId(cmdJson)}`,
+        )->Effect.runSync
+      })
+      throw(exn)
+    }
+  }
+
+  let publish = (command': Message.command'<Spec.Id.t, Spec.command>) => {
+    let commandJson = {
+      Message.id: command'.id->Spec.Id.toString,
+      meta: command'.meta,
+      commandJson: command'.command->Message.encode(Spec.commandSchema),
+    }
+    Ops.publishJsons([commandJson])
+  }
+}

package/src/components/CommandTopic/CommandTopic_Operations.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function Make(Spec) {
+  return Ops => {
+    let comp = `CommandTopic(` + Spec.name + `)`;
+    let publishJsons = async cmdJsons => {
+      let count = cmdJsons.length.toString();
+      cmdJsons.forEach((cmdJson, idx) => {
+        let idxStr = (idx + 1 | 0).toString();
+        Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, cmdJson.commandJson, `publishing command ` + idxStr + `/` + count + `: ` + LogFormat$ReventlessCore.cmdDetailNoId(cmdJson)));
+      });
+      try {
+        return await Ops.publishJsons(cmdJsons);
+      } catch (exn) {
+        cmdJsons.forEach((cmdJson, idx) => {
+          let idxStr = (idx + 1 | 0).toString();
+          Effect.runSync(EffectLogger$ReventlessCore.logError(comp, cmdJson.commandJson, `publish failed ` + idxStr + `/` + count + `: ` + LogFormat$ReventlessCore.cmdDetailNoId(cmdJson)));
+        });
+        throw exn;
+      }
+    };
+    let publish = command$p => {
+      let commandJson_id = Spec.Id.toString(command$p.id);
+      let commandJson_meta = command$p.meta;
+      let commandJson_commandJson = Message$ReventlessCore.encode(command$p.command, Spec.commandSchema);
+      let commandJson = {
+        id: commandJson_id,
+        meta: commandJson_meta,
+        commandJson: commandJson_commandJson
+      };
+      return Ops.publishJsons([commandJson]);
+    };
+    return {
+      comp: comp,
+      publishJsons: publishJsons,
+      publish: publish
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/components/Component.res

@@ -0,0 +1 @@
+include ReventlessInfra.Component

package/src/components/Component.res.mjs

@@ -0,0 +1,34 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Component.res.mjs";
+
+let registerOutputs = Component$ReventlessInfra.registerOutputs;
+
+let setOutputs = Component$ReventlessInfra.setOutputs;
+
+let outputs = Component$ReventlessInfra.outputs;
+
+let wrappedOutputs = Component$ReventlessInfra.wrappedOutputs;
+
+let setOperations = Component$ReventlessInfra.setOperations;
+
+let operations = Component$ReventlessInfra.operations;
+
+let toPulumiResource = Component$ReventlessInfra.toPulumiResource;
+
+let fromPulumiResource = Component$ReventlessInfra.fromPulumiResource;
+
+let make = Component$ReventlessInfra.make;
+
+export {
+  registerOutputs,
+  setOutputs,
+  outputs,
+  wrappedOutputs,
+  setOperations,
+  operations,
+  toPulumiResource,
+  fromPulumiResource,
+  make,
+}
+/* Component-ReventlessInfra Not a pure module */

package/src/components/Component.resi

@@ -0,0 +1 @@
+include module type of ReventlessInfra.Component

package/src/components/Counter/Counter.res

@@ -0,0 +1,47 @@
+let componentType = ComponentType.Counter
+
+type countItem = ReventlessInfra.Counter.countItem
+type counterTargetRef = ReventlessInfra.Counter.counterTargetRef
+
+type count = ReventlessInfra.Counter.count
+type addToCounterTarget = ReventlessInfra.Counter.addToCounterTarget
+
+type jsonEventsHandler = Stream.t<JSON.t, string, unit> => Effect.t<unit, string, unit>
+
+type t
+type outputs = ReventlessInfra.Counter.outputs
+type operations = ReventlessInfra.Counter.operations
+type component = Component.t<t, outputs, operations>
+
+type action =
+  | Count(countItem)
+  | AddToCounterTarget(counterTargetRef)
+
+@schema
+type counterEvent = CountFinished
+
+module Source = {
+  module Id = Reventless.Id.String
+  let name = ComponentType.Counter->ComponentType.toName
+  @schema
+  type event = counterEvent
+}
+
+module type T = ReventlessInfra.Counter.T
+
+let separator = "#"
+let makeId = ((counterId, reference)) => counterId ++ (separator ++ reference)
+let unmakeId = id =>
+  id
+  ->String.split(separator)
+  ->(
+    x =>
+      switch x {
+      | [] => ("", "")
+      | [counterId] => (counterId, "")
+      | parts => (parts->Array.getUnsafe(0), parts->Array.getUnsafe(1))
+      }
+  )
+
+@inline
+let countFieldName = "count"

package/src/components/Counter/Counter.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+
+let counterEventSchema = S.literal("CountFinished");
+
+let name = ComponentType$ReventlessCore.toName("Counter");
+
+let Source = {
+  Id: undefined,
+  name: name,
+  eventSchema: counterEventSchema
+};
+
+let separator = "#";
+
+function makeId(param) {
+  return param[0] + (separator + param[1]);
+}
+
+function unmakeId(id) {
+  let x = id.split(separator);
+  let len = x.length;
+  if (len !== 1) {
+    if (len !== 0) {
+      return [
+        x[0],
+        x[1]
+      ];
+    } else {
+      return [
+        "",
+        ""
+      ];
+    }
+  }
+  let counterId = x[0];
+  return [
+    counterId,
+    ""
+  ];
+}
+
+let componentType = "Counter";
+
+export {
+  componentType,
+  counterEventSchema,
+  Source,
+  separator,
+  makeId,
+  unmakeId,
+}
+/* counterEventSchema Not a pure module */

package/src/components/Counter/Counter_Adapter.res

@@ -0,0 +1,18 @@
+type handler = {addToCounterTarget: Counter.addToCounterTarget}
+
+type handlerMaker = (
+  ~name: string,
+  ~referencesName: string,
+  ~referencesDb: QueryDb.outputs,
+  ~countsName: string,
+  ~countsDb: QueryDb.outputs,
+  ~counterHandler: Counter_Callback.counterHandler,
+  ~specModulePath: string,
+  ~mappingsModulePath: string,
+  ~publishChannelId: Pulumi.Output.t<string>,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => handler
+
+module type Handler = {
+  let make: handlerMaker
+}

package/src/components/Counter/Counter_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/Counter/Counter_Builder.res

@@ -0,0 +1,142 @@
+module Make = (
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  Api: {
+    let api: unit => QueryDbStorage.api
+    let apiRole: unit => QueryDbStorage.role
+  },
+  Handler: Counter_Adapter.Handler,
+): Counter.T => {
+  type component = Counter.component
+
+  let construct = (
+    ~jsonEventsHandler: Counter.jsonEventsHandler,
+    ~ttl: option<int>,
+    ~specModulePath,
+    ~mappingsModulePath,
+    ~publishChannelId,
+    self,
+    name,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let opts2 = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    module ReferencesSpec = {
+      module Id = Reventless.Id.StringPure
+      let name = name ++ "References"
+      let moduleUrl: string = %raw(`import.meta.url`)
+      @schema
+      type state = Counter_Operations.referencesState
+
+      let subIdConfig = None
+      let config = Reventless.ReadModel.config()
+      let authorization: Reventless.Authorization.permission = AllowAuthenticated
+      let visibility: Reventless.Visibility.t = Public
+    }
+
+    module ReferencesDb = QueryDb_Builder.Make(
+      ReferencesSpec,
+      QueryDbStorage,
+      QueryDb_Adapter.NoResolvers(QueryDbStorage),
+    )
+
+    module CountsSpec = {
+      module Id = Reventless.Id.StringPure
+      let name = name ++ "Counts"
+      let moduleUrl: string = %raw(`import.meta.url`)
+      @schema
+      type state = Counter_Callback.countsState
+
+      let subIdConfig = None
+      let config = Reventless.ReadModel.config()
+      let authorization: Reventless.Authorization.permission = AllowAuthenticated
+      let visibility: Reventless.Visibility.t = Public
+    }
+    module CountsDb = QueryDb_Builder.Make(
+      CountsSpec,
+      QueryDbStorage,
+      QueryDb_Adapter.NoResolvers(QueryDbStorage),
+    )
+
+    let referencesDb = ReferencesDb.make(
+      ~api=Api.api(),
+      ~apiRole=Api.apiRole(),
+      ~ttl?,
+      ~opts,
+    )
+    let countsDb = CountsDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~ttl?, ~opts)
+
+    let handler =
+      countsDb
+      ->Component.operations
+      ->Pulumi.Output.apply(({count}) => {
+        module Callback = Counter_Callback.Make({
+          let name = name
+          let countsDbCount = count
+          let jsonEventsHandler = jsonEventsHandler
+        })
+
+        Handler.make(
+          ~name,
+          ~referencesName=ReferencesSpec.name,
+          ~referencesDb=referencesDb->Component.outputs,
+          ~countsName=CountsSpec.name,
+          ~countsDb=countsDb->Component.outputs,
+          ~counterHandler=Callback.counterHandler,
+          ~specModulePath,
+          ~mappingsModulePath,
+          ~publishChannelId,
+          ~opts=opts2,
+        )
+      })
+
+    self->Component.setOperations(
+      (referencesDb->Component.operations, handler)
+      ->Pulumi.Output.all2
+      ->Pulumi.Output.apply((({saveBatch}, handler)) => {
+        module Operations = Counter_Operations.Make({
+          let ttl = ttl
+          let saveBatch = saveBatch
+        })
+        let ops: Counter.operations = {
+          count: Operations.count,
+          addToCounterTarget: handler.addToCounterTarget,
+        }
+        ops
+      }),
+    )
+
+    let outputs: Counter.outputs = {
+      referencesDb: referencesDb->Component.outputs,
+      countsDb: countsDb->Component.outputs,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let oneWeek = 60 * 60 * 24 * 7 //604800 sec
+
+  let make = (
+    ~name,
+    ~jsonEventsHandler,
+    ~ttl=oneWeek,
+    ~specModulePath="",
+    ~mappingsModulePath="",
+    ~publishChannelId=Pulumi.Output.make(""),
+    ~opts=?,
+  ) =>
+    Component.make(
+      ~componentType=Counter.componentType->ComponentType.toString,
+      ~name=name->ComponentType.name(Counter.componentType),
+      ~construct=construct(
+        ~jsonEventsHandler,
+        ~ttl=Some(ttl),
+        ~specModulePath,
+        ~mappingsModulePath,
+        ~publishChannelId,
+        ...
+      ),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+  let operations = Component.operations
+}