@trycourier/courier-js 2.0.2-beta → 2.0.4-beta

package/dist/index.mjs

@@ -1,96 +1,32 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-const _CourierSocket = class _CourierSocket {
-  constructor(url, options) {
-    // Properties
-    __publicField(this, "webSocket", null);
-    __publicField(this, "pingInterval", null);
-    // Callbacks
-    __publicField(this, "onOpen");
-    __publicField(this, "onMessageReceived");
-    __publicField(this, "onClose");
-    __publicField(this, "onError");
-    // Properties
-    __publicField(this, "url");
-    __publicField(this, "options");
-    this.url = url;
-    this.options = options;
-  }
-  /**
-   * Dynamically checks if the WebSocket is connected
-   */
-  get isConnected() {
-    return this.webSocket !== null;
-  }
-  async connect() {
-    this.disconnect();
-    return new Promise((resolve, reject) => {
-      try {
-        this.webSocket = new WebSocket(this.url);
-        this.webSocket.onopen = () => {
-          var _a;
-          (_a = this.onOpen) == null ? void 0 : _a.call(this);
-          resolve();
-        };
-        this.webSocket.onmessage = (event) => {
-          var _a;
-          (_a = this.onMessageReceived) == null ? void 0 : _a.call(this, event.data);
-        };
-        this.webSocket.onclose = (event) => {
-          var _a;
-          this.webSocket = null;
-          (_a = this.onClose) == null ? void 0 : _a.call(this, event.code, event.reason);
-        };
-        this.webSocket.onerror = (event) => {
-          var _a;
-          this.webSocket = null;
-          const error = new Error("Courier Socket connection failed");
-          error.originalEvent = event;
-          (_a = this.onError) == null ? void 0 : _a.call(this, error);
-          reject(error);
-        };
-      } catch (error) {
-        this.webSocket = null;
-        reject(error);
-      }
-    });
-  }
-  disconnect() {
-    this.stopPing();
-    if (this.webSocket) {
-      this.webSocket.close(_CourierSocket.NORMAL_CLOSURE_STATUS);
-      this.webSocket = null;
-    }
-  }
-  async send(message) {
-    if (!this.webSocket) {
-      return false;
-    }
-    const json = JSON.stringify(message);
-    return this.webSocket.send(json) !== void 0;
-  }
-  keepAlive(props) {
-    this.stopPing();
-    this.pingInterval = setInterval(async () => {
-      var _a;
-      try {
-        await this.send({ action: "keepAlive" });
-      } catch (error) {
-        (_a = this.options.logger) == null ? void 0 : _a.error("Error occurred on Keep Alive:", error);
-      }
-    }, (props == null ? void 0 : props.intervalInMillis) ?? 3e5);
-  }
-  stopPing() {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
-    }
-  }
-};
-// Constants
-__publicField(_CourierSocket, "NORMAL_CLOSURE_STATUS", 1e3);
-let CourierSocket = _CourierSocket;
+var ClientAction = /* @__PURE__ */ ((ClientAction2) => {
+  ClientAction2["Subscribe"] = "subscribe";
+  ClientAction2["Unsubscribe"] = "unsubscribe";
+  ClientAction2["Pong"] = "pong";
+  ClientAction2["Ping"] = "ping";
+  ClientAction2["GetConfig"] = "get-config";
+  return ClientAction2;
+})(ClientAction || {});
+var ServerAction = /* @__PURE__ */ ((ServerAction2) => {
+  ServerAction2["Ping"] = "ping";
+  return ServerAction2;
+})(ServerAction || {});
+var InboxMessageEvent = /* @__PURE__ */ ((InboxMessageEvent2) => {
+  InboxMessageEvent2["NewMessage"] = "message";
+  InboxMessageEvent2["Archive"] = "archive";
+  InboxMessageEvent2["ArchiveAll"] = "archive-all";
+  InboxMessageEvent2["ArchiveRead"] = "archive-read";
+  InboxMessageEvent2["Clicked"] = "clicked";
+  InboxMessageEvent2["MarkAllRead"] = "mark-all-read";
+  InboxMessageEvent2["Opened"] = "opened";
+  InboxMessageEvent2["Read"] = "read";
+  InboxMessageEvent2["Unarchive"] = "unarchive";
+  InboxMessageEvent2["Unopened"] = "unopened";
+  InboxMessageEvent2["Unread"] = "unread";
+  return InboxMessageEvent2;
+})(InboxMessageEvent || {});
 const getCourierApiUrls = (urls) => ({
   courier: {
     rest: (urls == null ? void 0 : urls.courier.rest) || "https://api.courier.com",
@@ -98,7 +34,7 @@ const getCourierApiUrls = (urls) => ({
   },
   inbox: {
     graphql: (urls == null ? void 0 : urls.inbox.graphql) || "https://inbox.courier.com/q",
-    webSocket: (urls == null ? void 0 : urls.inbox.webSocket) || "wss://realtime.courier.com"
+    webSocket: (urls == null ? void 0 : urls.inbox.webSocket) || "wss://realtime.courier.io"
   }
 });
 class Logger {
@@ -132,12 +68,27 @@ class Logger {
     }
   }
 }
-class UUID {
-  static generate(prefix) {
-    const id = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    return prefix ? prefix + id : id;
+const _UUID = class _UUID {
+  /**
+   * nanoid
+   * Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+   *
+   * https://github.com/ai/nanoid/blob/main/LICENSE
+   *
+   * @param size - The size of the UUID to generate.
+   * @returns A string representing the UUID.
+   */
+  static nanoid(size = 21) {
+    let id = "";
+    let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+    while (size--) {
+      id += _UUID.ALPHABET[bytes[size] & 63];
+    }
+    return id;
   }
-}
+};
+__publicField(_UUID, "ALPHABET", "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict");
+let UUID = _UUID;
 class CourierRequestError extends Error {
   constructor(code, message, type) {
     super(message);
@@ -166,7 +117,7 @@ Response JSON: ${JSON.stringify(data.response, null, 2)}
 }
 async function http(props) {
   const validCodes = props.validCodes ?? [200];
-  const uid = props.options.showLogs ? UUID.generate() : void 0;
+  const uid = props.options.showLogs ? UUID.nanoid() : void 0;
   const request = new Request(props.url, {
     method: props.method,
     headers: {
@@ -216,7 +167,7 @@ async function http(props) {
   return data;
 }
 async function graphql(props) {
-  const uid = props.options.showLogs ? UUID.generate() : void 0;
+  const uid = props.options.showLogs ? UUID.nanoid() : void 0;
   if (uid) {
     logRequest(props.options.logger, uid, "GraphQL", {
       url: props.url,
@@ -305,70 +256,536 @@ class BrandClient extends Client {
     return json.data.brand;
   }
 }
-class InboxSocket extends CourierSocket {
+const CLOSE_CODE_NORMAL_CLOSURE = 1e3;
+const IPW_VERSION = "v1";
+const _CourierSocket = class _CourierSocket {
   constructor(options) {
-    const url = InboxSocket.buildUrl(options);
-    super(url, options);
-    __publicField(this, "receivedMessage");
-    __publicField(this, "receivedMessageEvent");
-    this.onMessageReceived = (data) => this.convertToType(data);
-  }
-  convertToType(data) {
-    var _a, _b, _c, _d;
+    /** The WebSocket instance, which may be null if the connection is not established. */
+    __publicField(this, "webSocket", null);
+    /** The number of connection retry attempts so far, reset after a successful connection. */
+    __publicField(this, "retryAttempt", 0);
+    /** The timeout ID for the current connectionretry attempt, reset when we attempt to connect. */
+    __publicField(this, "retryTimeoutId", null);
+    __publicField(this, "url");
+    __publicField(this, "options");
+    this.url = options.apiUrls.inbox.webSocket;
+    this.options = options;
+  }
+  /**
+   * Connects to the Courier WebSocket server.
+   *
+   * If the connection is already established, this is a no-op.
+   *
+   * @returns A promise that resolves when the connection is established or rejects if the connection could not be established.
+   */
+  async connect() {
+    var _a;
+    this.clearRetryTimeout();
+    if (this.isConnecting || this.isOpen) {
+      (_a = this.options.logger) == null ? void 0 : _a.info("Attempted to open a WebSocket connection, but one already exists.");
+      return Promise.reject(new Error("WebSocket connection already exists"));
+    }
+    return new Promise((resolve, reject) => {
+      this.webSocket = new WebSocket(this.getWebSocketUrl());
+      this.webSocket.addEventListener("open", (event) => {
+        this.retryAttempt = 0;
+        this.onOpen(event);
+        resolve();
+      });
+      this.webSocket.addEventListener("message", async (event) => {
+        var _a2;
+        try {
+          const json = JSON.parse(event.data);
+          if ("event" in json && json.event === "reconnect") {
+            this.close(CLOSE_CODE_NORMAL_CLOSURE);
+            await this.retryConnection(json.retryAfter * 1e3);
+            return;
+          }
+          this.onMessageReceived(json);
+        } catch (error) {
+          (_a2 = this.options.logger) == null ? void 0 : _a2.error("Error parsing socket message", error);
+        }
+      });
+      this.webSocket.addEventListener("close", (event) => {
+        if (event.code !== CLOSE_CODE_NORMAL_CLOSURE) {
+          const courierCloseEvent = _CourierSocket.parseCloseEvent(event);
+          if (courierCloseEvent.retryAfterSeconds) {
+            this.retryConnection(courierCloseEvent.retryAfterSeconds * 1e3);
+          } else {
+            this.retryConnection();
+          }
+        }
+        this.onClose(event);
+      });
+      this.webSocket.addEventListener("error", (event) => {
+        this.retryConnection();
+        this.onError(event);
+        reject(event);
+      });
+    });
+  }
+  /**
+   * Closes the WebSocket connection.
+   *
+   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close} for more details.
+   *
+   * @param code The WebSocket close code. Defaults to {@link CLOSE_CODE_NORMAL_CLOSURE}.
+   * @param reason The WebSocket close reason.
+   */
+  close(code = CLOSE_CODE_NORMAL_CLOSURE, reason) {
+    if (this.webSocket === null) {
+      return;
+    }
+    this.webSocket.close(code, reason);
+    this.webSocket = null;
+  }
+  /**
+   * Sends a message to the Courier WebSocket server.
+   *
+   * @param message The message to send. The message will be serialized to a JSON string.
+   */
+  send(message) {
+    var _a;
+    if (this.webSocket === null || this.isConnecting) {
+      (_a = this.options.logger) == null ? void 0 : _a.info("Attempted to send a message, but the WebSocket is not yet open.");
+      return;
+    }
+    const json = JSON.stringify(message);
+    this.webSocket.send(json);
+  }
+  get userId() {
+    return this.options.userId;
+  }
+  get logger() {
+    return this.options.logger;
+  }
+  /**
+   * Whether the WebSocket connection is currently being established.
+   */
+  get isConnecting() {
+    return this.webSocket !== null && this.webSocket.readyState === WebSocket.CONNECTING;
+  }
+  /**
+   * Whether the WebSocket connection is currently open.
+   */
+  get isOpen() {
+    return this.webSocket !== null && this.webSocket.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Constructs the WebSocket URL for the Courier WebSocket server using context
+   * from the {@link CourierClientOptions} passed to the constructor.
+   *
+   * @returns The WebSocket URL
+   */
+  getWebSocketUrl() {
+    const accessToken = this.options.accessToken;
+    const connectionId = this.options.connectionId;
+    const userId = this.userId;
+    return `${this.url}?auth=${accessToken}&cid=${connectionId}&iwpv=${IPW_VERSION}&userId=${userId}`;
+  }
+  /**
+   * Parses the Retry-After time from the WebSocket close event reason,
+   * and returns a new {@link CourierCloseEvent} with the retry after time in seconds
+   * if present.
+   *
+   * The Courier WebSocket server may send the close event reason in the following format:
+   *
+   * ```json
+   * {
+   *   "Retry-After": "10" // The retry after time in seconds
+   * }
+   * ```
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/reason
+   *
+   * @param closeEvent The WebSocket close event.
+   * @returns The WebSocket close event with the retry after time in seconds.
+   */
+  static parseCloseEvent(closeEvent) {
+    if (closeEvent.reason === null || closeEvent.reason === "") {
+      return closeEvent;
+    }
     try {
-      const payload = JSON.parse(data);
-      switch (payload.type) {
-        case "event":
-          const messageEvent = JSON.parse(data);
-          (_a = this.receivedMessageEvent) == null ? void 0 : _a.call(this, messageEvent);
-          break;
-        case "message":
-          const message = JSON.parse(data);
-          (_b = this.receivedMessage) == null ? void 0 : _b.call(this, message);
-          break;
+      const jsonReason = JSON.parse(closeEvent.reason);
+      if (!jsonReason[_CourierSocket.RETRY_AFTER_KEY]) {
+        return closeEvent;
+      }
+      const retryAfterSeconds = parseInt(jsonReason[_CourierSocket.RETRY_AFTER_KEY]);
+      if (Number.isNaN(retryAfterSeconds) || retryAfterSeconds < 0) {
+        return closeEvent;
       }
+      return {
+        ...closeEvent,
+        retryAfterSeconds
+      };
     } catch (error) {
-      (_c = this.options.logger) == null ? void 0 : _c.error("Error parsing socket message", error);
-      if (error instanceof Error) {
-        (_d = this.onError) == null ? void 0 : _d.call(this, error);
+      return closeEvent;
+    }
+  }
+  /**
+   * Calculates the retry backoff time in milliseconds based on the current retry attempt.
+   */
+  getBackoffTimeInMillis() {
+    const backoffIntervalInMillis = _CourierSocket.BACKOFF_INTERVALS_IN_MILLIS[this.retryAttempt];
+    const lowerBound = backoffIntervalInMillis - backoffIntervalInMillis * _CourierSocket.BACKOFF_JITTER_FACTOR;
+    const upperBound = backoffIntervalInMillis + backoffIntervalInMillis * _CourierSocket.BACKOFF_JITTER_FACTOR;
+    return Math.floor(Math.random() * (upperBound - lowerBound) + lowerBound);
+  }
+  /**
+   * Retries the connection to the Courier WebSocket server after
+   * either {@param suggestedBackoffTimeInMillis} or a random backoff time
+   * calculated using {@link getBackoffTimeInMillis}.
+   *
+   * @param suggestedBackoffTimeInMillis The suggested backoff time in milliseconds.
+   * @returns A promise that resolves when the connection is established or rejects if the connection could not be established.
+   */
+  async retryConnection(suggestedBackoffTimeInMillis) {
+    var _a, _b, _c;
+    if (this.retryTimeoutId !== null) {
+      (_a = this.logger) == null ? void 0 : _a.debug("Skipping retry attempt because a previous retry is already scheduled.");
+      return;
+    }
+    if (this.retryAttempt >= _CourierSocket.MAX_RETRY_ATTEMPTS) {
+      (_b = this.logger) == null ? void 0 : _b.error(`Max retry attempts (${_CourierSocket.MAX_RETRY_ATTEMPTS}) reached.`);
+      return;
+    }
+    const backoffTimeInMillis = suggestedBackoffTimeInMillis ?? this.getBackoffTimeInMillis();
+    this.retryTimeoutId = window.setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (error) {
       }
+    }, backoffTimeInMillis);
+    (_c = this.logger) == null ? void 0 : _c.debug(`Retrying connection in ${Math.floor(backoffTimeInMillis / 1e3)}s. Retry attempt ${this.retryAttempt + 1} of ${_CourierSocket.MAX_RETRY_ATTEMPTS}.`);
+    this.retryAttempt++;
+  }
+  /**
+   * Clears the retry timeout if it exists.
+   */
+  clearRetryTimeout() {
+    if (this.retryTimeoutId !== null) {
+      window.clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
     }
   }
-  async sendSubscribe(props) {
-    var _a;
-    const subscription = {
-      action: "subscribe",
+};
+/**
+ * The jitter factor for the backoff intervals.
+ *
+ * Backoff with jitter is calculated as a random value in the range:
+ * [BACKOFF_INTERVAL - BACKOFF_JITTER_FACTOR * BACKOFF_INTERVAL,
+ *  BACKOFF_INTERVAL + BACKOFF_JITTER_FACTOR * BACKOFF_INTERVAL).
+ */
+__publicField(_CourierSocket, "BACKOFF_JITTER_FACTOR", 0.5);
+/**
+ * The maximum number of retry attempts.
+ */
+__publicField(_CourierSocket, "MAX_RETRY_ATTEMPTS", 5);
+/**
+ * Backoff intervals in milliseconds.
+ *
+ * Each represents an offset from the previous interval, rather than a
+ * absolute offset from the initial request time.
+ */
+__publicField(_CourierSocket, "BACKOFF_INTERVALS_IN_MILLIS", [
+  3e4,
+  // 30 seconds
+  6e4,
+  // 1 minute
+  12e4,
+  // 2 minutes
+  24e4,
+  // 4 minutes
+  48e4
+  // 8 minutes
+]);
+/**
+ * The key of the retry after time in the WebSocket close event reason.
+ *
+ * The Courier WebSocket server may send the close event reason in the following format:
+ *
+ * ```json
+ * {
+ *   "Retry-After": "10" // The retry after time in seconds
+ * }
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/reason
+ */
+__publicField(_CourierSocket, "RETRY_AFTER_KEY", "Retry-After");
+let CourierSocket = _CourierSocket;
+class TransactionManager {
+  constructor(completedTransactionsToKeep = 10) {
+    /**
+     * The map of <transactionId, Transaction> representing outstanding requests.
+     */
+    __publicField(this, "outstandingRequestsMap", /* @__PURE__ */ new Map());
+    /**
+     * The queue of completed requests. This is a FIFO queue of the last N completed requests,
+     * where N is {@link completedTransactionsToKeep}.
+     */
+    __publicField(this, "completedTransactionsQueue", []);
+    /**
+     * Number of completed requests to keep in memory.
+     */
+    __publicField(this, "completedTransactionsToKeep");
+    this.completedTransactionsToKeep = completedTransactionsToKeep;
+  }
+  addOutstandingRequest(transactionId, request) {
+    const isOutstanding = this.outstandingRequestsMap.has(transactionId);
+    if (isOutstanding) {
+      throw new Error(`Transaction [${transactionId}] already has an outstanding request`);
+    }
+    const transaction = {
+      transactionId,
+      request,
+      response: null,
+      start: /* @__PURE__ */ new Date(),
+      end: null
+    };
+    this.outstandingRequestsMap.set(transactionId, transaction);
+  }
+  addResponse(transactionId, response) {
+    const transaction = this.outstandingRequestsMap.get(transactionId);
+    if (transaction === void 0) {
+      throw new Error(`Transaction [${transactionId}] does not have an outstanding request`);
+    }
+    transaction.response = response;
+    transaction.end = /* @__PURE__ */ new Date();
+    this.outstandingRequestsMap.delete(transactionId);
+    this.addCompletedTransaction(transaction);
+  }
+  get outstandingRequests() {
+    return Array.from(this.outstandingRequestsMap.values());
+  }
+  get completedTransactions() {
+    return this.completedTransactionsQueue;
+  }
+  clearOutstandingRequests() {
+    this.outstandingRequestsMap.clear();
+  }
+  /**
+   * Adds a completed request to the queue.
+   *
+   * If the number of completed requests exceeds the maximum number of completed requests to keep,
+   * remove the oldest completed request.
+   */
+  addCompletedTransaction(transaction) {
+    this.completedTransactionsQueue.push(transaction);
+    if (this.completedTransactionsQueue.length > this.completedTransactionsToKeep) {
+      this.completedTransactionsQueue.shift();
+    }
+  }
+}
+function ensureCreatedTime(envelope) {
+  if (envelope.event === InboxMessageEvent.NewMessage) {
+    const message = envelope.data;
+    if (!message.created) {
+      message.created = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return {
+      ...envelope,
+      data: message
+    };
+  }
+  return envelope;
+}
+function fixMessageEventEnvelope(envelope) {
+  return ensureCreatedTime(envelope);
+}
+const _CourierInboxSocket = class _CourierInboxSocket extends CourierSocket {
+  constructor(options) {
+    super(options);
+    /**
+     * The interval ID for the ping interval.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/setInterval
+     */
+    __publicField(this, "pingIntervalId", null);
+    /**
+     * The list of message event listeners, called when a message event is received
+     * from the Courier WebSocket server.
+     */
+    __publicField(this, "messageEventListeners", []);
+    /** Server-provided configuration for the client. */
+    __publicField(this, "config", null);
+    /**
+     * The transaction manager, used to track outstanding requests and responses.
+     */
+    __publicField(this, "pingTransactionManager", new TransactionManager());
+  }
+  onOpen(_) {
+    this.pingTransactionManager.clearOutstandingRequests();
+    this.restartPingInterval();
+    this.sendGetConfig();
+    this.sendSubscribe();
+    return Promise.resolve();
+  }
+  onMessageReceived(data) {
+    if ("action" in data && data.action === ServerAction.Ping) {
+      const envelope = data;
+      this.sendPong(envelope);
+    }
+    if ("response" in data && data.response === "pong") {
+      const envelope = data;
+      this.pingTransactionManager.addResponse(envelope.tid, envelope);
+      this.pingTransactionManager.clearOutstandingRequests();
+    }
+    if ("response" in data && data.response === "config") {
+      const envelope = data;
+      this.setConfig(envelope.data);
+    }
+    if ("event" in data && _CourierInboxSocket.isInboxMessageEvent(data.event)) {
+      const envelope = data;
+      const fixedEnvelope = fixMessageEventEnvelope(envelope);
+      for (const listener of this.messageEventListeners) {
+        listener(fixedEnvelope);
+      }
+    }
+    this.restartPingInterval();
+    return Promise.resolve();
+  }
+  onClose(_) {
+    return Promise.resolve();
+  }
+  onError(_) {
+    return Promise.resolve();
+  }
+  /**
+   * Sends a subscribe message to the server.
+   *
+   * Subscribes to all events for the user.
+   */
+  sendSubscribe() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Subscribe,
       data: {
-        userAgent: "courier-js",
-        // TODO: Equivalent to Courier.agent.value()
-        channel: this.options.userId,
-        event: "*",
-        version: (props == null ? void 0 : props.version) ?? 5
+        channel: this.userId,
+        event: "*"
       }
     };
-    if (this.options.connectionId) {
-      subscription.data.clientSourceId = this.options.connectionId;
+    this.send(envelope);
+  }
+  /**
+   * Sends an unsubscribe message to the server.
+   *
+   * Unsubscribes from all events for the user.
+   */
+  sendUnsubscribe() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Unsubscribe,
+      data: {
+        channel: this.userId
+      }
+    };
+    this.send(envelope);
+  }
+  /**
+   * Adds a message event listener, called when a message event is received
+   * from the Courier WebSocket server.
+   *
+   * @param listener The listener function
+   */
+  addMessageEventListener(listener) {
+    this.messageEventListeners.push(listener);
+  }
+  /**
+   * Send a ping message to the server.
+   *
+   * ping/pong is implemented at the application layer since the browser's
+   * WebSocket implementation does not support control-level ping/pong.
+   */
+  sendPing() {
+    var _a;
+    if (this.pingTransactionManager.outstandingRequests.length >= this.maxOutstandingPings) {
+      (_a = this.logger) == null ? void 0 : _a.debug("Max outstanding pings reached, retrying connection.");
+      this.close(CLOSE_CODE_NORMAL_CLOSURE, "Max outstanding pings reached, retrying connection.");
+      this.retryConnection();
+      return;
+    }
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Ping
+    };
+    this.send(envelope);
+    this.pingTransactionManager.addOutstandingRequest(envelope.tid, envelope);
+  }
+  /**
+   * Send a pong response to the server.
+   *
+   * ping/pong is implemented at the application layer since the browser's
+   * WebSocket implementation does not support control-level ping/pong.
+   */
+  sendPong(incomingMessage) {
+    const response = {
+      tid: incomingMessage.tid,
+      action: ClientAction.Pong
+    };
+    this.send(response);
+  }
+  /**
+   * Send a request for the client's configuration.
+   */
+  sendGetConfig() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.GetConfig
+    };
+    this.send(envelope);
+  }
+  /**
+   * Restart the ping interval, clearing the previous interval if it exists.
+   */
+  restartPingInterval() {
+    if (this.pingIntervalId) {
+      window.clearInterval(this.pingIntervalId);
     }
-    if (this.options.tenantId) {
-      subscription.data.accountId = this.options.tenantId;
+    this.pingIntervalId = window.setInterval(() => {
+      this.sendPing();
+    }, this.pingInterval);
+  }
+  get pingInterval() {
+    if (this.config) {
+      return this.config.pingInterval * 1e3;
     }
-    (_a = this.options.logger) == null ? void 0 : _a.debug("Sending subscribe request", subscription);
-    await this.send(subscription);
+    return _CourierInboxSocket.DEFAULT_PING_INTERVAL_MILLIS;
   }
-  static buildUrl(options) {
-    var _a;
-    let url = ((_a = options.apiUrls) == null ? void 0 : _a.inbox.webSocket) ?? "";
-    if (options.accessToken) {
-      url += `/?auth=${options.accessToken}`;
+  get maxOutstandingPings() {
+    if (this.config) {
+      return this.config.maxOutstandingPings;
     }
-    return url;
+    return _CourierInboxSocket.DEFAULT_MAX_OUTSTANDING_PINGS;
   }
-}
+  setConfig(config) {
+    this.config = config;
+  }
+  static isInboxMessageEvent(event) {
+    return Object.values(InboxMessageEvent).includes(event);
+  }
+};
+/**
+ * The default interval in milliseconds at which to send a ping message to the server
+ * if no other message has been received from the server.
+ *
+ * Fallback when the server does not provide a config.
+ */
+__publicField(_CourierInboxSocket, "DEFAULT_PING_INTERVAL_MILLIS", 6e4);
+// 1 minute
+/**
+ * The default maximum number of outstanding pings before the client should
+ * close the connection and retry connecting.
+ *
+ * Fallback when the server does not provide a config.
+ */
+__publicField(_CourierInboxSocket, "DEFAULT_MAX_OUTSTANDING_PINGS", 3);
+let CourierInboxSocket = _CourierInboxSocket;
 class InboxClient extends Client {
   constructor(options) {
     super(options);
     __publicField(this, "socket");
-    this.socket = new InboxSocket(options);
+    this.socket = new CourierInboxSocket(options);
   }
   /**
    * Get paginated messages
@@ -646,6 +1063,31 @@ class InboxClient extends Client {
       url: this.options.apiUrls.inbox.graphql
     });
   }
+  /**
+   * Unarchive a message
+   * @param messageId - ID of the message to unarchive
+   * @returns Promise resolving when message is unarchived
+   */
+  async unarchive(props) {
+    const query = `
+      mutation TrackEvent {
+        unarchive(messageId: "${props.messageId}")
+      }
+    `;
+    const headers = {
+      "x-courier-user-id": this.options.userId,
+      "Authorization": `Bearer ${this.options.accessToken}`
+    };
+    if (this.options.connectionId) {
+      headers["x-courier-client-source-id"] = this.options.connectionId;
+    }
+    await graphql({
+      options: this.options,
+      query,
+      headers,
+      url: this.options.apiUrls.inbox.graphql
+    });
+  }
   /**
    * Archive all read messages.
    */
@@ -669,6 +1111,29 @@ class InboxClient extends Client {
       url: this.options.apiUrls.inbox.graphql
     });
   }
+  /**
+   * Archive all read messages.
+   */
+  async archiveAll() {
+    const query = `
+      mutation TrackEvent {
+        archiveAll
+      }
+    `;
+    const headers = {
+      "x-courier-user-id": this.options.userId,
+      "Authorization": `Bearer ${this.options.accessToken}`
+    };
+    if (this.options.connectionId) {
+      headers["x-courier-client-source-id"] = this.options.connectionId;
+    }
+    await graphql({
+      options: this.options,
+      query,
+      headers,
+      url: this.options.apiUrls.inbox.graphql
+    });
+  }
 }
 class PreferenceTransformer {
   /**
@@ -983,7 +1448,7 @@ const _Courier = class _Courier {
     /**
      * The unique identifier for the Courier instance
      */
-    __publicField(this, "id", UUID.generate());
+    __publicField(this, "id", UUID.nanoid());
     /**
      * The Courier client instance
      */
@@ -1025,7 +1490,7 @@ const _Courier = class _Courier {
    * @param options - The options for the Courier client
    */
   signIn(props) {
-    const connectionId = props.connectionId ?? UUID.generate();
+    const connectionId = props.connectionId ?? UUID.nanoid();
     this.instanceClient = new CourierClient({ ...props, connectionId });
     this.notifyAuthenticationListeners({ userId: props.userId });
   }
@@ -1074,9 +1539,10 @@ export {
   BrandClient,
   Courier,
   CourierClient,
-  CourierSocket,
   InboxClient,
+  InboxMessageEvent,
   ListClient,
   PreferenceClient,
   TokenClient
 };
+//# sourceMappingURL=index.mjs.map