@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/util/FTPHandler.res.mjs

@@ -0,0 +1,136 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SSH2 from "@reventlessdev/rescript-ssh2/src/SSH2.res.mjs";
+import * as Ssh2 from "ssh2";
+import * as Stream from "stream";
+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 FTP$ReventlessCore from "./FTP.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../Message.res.mjs";
+import * as Util_Error$ReventlessCore from "./Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+import * as Util_Promise$ReventlessCore from "./Util_Promise.res.mjs";
+
+function ftp(connectionParams, ftpAction) {
+  let readyTimeout = connectionParams.readyTimeout;
+  let secret = connectionParams.secret;
+  let userName = connectionParams.userName;
+  let path = connectionParams.path;
+  let port = connectionParams.port;
+  let host = connectionParams.host;
+  let match = Util_Promise$ReventlessCore.make();
+  let resolve = match[1];
+  let result = {
+    contents: {
+      TAG: "Error",
+      _0: "Stream ended before action handling!"
+    }
+  };
+  let client = new Ssh2.Client();
+  let tmp;
+  tmp = secret.TAG === "Password" ? ({
+      host: host,
+      port: port,
+      username: userName,
+      password: secret._0,
+      readyTimeout: readyTimeout
+    }) : ({
+      host: host,
+      port: port,
+      username: userName,
+      privateKey: secret._0,
+      passphrase: secret._1,
+      readyTimeout: readyTimeout
+    });
+  SSH2.Client.onReady(client.on("end", () => {
+    Effect.runSync(EffectLogger$ReventlessCore.logInfo("FTPHandler-ReventlessCore", undefined, "Client.onEnd"));
+    resolve(result.contents);
+  }).on("error", err => resolve({
+    TAG: "Error",
+    _0: Stdlib_Option.getOr(Stdlib_JsExn.message(err), "Error contains no message.")
+  })).on("timeout", () => {
+    client.emit("error", Message$ReventlessCore.log(new Error("SSH-Client Error: Connection timed out"), "Client.onTimeout"));
+  }), client => {
+    Util_Promise$ReventlessCore.onEndHandler(async () => {
+      let exit = 0;
+      let sftp;
+      try {
+        sftp = await FTP$ReventlessCore.make(client);
+        exit = 1;
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === FTP$ReventlessCore.CouldNotEstablishSftpConnection) {
+          client.emit("error", Message$ReventlessCore.log(err._1, "Couldn't establish SFTP connection:"));
+          return;
+        }
+        throw err;
+      }
+      if (exit === 1) {
+        let fail = err => {
+          sftp.emit("error", err);
+        };
+        let endFtp = () => {
+          client.end();
+        };
+        sftp.on("end", () => Effect.runSync(EffectLogger$ReventlessCore.logInfo("FTPHandler-ReventlessCore", undefined, "end sftp stream"))).on("error", err => {
+          Effect.runSync(EffectLogger$ReventlessCore.logError("FTPHandler-ReventlessCore", undefined, `Error: ` + Stdlib_Option.getOr(JSON.stringify(err), "unknown")));
+          client.emit("error", err);
+          client.end();
+        });
+        if (ftpAction.TAG === "Download") {
+          let exit$1 = 0;
+          let entities;
+          try {
+            entities = await FTP$ReventlessCore.readdir(sftp, path);
+            exit$1 = 2;
+          } catch (raw_e) {
+            let e = Primitive_exceptions.internalToException(raw_e);
+            if (e.RE_EXN_ID === "JsExn") {
+              result.contents = {
+                TAG: "Error",
+                _0: Util_Error$ReventlessCore.message(undefined, e._1)
+              };
+              return;
+            }
+            throw e;
+          }
+          if (exit$1 === 2) {
+            result.contents = {
+              TAG: "Ok",
+              _0: await ftpAction._0(connectionParams, entities, sftp, fail, endFtp)
+            };
+            return;
+          }
+        } else {
+          let ws = sftp.createWriteStream(Message$ReventlessCore.log(path + ("/" + ftpAction._1), "FTPHandler: path for write stream")).on("finish", () => {
+            result.contents = {
+              TAG: "Ok",
+              _0: true
+            };
+            Effect.runSync(EffectLogger$ReventlessCore.logInfo("FTPHandler-ReventlessCore", undefined, "writable ended"));
+          }).on("close", () => {
+            result.contents = {
+              TAG: "Ok",
+              _0: true
+            };
+            Effect.runSync(EffectLogger$ReventlessCore.logInfo("FTPHandler-ReventlessCore", undefined, "writable closed"));
+            client.end();
+          }).on("error", err => {
+            Effect.runSync(EffectLogger$ReventlessCore.logError("FTPHandler-ReventlessCore", undefined, `Error in Write Stream: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(err), "unknown")));
+            let err$1 = new Error("FTPHandler: Error in Write Stream");
+            sftp.emit("error", err$1);
+          });
+          return await Stream.promises.pipeline(ftpAction._0, ws);
+        }
+      }
+    }, () => {});
+  }).connect(tmp);
+  return match[0];
+}
+
+export {
+  ftp,
+}
+/* ssh2 Not a pure module */

package/src/util/Hash.res

@@ -0,0 +1 @@
+include HashObj

package/src/util/Hash.res.mjs

@@ -0,0 +1,10 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as HashObj from "@reventlessdev/rescript-hash-object/src/HashObj.res.mjs";
+
+let Options = HashObj.Options;
+
+export {
+  Options,
+}
+/* No side effect */

package/src/util/Interstack.res

@@ -0,0 +1,74 @@
+let coreStackReference =
+  Pulumi.Config.make(Some("platform"))
+  ->Pulumi.Config.get("stack")
+  ->Option.map(stack =>
+    Pulumi.StackReference.makeWithName(stack ++ "-interstack", {"name": stack})
+  )
+
+// -----------------------------------------------------------------------
+// Typed, validated cross-stack queries using the reventless-interop engine.
+// Replaces the previous unchecked getOutputs() casts.
+//
+// Return type changed from:
+//   Pulumi.Output.t<array<T.outputs>>          (unchecked cast, silent wrong data)
+// to:
+//   Pulumi.Output.t<array<result<T.resolvedOutputs, ReventlessInterop.Compat.error>>>
+//                                              (validated, explicit error on mismatch)
+// -----------------------------------------------------------------------
+
+module DefaultTaskQuery = ReventlessInterop.Query.Task.Make({
+  type t = ReventlessInterop.Task.resolvedOutputs
+  let requiredFields = ["name"]
+  let optionalFields = ["bucketNames", "sideEffectSources"]
+  let fromJson = (json: JSON.t) =>
+    try Ok(json->S.parseOrThrow(ReventlessInterop.Task.resolvedOutputsSchema))
+    catch {
+    | exn =>
+      let msg =
+        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      Error(msg)
+    }
+})
+
+module DefaultEventMapperQuery = ReventlessInterop.Query.EventMapper.Make({
+  type t = ReventlessInterop.EventMapper.resolvedOutputs
+  let requiredFields = ["name", "eventCollector"]
+  let optionalFields = ["counter"]
+  let fromJson = (json: JSON.t) =>
+    try Ok(json->S.parseOrThrow(ReventlessInterop.EventMapper.resolvedOutputsSchema))
+    catch {
+    | exn =>
+      let msg =
+        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      Error(msg)
+    }
+})
+
+// Typed cross-stack queries.  Each item is either Ok(resolvedOutputs) or
+// Error(Compat.error) describing which field was missing or which decode failed.
+let stackDependenciesTasks = DefaultTaskQuery.queryAll()
+let stackDependenciesEventMappers = DefaultEventMapperQuery.queryAll()
+
+module DefaultExtensionPointQuery = ReventlessInterop.Query.ExtensionPoint.Make({
+  type t = ReventlessInterop.ExtensionPoint.resolvedOutputs
+  let requiredFields = ["name", "commandTopic", "eventTopic"]
+  let optionalFields = []
+  let fromJson = (json: JSON.t) =>
+    try Ok(json->S.parseOrThrow(ReventlessInterop.ExtensionPoint.resolvedOutputsSchema))
+    catch {
+    | exn =>
+      let msg =
+        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      Error(msg)
+    }
+})
+
+// Typed cross-stack queries.  Each item is either Ok(resolvedOutputs) or
+// Error(Compat.error) describing which field was missing or which decode failed.
+let stackDependenciesExtensionPoints = DefaultExtensionPointQuery.queryAll()
+
+// Merge local items with successfully queried remote items.
+// Remote errors are silently dropped; inspect queryAll() directly if you need them.
+let mergeTasks = DefaultTaskQuery.mergeWith
+let mergeEventMappers = DefaultEventMapperQuery.mergeWith
+let mergeExtensionPoints = DefaultExtensionPointQuery.mergeWith

package/src/util/Interstack.res.mjs

@@ -0,0 +1,126 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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 Pulumi from "@pulumi/pulumi";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Task$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/Task.res.mjs";
+import * as Query$ReventlessInterop from "@reventlessdev/reventless-interop/src/Query.res.mjs";
+import * as EventMapper$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/EventMapper.res.mjs";
+import * as ExtensionPoint$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ExtensionPoint.res.mjs";
+
+let coreStackReference = Stdlib_Option.map(new Pulumi.Config("platform").get("stack"), stack => new Pulumi.StackReference(stack + "-interstack", {
+  name: stack
+}));
+
+let requiredFields = ["name"];
+
+let optionalFields = [
+  "bucketNames",
+  "sideEffectSources"
+];
+
+function fromJson(json) {
+  try {
+    return {
+      TAG: "Ok",
+      _0: S.parseOrThrow(json, Task$ReventlessInterop.resolvedOutputsSchema)
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "parse error");
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  }
+}
+
+let DefaultTaskQuery = Query$ReventlessInterop.Task.Make({
+  requiredFields: requiredFields,
+  optionalFields: optionalFields,
+  fromJson: fromJson
+});
+
+let requiredFields$1 = [
+  "name",
+  "eventCollector"
+];
+
+let optionalFields$1 = ["counter"];
+
+function fromJson$1(json) {
+  try {
+    return {
+      TAG: "Ok",
+      _0: S.parseOrThrow(json, EventMapper$ReventlessInterop.resolvedOutputsSchema)
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "parse error");
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  }
+}
+
+let DefaultEventMapperQuery = Query$ReventlessInterop.EventMapper.Make({
+  requiredFields: requiredFields$1,
+  optionalFields: optionalFields$1,
+  fromJson: fromJson$1
+});
+
+let stackDependenciesTasks = DefaultTaskQuery.queryAll();
+
+let stackDependenciesEventMappers = DefaultEventMapperQuery.queryAll();
+
+let requiredFields$2 = [
+  "name",
+  "commandTopic",
+  "eventTopic"
+];
+
+let optionalFields$2 = [];
+
+function fromJson$2(json) {
+  try {
+    return {
+      TAG: "Ok",
+      _0: S.parseOrThrow(json, ExtensionPoint$ReventlessInterop.resolvedOutputsSchema)
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "parse error");
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  }
+}
+
+let DefaultExtensionPointQuery = Query$ReventlessInterop.ExtensionPoint.Make({
+  requiredFields: requiredFields$2,
+  optionalFields: optionalFields$2,
+  fromJson: fromJson$2
+});
+
+let stackDependenciesExtensionPoints = DefaultExtensionPointQuery.queryAll();
+
+let mergeTasks = DefaultTaskQuery.mergeWith;
+
+let mergeEventMappers = DefaultEventMapperQuery.mergeWith;
+
+let mergeExtensionPoints = DefaultExtensionPointQuery.mergeWith;
+
+export {
+  coreStackReference,
+  stackDependenciesTasks,
+  stackDependenciesEventMappers,
+  stackDependenciesExtensionPoints,
+  mergeTasks,
+  mergeEventMappers,
+  mergeExtensionPoints,
+}
+/* coreStackReference Not a pure module */

package/src/util/Interstack.resi

@@ -0,0 +1,25 @@
+let coreStackReference: option<Pulumi.StackReference.t>
+
+let stackDependenciesTasks: Pulumi.Output.t<
+  array<result<ReventlessInterop.Task.resolvedOutputs, ReventlessInterop.Compat.error>>,
+>
+
+let stackDependenciesEventMappers: Pulumi.Output.t<
+  array<result<ReventlessInterop.EventMapper.resolvedOutputs, ReventlessInterop.Compat.error>>,
+>
+
+let stackDependenciesExtensionPoints: Pulumi.Output.t<
+  array<result<ReventlessInterop.ExtensionPoint.resolvedOutputs, ReventlessInterop.Compat.error>>,
+>
+
+let mergeTasks: array<ReventlessInterop.Task.resolvedOutputs> => Pulumi.Output.t<
+  array<ReventlessInterop.Task.resolvedOutputs>,
+>
+
+let mergeEventMappers: array<ReventlessInterop.EventMapper.resolvedOutputs> => Pulumi.Output.t<
+  array<ReventlessInterop.EventMapper.resolvedOutputs>,
+>
+
+let mergeExtensionPoints: array<ReventlessInterop.ExtensionPoint.resolvedOutputs> => Pulumi.Output.t<
+  array<ReventlessInterop.ExtensionPoint.resolvedOutputs>,
+>

package/src/util/LogFormat.res

@@ -0,0 +1,222 @@
+// Log formatting utilities for domain objects.
+//
+// Three verbosity levels per domain object, each with singular + plural:
+//
+//   Commands (Message.commandJson):
+//     cmdName      → "Add"                    cmdNames      → "[Add,Remove]"
+//     cmdSummary   → "Add(1)"                 cmdSummaries  → "[Add(1),Remove(2)]"
+//     cmdDetail    → "Add(1, {name:"Cat 1"})" cmdDetails    → "[Add(1, {...}), ...]"
+//     cmdFull      → "{cmd+meta+id}"           cmdFulls      → "[{...}, ...]"
+//
+//   Events (JSON.t event' envelope):
+//     eventName    → "Added"                  eventNames    → "[Added,Removed]"
+//     eventSummary → "Added(1)"               eventSummaries → "[Added(1),Removed(2)]"
+//     eventDetail  → "Added(1, {name:"Cat 1"})" eventDetails → "[Added(1, {...}), ...]"
+//     eventFull    → "{evt+meta+id}"            eventFulls   → "[{...}, ...]"
+//
+//   Actions (Projection.action):
+//     actionName   → "Create"                 actionNames   → "[Create,Update]"
+//     actionDetail → "Create(order-1)"        actionDetails → "[Create(order-1),Update(order-2)]"
+//
+//   Other:
+//     fmtState → "state=Order(order-1) seq=42"
+//     fmtExn   → "err=<message>"
+
+// ─── Style ───────────────────────────────────────────────────────────────────
+
+// Re-exported so downstream callers in reventless-core can reach the shared
+// styling primitive through `LogFormat.bold` rather than the spec namespace.
+let bold = Reventless.AnsiStyle.bold
+
+// ─── Commands ────────────────────────────────────────────────────────────────
+
+// "Add"  (bold)
+let cmdName = (msg: Message.commandJson): string =>
+  msg.commandJson->Message.variantNameOfJson->bold
+
+// "[Add,Remove]"
+let cmdNames = (msgs: array<Message.commandJson>): string =>
+  `[${msgs->Array.map(cmdName)->Array.join(",")}]`
+
+// "Add(1)"
+let cmdSummary = (msg: Message.commandJson): string =>
+  `${msg->cmdName}(${msg.id})`
+
+// "[Add(1),Remove(2)]"
+let cmdSummaries = (msgs: array<Message.commandJson>): string =>
+  `[${msgs->Array.map(cmdSummary)->Array.join(",")}]`
+
+// Strip TAG from a variant JSON, return remaining fields as a compact string.
+// {"TAG":"Add","name":"Cat 1"} → {name:"Cat 1"}
+// "Add" (bare string variant) → ""
+let variantFields = (json: JSON.t): string =>
+  switch json {
+  | Object(dict) =>
+    let fields =
+      dict
+      ->Dict.toArray
+      ->Array.filter(((k, _)) => k != "TAG")
+      ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
+      ->Array.join(",")
+    fields == "" ? "" : `, {${fields}}`
+  | _ => ""
+  }
+
+// "Add(1, {name:"Cat 1"})"  (ReScript-style variant rendering)
+let cmdDetail = (msg: Message.commandJson): string =>
+  `${msg->cmdName}(${msg.id}${msg.commandJson->variantFields})`
+
+// "[Add(1, {name:"Cat 1"}), Remove(2)]"
+let cmdDetails = (msgs: array<Message.commandJson>): string =>
+  `[${msgs->Array.map(cmdDetail)->Array.join(", ")}]`
+
+// "Add({name:"Cat 1"})"  — like cmdDetail but WITHOUT the leading id. Used by DCB
+// command logs where the id is a partition-tag value already shown among the
+// fields, so a `(id)` prefix would just duplicate it.
+let cmdLabelOfJson = (json: JSON.t): string => {
+  let fields = json->variantFields
+  let body =
+    fields->String.startsWith(", ")
+      ? fields->String.slice(~start=2, ~end=fields->String.length)
+      : fields
+  `${json->Message.variantNameOfJson->bold}(${body})`
+}
+
+// "Add({name:"Cat 1"})"  — cmdLabelOfJson for a full command envelope.
+let cmdDetailNoId = (msg: Message.commandJson): string => msg.commandJson->cmdLabelOfJson
+
+// "{\"command\":{...},\"meta\":{...},\"id\":\"1\"}"  (full envelope with meta, no summary prefix)
+let cmdFull = (msg: Message.commandJson): string => {
+  let commandStr = msg.commandJson->JSON.stringify
+  let metaStr = msg.meta->Message.encode(Message.metaSchema)->JSON.stringify
+  `{"command":${commandStr},"meta":${metaStr},"id":"${msg.id}"}`
+}
+
+// "[Add(1): {\"command\":...,\"meta\":...}, ...]"
+let cmdFulls = (msgs: array<Message.commandJson>): string =>
+  `[${msgs->Array.map(cmdFull)->Array.join(", ")}]`
+
+// ─── Events (JSON.t event' envelope) ─────────────────────────────────────────
+
+// "Added"  (bold)
+let eventName = (j: JSON.t): string =>
+  j->Message.eventNameOfEvent'Json->bold
+
+// "[Added,Removed]"
+let eventNames = (events: array<JSON.t>): string =>
+  `[${events->Array.map(eventName)->Array.join(",")}]`
+
+// "Added(1)"
+let eventSummary = (j: JSON.t): string => {
+  let (id, _, _) = j->Message.idMetaEventOfEvent'Json
+  `${j->eventName}(${id})`
+}
+
+// "[Added(1),Removed(2)]"
+let eventSummaries = (events: array<JSON.t>): string =>
+  `[${events->Array.map(eventSummary)->Array.join(",")}]`
+
+// "Added(1, {name:"Cat 1"})"  (ReScript-style variant rendering)
+let eventDetail = (j: JSON.t): string => {
+  let (id, _, _) = j->Message.idMetaEventOfEvent'Json
+  let eventJson =
+    j->JSON.Decode.object->Option.flatMap(d => d->Dict.get("event"))->Option.getOr(JSON.Encode.null)
+  `${j->eventName}(${id}${eventJson->variantFields})`
+}
+
+// "[Added(1, {name:"Cat 1"}), Removed(2)]"
+let eventDetails = (events: array<JSON.t>): string =>
+  `[${events->Array.map(eventDetail)->Array.join(", ")}]`
+
+// "{\"event\":{...},\"meta\":{...},\"id\":\"1\"}"  (full envelope with meta, no summary prefix)
+let eventFull = (j: JSON.t): string => {
+  let (id, metaStr, eventStr) = j->Message.idMetaEventOfEvent'Json
+  `{"event":${eventStr},"meta":${metaStr},"id":"${id}"}`
+}
+
+// "[Added(1): {\"event\":...,\"meta\":...}, ...]"
+let eventFulls = (events: array<JSON.t>): string =>
+  `[${events->Array.map(eventFull)->Array.join(", ")}]`
+
+// ─── Actions (Projection.action) ─────────────────────────────────────────────
+
+// "Create"
+let actionName = (action: Reventless.Projection.action<'id, 'state>): string =>
+  switch action {
+  | Create(_, _) => "Create"
+  | CreateMany(_) => "CreateMany"
+  | CreateMultiState(_, _) => "CreateMultiState"
+  | Update(_, _) => "Update"
+  | UpdateMany(_, _) => "UpdateMany"
+  | UpdateWithDefault(_, _, _) => "UpdateWithDefault"
+  | UpdateManyWithDefault(_, _, _) => "UpdateManyWithDefault"
+  | UpdateMultiState(_, _) => "UpdateMultiState"
+  | UpdateManyMultiStates(_, _) => "UpdateManyMultiStates"
+  | Set(_, _) => "Set"
+  | SetMany(_, _) => "SetMany"
+  | Delete(_) => "Delete"
+  | DeleteMany(_) => "DeleteMany"
+  | DeleteIf(_, _) => "DeleteIf"
+  | DeleteManyIf(_, _) => "DeleteManyIf"
+  | Ignore => "Ignore"
+  }
+
+// "[Create,Update,Delete]"
+let actionNames = (actions: array<Reventless.Projection.action<'id, 'state>>): string =>
+  `[${actions->Array.map(actionName)->Array.join(",")}]`
+
+// "Create(order-1)" — includes id where the variant carries one
+let actionDetail = (action: Reventless.Projection.action<string, 'state>): string =>
+  switch action {
+  | Create(id, _) => `Create(${id})`
+  | CreateMany(items) => `CreateMany(${items->Array.length->Int.toString})`
+  | CreateMultiState(id, _) => `CreateMultiState(${id})`
+  | Update(id, _) => `Update(${id})`
+  | UpdateMany(ids, _) => `UpdateMany(${ids->Array.length->Int.toString})`
+  | UpdateWithDefault(id, _, _) => `UpdateWithDefault(${id})`
+  | UpdateManyWithDefault(ids, _, _) => `UpdateManyWithDefault(${ids->Array.length->Int.toString})`
+  | UpdateMultiState(id, _) => `UpdateMultiState(${id})`
+  | UpdateManyMultiStates(ids, _) => `UpdateManyMultiStates(${ids->Array.length->Int.toString})`
+  | Set(id, _) => `Set(${id})`
+  | SetMany(ids, _) => `SetMany(${ids->Array.length->Int.toString})`
+  | Delete(id) => `Delete(${id})`
+  | DeleteMany(ids) => `DeleteMany(${ids->Array.length->Int.toString})`
+  | DeleteIf(id, _) => `DeleteIf(${id})`
+  | DeleteManyIf(ids, _) => `DeleteManyIf(${ids->Array.length->Int.toString})`
+  | Ignore => "Ignore"
+  }
+
+// "[Create(order-1),Update(order-2)]"
+let actionDetails = (actions: array<Reventless.Projection.action<string, 'state>>): string =>
+  `[${actions->Array.map(actionDetail)->Array.join(",")}]`
+
+// ─── Other ───────────────────────────────────────────────────────────────────
+
+// "state=Order(order-1) seq=42"
+let fmtState = (~name: string, ~id: string, ~seq: int): string =>
+  `state=${name}(${id}) seq=${seq->Int.toString}`
+
+// "err=<message>"
+let fmtExn = (e: exn): string =>
+  `err=${e->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")}`
+
+// ─── Legacy aliases (kept for existing callers) ──────────────────────────────
+
+let commandJsonToLogMessage = cmdFull
+let commandJsonsToLogMessages: array<Message.commandJson> => array<string> = cmdJsons => {
+  let count = cmdJsons->Array.length->Int.toString
+  cmdJsons->Array.mapWithIndex((cmdJson, idx) => {
+    let idx = (idx + 1)->Int.toString
+    `${idx}/${count}: ${cmdJson->cmdSummary}: ${cmdJson->cmdFull}`
+  })
+}
+let event'JsonToLogMessage = (j: JSON.t): string =>
+  `${j->eventSummary}: ${j->eventFull}`
+
+// Legacy concise aliases
+let fmtCmd = cmdSummary
+let fmtCmds = (msgs: array<Message.commandJson>): string =>
+  `cmds=${msgs->Array.length->Int.toString} [${msgs->Array.map(cmdName)->Array.join(",")}]`
+let fmtEventJson = eventSummary
+let fmtAction = actionName
+let fmtActions = actionNames