@trycourier/courier-js 1.4.2 → 2.0.1-beta

package/dist/index.mjs

@@ -1,7 +1,681 @@
-// package.json
-var version = "1.4.2";
-
-// src/helpers/decode.ts
+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;
+const getCourierApiUrls = (urls) => ({
+  courier: {
+    rest: (urls == null ? void 0 : urls.courier.rest) || "https://api.courier.com",
+    graphql: (urls == null ? void 0 : urls.courier.graphql) || "https://api.courier.com/client/q"
+  },
+  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"
+  }
+});
+class Logger {
+  constructor(showLogs) {
+    __publicField(this, "PREFIX", "[COURIER]");
+    this.showLogs = showLogs;
+  }
+  warn(message, ...args) {
+    if (this.showLogs) {
+      console.warn(`${this.PREFIX} ${message}`, ...args);
+    }
+  }
+  log(message, ...args) {
+    if (this.showLogs) {
+      console.log(`${this.PREFIX} ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.showLogs) {
+      console.error(`${this.PREFIX} ${message}`, ...args);
+    }
+  }
+  debug(message, ...args) {
+    if (this.showLogs) {
+      console.debug(`${this.PREFIX} ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.showLogs) {
+      console.info(`${this.PREFIX} ${message}`, ...args);
+    }
+  }
+}
+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;
+  }
+}
+class CourierRequestError extends Error {
+  constructor(code, message, type) {
+    super(message);
+    this.code = code;
+    this.type = type;
+    this.name = "CourierRequestError";
+  }
+}
+function logRequest(logger, uid, type, data) {
+  logger.log(`
+📡 New Courier ${type} Request: ${uid}
+URL: ${data.url}
+${data.method ? `Method: ${data.method}` : ""}
+${data.query ? `Query: ${data.query}` : ""}
+${data.variables ? `Variables: ${JSON.stringify(data.variables, null, 2)}` : ""}
+Headers: ${JSON.stringify(data.headers, null, 2)}
+Body: ${data.body ? JSON.stringify(data.body, null, 2) : "Empty"}
+  `);
+}
+function logResponse(logger, uid, type, data) {
+  logger.log(`
+📡 New Courier ${type} Response: ${uid}
+Status Code: ${data.status}
+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 request = new Request(props.url, {
+    method: props.method,
+    headers: {
+      "Content-Type": "application/json",
+      ...props.headers
+    },
+    body: props.body ? JSON.stringify(props.body) : void 0
+  });
+  if (uid) {
+    logRequest(props.options.logger, uid, "HTTP", {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body: props.body
+    });
+  }
+  const response = await fetch(request);
+  if (response.status === 204) {
+    return;
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (error) {
+    if (response.status === 200) {
+      return;
+    }
+    throw new CourierRequestError(
+      response.status,
+      "Failed to parse response as JSON",
+      "PARSE_ERROR"
+    );
+  }
+  if (uid) {
+    logResponse(props.options.logger, uid, "HTTP", {
+      status: response.status,
+      response: data
+    });
+  }
+  if (!validCodes.includes(response.status)) {
+    throw new CourierRequestError(
+      response.status,
+      (data == null ? void 0 : data.message) || "Unknown Error",
+      data == null ? void 0 : data.type
+    );
+  }
+  return data;
+}
+async function graphql(props) {
+  const uid = props.options.showLogs ? UUID.generate() : void 0;
+  if (uid) {
+    logRequest(props.options.logger, uid, "GraphQL", {
+      url: props.url,
+      headers: props.headers,
+      query: props.query,
+      variables: props.variables
+    });
+  }
+  const response = await fetch(props.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...props.headers
+    },
+    body: JSON.stringify({
+      query: props.query,
+      variables: props.variables
+    })
+  });
+  let data;
+  try {
+    data = await response.json();
+  } catch (error) {
+    throw new CourierRequestError(
+      response.status,
+      "Failed to parse response as JSON",
+      "PARSE_ERROR"
+    );
+  }
+  if (uid) {
+    logResponse(props.options.logger, uid, "GraphQL", {
+      status: response.status,
+      response: data
+    });
+  }
+  if (!response.ok) {
+    throw new CourierRequestError(
+      response.status,
+      (data == null ? void 0 : data.message) || "Unknown Error",
+      data == null ? void 0 : data.type
+    );
+  }
+  return data;
+}
+class Client {
+  constructor(options) {
+    this.options = options;
+  }
+}
+class BrandClient extends Client {
+  /**
+   * Get a brand by ID using GraphQL
+   * @param brandId - The ID of the brand to retrieve
+   * @returns Promise resolving to the requested brand
+   */
+  async getBrand(props) {
+    const query = `
+      query GetBrand {
+        brand(brandId: "${props.brandId}") {
+          settings {
+            colors {
+              primary
+              secondary
+              tertiary
+            }
+            inapp {
+              borderRadius
+              disableCourierFooter
+            }
+          }
+        }
+      }
+    `;
+    const json = await graphql({
+      options: this.options,
+      url: this.options.apiUrls.courier.graphql,
+      headers: {
+        "x-courier-user-id": this.options.userId,
+        "x-courier-client-key": "empty",
+        // Empty for now. Will be removed in future.
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      query,
+      variables: { brandId: props.brandId }
+    });
+    return json.data.brand;
+  }
+}
+class InboxSocket extends 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;
+    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;
+      }
+    } 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);
+      }
+    }
+  }
+  async sendSubscribe(props) {
+    var _a;
+    const subscription = {
+      action: "subscribe",
+      data: {
+        userAgent: "courier-js",
+        // TODO: Equivalent to Courier.agent.value()
+        channel: this.options.userId,
+        event: "*",
+        version: (props == null ? void 0 : props.version) ?? 5
+      }
+    };
+    if (this.options.connectionId) {
+      subscription.data.clientSourceId = this.options.connectionId;
+    }
+    if (this.options.tenantId) {
+      subscription.data.accountId = this.options.tenantId;
+    }
+    (_a = this.options.logger) == null ? void 0 : _a.debug("Sending subscribe request", subscription);
+    await this.send(subscription);
+  }
+  static buildUrl(options) {
+    var _a;
+    let url = ((_a = options.apiUrls) == null ? void 0 : _a.inbox.webSocket) ?? "";
+    if (options.accessToken) {
+      url += `/?auth=${options.accessToken}`;
+    }
+    return url;
+  }
+}
+class InboxClient extends Client {
+  constructor(options) {
+    super(options);
+    __publicField(this, "socket");
+    this.socket = new InboxSocket(options);
+  }
+  /**
+   * Get paginated messages
+   * @param paginationLimit - Number of messages to return per page (default: 24)
+   * @param startCursor - Cursor for pagination
+   * @returns Promise resolving to paginated messages response
+   */
+  async getMessages(props) {
+    const query = `
+      query GetInboxMessages(
+        $params: FilterParamsInput = { ${this.options.tenantId ? `accountId: "${this.options.tenantId}"` : ""} }
+        $limit: Int = ${(props == null ? void 0 : props.paginationLimit) ?? 24}
+        $after: String ${(props == null ? void 0 : props.startCursor) ? `= "${props.startCursor}"` : ""}
+      ) {
+        count(params: $params)
+        messages(params: $params, limit: $limit, after: $after) {
+          totalCount
+          pageInfo {
+            startCursor
+            hasNextPage
+          }
+          nodes {
+            messageId
+            read
+            archived
+            created
+            opened
+            title
+            preview
+            data
+            tags
+            trackingIds {
+              clickTrackingId
+            }
+            actions {
+              content
+              data
+              href
+            }
+          }
+        }
+      }
+    `;
+    return await graphql({
+      options: this.options,
+      query,
+      headers: {
+        "x-courier-user-id": this.options.userId,
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      url: this.options.apiUrls.inbox.graphql
+    });
+  }
+  /**
+   * Get paginated archived messages
+   * @param paginationLimit - Number of messages to return per page (default: 24)
+   * @param startCursor - Cursor for pagination
+   * @returns Promise resolving to paginated archived messages response
+   */
+  async getArchivedMessages(props) {
+    const query = `
+      query GetInboxMessages(
+        $params: FilterParamsInput = { ${this.options.tenantId ? `accountId: "${this.options.tenantId}"` : ""}, archived: true }
+        $limit: Int = ${(props == null ? void 0 : props.paginationLimit) ?? 24}
+        $after: String ${(props == null ? void 0 : props.startCursor) ? `= "${props.startCursor}"` : ""}
+      ) {
+        count(params: $params)
+        messages(params: $params, limit: $limit, after: $after) {
+          totalCount
+          pageInfo {
+            startCursor
+            hasNextPage
+          }
+          nodes {
+            messageId
+            read
+            archived
+            created
+            opened
+            title
+            preview
+            data
+            tags
+            trackingIds {
+              clickTrackingId
+            }
+            actions {
+              content
+              data
+              href
+            }
+          }
+        }
+      }
+    `;
+    return graphql({
+      options: this.options,
+      query,
+      headers: {
+        "x-courier-user-id": this.options.userId,
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      url: this.options.apiUrls.inbox.graphql
+    });
+  }
+  /**
+   * Get unread message count
+   * @returns Promise resolving to number of unread messages
+   */
+  async getUnreadMessageCount() {
+    var _a;
+    const query = `
+      query GetMessages {
+        count(params: { status: "unread" ${this.options.tenantId ? `, accountId: "${this.options.tenantId}"` : ""} })
+      }
+    `;
+    const response = await graphql({
+      options: this.options,
+      query,
+      headers: {
+        "x-courier-user-id": this.options.userId,
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      url: this.options.apiUrls.inbox.graphql
+    });
+    return ((_a = response.data) == null ? void 0 : _a.count) ?? 0;
+  }
+  /**
+   * Track a click event
+   * @param messageId - ID of the message
+   * @param trackingId - ID for tracking the click
+   * @returns Promise resolving when click is tracked
+   */
+  async click(props) {
+    const query = `
+      mutation TrackEvent {
+        clicked(messageId: "${props.messageId}", trackingId: "${props.trackingId}")
+      }
+    `;
+    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
+    });
+  }
+  /**
+   * Mark a message as read
+   * @param messageId - ID of the message to mark as read
+   * @returns Promise resolving when message is marked as read
+   */
+  async read(props) {
+    const query = `
+      mutation TrackEvent {
+        read(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
+    });
+  }
+  /**
+   * Mark a message as unread
+   * @param messageId - ID of the message to mark as unread
+   * @returns Promise resolving when message is marked as unread
+   */
+  async unread(props) {
+    const query = `
+      mutation TrackEvent {
+        unread(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
+    });
+  }
+  /**
+   * Mark all messages as read
+   * @returns Promise resolving when all messages are marked as read
+   */
+  async readAll() {
+    const query = `
+      mutation TrackEvent {
+        markAllRead
+      }
+    `;
+    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
+    });
+  }
+  /**
+   * Mark a message as opened
+   * @param messageId - ID of the message to mark as opened
+   * @returns Promise resolving when message is marked as opened
+   */
+  async open(props) {
+    const query = `
+      mutation TrackEvent {
+        opened(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 a message
+   * @param messageId - ID of the message to archive
+   * @returns Promise resolving when message is archived
+   */
+  async archive(props) {
+    const query = `
+      mutation TrackEvent {
+        archive(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
+    });
+  }
+}
+class PreferenceTransformer {
+  /**
+   * Transforms a single API response item to the CourierUserPreferencesTopic type
+   * @param item - The API response item
+   * @returns A CourierUserPreferencesTopic object
+   */
+  transformItem(item) {
+    return {
+      topicId: item.topic_id,
+      topicName: item.topic_name,
+      sectionId: item.section_id,
+      sectionName: item.section_name,
+      status: item.status,
+      defaultStatus: item.default_status,
+      hasCustomRouting: item.has_custom_routing,
+      customRouting: item.custom_routing || []
+    };
+  }
+  /**
+   * Transforms an array of API response items to CourierUserPreferencesTopic objects
+   * @param items - The API response items
+   * @returns A generator of CourierUserPreferencesTopic objects
+   */
+  *transform(items) {
+    for (const item of items) {
+      yield this.transformItem(item);
+    }
+  }
+}
 function decode(clientKey) {
   const binaryString = atob(clientKey);
   const bytes = new Uint8Array(binaryString.length);
@@ -17,148 +691,369 @@ function encode(key) {
   }
   return btoa(String.fromCharCode(...bytes));
 }
-
-// src/helpers/client.ts
-async function tryCatch(fn, debug = true) {
-  var _a, _b;
-  const response = await fn();
-  if (!response.ok && debug) {
-    console.error(
-      `Error invoking ${response.url}: ${(_a = response.status) != null ? _a : 404} because ${JSON.stringify((_b = await response.json()) == null ? void 0 : _b.message)}`
-    );
+class PreferenceClient extends Client {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "transformer", new PreferenceTransformer());
   }
-}
-var Courier = class {
-  constructor({
-    authorization,
-    baseUrl,
-    clientKey,
-    debug = false,
-    userId,
-    userSignature
-  }) {
-    if (!clientKey) {
-      throw new Error("Courier client key is required");
-    }
-    this.authorization = authorization;
-    this.baseUrl = `${baseUrl != null ? baseUrl : "https://api.courier.com"}`;
-    this.clientKey = clientKey;
-    this.debug = debug;
-    this.userId = userId;
-    this.userSignature = userSignature;
-  }
-  getHeaders() {
-    return new Headers({
-      "Content-Type": "application/json",
-      "x-courier-client-version": `courier-js@${version}`,
-      "Access-Control-Allow-Origin": "*",
-      ...this.authorization && { Authorization: this.authorization },
-      ...this.userId && { "x-courier-user-id": this.userId },
-      ...this.userSignature && {
-        "x-courier-user-signature": this.userSignature
-      },
-      ...this.clientKey && { "x-courier-client-key": this.clientKey }
+  /**
+   * Get all preferences for a user
+   * @param paginationCursor - Optional cursor for pagination
+   * @returns Promise resolving to user preferences
+   * @see https://www.courier.com/docs/reference/user-preferences/list-all-user-preferences
+   */
+  async getUserPreferences(props) {
+    let url = `${this.options.apiUrls.courier.rest}/users/${this.options.userId}/preferences`;
+    if (props == null ? void 0 : props.paginationCursor) {
+      url += `?cursor=${props.paginationCursor}`;
+    }
+    const json = await http({
+      options: this.options,
+      url,
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.options.accessToken}`
+      }
     });
-  }
-  async post(path, body, useClientPath = true) {
-    const postFn = () => {
-      return fetch(this.getPathURL(path, useClientPath), {
-        body: JSON.stringify(body),
-        headers: this.getHeaders(),
-        method: "POST"
-      });
+    const data = json;
+    return {
+      items: [...this.transformer.transform(data.items)],
+      paging: data.paging
     };
-    await tryCatch(postFn, this.debug);
-  }
-  async put(path, body, useClientPath = true) {
-    const putFn = () => {
-      return fetch(this.getPathURL(path, useClientPath), {
-        ...body ? { body: JSON.stringify(body) } : {},
-        headers: this.getHeaders(),
-        method: "PUT"
-      });
+  }
+  /**
+   * Get preferences for a specific topic
+   * @param topicId - The ID of the topic to get preferences for
+   * @returns Promise resolving to topic preferences
+   * @see https://www.courier.com/docs/reference/user-preferences/get-subscription-topic-preferences
+   */
+  async getUserPreferenceTopic(props) {
+    const json = await http({
+      options: this.options,
+      url: `${this.options.apiUrls.courier.rest}/users/${this.options.userId}/preferences/${props.topicId}`,
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.options.accessToken}`
+      }
+    });
+    const res = json;
+    return this.transformer.transformItem(res.topic);
+  }
+  /**
+   * Update preferences for a specific topic
+   * @param topicId - The ID of the topic to update preferences for
+   * @param status - The new status for the topic
+   * @param hasCustomRouting - Whether the topic has custom routing
+   * @param customRouting - The custom routing channels for the topic
+   * @returns Promise resolving when update is complete
+   * @see https://www.courier.com/docs/reference/user-preferences/update-subscription-topic-preferences
+   */
+  async putUserPreferenceTopic(props) {
+    const payload = {
+      topic: {
+        status: props.status,
+        has_custom_routing: props.hasCustomRouting,
+        custom_routing: props.customRouting
+      }
     };
-    await tryCatch(putFn, this.debug);
-  }
-  async delete(path, useClientPath = true) {
-    const deleteFn = () => {
-      return fetch(this.getPathURL(path, useClientPath), {
-        headers: this.getHeaders(),
-        method: "DELETE"
-      });
+    await http({
+      options: this.options,
+      url: `${this.options.apiUrls.courier.rest}/users/${this.options.userId}/preferences/${props.topicId}`,
+      method: "PUT",
+      headers: {
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      body: payload
+    });
+  }
+  /**
+   * Get the notification center URL
+   * @param clientKey - The client key to use for the URL
+   * @returns The notification center URL
+   */
+  getNotificationCenterUrl(props) {
+    const rootTenantId = decode(props.clientKey);
+    const url = encode(`${rootTenantId}#${this.options.userId}${this.options.tenantId ? `#${this.options.tenantId}` : ""}#${false}`);
+    return `https://view.notificationcenter.app/p/${url}`;
+  }
+}
+class TokenClient extends Client {
+  /**
+   * Store a push notification token for a user
+   * @param token - The push notification token
+   * @param provider - The provider of the token
+   * @param device - The device information
+   * @see https://www.courier.com/docs/reference/token-management/put-token
+   */
+  async putUserToken(props) {
+    const payload = {
+      provider_key: props.provider,
+      ...props.device && {
+        device: {
+          app_id: props.device.appId,
+          ad_id: props.device.adId,
+          device_id: props.device.deviceId,
+          platform: props.device.platform,
+          manufacturer: props.device.manufacturer,
+          model: props.device.model
+        }
+      }
     };
-    await tryCatch(deleteFn, this.debug);
+    await http({
+      options: this.options,
+      url: `${this.options.apiUrls.courier.rest}/users/${this.options.userId}/tokens/${props.token}`,
+      method: "PUT",
+      headers: {
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      body: payload,
+      validCodes: [200, 204]
+    });
   }
-  generatePreferencesUrl(userId, options) {
-    var _a;
-    if (!userId) {
-      throw new Error("User ID is required to generate preferences URL");
-    }
-    const id = decode(this.clientKey);
-    return `https://view.notificationcenter.app/p/${encode(
-      `${id}#${(_a = options == null ? void 0 : options.brandId) != null ? _a : ""}#${userId}${(options == null ? void 0 : options.tenantId) ? `#${options.tenantId}` : ""}#${false}`
-    )}`;
+  /**
+   * Delete a push notification token for a user
+   * @param token - The push notification token
+   * @returns Promise resolving when token is deleted
+   */
+  async deleteUserToken(props) {
+    await http({
+      options: this.options,
+      url: `${this.options.apiUrls.courier.rest}/users/${this.options.userId}/tokens/${props.token}`,
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${this.options.accessToken}`
+      },
+      validCodes: [200, 204]
+    });
   }
-  getPathURL(path, useClientPath) {
-    let pathUrl = this.baseUrl;
-    if (useClientPath) {
-      pathUrl = pathUrl.concat("/client");
-    }
-    return pathUrl.concat(path);
+}
+class ListClient extends Client {
+  /**
+   * Subscribe a user to a list
+   * @param listId - The ID of the list to subscribe to
+   * @returns Promise resolving when subscription is complete
+   * @see https://www.courier.com/docs/reference/lists/recipient-subscribe
+   */
+  async putSubscription(props) {
+    return await http({
+      url: `${this.options.apiUrls.courier.rest}/lists/${props.listId}/subscriptions/${this.options.userId}`,
+      options: this.options,
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${this.options.accessToken}`
+      }
+    });
   }
-};
-
-// src/index.ts
-var client = {
-  __instance: null,
-  init(options) {
-    this.__instance = new Courier(options);
-  },
-  get instance() {
-    if (!this.__instance) {
-      throw new Error("Courier instance not initialized");
-    }
-    return this.__instance;
-  },
-  async identify(userId, payload) {
-    if (!userId) {
-      throw new Error("userId is required");
-    }
-    await this.instance.post(`/identify/${userId}`, {
-      profile: {
-        ...payload
+  /**
+   * Unsubscribe a user from a list
+   * @param listId - The ID of the list to unsubscribe from
+   * @returns Promise resolving when unsubscription is complete
+   * @see https://www.courier.com/docs/reference/lists/delete-subscription
+   */
+  async deleteSubscription(props) {
+    return await http({
+      url: `${this.options.apiUrls.courier.rest}/lists/${props.listId}/subscriptions/${this.options.userId}`,
+      options: this.options,
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.options.accessToken}`
       }
     });
-  },
-  async subscribe(userId, listId) {
-    if (!userId || !listId) {
-      throw new Error("userId is required");
+  }
+}
+class TrackingClient extends Client {
+  /**
+   * Post an inbound courier event
+   * @param event - The event type: Example: "New Order Placed"
+   * @param messageId - The message ID
+   * @param type - The type of event: Available options: "track"
+   * @param properties - The properties of the event
+   * @returns Promise resolving to the message ID
+   * @see https://www.courier.com/docs/reference/inbound/courier-track-event
+   */
+  async postInboundCourier(props) {
+    return await http({
+      url: `${this.options.apiUrls.courier.rest}/inbound/courier`,
+      options: this.options,
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.options.accessToken}`
+      },
+      body: {
+        ...props,
+        userId: this.options.userId
+      },
+      validCodes: [200, 202]
+    });
+  }
+  /**
+   * Post a tracking URL event
+   * These urls are found in messages sent from Courier
+   * @param url - The URL to post the event to
+   * @param event - The event type: Available options: "click", "open", "unsubscribe"
+   * @returns Promise resolving when the event is posted
+   */
+  async postTrackingUrl(props) {
+    return await http({
+      url: props.url,
+      options: this.options,
+      method: "POST",
+      body: {
+        event: props.event
+      }
+    });
+  }
+}
+class CourierClient extends Client {
+  constructor(props) {
+    var _a, _b;
+    const showLogs = props.showLogs !== void 0 ? props.showLogs : process.env.NODE_ENV === "development";
+    const baseOptions = {
+      ...props,
+      showLogs,
+      apiUrls: props.apiUrls || getCourierApiUrls(),
+      accessToken: props.jwt ?? props.publicApiKey
+    };
+    super({
+      ...baseOptions,
+      logger: new Logger(baseOptions.showLogs),
+      apiUrls: getCourierApiUrls(baseOptions.apiUrls)
+    });
+    __publicField(this, "tokens");
+    __publicField(this, "brands");
+    __publicField(this, "preferences");
+    __publicField(this, "inbox");
+    __publicField(this, "lists");
+    __publicField(this, "tracking");
+    this.tokens = new TokenClient(this.options);
+    this.brands = new BrandClient(this.options);
+    this.preferences = new PreferenceClient(this.options);
+    this.inbox = new InboxClient(this.options);
+    this.lists = new ListClient(this.options);
+    this.tracking = new TrackingClient(this.options);
+    if (!this.options.jwt && !this.options.publicApiKey) {
+      this.options.logger.warn("Courier Client initialized with no authentication method. Please provide a JWT or public API key.");
     }
-    await this.instance.put(`/lists/${listId}/subscribe/${userId}`);
-  },
-  async track(event, properties) {
-    if (!event) {
-      throw new Error("event is required");
-    }
-    let indempotentKey = self.crypto.randomUUID ? self.crypto.randomUUID() : Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    await this.instance.post(`/inbound/courier`, {
-      messageId: indempotentKey,
-      type: "track",
-      event,
-      properties: { ...properties }
-    }, false);
-  },
-  async unsubscribe(userId, listId) {
-    if (!userId || !listId) {
-      throw new Error("userId is required");
+    if (this.options.publicApiKey) {
+      (_a = this.options.logger) == null ? void 0 : _a.warn(
+        "Courier Warning: Public API Keys are for testing only. Please use JWTs for production.\nYou can generate a JWT with this endpoint: https://www.courier.com/docs/reference/auth/issue-token\nThis endpoint should be called from your backend server, not the SDK."
+      );
     }
-    this.instance.delete(`/lists/${listId}/unsubscribe/${userId}`);
-  },
-  generatePreferencesUrl(userId, options) {
-    return this.instance.generatePreferencesUrl(userId, options);
+    if (this.options.jwt && this.options.publicApiKey) {
+      (_b = this.options.logger) == null ? void 0 : _b.warn(
+        "Courier Warning: Both a JWT and a Public API Key were provided. The Public API Key will be ignored."
+      );
+    }
+  }
+}
+class AuthenticationListener {
+  constructor(callback) {
+    __publicField(this, "callback");
+    this.callback = callback;
+  }
+  remove() {
+    Courier.shared.removeAuthenticationListener(this);
+  }
+}
+const _Courier = class _Courier {
+  constructor() {
+    /**
+     * The unique identifier for the Courier instance
+     */
+    __publicField(this, "id", UUID.generate());
+    /**
+     * The Courier client instance
+     */
+    __publicField(this, "instanceClient");
+    /**
+     * The pagination limit (min: 1, max: 100)
+     */
+    __publicField(this, "_paginationLimit", 24);
+    /**
+     * The authentication listeners
+     */
+    __publicField(this, "authenticationListeners", []);
+  }
+  get paginationLimit() {
+    return this._paginationLimit;
+  }
+  set paginationLimit(value) {
+    this._paginationLimit = Math.min(Math.max(value, 1), 100);
+  }
+  /**
+   * Get the Courier client instance
+   * @returns The Courier client instance or undefined if not signed in
+   */
+  get client() {
+    return this.instanceClient;
+  }
+  /**
+   * Get the shared Courier instance
+   * @returns The shared Courier instance
+   */
+  static get shared() {
+    if (!_Courier.instance) {
+      _Courier.instance = new _Courier();
+    }
+    return _Courier.instance;
+  }
+  /**
+   * Sign in to Courier
+   * @param options - The options for the Courier client
+   */
+  signIn(props) {
+    const connectionId = props.connectionId ?? UUID.generate();
+    this.instanceClient = new CourierClient({ ...props, connectionId });
+    this.notifyAuthenticationListeners({ userId: props.userId });
+  }
+  /**
+   * Sign out of Courier
+   */
+  signOut() {
+    this.instanceClient = void 0;
+    this.notifyAuthenticationListeners({ userId: void 0 });
+  }
+  /**
+   * Register a callback to be notified of authentication state changes
+   * @param callback - Function to be called when authentication state changes
+   * @returns AuthenticationListener instance that can be used to remove the listener
+   */
+  addAuthenticationListener(callback) {
+    var _a;
+    (_a = this.instanceClient) == null ? void 0 : _a.options.logger.info("Adding authentication listener");
+    const listener = new AuthenticationListener(callback);
+    this.authenticationListeners.push(listener);
+    return listener;
+  }
+  /**
+   * Unregister an authentication state change listener
+   * @param listener - The AuthenticationListener instance to remove
+   */
+  removeAuthenticationListener(listener) {
+    var _a;
+    (_a = this.instanceClient) == null ? void 0 : _a.options.logger.info("Removing authentication listener");
+    this.authenticationListeners = this.authenticationListeners.filter((l) => l !== listener);
+  }
+  /**
+   * Notify all authentication listeners
+   * @param props - The props to notify the listeners with
+   */
+  notifyAuthenticationListeners(props) {
+    this.authenticationListeners.forEach((listener) => listener.callback(props));
   }
 };
-var src_default = client;
+/**
+ * The shared Courier instance
+ */
+__publicField(_Courier, "instance");
+let Courier = _Courier;
 export {
-  src_default as default
+  BrandClient,
+  Courier,
+  CourierClient,
+  CourierSocket,
+  InboxClient,
+  ListClient,
+  PreferenceClient,
+  TokenClient
 };