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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ermis-network/ermis-chat-sdk",
-  "version": "1.0.6",
+  "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.
@@ -224,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,
@@ -726,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}`;
@@ -1079,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`,
       {
@@ -1390,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 = {
@@ -1545,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;
@@ -1359,53 +1446,60 @@ export class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGen
   };
 
   /**
-   * Creates an interactive `meeting` Channel locally, and immediately creates it on the server.
-   * Consumers can customize the `name` field. `members` and `public` fields are constrained.
+   * 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 - The custom name for the meeting channel.
+   * @param name - An optional display name for the channel.
    * @returns A promise that resolves to the created `Channel` object.
    */
-  async createMeetingChannel(name?: string): Promise<Channel<ErmisChatGenerics>> {
+  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 || `Meeting Public - ${new Date().toISOString()}`,
+      name: name || `Quick Channel - ${formattedDate}`,
       members: [this.userID],
       public: true,
     } as unknown as ChannelData<ErmisChatGenerics>;
 
-    const meetingChannel = this.channel('meeting', payload);
-    await meetingChannel.create();
+    const quickChannel = this.channel('meeting', payload);
+    await quickChannel.create();
     
-    return meetingChannel;
+    return quickChannel;
   }
 
   /**
-   * Joins a `meeting` channel.
-   * It queries/watches the channel to see if caller is already a member.
-   * If not, it accepts the invite to join the channel, then watches it again to reflect changes.
+   * 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 meeting channel to join.
+   * @param channelId - The ID of the quick channel to join.
    * @returns A promise that resolves to the joined `Channel` object.
    */
-  async joinMeetingChannel(channelId: string): Promise<Channel<ErmisChatGenerics>> {
+  async joinQuickChannel(channelId: string): Promise<Channel<ErmisChatGenerics>> {
     if (!this.userID) {
       throw Error('Call connectUser before joining a channel');
     }
 
-    const meetingChannel = this.channel('meeting', channelId);
-    await meetingChannel.watch();
+    const quickChannel = this.channel('meeting', channelId);
+    await quickChannel.watch();
 
-    const isMember = meetingChannel.state.members && meetingChannel.state.members[this.userID];
+    const isMember = quickChannel.state.members && quickChannel.state.members[this.userID];
 
     if (!isMember) {
-      await meetingChannel.acceptInvite('join');
-      await meetingChannel.watch();
+      await quickChannel.acceptInvite('join');
+      await quickChannel.watch();
     }
 
-    return meetingChannel;
+    return quickChannel;
   }
 
   _normalizeExpiration(timeoutOrExpirationDate?: null | number | string | Date) {

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;