@novu/js 3.15.0 → 3.16.0

package/dist/esm/{chunk-DXONCY42.mjs → chunk-FBE56J52.mjs}

@@ -1,4 +1,4 @@
-import { NovuError, buildSubscriber, buildContextKey, Notification, read, unread, seen, archive, unarchive, deleteNotification, snooze, unsnooze, completeAction, revertAction, readAll, seenAll, archiveAll, archiveAllRead, deleteAll, buildSubscriptionIdentifier, createNotification } from './chunk-3WBJEI4O.mjs';
+import { NovuError, buildSubscriber, buildContextKey, Notification, read, unread, seen, archive, unarchive, deleteNotification, snooze, unsnooze, completeAction, revertAction, readAll, seenAll, archiveAll, archiveAllRead, deleteAll, buildSubscriptionIdentifier, createNotification } from './chunk-4S22IB5W.mjs';
 import { __privateAdd, __privateSet, __spreadValues, __privateGet, __async, __spreadProps, __objRest, __privateMethod } from './chunk-STZMOEWR.mjs';
 import mitt from 'mitt';
 import 'event-target-polyfill';
@@ -1036,7 +1036,7 @@ _contextKey = new WeakMap();
 
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_CLIENT_VERSION = `${"@novu/js"}@${"3.15.0"}`;
+var DEFAULT_CLIENT_VERSION = `${"@novu/js"}@${"3.16.0"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -1150,6 +1150,30 @@ function combineUrl(...args) {
 // src/api/inbox-service.ts
 var INBOX_ROUTE = "/inbox";
 var INBOX_NOTIFICATIONS_ROUTE = `${INBOX_ROUTE}/notifications`;
+var CHAT_OAUTH_ROUTE = `${INBOX_ROUTE}/chat/oauth`;
+var CHANNEL_CONNECTIONS_ROUTE = `${INBOX_ROUTE}/channel-connections`;
+var CHANNEL_ENDPOINTS_ROUTE = `${INBOX_ROUTE}/channel-endpoints`;
+function buildChannelListSearchParams(args) {
+  const searchParams = new URLSearchParams();
+  if (args.subscriberId) searchParams.append("subscriberId", args.subscriberId);
+  if (args.integrationIdentifier) searchParams.append("integrationIdentifier", args.integrationIdentifier);
+  if (args.connectionIdentifier) searchParams.append("connectionIdentifier", args.connectionIdentifier);
+  if (args.channel) searchParams.append("channel", args.channel);
+  if (args.providerId) searchParams.append("providerId", args.providerId);
+  if (args.contextKeys !== void 0) {
+    if (args.contextKeys.length === 0) {
+      searchParams.append("contextKeys", "");
+    } else {
+      for (const key of args.contextKeys) {
+        searchParams.append("contextKeys", key);
+      }
+    }
+  }
+  if (args.limit) searchParams.append("limit", String(args.limit));
+  if (args.after) searchParams.append("after", args.after);
+  if (args.before) searchParams.append("before", args.before);
+  return searchParams.size ? `?${searchParams.toString()}` : "";
+}
 function appendTagsToSearchParams(searchParams, tags) {
   if (tags === void 0) {
     return;
@@ -1467,8 +1491,319 @@ var InboxService = class {
   deleteSubscription({ topicKey, identifier }) {
     return __privateGet(this, _httpClient).delete(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions/${identifier}`);
   }
+  generateChatOAuthUrl({
+    integrationIdentifier,
+    connectionIdentifier,
+    subscriberId,
+    context,
+    scope,
+    userScope,
+    mode,
+    connectionMode
+  }) {
+    return __privateGet(this, _httpClient).post(CHAT_OAUTH_ROUTE, {
+      integrationIdentifier,
+      connectionIdentifier,
+      subscriberId,
+      context,
+      scope,
+      userScope,
+      mode,
+      connectionMode
+    });
+  }
+  listChannelConnections(args = {}) {
+    const query = buildChannelListSearchParams(args);
+    return __privateGet(this, _httpClient).get(`${CHANNEL_CONNECTIONS_ROUTE}${query}`, void 0, false);
+  }
+  getChannelConnection(identifier) {
+    return __privateGet(this, _httpClient).get(`${CHANNEL_CONNECTIONS_ROUTE}/${identifier}`);
+  }
+  createChannelConnection({
+    identifier,
+    integrationIdentifier,
+    subscriberId,
+    context,
+    workspace,
+    auth
+  }) {
+    return __privateGet(this, _httpClient).post(CHANNEL_CONNECTIONS_ROUTE, {
+      identifier,
+      integrationIdentifier,
+      subscriberId,
+      context,
+      workspace,
+      auth
+    });
+  }
+  deleteChannelConnection(identifier) {
+    return __privateGet(this, _httpClient).delete(`${CHANNEL_CONNECTIONS_ROUTE}/${identifier}`);
+  }
+  listChannelEndpoints(args = {}) {
+    const query = buildChannelListSearchParams(args);
+    return __privateGet(this, _httpClient).get(`${CHANNEL_ENDPOINTS_ROUTE}${query}`, void 0, false);
+  }
+  getChannelEndpoint(identifier) {
+    return __privateGet(this, _httpClient).get(`${CHANNEL_ENDPOINTS_ROUTE}/${identifier}`);
+  }
+  createChannelEndpoint({
+    identifier,
+    integrationIdentifier,
+    connectionIdentifier,
+    subscriberId,
+    context,
+    type,
+    endpoint
+  }) {
+    return __privateGet(this, _httpClient).post(CHANNEL_ENDPOINTS_ROUTE, {
+      identifier,
+      integrationIdentifier,
+      connectionIdentifier,
+      subscriberId,
+      context,
+      type,
+      endpoint
+    });
+  }
+  deleteChannelEndpoint(identifier) {
+    return __privateGet(this, _httpClient).delete(`${CHANNEL_ENDPOINTS_ROUTE}/${identifier}`);
+  }
 };
 _httpClient = new WeakMap();
+
+// src/channel-connections/helpers.ts
+var generateChatOAuthUrl = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-connection.oauth-url.pending", { args });
+    const data = yield apiService.generateChatOAuthUrl(args);
+    emitter.emit("channel-connection.oauth-url.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-connection.oauth-url.resolved", { args, error });
+    return { error: new NovuError("Failed to generate chat OAuth URL", error) };
+  }
+});
+var listChannelConnections = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-connections.list.pending", { args });
+    const response = yield apiService.listChannelConnections(args);
+    const data = response.data;
+    emitter.emit("channel-connections.list.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-connections.list.resolved", { args, error });
+    return { error: new NovuError("Failed to list channel connections", error) };
+  }
+});
+var getChannelConnection = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-connection.get.pending", { args });
+    const data = yield apiService.getChannelConnection(args.identifier);
+    emitter.emit("channel-connection.get.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-connection.get.resolved", { args, error });
+    return { error: new NovuError("Failed to get channel connection", error) };
+  }
+});
+var deleteChannelConnection = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-connection.delete.pending", { args });
+    yield apiService.deleteChannelConnection(args.identifier);
+    emitter.emit("channel-connection.delete.resolved", { args });
+    return { data: void 0 };
+  } catch (error) {
+    emitter.emit("channel-connection.delete.resolved", { args, error });
+    return { error: new NovuError("Failed to delete channel connection", error) };
+  }
+});
+
+// src/channel-connections/channel-connections.ts
+var ChannelConnections = class extends BaseModule {
+  constructor({
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({ inboxServiceInstance, eventEmitterInstance });
+  }
+  generateOAuthUrl(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => generateChatOAuthUrl({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  list() {
+    return __async(this, arguments, function* (args = {}) {
+      return this.callWithSession(
+        () => listChannelConnections({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  get(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => getChannelConnection({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  delete(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => deleteChannelConnection({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+};
+
+// src/channel-endpoints/helpers.ts
+var listChannelEndpoints = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-endpoints.list.pending", { args });
+    const response = yield apiService.listChannelEndpoints(args);
+    const data = response.data;
+    emitter.emit("channel-endpoints.list.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-endpoints.list.resolved", { args, error });
+    return { error: new NovuError("Failed to list channel endpoints", error) };
+  }
+});
+var getChannelEndpoint = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-endpoint.get.pending", { args });
+    const data = yield apiService.getChannelEndpoint(args.identifier);
+    emitter.emit("channel-endpoint.get.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-endpoint.get.resolved", { args, error });
+    return { error: new NovuError("Failed to get channel endpoint", error) };
+  }
+});
+var createChannelEndpoint = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-endpoint.create.pending", { args });
+    const data = yield apiService.createChannelEndpoint(args);
+    emitter.emit("channel-endpoint.create.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("channel-endpoint.create.resolved", { args, error });
+    return { error: new NovuError("Failed to create channel endpoint", error) };
+  }
+});
+var deleteChannelEndpoint = (_0) => __async(null, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  try {
+    emitter.emit("channel-endpoint.delete.pending", { args });
+    yield apiService.deleteChannelEndpoint(args.identifier);
+    emitter.emit("channel-endpoint.delete.resolved", { args });
+    return { data: void 0 };
+  } catch (error) {
+    emitter.emit("channel-endpoint.delete.resolved", { args, error });
+    return { error: new NovuError("Failed to delete channel endpoint", error) };
+  }
+});
+
+// src/channel-endpoints/channel-endpoints.ts
+var ChannelEndpoints = class extends BaseModule {
+  constructor({
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({ inboxServiceInstance, eventEmitterInstance });
+  }
+  list() {
+    return __async(this, arguments, function* (args = {}) {
+      return this.callWithSession(
+        () => listChannelEndpoints({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  get(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => getChannelEndpoint({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  create(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => createChannelEndpoint({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+  delete(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => deleteChannelEndpoint({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+};
 var _mittEmitter;
 var NovuEventEmitter = class {
   constructor() {
@@ -3426,6 +3761,14 @@ var Novu = class {
       inboxServiceInstance: __privateGet(this, _inboxService6),
       eventEmitterInstance: __privateGet(this, _emitter12)
     });
+    this.channelConnections = new ChannelConnections({
+      inboxServiceInstance: __privateGet(this, _inboxService6),
+      eventEmitterInstance: __privateGet(this, _emitter12)
+    });
+    this.channelEndpoints = new ChannelEndpoints({
+      inboxServiceInstance: __privateGet(this, _inboxService6),
+      eventEmitterInstance: __privateGet(this, _emitter12)
+    });
     this.socket = createSocket({
       socketUrl: options.socketUrl,
       socketOptions: options.socketOptions,