feat: support scheduled messages State Layer

src/channel.ts

@@ -214,17 +214,24 @@ export class Channel {
    *
    * @return {Promise<SendMessageAPIResponse>} The Server Response
    */
-  async _sendMessage(rawMessage: Message, options?: SendMessageOptions) {
+  async _sendMessage(rawMessage: Message, options: SendMessageOptions = {}) {
     const client = this.getClient();
     const message = sanitizeOutgoingAttachments({
       client,
       message: rawMessage,
     });
 
-    return await client.post<SendMessageAPIResponse>(this._channelURL() + '/message', {
-      message,
-      ...options,
-    });
+    const response = await client.post<SendMessageAPIResponse>(
+      `${this._channelURL()}/message`,
+      {
+        message,
+        ...options,
+      },
+    );
+    if (response.scheduled_message) {
+      client.scheduledMessages.upsertToState(response.scheduled_message);
+    }
+    return response;
   }
 
   async sendMessage(message: Message, options?: SendMessageOptions) {
@@ -1575,6 +1582,8 @@ export class Channel {
     // Make sure we wait for the connect promise if there is a pending one
     await this.getClient().wsPromise;
 
+    const scheduledMessagesVersion = this.getClient().scheduledMessages.version;
+
     const createdById =
       options.created_by?.id ??
       options.created_by_id ??
@@ -1660,6 +1669,11 @@ export class Channel {
 
     this.getClient().polls.hydratePollCache(state.messages, true);
     this.getClient().reminders.hydrateState(state.messages);
+    this.getClient().scheduledMessages.hydrateChannelState(
+      this.cid,
+      state.scheduled_messages,
+      scheduledMessagesVersion,
+    );
 
     this.messageComposer.initStateFromChannelResponse(state);
 

src/client.ts

@@ -298,6 +298,7 @@ import { ChannelManager } from './channel_manager';
 import { MessageDeliveryReporter } from './messageDelivery';
 import { NotificationManager } from './notifications';
 import { ReminderManager } from './reminders';
+import { ScheduledMessageManager } from './scheduledMessages';
 import { StateStore } from './store';
 import type { MessageComposer } from './messageComposer';
 import type { AbstractOfflineDB } from './offline-support';
@@ -354,6 +355,7 @@ export class StreamChat {
   offlineDb?: AbstractOfflineDB;
   notifications: NotificationManager;
   reminders: ReminderManager;
+  scheduledMessages: ScheduledMessageManager;
   anonymous: boolean;
   persistUserOnConnectionFailure?: boolean;
   axiosInstance: AxiosInstance;
@@ -590,6 +592,7 @@ export class StreamChat {
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
     this.reminders = new ReminderManager({ client: this });
+    this.scheduledMessages = new ScheduledMessageManager({ client: this });
     this.messageDeliveryReporter = new MessageDeliveryReporter({ client: this });
     this.messageComposerCache = new FixedSizeQueueCache<string, MessageComposer>(64);
   }
@@ -1139,6 +1142,7 @@ export class StreamChat {
     this.state = new ClientState({ client: this });
     // reset thread manager
     this.threads.resetState();
+    this.scheduledMessages.resetState();
     this.uploadManager.reset();
     this.messageComposerCache.clear();
 
@@ -2264,14 +2268,15 @@ export class StreamChat {
     options: ChannelOptions = {},
     stateOptions: ChannelStateOptions = {},
   ): Promise<Channel[] | QueryChannelsResponseWithChannels> {
+    const scheduledMessagesVersion = this.scheduledMessages.version;
     const queryChannelsResponse = await this.queryChannelsRequestWithResponse(
       filterConditions,
       sort,
       options,
       // stateOptions is never serialized, so it carries the abort signal
       { signal: stateOptions.signal },
     );
-    const channels = queryChannelsResponse.channels;
+    const channels = queryChannelsResponse.channels ?? [];
 
     this.dispatchEvent({
       type: 'channels.queried',
@@ -2280,13 +2285,23 @@ export class StreamChat {
         isLatestMessageSet: true,
       },
     });
-    if (channels?.length && this.offlineDb?.upsertChannels) {
+    if (channels.length && this.offlineDb?.upsertChannels) {
       await this.offlineDb.upsertChannels({
         channels,
         isLatestMessagesSet: true,
       });
     }
 
+    const { skipInitialization } = stateOptions;
+    for (const channelState of channels) {
+      if (skipInitialization?.includes(channelState.channel.id)) continue;
+
+      this.scheduledMessages.hydrateChannelState(
+        channelState.channel.cid,
+        channelState.scheduled_messages,
+        scheduledMessagesVersion,
+      );
+    }
     const hydratedChannels = this.hydrateActiveChannels(channels, stateOptions, options);
 
     if (stateOptions.withResponse) {