@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -0,0 +1,58 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+
+let statusSchema = S.union([
+  S.literal("Connected"),
+  S.literal("Disconnected"),
+  S.literal("Inactive"),
+  S.literal("Retired")
+]);
+
+let stateSchema = S.schema(s => ({
+  name: s.m(Plugin$Reventless.nameSchema),
+  version: s.m(Plugin$Reventless.versionSchema),
+  eventCollector: s.m(S.string),
+  extensionPoints: s.m(S.array(Plugin$Reventless.extensionPointDefinitionSchema)),
+  extensionPointNames: s.m(S.array(S.string)),
+  extensionNames: s.m(S.array(S.string)),
+  extensions: s.m(S.array(Plugin$Reventless.extensionDefinitionSchema)),
+  status: s.m(statusSchema),
+  statusChange: s.m(Message$ReventlessCore.statusChangeSchema),
+  apiSchemaFragment: s.m(Plugin$Reventless.apiSchemaFragmentOptionSchema),
+  apiTarget: s.m(S.option(S.string)),
+  uiFragments: s.m(Plugin$Reventless.uiFragmentManifestOptionSchema),
+  structure: s.m(Plugin$Reventless.pluginStructureOptionSchema),
+  dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
+  otherConnectedVersions: s.m(S.array(Plugin$Reventless.versionSchema))
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "Plugins";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  statusSchema,
+  stateSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* statusSchema Not a pure module */

package/src/util/AWS.res

@@ -0,0 +1,7 @@
+let invalidNameChars = /[^.\-_a-zA-Z0-9]/g
+
+let validateName = String.replaceRegExp(_, invalidNameChars, "_")
+
+// Example ARN: arn:aws:sqs:eu-west-1:xxxxxx:MarketplaceServiceExtensionPointCommandTopic-0101023
+let arn2Name: string => string = arn =>
+  arn->String.split(":")->Array.get(5)->Option.getOr("unknown")

package/src/util/AWS.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let invalidNameChars = /[^.\-_a-zA-Z0-9]/g;
+
+function validateName(__x) {
+  return __x.replace(invalidNameChars, "_");
+}
+
+function arn2Name(arn) {
+  return Stdlib_Option.getOr(arn.split(":")[5], "unknown");
+}
+
+export {
+  invalidNameChars,
+  validateName,
+  arn2Name,
+}
+/* No side effect */

package/src/util/CSV.res

@@ -0,0 +1,27 @@
+/** FastCSV bindings with added helper functions to handle Validation.t as well */
+include FastCSV
+include FastCSV_Helpers
+
+/** Add correct callback for validation to Validation.t - to be used in validation function
+   TODO: hide behind an interface definition
+ */
+let fromValidation: (Validation.t<unit, string>, callback) => calledBack = (validation, cb) =>
+  switch validation {
+  | Failure(msg) => cb->toInvalid(msg)
+  | Failures(msgs) => cb->toInvalid(msgs->Array.joinUnsafe(", "))
+  | Success(_)
+  | Successes(_) =>
+    cb->toValid
+  }
+
+/** Register a single validation function based on Validation.t
+   example:
+   {[
+     parseFile(~path=\"x\",())
+     -> validateValidation(_row => Validation.Failure(\"Some reason for invalidation\"))
+   ]}
+ */
+let validateValidation: (row => Validation.t<unit, string>, csvParserStream) => csvParserStream = (
+  validation,
+  parser,
+) => parser->validate((row, cb) => row->validation->fromValidation(cb))

package/src/util/CSV.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FastCSV from "@reventlessdev/rescript-fast-csv/src/FastCSV.res.mjs";
+import * as FastCSV_Helpers from "@reventlessdev/rescript-fast-csv/src/FastCSV_Helpers.res.mjs";
+
+function fromValidation(validation, cb) {
+  switch (validation.TAG) {
+    case "Success" :
+    case "Successes" :
+      return FastCSV_Helpers.toValid(cb);
+    case "Failure" :
+      return FastCSV_Helpers.toInvalid(cb, validation._0);
+    case "Failures" :
+      return FastCSV_Helpers.toInvalid(cb, validation._0.join(", "));
+  }
+}
+
+function validateValidation(validation, parser) {
+  return parser.validate((row, cb) => fromValidation(validation(row), cb));
+}
+
+let Options = FastCSV.Options;
+
+let toInvalid = FastCSV_Helpers.toInvalid;
+
+let toValid = FastCSV_Helpers.toValid;
+
+let toError = FastCSV_Helpers.toError;
+
+let toValidTransformation = FastCSV_Helpers.toValidTransformation;
+
+let toErrorTransformation = FastCSV_Helpers.toErrorTransformation;
+
+let fromImporterValidation = FastCSV_Helpers.fromImporterValidation;
+
+let validateMultiple = FastCSV_Helpers.validateMultiple;
+
+let validateResult = FastCSV_Helpers.validateResult;
+
+let validateMultipleResults = FastCSV_Helpers.validateMultipleResults;
+
+export {
+  Options,
+  toInvalid,
+  toValid,
+  toError,
+  toValidTransformation,
+  toErrorTransformation,
+  fromImporterValidation,
+  validateMultiple,
+  validateResult,
+  validateMultipleResults,
+  fromValidation,
+  validateValidation,
+}
+/* No side effect */

package/src/util/CommandPublisher.res

@@ -0,0 +1,133 @@
+module type Spec = {
+  @schema
+  let name: string
+  @schema
+  type command
+}
+
+type mode = SendChunks(int) | SendAllInOneChunk
+
+module type Config = {
+  let user: string
+  let publishCommands: Task.publishCommands
+  let mode: mode
+}
+
+module Make = (Spec: Spec, Config: Config) => {
+  let buffer = []
+  let running = ref(None)
+  let flush = ref(false)
+  let chunkCount = ref(0)
+
+  let finishRunning = async () =>
+    switch running.contents {
+    | None => ()
+    | Some(promise) =>
+      try await promise catch {
+      | JsExn(e) =>
+        let errMsg = e->JsExn.message->Option.getOr("unknown")
+        EffectLogger.logError(~comp="CommandPublisher", `Couldn't publish commands: ${errMsg}`)->Effect.runSync
+      }
+    }
+
+  let toJsons = commandsToSend => {
+    EffectLogger.logDebug(
+      ~comp="CommandPublisher",
+      `toJsons: commandsToSend: ${commandsToSend->Array.length->Int.toString} rest: ${buffer
+        ->Array.length
+        ->Int.toString}`,
+    )->Effect.runSync
+    commandsToSend->Array.map(((id, command)) => {
+      let commandJson = command->Message.encode(Spec.commandSchema)
+      {
+        Reventless.Message.id,
+        meta: Message.generateMeta(~service=Spec.name, ~user=Config.user),
+        commandJson,
+      }
+    })
+  }
+
+  // Sends buffered commands. The underlying publishCommands (SQS) already retries
+  // transient failures — no retry at this layer.
+  let rec send = async () => {
+    await finishRunning()
+    switch Config.mode {
+    | SendChunks(chunkSize) =>
+      let size = Math.Int.min(chunkSize, buffer->Array.length)
+      if size >= chunkSize || (size > 0 && flush.contents) {
+        chunkCount := chunkCount.contents + 1
+        let sizeStr = size->Int.toString
+        let bufferSizeStr = buffer->Array.length->Int.toString
+        let chunkCountStr = chunkCount.contents->Int.toString
+        EffectLogger.logDebug(
+          ~comp="CommandPublisher",
+          `send: bufferSize: ${bufferSizeStr}, chunk: ${chunkCountStr}, size: ${sizeStr}`,
+        )->Effect.runSync
+        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
+        running := Some(promise)
+        switch await promise {
+        | () => EffectLogger.logDebug(~comp="CommandPublisher", `send: finished chunk ${chunkCountStr}: ${sizeStr}`)->Effect.runSync
+        | exception JsExn(e) =>
+          let errorMessage = e->JsExn.message->Option.getOr("unknown Error")
+          EffectLogger.logError(
+            ~comp="CommandPublisher",
+            `send error: couldn't publish chunk ${chunkCountStr} (${sizeStr} commands): ${errorMessage}`,
+          )->Effect.runSync
+        }
+        await send()
+      } else {
+        running := None
+      }
+    | SendAllInOneChunk =>
+      let size = buffer->Array.length
+      if size > 0 {
+        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
+        running := Some(promise)
+        switch await promise {
+        | () =>
+          EffectLogger.logDebug(
+            ~comp="CommandPublisher",
+            `send: finished SendAllInOneChunk: ${size->Int.toString}`,
+          )->Effect.runSync
+        | exception JsExn(e) =>
+          let errMsg = e->JsExn.message->Option.getOr("unknown")
+          EffectLogger.logError(
+            ~comp="CommandPublisher",
+            `send error: couldn't publish ${size->Int.toString} commands: ${errMsg}`,
+          )->Effect.runSync
+        }
+        running := None
+      }
+    }
+  }
+
+  let publish = (id: string, command: Spec.command) => {
+    let _ = buffer->Array.push((id, command))
+    switch (running.contents, Config.mode) {
+    | (None, SendChunks(chunkSize)) if buffer->Array.length >= chunkSize =>
+      running := Some(Promise.resolve())
+      let _ = send()
+    | _ => ()
+    }
+  }
+
+  let clear = () => {
+    EffectLogger.logDebug(~comp="CommandPublisher", "clear")->Effect.runSync
+    let _ = buffer->Array.removeInPlace(0)
+    flush := false
+  }
+
+  let flush = async () => {
+    EffectLogger.logDebug(~comp="CommandPublisher", "flush")->Effect.runSync
+    flush := true
+    switch running.contents {
+    | None => await send()
+    | _ =>
+      while running.contents->Option.isNone {
+        await finishRunning()
+      }
+    }
+  }
+}

package/src/util/CommandPublisher.res.mjs

@@ -0,0 +1,161 @@
+// 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function Make(Spec) {
+  return Config => {
+    let buffer = [];
+    let running = {
+      contents: undefined
+    };
+    let flush = {
+      contents: false
+    };
+    let chunkCount = {
+      contents: 0
+    };
+    let finishRunning = async () => {
+      let promise = running.contents;
+      if (promise === undefined) {
+        return;
+      }
+      try {
+        return await promise;
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        if (e.RE_EXN_ID === "JsExn") {
+          let errMsg = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "unknown");
+          return Effect.runSync(EffectLogger$ReventlessCore.logError("CommandPublisher", undefined, `Couldn't publish commands: ` + errMsg));
+        }
+        throw e;
+      }
+    };
+    let toJsons = commandsToSend => {
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `toJsons: commandsToSend: ` + commandsToSend.length.toString() + ` rest: ` + buffer.length.toString()));
+      return commandsToSend.map(param => {
+        let commandJson = Message$ReventlessCore.encode(param[1], Spec.commandSchema);
+        return {
+          id: param[0],
+          meta: Message$ReventlessCore.generateMeta(Spec.name, undefined, Config.user, undefined, undefined, undefined, undefined, undefined),
+          commandJson: commandJson
+        };
+      });
+    };
+    let send = async () => {
+      await finishRunning();
+      let chunkSize = Config.mode;
+      if (typeof chunkSize !== "object") {
+        let size = buffer.length;
+        if (size <= 0) {
+          return;
+        }
+        let commandsToSend = buffer.toSpliced(0, size);
+        let promise = Config.publishCommands(Spec.name, toJsons(commandsToSend));
+        running.contents = promise;
+        let exit = 0;
+        let val;
+        try {
+          val = await promise;
+          exit = 1;
+        } catch (raw_e) {
+          let e = Primitive_exceptions.internalToException(raw_e);
+          if (e.RE_EXN_ID === "JsExn") {
+            let errMsg = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "unknown");
+            Effect.runSync(EffectLogger$ReventlessCore.logError("CommandPublisher", undefined, `send error: couldn't publish ` + size.toString() + ` commands: ` + errMsg));
+          } else {
+            throw e;
+          }
+        }
+        if (exit === 1) {
+          Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `send: finished SendAllInOneChunk: ` + size.toString()));
+        }
+        running.contents = undefined;
+        return;
+      }
+      let chunkSize$1 = chunkSize._0;
+      let size$1 = Math.min(chunkSize$1, buffer.length);
+      if (!(size$1 >= chunkSize$1 || size$1 > 0 && flush.contents)) {
+        running.contents = undefined;
+        return;
+      }
+      chunkCount.contents = chunkCount.contents + 1 | 0;
+      let sizeStr = size$1.toString();
+      let bufferSizeStr = buffer.length.toString();
+      let chunkCountStr = chunkCount.contents.toString();
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `send: bufferSize: ` + bufferSizeStr + `, chunk: ` + chunkCountStr + `, size: ` + sizeStr));
+      let commandsToSend$1 = buffer.toSpliced(0, size$1);
+      let promise$1 = Config.publishCommands(Spec.name, toJsons(commandsToSend$1));
+      running.contents = promise$1;
+      let exit$1 = 0;
+      let val$1;
+      try {
+        val$1 = await promise$1;
+        exit$1 = 1;
+      } catch (raw_e$1) {
+        let e$1 = Primitive_exceptions.internalToException(raw_e$1);
+        if (e$1.RE_EXN_ID === "JsExn") {
+          let errorMessage = Stdlib_Option.getOr(Stdlib_JsExn.message(e$1._1), "unknown Error");
+          Effect.runSync(EffectLogger$ReventlessCore.logError("CommandPublisher", undefined, `send error: couldn't publish chunk ` + chunkCountStr + ` (` + sizeStr + ` commands): ` + errorMessage));
+        } else {
+          throw e$1;
+        }
+      }
+      if (exit$1 === 1) {
+        Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `send: finished chunk ` + chunkCountStr + `: ` + sizeStr));
+      }
+      return await send();
+    };
+    let publish = (id, command) => {
+      buffer.push([
+        id,
+        command
+      ]);
+      let match = running.contents;
+      let match$1 = Config.mode;
+      if (match !== undefined || typeof match$1 !== "object" || buffer.length < match$1._0) {
+        return;
+      } else {
+        running.contents = Promise.resolve();
+        send();
+        return;
+      }
+    };
+    let clear = () => {
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "clear"));
+      buffer.splice(0, 1);
+      flush.contents = false;
+    };
+    let flush$1 = async () => {
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "flush"));
+      flush.contents = true;
+      let match = running.contents;
+      if (match === undefined) {
+        return await send();
+      }
+      while (Stdlib_Option.isNone(running.contents)) {
+        await finishRunning();
+      };
+    };
+    return {
+      buffer: buffer,
+      running: running,
+      chunkCount: chunkCount,
+      finishRunning: finishRunning,
+      toJsons: toJsons,
+      send: send,
+      publish: publish,
+      clear: clear,
+      flush: flush$1
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/util/CsvStream.res

@@ -0,0 +1,39 @@
+// CsvStream.res
+// Bridges FastCSV's callback-based API to an Effect Stream.
+// Rows are emitted as CSV.row (= dict<string>) using the header row as keys.
+//
+// Implementation: each onData callback offers its row into an unbounded Queue;
+// Stream.fromQueue drains the queue lazily. This lets callers start processing
+// rows as they arrive rather than waiting for the entire file to be loaded.
+//
+// Note: Stream.take(n) short-circuits queue consumption, but the underlying
+// CSV parser runs at full speed and continues reading in the background.
+// Effect.runSyncExit is used inside the onData/onEnd/onError callbacks so that
+// a shut-down queue (e.g. after stream interruption) never throws.
+
+// Parse a CSV file, emitting one row per stream item.
+// The first row is treated as column headers (not emitted as data).
+// CSV parse errors are propagated through the stream's error channel.
+let parseRows = (~path: string): Stream.t<CSV.row, string, unit> =>
+  Queue.unbounded()
+  ->Effect.flatMap(queue => {
+    let _ = CSV.parseFile(~path, ~options={headers: CSV.Options.Bool(true)})
+      ->CSV.onData(row => Queue.offer(queue, Ok(row))->Effect.runSyncExit->ignore)
+      ->CSV.onEnd(_ => Queue.shutdown(queue)->Effect.runSyncExit->ignore)
+      ->CSV.onError(err => {
+        let msg = err->JsExn.message->Option.getOr("CSV parse error")
+        Queue.offer(queue, Error(msg))->Effect.runSyncExit->ignore
+        Queue.shutdown(queue)->Effect.runSyncExit->ignore
+      })
+    Effect.succeed(queue)
+  })
+  ->Stream.fromEffect
+  ->Stream.flatMap(queue =>
+    Stream.fromQueue(queue)
+    ->Stream.mapEffect(item =>
+      switch item {
+      | Ok(row) => Effect.succeed(row)
+      | Error(msg) => Effect.fail(msg)
+      }
+    )
+  )

package/src/util/CsvStream.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FastCsv from "fast-csv";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Queue from "effect/Queue";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+function parseRows(path) {
+  return Stream.flatMap(Stream.fromEffect(Effect.flatMap(Queue.unbounded(), queue => {
+    FastCsv.parseFile(path, {
+      headers: true
+    }).on("data", row => {
+      Effect.runSyncExit(Queue.offer(queue, {
+        TAG: "Ok",
+        _0: row
+      }));
+    }).on("end", param => {
+      Effect.runSyncExit(Queue.shutdown(queue));
+    }).on("error", err => {
+      let msg = Stdlib_Option.getOr(Stdlib_JsExn.message(err), "CSV parse error");
+      Effect.runSyncExit(Queue.offer(queue, {
+        TAG: "Error",
+        _0: msg
+      }));
+      Effect.runSyncExit(Queue.shutdown(queue));
+    });
+    return Effect.succeed(queue);
+  })), queue => Stream.mapEffect(Stream.fromQueue(queue), item => {
+    if (item.TAG === "Ok") {
+      return Effect.succeed(item._0);
+    } else {
+      return Effect.fail(item._0);
+    }
+  }));
+}
+
+export {
+  parseRows,
+}
+/* fast-csv Not a pure module */