@ermis-network/ermis-chat-sdk 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ermis-network/ermis-chat-sdk",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Ermis Chat SDK",
   "author": "Ermis",
   "homepage": "https://ermis.network/",

package/src/channel.ts

@@ -36,6 +36,8 @@ import {
   PollMessage,
   EditMessage,
   ForwardMessage,
+  CreateTopicData,
+  EditTopicData,
 } from './types';
 /**
  * Represents a Channel in the Ermis Network.
@@ -132,13 +134,16 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
 
     // 3. Call API — don't update status on success (WS message.new will handle it)
     try {
-      return await this.getClient().post<SendMessageAPIResponse<ErmisChatGenerics>>(
-        this._channelURL() + '/message',
-        { message: { ...message } },
-      );
+      return await this.getClient().post<SendMessageAPIResponse<ErmisChatGenerics>>(this._channelURL() + '/message', {
+        message: { ...message },
+      });
     } catch (error: any) {
       // 4. On error: check if it's an offline/network error
-      const isOfflineError = !error.response || error.code === 'ERR_NETWORK' || error.isWSFailure || !this.getClient().wsConnection?.isHealthy;
+      const isOfflineError =
+        !error.response ||
+        error.code === 'ERR_NETWORK' ||
+        error.isWSFailure ||
+        !this.getClient().wsConnection?.isHealthy;
       const statusToSet = isOfflineError ? 'failed_offline' : 'error';
       this.state.updateMessageStatus(messageId, statusToSet);
       throw error;
@@ -166,12 +171,15 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
     }
 
     try {
-      return await this.getClient().post<SendMessageAPIResponse<ErmisChatGenerics>>(
-        this._channelURL() + '/message',
-        { message: messagePayload },
-      );
+      return await this.getClient().post<SendMessageAPIResponse<ErmisChatGenerics>>(this._channelURL() + '/message', {
+        message: messagePayload,
+      });
     } catch (error: any) {
-      const isOfflineError = !error.response || error.code === 'ERR_NETWORK' || error.isWSFailure || !this.getClient().wsConnection?.isHealthy;
+      const isOfflineError =
+        !error.response ||
+        error.code === 'ERR_NETWORK' ||
+        error.isWSFailure ||
+        !this.getClient().wsConnection?.isHealthy;
       this.state.updateMessageStatus(messageId, isOfflineError ? 'failed_offline' : 'error');
       throw error;
     }
@@ -218,6 +226,48 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
     );
   }
 
+  async pin() {
+    if (this.data) this.data.is_pinned = true;
+    this.getClient().dispatchEvent({
+      type: 'channel.pinned',
+      cid: this.cid,
+      channel: this.data,
+    } as Event<ErmisChatGenerics>);
+
+    try {
+      return await this.getClient().pinChannel(this.type, this.id as string);
+    } catch (e) {
+      if (this.data) this.data.is_pinned = false;
+      this.getClient().dispatchEvent({
+        type: 'channel.unpinned',
+        cid: this.cid,
+        channel: this.data,
+      } as Event<ErmisChatGenerics>);
+      throw e;
+    }
+  }
+
+  async unpin() {
+    if (this.data) this.data.is_pinned = false;
+    this.getClient().dispatchEvent({
+      type: 'channel.unpinned',
+      cid: this.cid,
+      channel: this.data,
+    } as Event<ErmisChatGenerics>);
+
+    try {
+      return await this.getClient().unpinChannel(this.type, this.id as string);
+    } catch (e) {
+      if (this.data) this.data.is_pinned = true;
+      this.getClient().dispatchEvent({
+        type: 'channel.pinned',
+        cid: this.cid,
+        channel: this.data,
+      } as Event<ErmisChatGenerics>);
+      throw e;
+    }
+  }
+
   async editMessage(oldMessageID: string, message: EditMessage) {
     return await this.getClient().post(this.getClient().baseURL + `/messages/${this.type}/${this.id}/${oldMessageID}`, {
       message,
@@ -263,9 +313,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
 
     // 2. Upload all files in parallel
     const uploadResults = await Promise.allSettled(
-      processedFiles.map((file) =>
-        this.sendFile(file, file.name, file.type),
-      ),
+      processedFiles.map((file) => this.sendFile(file, file.name, file.type)),
     );
 
     // 3. For successful video uploads, generate and upload thumbnails
@@ -280,11 +328,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
             try {
               const thumbBlob = await this.getThumbBlobVideo(files[i]);
               if (thumbBlob) {
-                const thumbFile = new File(
-                  [thumbBlob],
-                  `thumb_${processedFiles[i].name}.jpg`,
-                  { type: 'image/jpeg' },
-                );
+                const thumbFile = new File([thumbBlob], `thumb_${processedFiles[i].name}.jpg`, { type: 'image/jpeg' });
                 const thumbResp = await this.sendFile(thumbFile, thumbFile.name, 'image/jpeg');
                 thumbUrls.set(i, thumbResp.file);
               }
@@ -306,9 +350,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
         const uploadedUrl = result.value.file;
         const thumbUrl = thumbUrls.get(i);
         const voiceMeta = options?.voiceMetadata?.get(i);
-        attachments.push(
-          buildAttachmentPayload(processedFiles[i], uploadedUrl, thumbUrl, voiceMeta),
-        );
+        attachments.push(buildAttachmentPayload(processedFiles[i], uploadedUrl, thumbUrl, voiceMeta));
       } else {
         failedFiles.push({
           file: files[i],
@@ -728,7 +770,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
     }
   };
 
-  async createTopic(data: any) {
+  async createTopic(data: CreateTopicData) {
     const project_id = this._client.projectId;
     const uuid = randomId();
     const topicID = `${project_id}:${uuid}`;
@@ -756,7 +798,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
     if (this.id) {
       queryURL += `/${this.id}`;
     } else {
-      if (this.type === 'team') {
+      if (this.type === 'team' || this.type === 'meeting') {
         const uuid = randomId();
         this.id = `${project_id}:${uuid}`;
         queryURL += `/${this.id}`;
@@ -1081,7 +1123,7 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
     });
   }
 
-  async editTopic(topicCID: string, data: any) {
+  async editTopic(topicCID: string, data: EditTopicData) {
     const response: any = await this.getClient().post(
       this.getClient().baseURL + `/channels/${this.type}/${this.id}/topics`,
       {
@@ -1392,6 +1434,18 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
           delete channelState.members[event.user.id];
         }
         break;
+      case 'channel.topic.enabled':
+        if (channel.data) {
+          channel.data.topics_enabled = true;
+        }
+        channelState.topics = channelState.topics || [];
+        break;
+      case 'channel.topic.disabled':
+        if (channel.data) {
+          channel.data.topics_enabled = false;
+        }
+        channelState.topics = [];
+        break;
       case 'channel.updated':
         if (event.channel) {
           channel.data = {
@@ -1547,7 +1601,13 @@ export class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGener
         const topic = this.getClient().channel(event.channel_type || '', event.channel_id || '');
         topic.data = event.channel;
         topic._initializeState(topicState, 'latest');
-        channelState.topics?.unshift(topic);
+        
+        if (!channelState.topics) {
+          channelState.topics = [];
+        }
+        if (!channelState.topics.some((t) => t.cid === topic.cid)) {
+          channelState.topics.push(topic);
+        }
         break;
       case 'channel.topic.closed':
         if (channel.data) {

package/src/client.ts

@@ -205,7 +205,6 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
       params.avatar = user.avatar;
     }
     const url = this.userBaseURL + '/get_token/external_auth';
-    const query = new URLSearchParams(params).toString();
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
     };
@@ -213,21 +212,21 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
       const tokenStr = typeof token === 'string' && token.startsWith('Bearer ') ? token : `Bearer ${token}`;
       headers['Authorization'] = tokenStr;
     }
-    const response = await fetch(`${url}?${query}`, {
-      method: 'GET',
-      headers,
-    });
-    if (!response.ok) {
-      let errorMsg = '';
-      try {
-        const errorData = await response.json();
-        errorMsg = errorData.message || JSON.stringify(errorData);
-      } catch {
-        errorMsg = await response.text();
+    try {
+      const response = await this.axiosInstance.get(url, {
+        params,
+        headers,
+      });
+      return response.data;
+    } catch (error: any) {
+      let errorMsg = 'Failed to fetch external auth token';
+      if (error.response && error.response.data) {
+        errorMsg = error.response.data.message || JSON.stringify(error.response.data);
+      } else if (error.message) {
+        errorMsg = error.message;
       }
       throw new Error(errorMsg);
     }
-    return await response.json();
   }
 
   /**
@@ -242,7 +241,7 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
   connectUser = async (
     user: UserResponse<ErmisChatGenerics>,
     userTokenOrProvider: string | null,
-    extenal_auth?: boolean, // pass true if you are using external auth
+    external_auth?: boolean, // pass true if you are using external auth
   ) => {
     this.logger('info', 'client:connectUser() - started', {
       tags: ['connection', 'client'],
@@ -251,19 +250,25 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
       throw new Error('The "id" field on the user is missing');
     }
 
+    let connectionUser = user;
+    let connectionToken = userTokenOrProvider;
+
     // If external auth is enabled, get the token from the server
-    if (extenal_auth) {
+    if (external_auth) {
       const external_auth_token = await this.getExternalAuthToken(user, userTokenOrProvider);
 
-      userTokenOrProvider = external_auth_token.token;
-      user.id = external_auth_token.user_id;
+      connectionToken = external_auth_token.token;
+      connectionUser = {
+        ...user,
+        id: external_auth_token.user_id,
+      };
     }
 
     /**
      * Calling connectUser multiple times is potentially the result of a  bad integration, however,
      * If the user id remains the same we don't throw error
      */
-    if (this.userID === user.id && this.setUserPromise) {
+    if (this.userID === connectionUser.id && this.setUserPromise) {
       console.warn(
         'Consecutive calls to connectUser is detected, ideally you should only call this function once in your app.',
       );
@@ -283,11 +288,11 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
     }
 
     // we generate the client id client side
-    this.userID = user.id;
+    this.userID = connectionUser.id;
 
-    const setTokenPromise = this._setToken(user, userTokenOrProvider);
-    this._setUser(user);
-    this.state.updateUser({ id: user.id, name: user?.name || user.id, avatar: user?.avatar || '' });
+    const setTokenPromise = this._setToken(connectionUser, connectionToken);
+    this._setUser(connectionUser);
+    this.state.updateUser({ id: connectionUser.id, name: connectionUser?.name || connectionUser.id, avatar: connectionUser?.avatar || '' });
 
     const wsPromise = this.openConnection();
 
@@ -609,8 +614,8 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
   dispatchEvent = (event: Event<ErmisChatGenerics>) => {
     if (!event.received_at) event.received_at = new Date();
 
-    // If the event is channel.created, handle it asynchronously
-    if (event.type === 'channel.created') {
+    // If the event is channel.created or channel.topic.created, handle it asynchronously
+    if (event.type === 'channel.created' || event.type === 'channel.topic.created') {
       this._handleChannelCreatedEvent(event).then(() => {
         this._afterDispatchEvent(event);
       });
@@ -789,6 +794,85 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
       }
     }
 
+    if (event.type === 'message.new' && event.channel_type === 'topic') {
+      postListenerCallbacks.push(() => {
+        const parentCid = event.parent_cid || event.channel?.parent_cid;
+        if (parentCid && this.activeChannels[parentCid]) {
+          const parentChannel = this.activeChannels[parentCid];
+          if (parentChannel.state.topics) {
+            parentChannel.state.topics.sort((a, b) => {
+              const aLatest = a.state?.latestMessages?.[a.state.latestMessages.length - 1]?.created_at;
+              const bLatest = b.state?.latestMessages?.[b.state.latestMessages.length - 1]?.created_at;
+              const aTime = aLatest ? new Date(aLatest).getTime() : 0;
+              const bTime = bLatest ? new Date(bLatest).getTime() : 0;
+              return bTime - aTime;
+            });
+            parentChannel._callChannelListeners({ ...event, type: 'channel.updated', channel: parentChannel.data } as any);
+          }
+        }
+      });
+    }
+    if (event.type === 'channel.topic.updated') {
+      postListenerCallbacks.push(() => {
+        const parentCid = event.parent_cid || event.channel?.parent_cid;
+        if (parentCid && this.activeChannels[parentCid]) {
+          const parentChannel = this.activeChannels[parentCid];
+          if (parentChannel.state?.topics && event.channel) {
+            const topicIndex = parentChannel.state.topics.findIndex((t: any) => t.cid === event.cid || t.channel?.cid === event.cid);
+            if (topicIndex !== -1) {
+              const t = parentChannel.state.topics[topicIndex] as any;
+              if (t.data) {
+                t.data = { ...t.data, ...event.channel };
+              } else if (t.channel) {
+                t.channel = { ...t.channel, ...event.channel };
+              } else {
+                Object.assign(t, event.channel);
+              }
+            }
+            parentChannel._callChannelListeners({ ...event, type: 'channel.updated', channel: parentChannel.data } as any);
+          }
+        }
+
+        if (event.cid && this.activeChannels[event.cid]) {
+          const topicChannel = this.activeChannels[event.cid];
+          if (event.channel) {
+            topicChannel.data = { ...topicChannel.data, ...event.channel };
+            topicChannel._callChannelListeners({ ...event, type: 'channel.updated', channel: topicChannel.data } as any);
+          }
+        }
+      });
+    }
+
+    if (event.type === 'channel.topic.closed' || event.type === 'channel.topic.reopen') {
+      postListenerCallbacks.push(() => {
+        const isClosed = event.type === 'channel.topic.closed';
+        const parentCid = event.parent_cid;
+        if (parentCid && this.activeChannels[parentCid]) {
+          const parentChannel = this.activeChannels[parentCid];
+          if (parentChannel.state?.topics) {
+            const topicIndex = parentChannel.state.topics.findIndex((t: any) => t.cid === event.cid || t.channel?.cid === event.cid);
+            if (topicIndex !== -1) {
+              const t = parentChannel.state.topics[topicIndex] as any;
+              if (t.data) t.data.is_closed_topic = isClosed;
+              else if (t.channel) t.channel.is_closed_topic = isClosed;
+              else t.is_closed_topic = isClosed;
+            }
+            parentChannel._callChannelListeners({ ...event, type: 'channel.updated', channel: parentChannel.data } as any);
+          }
+        }
+
+        if (event.cid && this.activeChannels[event.cid]) {
+          const topicChannel = this.activeChannels[event.cid];
+          if (topicChannel.data) {
+            topicChannel.data.is_closed_topic = isClosed;
+          }
+          topicChannel._callChannelListeners({ ...event, type: 'channel.updated', channel: topicChannel.data } as any);
+        }
+      });
+    }
+
+
+
     if (event.type === 'connection.recovered') {
       postListenerCallbacks.push(() => {
         // Auto-resend offline failed messages
@@ -1086,7 +1170,14 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
     this.projectId = project_id;
   }
 
-  async uploadFile(file: File) {
+  /**
+   * Uploads a new avatar image for the current user.
+   * The user's avatar URL is automatically updated in both the client and the local state.
+   *
+   * @param file - The image file to upload.
+   * @returns The response containing the new avatar URL.
+   */
+  async uploadAvatar(file: File) {
     const formData = new FormData();
     formData.append('avatar', file);
     let response = await this.post<{ avatar: string }>(this.userBaseURL + '/users/upload', formData, {
@@ -1102,12 +1193,8 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
 
     return response;
   }
-  async updateProfile(name: string, about_me: string) {
-    let body = {
-      name,
-      about_me,
-    };
-    let response = await this.patch<UserResponse<ErmisChatGenerics>>(this.userBaseURL + '/users/update', body);
+  async updateProfile(updates: Partial<UserResponse<ErmisChatGenerics>>) {
+    let response = await this.patch<UserResponse<ErmisChatGenerics>>(this.userBaseURL + '/users/update', updates);
     this.user = response;
     this.state.updateUser(response);
     return response;
@@ -1358,6 +1445,63 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
     return channel;
   };
 
+  /**
+   * Creates a quick channel and immediately registers it on the server.
+   * Quick channels are public group channels that anyone can join without an invitation.
+   * The creator is added as the first member automatically.
+   *
+   * @param name - An optional display name for the channel.
+   * @returns A promise that resolves to the created `Channel` object.
+   */
+  async createQuickChannel(name?: string): Promise<Channel<ErmisChatGenerics>> {
+    if (!this.userID) {
+      throw Error('Call connectUser before creating a channel');
+    }
+
+    const now = new Date();
+    const formattedDate = new Intl.DateTimeFormat('en-US', {
+      month: 'short', day: '2-digit', year: 'numeric',
+      hour: '2-digit', minute: '2-digit', hour12: false,
+    }).format(now);
+
+    const payload = {
+      name: name || `Quick Channel - ${formattedDate}`,
+      members: [this.userID],
+      public: true,
+    } as unknown as ChannelData<ErmisChatGenerics>;
+
+    const quickChannel = this.channel('meeting', payload);
+    await quickChannel.create();
+    
+    return quickChannel;
+  }
+
+  /**
+   * Joins a quick channel by its ID.
+   * Automatically checks whether the caller is already a member.
+   * If not, it joins the channel and synchronizes state.
+   *
+   * @param channelId - The ID of the quick channel to join.
+   * @returns A promise that resolves to the joined `Channel` object.
+   */
+  async joinQuickChannel(channelId: string): Promise<Channel<ErmisChatGenerics>> {
+    if (!this.userID) {
+      throw Error('Call connectUser before joining a channel');
+    }
+
+    const quickChannel = this.channel('meeting', channelId);
+    await quickChannel.watch();
+
+    const isMember = quickChannel.state.members && quickChannel.state.members[this.userID];
+
+    if (!isMember) {
+      await quickChannel.acceptInvite('join');
+      await quickChannel.watch();
+    }
+
+    return quickChannel;
+  }
+
   _normalizeExpiration(timeoutOrExpirationDate?: null | number | string | Date) {
     let pinExpires: null | string = null;
     if (typeof timeoutOrExpirationDate === 'number') {

package/src/types.ts

@@ -58,6 +58,7 @@ export type ChannelResponse<ErmisChatGenerics extends ExtendableGenerics = Defau
     member_capabilities?: string[];
     is_pinned?: boolean;
     topics_enabled?: boolean;
+    parent_cid?: string;
     is_closed_topic?: boolean;
   };
 
@@ -265,6 +266,7 @@ export type Event<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics
   message?: MessageResponse<ErmisChatGenerics>;
   online?: boolean;
   parent_id?: string;
+  parent_cid?: string;
   reaction?: ReactionResponse<ErmisChatGenerics>;
   received_at?: string | Date;
   unread_messages?: number;
@@ -300,6 +302,18 @@ export type ChannelFilters = {
   include_parent?: boolean;
 };
 
+export type CreateTopicData = {
+  name: string;
+  image?: string;
+  [key: string]: any;
+};
+
+export type EditTopicData = {
+  name?: string;
+  image?: string;
+  description?: string;
+};
+
 export type ChannelSort = {
   field: string;
   direction: -1 | 1;