@mindignited/continuum-client 2.14.6

package/dist/continuum.js

@@ -0,0 +1,1156 @@
+import { RxStomp as k } from "@stomp/rx-stomp";
+import { ReconnectionTimeMode as B } from "@stomp/stompjs";
+import { v4 as S } from "uuid";
+import q from "debug";
+import b, { propagation as F, context as $, SpanKind as U, SpanStatusCode as Y } from "@opentelemetry/api";
+import { Subject as A, firstValueFrom as V, Observable as j, throwError as N } from "rxjs";
+import { map as R, multicast as J, filter as X, first as W } from "rxjs/operators";
+import { Optional as C } from "typescript-optional";
+import "reflect-metadata";
+import { ATTR_SERVER_ADDRESS as G, ATTR_SERVER_PORT as K } from "@opentelemetry/semantic-conventions";
+class Le {
+}
+class w {
+  host;
+  port;
+  useSSL;
+}
+class Me extends w {
+  /**
+   * The headers to send during the connection to the continuum server.
+   * If a function is provided, it will be called to get the headers each time the connection is established.
+   * This is useful for providing dynamic headers, such as a JWT token that expires.
+   */
+  connectHeaders;
+  /**
+   * The maximum number of connection attempts to make during the {@link IEventBus} initial connection request.
+   * If the limit is reached the {@link IEventBus} will return an error to the caller of {@link IEventBus#connect}
+   * Set to 0, undefined, or null to try forever
+   */
+  maxConnectionAttempts;
+  /**
+   * If true, the session will not be kept alive after the connection is established and then disrupted.
+   * If false, the session will be kept alive after the connection is established and then disrupted, for a period of time.
+   */
+  disableStickySession;
+}
+class m extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, m.prototype);
+  }
+}
+var o = /* @__PURE__ */ ((s) => (s.CONTENT_TYPE_HEADER = "content-type", s.CONTENT_LENGTH_HEADER = "content-length", s.REPLY_TO_HEADER = "reply-to", s.REPLY_TO_ID_HEADER = "reply-to-id", s.SESSION_HEADER = "session", s.CONNECTED_INFO_HEADER = "connected-info", s.DISABLE_STICKY_SESSION_HEADER = "disable-sticky-session", s.CORRELATION_ID_HEADER = "__correlation-id", s.ERROR_HEADER = "error", s.COMPLETE_HEADER = "complete", s.CONTROL_HEADER = "control", s.CONTROL_VALUE_COMPLETE = "complete", s.CONTROL_VALUE_CANCEL = "cancel", s.CONTROL_VALUE_SUSPEND = "suspend", s.CONTROL_VALUE_RESUME = "resume", s.SERVICE_DESTINATION_PREFIX = "srv://", s.SERVICE_DESTINATION_SCHEME = "srv", s.STREAM_DESTINATION_PREFIX = "stream://", s.STREAM_DESTINATION_SCHEME = "stream", s.CONTENT_JSON = "application/json", s.CONTENT_TEXT = "text/plain", s.TRACEPARENT_HEADER = "traceparent", s.TRACESTATE_HEADER = "tracestate", s))(o || {});
+class z {
+  lastWebsocketError = null;
+  /**
+   * This will return true if a {@link ConnectionInfo#maxConnectionAttempts} threshold was set and was reached
+   */
+  maxConnectionAttemptsReached = !1;
+  rxStomp = null;
+  INITIAL_RECONNECT_DELAY = 2e3;
+  MAX_RECONNECT_DELAY = 12e4;
+  // 2 mins
+  JITTER_MAX = 5e3;
+  connectionAttempts = 0;
+  initialConnectionSuccessful = !1;
+  debugLogger = q("continuum:stomp");
+  replyToId = S();
+  replyToCri = o.SERVICE_DESTINATION_PREFIX + this.replyToId + ":" + S() + "@continuum.js.EventBus/replyHandler";
+  deactivationHandler = null;
+  /**
+   * @return true if this {@link StompConnectionManager} is actively trying to maintain a connection to the Stomp server, false if not.
+   */
+  get active() {
+    return !!this.rxStomp;
+  }
+  /**
+   * return true if this {@link StompConnectionManager} is active and has a connection to the stomp server
+   */
+  get connected() {
+    return this.rxStomp != null && this.rxStomp.connected();
+  }
+  activate(e) {
+    return new Promise((t, r) => {
+      if (!e) {
+        r("You must supply a valid connectionInfo object");
+        return;
+      }
+      if (!e.host) {
+        r("No host provided");
+        return;
+      }
+      if (this.rxStomp) {
+        r("Stomp connection already active");
+        return;
+      }
+      this.connectionAttempts = 0, this.initialConnectionSuccessful = !1, this.lastWebsocketError = null, this.maxConnectionAttemptsReached = !1;
+      const n = "ws" + (e.useSSL ? "s" : "") + "://" + e.host + (e.port ? ":" + e.port : "") + "/v1";
+      this.rxStomp = new k();
+      let i = typeof e.connectHeaders != "function" && e.connectHeaders != null ? e.connectHeaders : {};
+      const c = {
+        brokerURL: n,
+        connectHeaders: i,
+        heartbeatIncoming: 12e4,
+        heartbeatOutgoing: 3e4,
+        reconnectDelay: this.INITIAL_RECONNECT_DELAY,
+        beforeConnect: async () => {
+          if (typeof e.connectHeaders == "function") {
+            const u = await e.connectHeaders();
+            for (const l in u)
+              i[l] = u[l];
+          }
+          if (e.disableStickySession && (i[o.DISABLE_STICKY_SESSION_HEADER] = "true"), i[o.REPLY_TO_ID_HEADER] = this.replyToId, e?.maxConnectionAttempts)
+            if (this.connectionAttempts++, this.connectionAttempts > e.maxConnectionAttempts) {
+              if (this.maxConnectionAttemptsReached = !0, await this.deactivate(), !this.initialConnectionSuccessful) {
+                let u = this.lastWebsocketError?.message ? this.lastWebsocketError?.message : "UNKNOWN";
+                r(`Max number of reconnection attempts reached. Last WS Error ${u}`);
+              }
+            } else
+              await this.connectionJitterDelay();
+          else
+            await this.connectionJitterDelay();
+        }
+      };
+      this.debugLogger.enabled && (c.debug = (u) => {
+        this.debugLogger(u);
+      }), this.rxStomp.configure(c), this.rxStomp.stompClient.maxReconnectDelay = this.MAX_RECONNECT_DELAY, this.rxStomp.stompClient.reconnectTimeMode = B.EXPONENTIAL, this.rxStomp.webSocketErrors$.subscribe((u) => {
+        this.lastWebsocketError = u;
+      });
+      const a = this.rxStomp.connected$.subscribe(() => {
+        a.unsubscribe(), this.initialConnectionSuccessful || (this.initialConnectionSuccessful = !0);
+      }), h = this.rxStomp.stompErrors$.subscribe((u) => {
+        h.unsubscribe();
+        const l = u.headers.message;
+        this.rxStomp?.deactivate(), this.rxStomp = null, r(l);
+      }), p = this.rxStomp.serverHeaders$.subscribe((u) => {
+        let l = u[o.CONNECTED_INFO_HEADER];
+        if (l != null) {
+          const d = JSON.parse(l);
+          if (e.disableStickySession)
+            if (typeof e.connectHeaders == "function") {
+              for (let v in i)
+                delete i[v];
+              this.initialConnectionSuccessful || t(d);
+            } else typeof e.connectHeaders == "object" && (p.unsubscribe(), t(d));
+          else if (p.unsubscribe(), d.sessionId != null && d.replyToId != null) {
+            if (e.connectHeaders != null)
+              for (let v in i)
+                delete i[v];
+            i[o.SESSION_HEADER] = d.sessionId, t(d);
+          } else
+            r("Server did not return proper data for successful login");
+        } else
+          r("Server did not return proper data for successful login");
+      });
+      this.rxStomp.activate();
+    });
+  }
+  async deactivate(e) {
+    this.rxStomp && (await this.rxStomp.deactivate({ force: e }), this.deactivationHandler && this.deactivationHandler(), this.rxStomp = null);
+  }
+  /**
+   * Make sure clients don't all try to reconnect at the same time.
+   */
+  async connectionJitterDelay() {
+    if (this.initialConnectionSuccessful) {
+      const e = Math.random() * this.JITTER_MAX;
+      return this.debugLogger(`Adding ${e}ms of jitter delay`), new Promise((t) => setTimeout(t, e));
+    }
+  }
+}
+class g {
+  cri;
+  headers;
+  data;
+  constructor(e, t, r) {
+    this.cri = e, t !== void 0 ? this.headers = t : this.headers = /* @__PURE__ */ new Map(), this.data = C.ofNullable(r);
+  }
+  getHeader(e) {
+    return this.headers.get(e);
+  }
+  hasHeader(e) {
+    return this.headers.has(e);
+  }
+  setHeader(e, t) {
+    this.headers.set(e, t);
+  }
+  removeHeader(e) {
+    return this.headers.delete(e);
+  }
+  setDataString(e) {
+    const t = new TextEncoder().encode(e);
+    this.data = C.ofNonNull(t);
+  }
+  getDataString() {
+    let e = "";
+    return this.data.ifPresent((t) => e = new TextDecoder().decode(t)), e;
+  }
+}
+class Z {
+  fatalErrors;
+  serverInfo = null;
+  stompConnectionManager = new z();
+  replyToCri = null;
+  requestRepliesObservable = null;
+  requestRepliesSubject = null;
+  requestRepliesSubscription = null;
+  errorSubject = new A();
+  errorSubjectSubscription = null;
+  constructor() {
+    this.fatalErrors = this.errorSubject.pipe(R((e) => (this.disconnect().catch((t) => {
+      console && console.error("Error disconnecting from Stomp: " + t);
+    }), new m(e.headers.message)))), this.stompConnectionManager.deactivationHandler = () => {
+      this.cleanup();
+    };
+  }
+  isConnectionActive() {
+    return this.stompConnectionManager.active;
+  }
+  isConnected() {
+    return this.stompConnectionManager.connected;
+  }
+  async connect(e) {
+    if (this.stompConnectionManager.active)
+      throw new Error("Event Bus connection already active");
+    {
+      this.cleanup();
+      const t = await this.stompConnectionManager.activate(e);
+      return this.serverInfo = new w(), this.serverInfo.host = e.host, this.serverInfo.port = e.port, this.serverInfo.useSSL = e.useSSL, this.replyToCri = this.stompConnectionManager.replyToCri, this.errorSubjectSubscription = this.stompConnectionManager.rxStomp?.stompErrors$.subscribe(this.errorSubject), t;
+    }
+  }
+  async disconnect(e) {
+    await this.stompConnectionManager.deactivate(e), this.cleanup();
+  }
+  send(e) {
+    if (this.stompConnectionManager.rxStomp) {
+      const t = {};
+      for (const [n, i] of e.headers.entries())
+        t[n] = i;
+      const r = {};
+      F.inject($.active(), r), r.traceparent && (t[o.TRACEPARENT_HEADER] = r.traceparent), r.tracestate && (t[o.TRACESTATE_HEADER] = r.tracestate), this.stompConnectionManager.rxStomp.publish({
+        destination: e.cri,
+        headers: t,
+        binaryBody: e.data.orUndefined()
+      });
+    } else
+      throw this.createSendUnavailableError();
+  }
+  request(e) {
+    return V(this.requestStream(e, !1));
+  }
+  requestStream(e, t = !0) {
+    return this.stompConnectionManager?.rxStomp ? new j((r) => {
+      this.requestRepliesObservable == null && (this.requestRepliesSubject = new A(), this.requestRepliesObservable = this._observe(this.replyToCri).pipe(J(this.requestRepliesSubject)), this.requestRepliesSubscription = this.requestRepliesObservable.connect());
+      let n = !1;
+      const i = S(), c = this.requestRepliesObservable.pipe(X((a) => a.headers.get(o.CORRELATION_ID_HEADER) === i)).subscribe({
+        next(a) {
+          if (a.hasHeader(o.CONTROL_HEADER))
+            if (a.headers.get(o.CONTROL_HEADER) === "complete")
+              n = !0, r.complete();
+            else
+              throw new Error("Control Header " + a.headers.get(o.CONTROL_HEADER) + " is not supported");
+          else a.hasHeader(o.ERROR_HEADER) ? (n = !0, r.error(new Error(a.getHeader(o.ERROR_HEADER)))) : r.next(a);
+        },
+        error(a) {
+          r.error(a);
+        },
+        complete() {
+          r.complete();
+        }
+      });
+      return r.add(c), e.setHeader(o.REPLY_TO_HEADER, this.replyToCri), e.setHeader(o.CORRELATION_ID_HEADER, i), this.send(e), () => {
+        if (t && !n) {
+          const a = new g(e.cri);
+          a.setHeader(o.CONTROL_HEADER, o.CONTROL_VALUE_CANCEL), a.setHeader(o.CORRELATION_ID_HEADER, i), this.send(a);
+        }
+      };
+    }) : N(() => this.createSendUnavailableError());
+  }
+  observe(e) {
+    return this._observe(e);
+  }
+  cleanup() {
+    this.requestRepliesSubject != null && (this.requestRepliesSubject.error(new Error("Connection disconnected")), this.requestRepliesSubscription != null && (this.requestRepliesSubscription.unsubscribe(), this.requestRepliesSubscription = null), this.requestRepliesSubject = null, this.requestRepliesObservable = null), this.errorSubjectSubscription && (this.errorSubjectSubscription.unsubscribe(), this.errorSubjectSubscription = null), this.serverInfo = null;
+  }
+  /**
+   * Creates the proper error to return if this.stompConnectionManager?.rxStomp is not available on a send request
+   */
+  createSendUnavailableError() {
+    let e = "You must call connect on the event bus before sending any request";
+    return this.stompConnectionManager.maxConnectionAttemptsReached && (e = "Max connection attempts reached event bus is not available"), new Error(e);
+  }
+  /**
+   * This is internal impl of observe that creates a cold observable.
+   * The public variants transform this to some type of hot observable depending on the need
+   * @param cri to observe
+   * @return the cold {@link Observable<IEvent>} for the given destination
+   */
+  _observe(e) {
+    return this.stompConnectionManager?.rxStomp ? this.stompConnectionManager.rxStomp.watch(e).pipe(R((t) => {
+      const r = /* @__PURE__ */ new Map();
+      let n = "";
+      for (const i of Object.keys(t.headers))
+        i === "destination" ? n = t.headers[i] : r.set(i, t.headers[i]);
+      return new g(n, r, t.binaryBody);
+    })) : N(() => this.createSendUnavailableError());
+  }
+}
+class E {
+  _scheme;
+  _scope;
+  _resourceName;
+  _path;
+  _version;
+  _raw;
+  constructor(...e) {
+    if (e.length === 1) {
+      const t = e[0];
+      if (typeof t != "string")
+        throw new Error("Raw URI must be a string");
+      const r = E.parseRaw(t);
+      this._scheme = r.scheme, this._scope = r.scope, this._resourceName = r.resourceName, this._path = r.path, this._version = r.version, this._raw = t;
+    } else if (e.length === 5) {
+      const [t, r, n, i, c] = e;
+      this._scheme = t, this._scope = r, this._resourceName = n, this._path = i, this._version = c, this._raw = E.buildRaw(t, r, n, i, c);
+    } else
+      throw new Error("Invalid constructor arguments for DefaultCRI");
+    if (!this._scheme || !this._resourceName)
+      throw new Error(`Invalid CRI: scheme and resourceName are required. Got: ${this._raw}`);
+  }
+  scheme() {
+    return this._scheme;
+  }
+  scope() {
+    return this._scope;
+  }
+  hasScope() {
+    return this._scope !== null;
+  }
+  resourceName() {
+    return this._resourceName;
+  }
+  version() {
+    return this._version;
+  }
+  hasVersion() {
+    return this._version !== null;
+  }
+  path() {
+    return this._path;
+  }
+  hasPath() {
+    return this._path !== null;
+  }
+  baseResource() {
+    let e = `${this._scheme}://`;
+    return this.hasScope() && (e += `${this._scope}@`), e += this._resourceName, e;
+  }
+  raw() {
+    return this._raw;
+  }
+  equals(e) {
+    return this === e ? !0 : e instanceof E ? this._raw === e.raw() : !1;
+  }
+  hashCode() {
+    let e = 17;
+    return e = e * 37 + this._raw.split("").reduce((t, r) => t + r.charCodeAt(0), 0), e;
+  }
+  toString() {
+    return this._raw;
+  }
+  // Helper to parse a raw CRI string
+  static parseRaw(e) {
+    const t = /^([^:]+):\/\/(?:([^@]+)@)?([^\/#]+)(\/[^#]*)?(?:#(.+))?$/, r = e.match(t);
+    if (!r)
+      throw new Error(`Invalid CRI format: ${e}`);
+    const [, n, i, c, a, h] = r;
+    return {
+      scheme: n,
+      scope: i || null,
+      resourceName: c,
+      path: a ? a.substring(1) : null,
+      version: h || null
+    };
+  }
+  // Helper to build a raw CRI string
+  static buildRaw(e, t, r, n, i) {
+    let c = `${e}://`;
+    return t && (c += `${t}@`), c += r, n && (c += `/${n}`), i && (c += `#${i}`), c;
+  }
+}
+function I(...s) {
+  if (s.length === 1) return new E(s[0]);
+  if (s.length === 2) return new E(s[0], null, s[1], null, null);
+  if (s.length === 3) return new E(s[0], s[1], s[2], null, null);
+  if (s.length === 5) return new E(s[0], s[1], s[2], s[3], s[4]);
+  throw new Error("Invalid arguments for createCRI");
+}
+class Q {
+  resolveArguments(e) {
+    if (this.containsJsonContent(e)) {
+      const t = e.getDataString();
+      return t ? JSON.parse(t) : [];
+    } else
+      throw new Error("Currently only JSON content is supported");
+  }
+  containsJsonContent(e) {
+    const t = e.getHeader(o.CONTENT_TYPE_HEADER);
+    return t != null && t !== "" && t === "application/json";
+  }
+}
+class O {
+  static createReplyEvent(e, t, r) {
+    if (!e)
+      throw new Error("incomingHeaders cannot be null");
+    const n = e.get(o.REPLY_TO_HEADER);
+    if (!n || n.trim() === "")
+      throw new Error("No reply-to header found, cannot create outgoing message");
+    const i = /* @__PURE__ */ new Map();
+    for (const [c, a] of e)
+      c.startsWith("__") && i.set(c, a);
+    if (t)
+      for (const [c, a] of t)
+        i.set(c, a);
+    return new g(n, i, r || void 0);
+  }
+}
+class ee {
+  convert(e, t) {
+    return O.createReplyEvent(
+      e,
+      /* @__PURE__ */ new Map([[o.CONTENT_TYPE_HEADER, "application/json"]]),
+      new TextEncoder().encode(JSON.stringify(t))
+    );
+  }
+}
+function te(s) {
+  let e;
+  try {
+    e = require("debug")(s);
+  } catch {
+    e = (...r) => console.debug(`[${s}]`, ...r);
+  }
+  return {
+    trace: (...t) => e("TRACE", ...t),
+    debug: (...t) => e("DEBUG", ...t),
+    info: (...t) => e("INFO", ...t),
+    warn: (...t) => e("WARN", ...t),
+    error: (...t) => e("ERROR", ...t)
+  };
+}
+class re {
+  namespace;
+  name;
+  scope;
+  version;
+  _cri = null;
+  constructor(e, t) {
+    this.namespace = e, this.name = t;
+  }
+  /**
+   * Returns the qualified name for this {@link ServiceIdentifier}
+   * This is the namespace.name
+   * @return string containing the qualified name
+   */
+  qualifiedName() {
+    return this.namespace + "." + this.name;
+  }
+  /**
+   * The {@link CRI} that represents this {@link ServiceIdentifier}
+   * @return the cri for this {@link ServiceIdentifier}
+   */
+  cri() {
+    return this._cri == null && (this._cri = I(
+      o.SERVICE_DESTINATION_SCHEME,
+      // scheme
+      this.scope || null,
+      // scope
+      this.qualifiedName(),
+      // resourceName
+      null,
+      // path (null as per your example)
+      this.version || null
+      // version
+    )), this._cri;
+  }
+}
+const P = /* @__PURE__ */ Symbol("scope"), x = /* @__PURE__ */ Symbol("version"), T = /* @__PURE__ */ Symbol("context");
+function ke(s, e, t) {
+  Reflect.defineMetadata(P, e, s);
+}
+function Be(s) {
+  if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9]+)?$/.test(s))
+    throw new Error(`Invalid semantic version: ${s}. Must follow X.Y.Z[-optional] format.`);
+  return function(e) {
+    Reflect.defineMetadata(x, s, e);
+  };
+}
+function qe() {
+  return function(s, e, t) {
+    const r = Reflect.getMetadata(T, s, e) || [];
+    r.push(t), Reflect.defineMetadata(T, r, s, e);
+  };
+}
+function Fe(s, e) {
+  return function(t) {
+    const r = t, n = new re(s, e || t.name), i = Reflect.getMetadata(x, t);
+    i && (n.version = i);
+    const c = function(...a) {
+      const h = Reflect.construct(r, a), p = Reflect.getMetadata(P, t.prototype);
+      if (p) {
+        const u = h[p];
+        n.scope = typeof u == "function" ? u.call(h) : u;
+      }
+      return D.serviceRegistry.register(n, h), h;
+    };
+    return c.prototype = r.prototype, c;
+  };
+}
+class se {
+  log;
+  active = !1;
+  eventBusService;
+  interceptorProvider;
+  argumentResolver;
+  returnValueConverter;
+  serviceIdentifier;
+  serviceInstance;
+  methodSubscription = null;
+  methodMap;
+  constructor(e, t, r, n, i = {}) {
+    if (!e) throw new Error("ServiceIdentifier must not be null");
+    if (!t) throw new Error("Service instance must not be null");
+    if (!r) throw new Error("EventBusService must not be null");
+    if (!n) throw new Error("interceptorProvider must not be null");
+    this.serviceIdentifier = e, this.serviceInstance = t, this.eventBusService = r, this.interceptorProvider = n, this.log = i.logger || te("continuum:ServiceInvocationSupervisor"), this.argumentResolver = i.argumentResolver || new Q(), this.returnValueConverter = i.returnValueConverter || new ee(), this.methodMap = this.buildMethodMap(t);
+  }
+  isActive() {
+    return this.active;
+  }
+  start() {
+    if (this.active)
+      throw new Error("Service already started");
+    this.active = !0;
+    const e = this.serviceIdentifier.cri().baseResource();
+    this.methodSubscription = this.eventBusService.observe(e).subscribe({
+      next: async (t) => {
+        await this.processEvent(t);
+      },
+      error: (t) => {
+        this.log.error("Event listener error", t), this.active = !1;
+      },
+      complete: () => {
+        this.log.error("Event listener stopped unexpectedly. Setting supervisor inactive."), this.active = !1;
+      }
+    }), this.log.info(`ServiceInvocationSupervisor started for ${e}`);
+  }
+  stop() {
+    if (!this.active)
+      throw new Error("Service already stopped");
+    this.active = !1, this.methodSubscription && (this.methodSubscription.unsubscribe(), this.methodSubscription = null), this.log.info("ServiceInvocationSupervisor stopped");
+  }
+  buildMethodMap(e) {
+    const t = {};
+    for (const r of Object.getOwnPropertyNames(Object.getPrototypeOf(e))) {
+      const n = e[r];
+      typeof n == "function" && r !== "constructor" && (t[r] = n.bind(e));
+    }
+    return t;
+  }
+  async processEvent(e) {
+    const t = e.hasHeader(o.CONTROL_HEADER);
+    this.log.trace(`Service ${t ? "Control" : "Invocation"} requested for ${e.cri}`);
+    try {
+      t ? this.processControlPlaneRequest(e) : this.validateReplyTo(e) ? await this.processInvocationRequest(e) : this.log.error(`ReplyTo header missing or invalid. Ignoring event: ${JSON.stringify(e)}`);
+    } catch (r) {
+      this.log.debug(`Exception processing service request: ${JSON.stringify(e)}`, r), this.handleException(e, r);
+    }
+  }
+  processControlPlaneRequest(e) {
+    const t = e.getHeader(o.CORRELATION_ID_HEADER);
+    if (!t)
+      throw new Error("Streaming control plane messages require a CORRELATION_ID_HEADER");
+    this.log.trace(`Processing control event for correlationId: ${t}`);
+  }
+  async processInvocationRequest(e) {
+    const t = I(e.cri).path();
+    if (!t)
+      throw new Error("The methodId must not be blank");
+    const r = this.methodMap[t];
+    if (!r)
+      throw new Error(`No method resolved for methodId ${t}`);
+    const n = t, i = this.argumentResolver.resolveArguments(e), c = Reflect.getMetadata(T, this.serviceInstance, n) || [];
+    let a = {};
+    const h = this.interceptorProvider();
+    if (h)
+      try {
+        a = await h.intercept(e, a);
+      } catch (l) {
+        this.log.error(`Interceptor failed to create context for event: ${JSON.stringify(e)}`, l), this.handleException(e, new Error("Internal server error"));
+        return;
+      }
+    for (const l of c)
+      i[l] = a;
+    const p = r.length;
+    if (i.length !== p)
+      throw new Error(`Argument count mismatch for method ${t}: expected ${p}, got ${i.length}`);
+    let u;
+    try {
+      u = r(...i), u instanceof Promise ? u.then(
+        (l) => this.processMethodInvocationResult(e, l),
+        (l) => this.handleException(e, l)
+      ) : this.processMethodInvocationResult(e, u);
+    } catch (l) {
+      this.handleException(e, l);
+    }
+  }
+  processMethodInvocationResult(e, t) {
+    const r = this.returnValueConverter.convert(e.headers, t);
+    this.eventBusService.send(r);
+  }
+  handleException(e, t) {
+    const r = O.createReplyEvent(
+      e.headers,
+      /* @__PURE__ */ new Map([
+        [o.ERROR_HEADER, t.message || "Unknown error"],
+        [o.CONTENT_TYPE_HEADER, "application/json"]
+      ]),
+      new TextEncoder().encode(JSON.stringify({ message: t.message }))
+    );
+    this.eventBusService.send(r);
+  }
+  validateReplyTo(e) {
+    const t = e.getHeader(o.REPLY_TO_HEADER);
+    return t ? t.trim() === "" ? (this.log.warn("Reply-to header must not be blank"), !1) : t.startsWith(`${o.SERVICE_DESTINATION_SCHEME}:`) ? !0 : (this.log.warn("Reply-to header must be a valid service destination"), !1) : (this.log.warn("No reply-to header found in event"), !1);
+  }
+}
+const ne = "2.14.6", ie = {
+  version: ne
+};
+class oe {
+  create(e, t) {
+    const r = new g(e);
+    return r.setHeader(o.CONTENT_TYPE_HEADER, o.CONTENT_JSON), t != null && r.setDataString(JSON.stringify(t)), r;
+  }
+}
+class $e {
+  create(e, t) {
+    const r = new g(e);
+    if (r.setHeader(o.CONTENT_TYPE_HEADER, o.CONTENT_TEXT), t != null) {
+      let n = "", i = 0;
+      for (const c of t)
+        i > 0 && (n = n + `
+`), n = n + c, i++;
+      n.length > 0 && r.setDataString(n);
+    }
+    return r;
+  }
+}
+class ce {
+  eventBus;
+  supervisors = /* @__PURE__ */ new Map();
+  contextInterceptor = null;
+  constructor(e) {
+    this.eventBus = e;
+  }
+  serviceProxy(e) {
+    return new ue(e, this.eventBus);
+  }
+  register(e, t) {
+    const r = e.cri().raw();
+    if (!this.supervisors.has(r)) {
+      const n = new se(
+        e,
+        t,
+        this.eventBus,
+        () => this.contextInterceptor
+      );
+      this.supervisors.set(r, n), n.start();
+    }
+  }
+  unRegister(e) {
+    const t = e.cri().raw(), r = this.supervisors.get(t);
+    r && (r.stop(), this.supervisors.delete(t));
+  }
+  registerContextInterceptor(e) {
+    this.contextInterceptor = e;
+  }
+}
+const ae = new oe();
+class ue {
+  serviceIdentifier;
+  eventBus;
+  tracer;
+  constructor(e, t) {
+    if (typeof e > "u" || e.length === 0)
+      throw new Error("The serviceIdentifier provided must contain a value");
+    this.serviceIdentifier = e, this.eventBus = t, this.tracer = b.trace.getTracer(
+      "continuum.client",
+      ie.version
+    );
+  }
+  invoke(e, t, r, n) {
+    return this.tracer.startActiveSpan(
+      `${this.serviceIdentifier}/${e}`,
+      {
+        kind: U.CLIENT
+      },
+      async (i) => (r && i.setAttribute("continuum.scope", r), i.setAttribute("rpc.system", "continuum"), i.setAttribute("rpc.service", this.serviceIdentifier), i.setAttribute("rpc.method", e), this.__invokeStream(!1, e, t, r, n).pipe(W()).toPromise().then(
+        async (c) => (i.end(), c),
+        async (c) => {
+          throw i.recordException(c), i.setStatus({ code: Y.ERROR }), i.end(), c;
+        }
+      ))
+    );
+  }
+  invokeStream(e, t, r, n) {
+    return this.__invokeStream(!0, e, t, r, n);
+  }
+  __invokeStream(e, t, r, n, i) {
+    const c = o.SERVICE_DESTINATION_PREFIX + (n != null ? n + "@" : "") + this.serviceIdentifier + "/" + t;
+    let a = ae;
+    i ? a = i : f.getEventFactory() && (a = f.getEventFactory());
+    let h = this.eventBus;
+    f.getContinuumInstance() && (h = f.getContinuumInstance().eventBus);
+    const p = b.trace.getActiveSpan();
+    p && (p.setAttribute(G, h.serverInfo?.host || "unknown"), p.setAttribute(K, h.serverInfo?.port || "unknown"));
+    let u = a.create(c, r);
+    return h.requestStream(u, e).pipe(R((l) => {
+      const d = l.getHeader(o.CONTENT_TYPE_HEADER);
+      if (d !== void 0) {
+        if (d === "application/json")
+          return JSON.parse(l.getDataString());
+        if (d === "text/plain")
+          return l.getDataString();
+        throw new Error("Content Type " + d + " is not supported");
+      } else
+        return null;
+    }));
+  }
+}
+class _ {
+  pageable;
+  currentPage;
+  firstPage = !0;
+  constructor(e, t) {
+    this.pageable = e, this.currentPage = t;
+  }
+  async next() {
+    let e;
+    if (this.firstPage)
+      this.firstPage = !1, e = { done: !this.hasContent(), value: this };
+    else if (this.isOffsetPageable()) {
+      const t = this.pageable;
+      t.pageNumber++;
+      const r = Math.ceil(this.totalElements / this.pageable.pageSize);
+      t.pageNumber < r ? (this.currentPage = await this.findNext(this.pageable), e = { done: !1, value: this }) : e = { done: !0, value: this };
+    } else {
+      const t = this.pageable;
+      t.cursor = this.currentPage.cursor || null, this.currentPage = await this.findNext(this.pageable), e = { done: this.isLastPage(), value: this };
+    }
+    return e;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  hasContent() {
+    return this.currentPage.content !== null && this.currentPage.content !== void 0 && this.currentPage.content.length > 0;
+  }
+  isLastPage() {
+    let e;
+    return this.isOffsetPageable() ? e = Math.ceil(this.totalElements / this.pageable.pageSize) === this.pageable.pageNumber + 1 : e = !this.firstPage && this.currentPage.cursor === null, e;
+  }
+  isOffsetPageable() {
+    return this.pageable.pageNumber !== void 0;
+  }
+  get totalElements() {
+    return this.currentPage.totalElements;
+  }
+  get cursor() {
+    return this.currentPage.cursor;
+  }
+  get content() {
+    return this.currentPage.content;
+  }
+}
+class le extends _ {
+  crudServiceProxy;
+  constructor(e, t, r) {
+    super(e, t), this.crudServiceProxy = r;
+  }
+  findNext(e) {
+    return this.crudServiceProxy.findAllSinglePage(e);
+  }
+}
+class he extends _ {
+  searchText;
+  crudServiceProxy;
+  constructor(e, t, r, n) {
+    super(e, t), this.searchText = r, this.crudServiceProxy = n;
+  }
+  findNext(e) {
+    return this.crudServiceProxy.searchSinglePage(this.searchText, e);
+  }
+}
+class pe {
+  serviceProxy;
+  constructor(e) {
+    this.serviceProxy = e;
+  }
+  count() {
+    return this.serviceProxy.invoke("count");
+  }
+  create(e) {
+    return this.serviceProxy.invoke("create", [e]);
+  }
+  deleteById(e) {
+    return this.serviceProxy.invoke("deleteById", [e]);
+  }
+  async findAll(e) {
+    const t = await this.findAllSinglePage(e);
+    return new le(e, t, this);
+  }
+  findAllSinglePage(e) {
+    return this.serviceProxy.invoke("findAll", [e]);
+  }
+  findById(e) {
+    return this.serviceProxy.invoke("findById", [e]);
+  }
+  save(e) {
+    return this.serviceProxy.invoke("save", [e]);
+  }
+  findByIdNotIn(e, t) {
+    return this.serviceProxy.invoke("findByIdNotIn", [e, t]);
+  }
+  async search(e, t) {
+    const r = await this.searchSinglePage(e, t);
+    return new he(t, r, e, this);
+  }
+  searchSinglePage(e, t) {
+    return this.serviceProxy.invoke("search", [e, t]);
+  }
+}
+class de {
+  serviceRegistry;
+  constructor(e) {
+    this.serviceRegistry = e;
+  }
+  crudServiceProxy(e) {
+    if (typeof e > "u" || e.length === 0)
+      throw new Error("The serviceIdentifier provided must contain a value");
+    return new pe(this.serviceRegistry.serviceProxy(e));
+  }
+}
+class Ee {
+  continuumOverride = [];
+  getContinuumInstance() {
+    return this.continuumOverride[this.continuumOverride.length - 1]?.instance;
+  }
+  getEventFactory() {
+    return this.continuumOverride[this.continuumOverride.length - 1]?.eventFactory;
+  }
+  /**
+   * Sets the current {@link ContinuumContext} instance to use for all {@link IServiceProxy} instances invoked with {@link ContinuumContext.execute}
+   * @param continuumContext
+   */
+  push(e) {
+    this.continuumOverride.push(e);
+  }
+  /**
+   * Removes the current {@link ContinuumContext} from the stack
+   */
+  pop() {
+    this.continuumOverride.pop();
+  }
+}
+const f = new Ee();
+class fe {
+  /**
+   * The {@link IEventBus} that is used to communicate with the Continuum server
+   */
+  eventBus;
+  /**
+   * The {@link ServiceRegistry} that is used to manage the services that are available
+   */
+  serviceRegistry;
+  /**
+   * The {@link CrudServiceProxyFactory} that is used to create {@link ICrudServiceProxy} instances
+   */
+  crudServiceProxyFactory;
+  constructor() {
+    this.eventBus = new Z(), this.serviceRegistry = new ce(this.eventBus), this.crudServiceProxyFactory = new de(this.serviceRegistry);
+  }
+  /**
+   * Requests a connection to the given Stomp url
+   * @param connectionInfo provides the information needed to connect to the continuum server
+   * @return Promise containing the result of the initial connection attempt
+   */
+  connect(e) {
+    return this.eventBus.connect(e);
+  }
+  /**
+   * Disconnects the client from the server
+   * This will clear any subscriptions and close the connection
+   */
+  disconnect(e) {
+    return this.eventBus.disconnect(e);
+  }
+  /**
+   * Creates a new service proxy that can be used to access the desired service.
+   * @param serviceIdentifier the identifier of the service to be accessed
+   * @return the {@link IServiceProxy} that can be used to access the service
+   */
+  serviceProxy(e) {
+    return this.serviceRegistry.serviceProxy(e);
+  }
+  /**
+   * Returns a {@link ICrudServiceProxy} for the given service identifier
+   * @param serviceIdentifier the identifier of the service to be accessed
+   */
+  crudServiceProxy(e) {
+    return this.crudServiceProxyFactory.crudServiceProxy(e);
+  }
+  /**
+   * Allows for the execution of a function that requires a connection to the Continuum server
+   * When the function is executed any calls using an {@link IServiceProxy} will be executed using the connection defined by this {@link ContinuumSingleton}
+   * @param toExecute the function to execute
+   * @param eventFactory an optional {@link IEventFactory} to use for the duration of the execution
+   * @return the result of the function that was executed
+   * @deprecated we have decided to deprecate this method as it is not thread safe and can cause issues when used in async operations
+   * NOTE: this method is experimental and does not work well across multiple threads / async operations
+   */
+  async execute(e, t) {
+    const r = f;
+    r.push({ instance: this, eventFactory: t });
+    let n;
+    try {
+      n = await e();
+    } finally {
+      r.pop();
+    }
+    return n;
+  }
+}
+const D = new fe();
+var ge = /* @__PURE__ */ ((s) => (s.TRACE = "TRACE", s.DEBUG = "DEBUG", s.INFO = "INFO", s.WARN = "WARN", s.ERROR = "ERROR", s.FATAL = "FATAL", s.OFF = "OFF", s))(ge || {});
+class y {
+  configuredLevel;
+}
+class me extends y {
+  members = [];
+}
+class ve extends y {
+  effectiveLevel;
+}
+class Ue {
+  levels = [];
+  loggerLevels = /* @__PURE__ */ new Map();
+  groups = /* @__PURE__ */ new Map();
+}
+class Se {
+  serviceProxy;
+  constructor() {
+    this.serviceProxy = D.serviceProxy("org.kinotic.continuum.api.log.LogManager");
+  }
+  loggers(e) {
+    return this.serviceProxy.invoke("loggers", null, e);
+  }
+  async loggerLevels(e, t) {
+    const r = await this.serviceProxy.invoke("loggerLevels", [t], e);
+    let n = null;
+    return r.hasOwnProperty("members") ? n = new me() : r.hasOwnProperty("effectiveLevel") ? n = new ve() : n = new y(), Object.assign(n, r), n;
+  }
+  configureLogLevel(e, t, r) {
+    return this.serviceProxy.invoke("configureLogLevel", [t, r], e);
+  }
+}
+const Ye = new Se();
+class H extends m {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, H.prototype);
+  }
+}
+class L extends m {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, L.prototype);
+  }
+}
+class Ve {
+  sessionId;
+  replyToId;
+  participant;
+}
+class je {
+  id;
+  tenantId;
+  metadata;
+  roles;
+  constructor(e, t, r, n) {
+    this.id = e, this.tenantId = t, this.metadata = r || /* @__PURE__ */ new Map(), this.roles = n || [];
+  }
+}
+class Je {
+  static PARTICIPANT_TYPE_METADATA_KEY = "type";
+  static PARTICIPANT_TYPE_DEVICE = "device";
+  static PARTICIPANT_TYPE_CLI = "cli";
+  static PARTICIPANT_TYPE_USER = "user";
+  static PARTICIPANT_TYPE_NODE = "node";
+  static CLI_PARTICIPANT_ID = "-42-Continuum-CLI-42-";
+}
+var Re = /* @__PURE__ */ ((s) => (s.EXISTING = "EXISTING", s.UPDATE = "UPDATE", s.REMOVE = "REMOVE", s))(Re || {});
+class Xe {
+  streamOperation;
+  id;
+  value;
+  constructor(e, t, r) {
+    this.streamOperation = e, this.id = t, this.value = r;
+  }
+  isSet() {
+    return this.value !== null && this.value !== void 0;
+  }
+}
+class We extends _ {
+  pageFunction;
+  constructor(e, t, r) {
+    super(e, t), this.pageFunction = r;
+  }
+  findNext(e) {
+    return this.pageFunction(e);
+  }
+}
+class Ge {
+  static instanceOfEditableDataSource(e) {
+    return "create" in e;
+  }
+}
+class M {
+  /**
+   * Returns the sorting parameters (optional).
+   */
+  sort = null;
+  /**
+   * Returns the number of items to be returned.
+   */
+  pageSize = 25;
+  /**
+   * Creates a {@link Pageable} that uses Offset based pagination.
+   * @param pageNumber zero based page index.
+   * @param pageSize the size of the page to be returned.
+   * @param sort the sorting parameters (optional).
+   */
+  static create(e, t, r) {
+    return new Te(e, t, r);
+  }
+  /**
+   * Creates a {@link Pageable} that uses Cursor based pagination.
+   * @param cursor the cursor to be used for subsequent retrieval of data, or null if this is the first page.
+   * @param pageSize the size of the page to be returned.
+   * @param sort the sorting parameters (optional).
+   */
+  static createWithCursor(e, t, r) {
+    return new _e(e, t, r);
+  }
+}
+class Te extends M {
+  /**
+   * Returns the page to be returned.
+   */
+  pageNumber = 0;
+  /**
+   * Creates a {@link Pageable} that uses Offset based pagination.
+   * @param pageNumber zero based page index.
+   * @param pageSize the size of the page to be returned.
+   * @param sort the sorting parameters (optional).
+   */
+  constructor(e, t, r) {
+    super(), this.pageNumber = e, this.pageSize = t, this.sort = r;
+  }
+}
+class _e extends M {
+  /**
+   * The cursor to be used for subsequent retrieval of data, or null if this is the first page.
+   */
+  cursor;
+  /**
+   * Creates a {@link Pageable} that uses Cursor based pagination.
+   * @param cursor the cursor to be used for subsequent retrieval of data, or null if this is the first page.
+   * @param pageSize the size of the page to be returned.
+   * @param sort the sorting parameters (optional).
+   */
+  constructor(e, t, r) {
+    super(), this.cursor = e, this.pageSize = t, this.sort = r;
+  }
+}
+var ye = /* @__PURE__ */ ((s) => (s.ASC = "ASC", s.DESC = "DESC", s))(ye || {}), be = /* @__PURE__ */ ((s) => (s.NATIVE = "NATIVE", s.NULLS_FIRST = "NULLS_FIRST", s.NULLS_LAST = "NULLS_LAST", s))(be || {});
+class Ke {
+  property;
+  direction = "ASC";
+  nullHandling = "NATIVE";
+  constructor(e, t) {
+    this.property = e, t !== null && (this.direction = t);
+  }
+  /**
+   * Returns whether sorting for this property shall be ascending.
+   */
+  isAscending() {
+    return this.direction === "ASC";
+  }
+  /**
+   * Returns whether sorting for this property shall be descending.
+   */
+  isDescending() {
+    return this.direction === "DESC";
+  }
+}
+class ze {
+  orders = [];
+}
+export {
+  _ as AbstractIterablePage,
+  H as AuthenticationError,
+  L as AuthorizationError,
+  T as CONTEXT_METADATA_KEY,
+  Le as ConnectHeaders,
+  Ve as ConnectedInfo,
+  Me as ConnectionInfo,
+  qe as Context,
+  D as Continuum,
+  f as ContinuumContextStack,
+  m as ContinuumError,
+  fe as ContinuumSingleton,
+  pe as CrudServiceProxy,
+  de as CrudServiceProxyFactory,
+  _e as CursorPageable,
+  Ge as DataSourceUtils,
+  E as DefaultCRI,
+  ye as Direction,
+  g as Event,
+  Z as EventBus,
+  o as EventConstants,
+  We as FunctionalIterablePage,
+  me as GroupLoggerLevelsDescriptor,
+  oe as JsonEventFactory,
+  ge as LogLevel,
+  Se as LogManager,
+  y as LoggerLevelsDescriptor,
+  Ue as LoggersDescriptor,
+  be as NullHandling,
+  Te as OffsetPageable,
+  Ke as Order,
+  M as Pageable,
+  je as Participant,
+  Je as ParticipantConstants,
+  Fe as Publish,
+  ke as Scope,
+  w as ServerInfo,
+  ce as ServiceRegistry,
+  ve as SingleLoggerLevelsDescriptor,
+  ze as Sort,
+  Xe as StreamData,
+  Re as StreamOperation,
+  $e as TextEventFactory,
+  Be as Version,
+  I as createCRI,
+  Ye as logManager
+};
+//# sourceMappingURL=continuum.js.map