@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/Message.res.mjs

@@ -0,0 +1,418 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Uuid from "uuid";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
+
+let logger = Logger$ReventlessCore.fromEnv();
+
+function toEventSchema$p(idSchema, eventSchema) {
+  return S.object(s => ({
+    id: s.f("id", idSchema),
+    meta: s.f("meta", Message$Reventless.metaSchema),
+    event: s.f("event", eventSchema)
+  }));
+}
+
+function toCommandSchema$p(idSchema, commandSchema) {
+  return S.object(s => ({
+    id: s.f("id", idSchema),
+    meta: s.f("meta", Message$Reventless.metaSchema),
+    command: s.f("command", commandSchema)
+  }));
+}
+
+function decodeEvent$p(json, idSchema, eventSchema) {
+  return S.parseJsonOrThrow(json, toEventSchema$p(idSchema, eventSchema));
+}
+
+function decodeCommand$p(json, idSchema, commandSchema) {
+  return S.parseJsonOrThrow(json, toCommandSchema$p(idSchema, commandSchema));
+}
+
+function encodeEvent$p(event$p, idSchema, eventSchema) {
+  return S.reverseConvertToJsonOrThrow(event$p, toEventSchema$p(idSchema, eventSchema));
+}
+
+function encodeCommand$p(command$p, idSchema, commandSchema) {
+  return S.reverseConvertToJsonOrThrow(command$p, toCommandSchema$p(idSchema, commandSchema));
+}
+
+function uuid(prim) {
+  return Uuid.v4();
+}
+
+function log(value, str) {
+  logger.debug("Message", Stdlib_Option.getOr(JSON.stringify(value), ""), str);
+  return value;
+}
+
+function now() {
+  return new Date().getTime();
+}
+
+function nowAsISOString() {
+  return new Date().toISOString();
+}
+
+function toMessageBody(param) {
+  let newrecord = {...param.meta};
+  newrecord.msgId = Uuid.v4();
+  newrecord.time = new Date().toISOString();
+  return JSON.stringify(Object.fromEntries([
+    [
+      "id",
+      param.id
+    ],
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(newrecord, Message$Reventless.metaSchema)
+    ],
+    [
+      "command",
+      param.commandJson
+    ]
+  ]));
+}
+
+function serviceNameOfMsg(msgJson) {
+  let msgObj = Stdlib_JSON.Decode.object(msgJson);
+  if (msgObj !== undefined) {
+    return Stdlib_Option.flatMap(msgObj["meta"], meta => {
+      let msgMeta;
+      try {
+        msgMeta = S.parseJsonOrThrow(meta, Message$Reventless.metaSchema);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        logger.warn("Message", Stdlib_Option.getOr(JSON.stringify(err), ""), "serviceNameOfMsg: Couldn't parse meta");
+        return;
+      }
+      return msgMeta.service;
+    });
+  } else {
+    logger.warn("Message", msgJson, "serviceNameOfMsg: couldn't decodeObject");
+    return;
+  }
+}
+
+function variantNameOfJson(json) {
+  if (json === null || Array.isArray(json)) {
+    return "unknown";
+  }
+  switch (typeof json) {
+    case "string" :
+      return json;
+    case "object" :
+      let match = json["TAG"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return "unknown";
+      }
+    default:
+      return "unknown";
+  }
+}
+
+function eventNameOfEvent$pJson(json) {
+  let dict = Stdlib_JSON.Decode.object(json);
+  if (dict !== undefined) {
+    return variantNameOfJson(dict["event"]);
+  } else {
+    return "unknownEventName";
+  }
+}
+
+function idOfEvent$pJson(json) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), event$p => Stdlib_JSON.Decode.string(event$p["id"]));
+}
+
+function idMetaEventOfEvent$pJson(json) {
+  let dict = Stdlib_JSON.Decode.object(json);
+  let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(dict, dict => Stdlib_Option.flatMap(dict["id"], id => Stdlib_JSON.Decode.string(id))), "unknownId");
+  let meta = Stdlib_Option.getOr(Stdlib_Option.flatMap(dict, dict => Stdlib_Option.map(dict["meta"], metaStr => JSON.stringify(metaStr))), "noMeta");
+  let event = Stdlib_Option.getOr(Stdlib_Option.flatMap(dict, dict => Stdlib_Option.map(dict["event"], eventStr => JSON.stringify(eventStr))), "noEvent");
+  return [
+    id,
+    meta,
+    event
+  ];
+}
+
+let InvalidCommand = /* @__PURE__ */Primitive_exceptions.create("Message-ReventlessCore.InvalidCommand");
+
+function hrtimeToString(hrtime, now) {
+  let milString = hrtime[1].toString();
+  let milLength = milString.length;
+  return now.toString() + ("-" + ("0".repeat(9 - milLength | 0) + milString));
+}
+
+function generateMeta(service, ip, user, causationId, traceparent, correlationId, schemaVersion, headers) {
+  let msgId = Uuid.v4();
+  return {
+    service: service,
+    time: new Date().toISOString(),
+    ip: ip,
+    user: user,
+    msgId: msgId,
+    correlationId: Stdlib_Option.getOr(correlationId, msgId),
+    causationId: causationId,
+    traceparent: traceparent,
+    schemaVersion: schemaVersion,
+    headers: headers
+  };
+}
+
+function deriveMeta(parent, service) {
+  return {
+    service: Stdlib_Option.getOr(service, parent.service),
+    time: new Date().toISOString(),
+    ip: parent.ip,
+    user: parent.user,
+    msgId: Uuid.v4(),
+    correlationId: parent.correlationId,
+    causationId: parent.msgId,
+    traceparent: parent.traceparent,
+    schemaVersion: parent.schemaVersion,
+    headers: parent.headers
+  };
+}
+
+function decomposeMeta(meta) {
+  return Object.entries(Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)), undefined));
+}
+
+function composeEventJson$p(id, meta, eventJson) {
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      eventJson
+    ]
+  ]);
+}
+
+function composeMeta(dict) {
+  let out = [
+    [
+      "service",
+      Stdlib_Option.getOrThrow(dict["service"], undefined)
+    ],
+    [
+      "time",
+      Stdlib_Option.getOrThrow(dict["time"], undefined)
+    ],
+    [
+      "msgId",
+      Stdlib_Option.getOrThrow(dict["msgId"], undefined)
+    ],
+    [
+      "correlationId",
+      Stdlib_Option.getOrThrow(dict["correlationId"], undefined)
+    ]
+  ];
+  let optionalKeys = [
+    "ip",
+    "user",
+    "causationId",
+    "traceparent",
+    "schemaVersion",
+    "headers"
+  ];
+  let optional = Stdlib_Array.filterMap(optionalKeys.map(k => Stdlib_Option.map(dict[k], v => [
+    k,
+    v
+  ])), x => x);
+  return Object.fromEntries(out.concat(optional));
+}
+
+let metaKeys = [
+  "service",
+  "time",
+  "ip",
+  "user",
+  "msgId",
+  "correlationId",
+  "causationId",
+  "traceparent",
+  "schemaVersion",
+  "headers"
+];
+
+function storedEventToFlatJson(stored, idSchema) {
+  let fields = [
+    [
+      "id",
+      S.reverseConvertToJsonOrThrow(stored.id, idSchema)
+    ],
+    [
+      "position",
+      stored.position
+    ],
+    [
+      "event",
+      stored.event
+    ],
+    [
+      "data",
+      stored.data
+    ],
+    [
+      "recordedAt",
+      stored.recordedAt
+    ]
+  ];
+  let tags = stored.tags;
+  let withTags;
+  if (tags !== undefined) {
+    let tagsJson = S.reverseConvertToJsonOrThrow(tags, S.array(DcbTag$Reventless.tagSchema));
+    withTags = fields.concat([[
+        "tags",
+        tagsJson
+      ]]);
+  } else {
+    withTags = fields;
+  }
+  return Object.fromEntries(withTags.concat(decomposeMeta(stored.meta)));
+}
+
+function flatJsonToStoredEvent(json, idSchema) {
+  let dict = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(json), undefined);
+  let id = S.parseJsonOrThrow(Stdlib_Option.getOrThrow(dict["id"], undefined), idSchema);
+  let position = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["position"], undefined)), undefined);
+  let event = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["event"], undefined)), undefined);
+  let data = Stdlib_Option.getOrThrow(dict["data"], undefined);
+  let recordedAt = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.string(Stdlib_Option.getOrThrow(dict["recordedAt"], undefined)), undefined);
+  let meta = S.parseJsonOrThrow(composeMeta(dict), Message$Reventless.metaSchema);
+  let tags = Stdlib_Option.map(dict["tags"], t => S.parseJsonOrThrow(t, S.array(DcbTag$Reventless.tagSchema)));
+  return {
+    id: id,
+    position: position,
+    event: event,
+    data: data,
+    meta: meta,
+    recordedAt: recordedAt,
+    tags: tags
+  };
+}
+
+function commandJsonOfCommand$p(idToString, commandSchema, cmd) {
+  return {
+    id: idToString(cmd.id),
+    meta: cmd.meta,
+    commandJson: Message$Reventless.encode(cmd.command, commandSchema)
+  };
+}
+
+function splitMessage(json) {
+  let dict = Stdlib_JSON.Decode.object(json);
+  if (dict !== undefined) {
+    let match = Stdlib_Array.partition(Object.entries(dict), param => param[0] === "TAG");
+    let match$1 = match[0][0];
+    let typ;
+    if (match$1 !== undefined) {
+      let t = match$1[1];
+      typ = typeof t === "string" ? t : "Unknown";
+    } else {
+      typ = "Unknown";
+    }
+    return [
+      typ,
+      Object.fromEntries(match[1])
+    ];
+  }
+  let t$1 = Stdlib_JSON.Decode.string(json);
+  if (t$1 !== undefined) {
+    return [
+      t$1,
+      {}
+    ];
+  } else {
+    return [
+      "Unknown",
+      {}
+    ];
+  }
+}
+
+function combineMessage(typ, data) {
+  if (Object.entries(data).length === 0) {
+    return typ;
+  } else {
+    return Object.fromEntries([[
+        "TAG",
+        typ
+      ]].concat(Object.entries(data)));
+  }
+}
+
+let serviceSchema = Message$Reventless.serviceSchema;
+
+let metaSchema = Message$Reventless.metaSchema;
+
+let contextSchema = Message$Reventless.contextSchema;
+
+let statusChangeSchema = Message$Reventless.statusChangeSchema;
+
+let commandJsonSchema = Message$Reventless.commandJsonSchema;
+
+let decode = Message$Reventless.decode;
+
+let encode = Message$Reventless.encode;
+
+let InvalidEvent = Message$Reventless.InvalidEvent;
+
+export {
+  logger,
+  serviceSchema,
+  metaSchema,
+  contextSchema,
+  statusChangeSchema,
+  commandJsonSchema,
+  decode,
+  encode,
+  InvalidEvent,
+  toEventSchema$p,
+  toCommandSchema$p,
+  decodeEvent$p,
+  decodeCommand$p,
+  encodeEvent$p,
+  encodeCommand$p,
+  uuid,
+  log,
+  now,
+  nowAsISOString,
+  toMessageBody,
+  serviceNameOfMsg,
+  variantNameOfJson,
+  eventNameOfEvent$pJson,
+  idOfEvent$pJson,
+  idMetaEventOfEvent$pJson,
+  InvalidCommand,
+  hrtimeToString,
+  generateMeta,
+  deriveMeta,
+  decomposeMeta,
+  composeEventJson$p,
+  composeMeta,
+  metaKeys,
+  storedEventToFlatJson,
+  flatJsonToStoredEvent,
+  commandJsonOfCommand$p,
+  splitMessage,
+  combineMessage,
+}
+/* logger Not a pure module */

package/src/PluginRuntimeOperations.res

@@ -0,0 +1,15 @@
+// Provider-agnostic interface for plugin runtime operations.
+//
+// Phase 3 of the plugin-eventcollector-runtime-rewire plans moved cross-plugin
+// SNS subscription management to the admin EventCollector
+// (manageSubscriptions hook in PluginExtensionPoint_Plugin.Spec). The plugin
+// side no longer subscribes / unsubscribes anything at runtime, so the prior
+// `topicSubscription` operations have been removed.
+
+type messagePublishOps = {
+  sendMessageToChannel: (~channelId: string, ~messageBody: string) => promise<unit>,
+}
+
+type operations = {
+  messagePublish: messagePublishOps,
+}

package/src/PluginRuntimeOperations.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. */