stream-chat 9.11.0 → 9.13.0

package/src/LiveLocationManager.ts

@@ -0,0 +1,297 @@
+/**
+ * RULES:
+ *
+ * 1. one loc-sharing message per channel per user
+ * 2. live location is intended to be per device
+ * but created_by_device_id has currently no checks,
+ * and user can update the location from another device
+ * thus making location sharing based on user and channel
+ */
+
+import { withCancellation } from './utils/concurrency';
+import { StateStore } from './store';
+import { WithSubscriptions } from './utils/WithSubscriptions';
+import type { StreamChat } from './client';
+import type { Unsubscribe } from './store';
+import type {
+  EventTypes,
+  MessageResponse,
+  SharedLiveLocationResponse,
+  SharedLocationResponse,
+} from './types';
+import type { Coords } from './messageComposer';
+
+export type WatchLocationHandler = (value: Coords) => void;
+export type WatchLocation = (handler: WatchLocationHandler) => Unsubscribe;
+type DeviceIdGenerator = () => string;
+type MessageId = string;
+
+export type ScheduledLiveLocationSharing = SharedLiveLocationResponse & {
+  stopSharingTimeout: ReturnType<typeof setTimeout> | null;
+};
+
+export type LiveLocationManagerState = {
+  ready: boolean;
+  messages: Map<MessageId, ScheduledLiveLocationSharing>;
+};
+
+const isExpiredLocation = (location: SharedLiveLocationResponse) => {
+  const endTimeTimestamp = new Date(location.end_at).getTime();
+
+  return endTimeTimestamp < Date.now();
+};
+
+function isValidLiveLocationMessage(
+  message?: MessageResponse,
+): message is MessageResponse & { shared_location: SharedLiveLocationResponse } {
+  if (!message || message.type === 'deleted' || !message.shared_location?.end_at)
+    return false;
+
+  return !isExpiredLocation(message.shared_location as SharedLiveLocationResponse);
+}
+
+export type LiveLocationManagerConstructorParameters = {
+  client: StreamChat;
+  getDeviceId: DeviceIdGenerator;
+  watchLocation: WatchLocation;
+};
+
+// Hard-coded minimal throttle timeout
+export const UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT = 3000;
+
+export class LiveLocationManager extends WithSubscriptions {
+  public state: StateStore<LiveLocationManagerState>;
+  private client: StreamChat;
+  private getDeviceId: DeviceIdGenerator;
+  private _deviceId: string;
+  private watchLocation: WatchLocation;
+
+  static symbol = Symbol(LiveLocationManager.name);
+
+  constructor({
+    client,
+    getDeviceId,
+    watchLocation,
+  }: LiveLocationManagerConstructorParameters) {
+    if (!client.userID) {
+      throw new Error('Live-location sharing is reserved for client-side use only');
+    }
+
+    super();
+
+    this.client = client;
+    this.state = new StateStore<LiveLocationManagerState>({
+      messages: new Map(),
+      ready: false,
+    });
+    this._deviceId = getDeviceId();
+    this.getDeviceId = getDeviceId;
+    this.watchLocation = watchLocation;
+  }
+
+  public async init() {
+    await this.assureStateInit();
+    this.registerSubscriptions();
+  }
+
+  public registerSubscriptions = () => {
+    this.incrementRefCount();
+    if (this.hasSubscriptions) return;
+
+    this.addUnsubscribeFunction(this.subscribeLiveLocationSharingUpdates());
+    this.addUnsubscribeFunction(this.subscribeTargetMessagesChange());
+  };
+
+  public unregisterSubscriptions = () => super.unregisterSubscriptions();
+
+  get messages() {
+    return this.state.getLatestValue().messages;
+  }
+
+  get stateIsReady() {
+    return this.state.getLatestValue().ready;
+  }
+
+  get deviceId() {
+    if (!this._deviceId) {
+      this._deviceId = this.getDeviceId();
+    }
+    return this._deviceId;
+  }
+
+  private async assureStateInit() {
+    if (this.stateIsReady) return;
+    const { active_live_locations } = await this.client.getSharedLocations();
+    this.state.next({
+      messages: new Map(
+        active_live_locations
+          .filter((location) => !isExpiredLocation(location))
+          .map((location) => [
+            location.message_id,
+            {
+              ...location,
+              stopSharingTimeout: setTimeout(
+                () => {
+                  this.unregisterMessages([location.message_id]);
+                },
+                new Date(location.end_at).getTime() - Date.now(),
+              ),
+            },
+          ]),
+      ),
+      ready: true,
+    });
+  }
+
+  private subscribeTargetMessagesChange() {
+    let unsubscribeWatchLocation: null | (() => void) = null;
+
+    // Subscribe to location updates only if there are relevant messages to
+    // update, no need for the location watcher to be active/instantiated otherwise
+    const unsubscribe = this.state.subscribeWithSelector(
+      ({ messages }) => ({ messages }),
+      ({ messages }) => {
+        if (!messages.size) {
+          unsubscribeWatchLocation?.();
+          unsubscribeWatchLocation = null;
+        } else if (messages.size && !unsubscribeWatchLocation) {
+          unsubscribeWatchLocation = this.subscribeWatchLocation();
+        }
+      },
+    );
+
+    return () => {
+      unsubscribe();
+      unsubscribeWatchLocation?.();
+    };
+  }
+
+  private subscribeWatchLocation() {
+    let nextAllowedUpdateCallTimestamp = Date.now();
+
+    const unsubscribe = this.watchLocation(({ latitude, longitude }) => {
+      // Integrators can adjust the update interval by supplying custom watchLocation subscription,
+      // but the minimal timeout still has to be set as a failsafe (to prevent rate-limitting)
+      if (Date.now() < nextAllowedUpdateCallTimestamp) return;
+
+      nextAllowedUpdateCallTimestamp =
+        Date.now() + UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT;
+
+      withCancellation(LiveLocationManager.symbol, async () => {
+        const promises: Promise<SharedLocationResponse>[] = [];
+        await this.assureStateInit();
+        const expiredLocations: string[] = [];
+
+        for (const [messageId, location] of this.messages) {
+          if (isExpiredLocation(location)) {
+            expiredLocations.push(location.message_id);
+            continue;
+          }
+          if (location.latitude === latitude && location.longitude === longitude)
+            continue;
+          const promise = this.client.updateLocation({
+            created_by_device_id: location.created_by_device_id,
+            message_id: messageId,
+            latitude,
+            longitude,
+          });
+
+          promises.push(promise);
+        }
+        this.unregisterMessages(expiredLocations);
+        if (promises.length > 0) {
+          await Promise.allSettled(promises);
+        }
+        // TODO: handle values (remove failed - based on specific error code), keep re-trying others
+      });
+    });
+
+    return unsubscribe;
+  }
+
+  private subscribeLiveLocationSharingUpdates() {
+    /**
+     * Both message.updated & live_location_sharing.stopped get emitted when message gets an
+     * update, live_location_sharing.stopped gets emitted only locally and only if the update goes
+     * through, it's a failsafe for when channel is no longer being watched for whatever reason
+     */
+    const subscriptions = [
+      ...(
+        [
+          'live_location_sharing.started',
+          'message.updated',
+          'message.deleted',
+        ] as EventTypes[]
+      ).map((eventType) =>
+        this.client.on(eventType, (event) => {
+          if (!event.message) return;
+
+          if (event.type === 'live_location_sharing.started') {
+            this.registerMessage(event.message);
+          } else if (event.type === 'message.updated') {
+            const isRegistered = this.messages.has(event.message.id);
+            if (isRegistered && !isValidLiveLocationMessage(event.message)) {
+              this.unregisterMessages([event.message.id]);
+            }
+            this.registerMessage(event.message);
+          } else {
+            this.unregisterMessages([event.message.id]);
+          }
+        }),
+      ),
+      this.client.on('live_location_sharing.stopped', (event) => {
+        if (!event.live_location) return;
+
+        this.unregisterMessages([event.live_location?.message_id]);
+      }),
+    ];
+
+    return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+  }
+
+  private registerMessage(message: MessageResponse) {
+    if (
+      !this.client.userID ||
+      message?.user?.id !== this.client.userID ||
+      !isValidLiveLocationMessage(message)
+    )
+      return;
+
+    this.state.next((currentValue) => {
+      const messages = new Map(currentValue.messages);
+      messages.set(message.id, {
+        ...message.shared_location,
+        stopSharingTimeout: setTimeout(
+          () => {
+            this.unregisterMessages([message.id]);
+          },
+          new Date(message.shared_location.end_at).getTime() - Date.now(),
+        ),
+      });
+      return {
+        ...currentValue,
+        messages,
+      };
+    });
+  }
+
+  private unregisterMessages(messageIds: string[]) {
+    const messages = this.messages;
+    const removedMessages = new Set(messageIds);
+    const newMessages = new Map(
+      Array.from(messages).filter(([messageId, location]) => {
+        if (removedMessages.has(messageId) && location.stopSharingTimeout) {
+          clearTimeout(location.stopSharingTimeout);
+          location.stopSharingTimeout = null;
+        }
+        return !removedMessages.has(messageId);
+      }),
+    );
+
+    if (newMessages.size === messages.size) return;
+
+    this.state.partialNext({
+      messages: newMessages,
+    });
+  }
+}

package/src/channel.ts

@@ -31,6 +31,7 @@ import type {
   GetMultipleMessagesAPIResponse,
   GetReactionsAPIResponse,
   GetRepliesAPIResponse,
+  LiveLocationPayload,
   LocalMessage,
   MarkReadOptions,
   MarkUnreadOptions,
@@ -63,10 +64,12 @@ import type {
   SendMessageAPIResponse,
   SendMessageOptions,
   SendReactionOptions,
+  StaticLocationPayload,
   TruncateChannelAPIResponse,
   TruncateOptions,
   UpdateChannelAPIResponse,
   UpdateChannelOptions,
+  UpdateLocationPayload,
   UserResponse,
 } from './types';
 import type { Role } from './permissions';
@@ -669,6 +672,37 @@ export class Channel {
     return data;
   }
 
+  public async sendSharedLocation(
+    location: StaticLocationPayload | LiveLocationPayload,
+    userId?: string,
+  ) {
+    const result = await this.sendMessage({
+      id: location.message_id,
+      shared_location: location,
+      user: userId ? { id: userId } : undefined,
+    });
+
+    if ((location as LiveLocationPayload).end_at) {
+      this.getClient().dispatchEvent({
+        message: result.message,
+        type: 'live_location_sharing.started',
+      });
+    }
+
+    return result;
+  }
+
+  public async stopLiveLocationSharing(payload: UpdateLocationPayload) {
+    const location = await this.getClient().updateLocation({
+      ...payload,
+      end_at: new Date().toISOString(),
+    });
+    this.getClient().dispatchEvent({
+      live_location: location,
+      type: 'live_location_sharing.stopped',
+    });
+  }
+
   /**
    * delete - Delete the channel. Messages are permanently removed.
    *

package/src/channel_manager.ts

@@ -133,6 +133,10 @@ export type ChannelManagerOptions = {
   lockChannelOrder?: boolean;
 };
 
+export type QueryChannelsRequestType = (
+  ...params: Parameters<StreamChat['queryChannels']>
+) => Promise<Channel[]>;
+
 export const DEFAULT_CHANNEL_MANAGER_OPTIONS = {
   abortInFlightQuery: false,
   allowNotLoadedChannelPromotionForEvent: {
@@ -160,6 +164,7 @@ export class ChannelManager extends WithSubscriptions {
   private client: StreamChat;
   private eventHandlers: Map<string, EventHandlerType> = new Map();
   private eventHandlerOverrides: Map<string, EventHandlerOverrideType> = new Map();
+  private queryChannelsRequest: QueryChannelsRequestType;
   private options: ChannelManagerOptions = {};
   private stateOptions: ChannelStateOptions = {};
   private id: string;
@@ -168,10 +173,12 @@ export class ChannelManager extends WithSubscriptions {
     client,
     eventHandlerOverrides = {},
     options = {},
+    queryChannelsOverride,
   }: {
     client: StreamChat;
     eventHandlerOverrides?: ChannelManagerEventHandlerOverrides;
     options?: ChannelManagerOptions;
+    queryChannelsOverride?: QueryChannelsRequestType;
   }) {
     super();
 
@@ -192,6 +199,8 @@ export class ChannelManager extends WithSubscriptions {
     });
     this.setEventHandlerOverrides(eventHandlerOverrides);
     this.setOptions(options);
+    this.queryChannelsRequest =
+      queryChannelsOverride ?? ((...params) => this.client.queryChannels(...params));
     this.eventHandlers = new Map(
       Object.entries<EventHandlerType>({
         channelDeletedHandler: this.channelDeletedHandler,
@@ -252,6 +261,10 @@ export class ChannelManager extends WithSubscriptions {
     );
   };
 
+  public setQueryChannelsRequest = (queryChannelsRequest: QueryChannelsRequestType) => {
+    this.queryChannelsRequest = queryChannelsRequest;
+  };
+
   public setOptions = (options: ChannelManagerOptions = {}) => {
     this.options = { ...DEFAULT_CHANNEL_MANAGER_OPTIONS, ...options };
   };
@@ -266,7 +279,7 @@ export class ChannelManager extends WithSubscriptions {
       ...options,
     };
     try {
-      const channels = await this.client.queryChannels(
+      const channels = await this.queryChannelsRequest(
         filters,
         sort,
         options,
@@ -304,7 +317,19 @@ export class ChannelManager extends WithSubscriptions {
           `Maximum number of retries reached in queryChannels. Last error message is: ${err}`,
         );
 
-        this.state.partialNext({ error: wrappedError });
+        const state = this.state.getLatestValue();
+        // If the offline support is enabled, and there are channels in the DB, we should not error out.
+        const isOfflineSupportEnabledWithChannels =
+          this.client.offlineDb && state.channels.length > 0;
+
+        this.state.partialNext({
+          error: isOfflineSupportEnabledWithChannels ? undefined : wrappedError,
+          pagination: {
+            ...state.pagination,
+            isLoading: false,
+            isLoadingNext: false,
+          },
+        });
         return;
       }
 
@@ -407,7 +432,7 @@ export class ChannelManager extends WithSubscriptions {
       this.state.partialNext({
         pagination: { ...pagination, isLoading: false, isLoadingNext: true },
       });
-      const nextChannels = await this.client.queryChannels(
+      const nextChannels = await this.queryChannelsRequest(
         filters,
         sort,
         options,
@@ -431,7 +456,11 @@ export class ChannelManager extends WithSubscriptions {
       this.client.logger('error', (error as Error).message);
       this.state.next((currentState) => ({
         ...currentState,
-        pagination: { ...currentState.pagination, isLoadingNext: false },
+        pagination: {
+          ...currentState.pagination,
+          isLoadingNext: false,
+          isLoading: false,
+        },
       }));
       throw error;
     }

package/src/client.ts

@@ -106,6 +106,7 @@ import type {
   GetCampaignOptions,
   GetChannelTypeResponse,
   GetCommandResponse,
+  GetHookEventsResponse,
   GetImportResponse,
   GetMessageAPIResponse,
   GetMessageOptions,
@@ -148,6 +149,7 @@ import type {
   PollVote,
   PollVoteData,
   PollVotesAPIResponse,
+  Product,
   PushPreference,
   PushProvider,
   PushProviderConfig,
@@ -191,7 +193,6 @@ import type {
   SegmentTargetsResponse,
   SegmentType,
   SendFileAPIResponse,
-  SharedLocationRequest,
   SharedLocationResponse,
   SortParam,
   StreamChatOptions,
@@ -209,6 +210,7 @@ import type {
   UpdateChannelTypeResponse,
   UpdateCommandOptions,
   UpdateCommandResponse,
+  UpdateLocationPayload,
   UpdateMessageAPIResponse,
   UpdateMessageOptions,
   UpdatePollAPIResponse,
@@ -233,6 +235,7 @@ import { PollManager } from './poll_manager';
 import type {
   ChannelManagerEventHandlerOverrides,
   ChannelManagerOptions,
+  QueryChannelsRequestType,
 } from './channel_manager';
 import { ChannelManager } from './channel_manager';
 import { NotificationManager } from './notifications';
@@ -720,10 +723,18 @@ export class StreamChat {
   createChannelManager = ({
     eventHandlerOverrides = {},
     options = {},
+    queryChannelsOverride,
   }: {
     eventHandlerOverrides?: ChannelManagerEventHandlerOverrides;
     options?: ChannelManagerOptions;
-  }) => new ChannelManager({ client: this, eventHandlerOverrides, options });
+    queryChannelsOverride?: QueryChannelsRequestType;
+  }) =>
+    new ChannelManager({
+      client: this,
+      eventHandlerOverrides,
+      options,
+      queryChannelsOverride,
+    });
 
   /**
    * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
@@ -2155,6 +2166,17 @@ export class StreamChat {
     });
   }
 
+  /**
+   * getHookEvents - Get available events for hooks (webhook, SQS, and SNS)
+   *
+   * @param {Product[]} [products] Optional array of products to filter events by (e.g., [Product.Chat, Product.Video])
+   * @returns {Promise<GetHookEventsResponse>} Response containing available hook events
+   */
+  async getHookEvents(products?: Product[]) {
+    const params = products && products.length > 0 ? { product: products.join(',') } : {};
+    return await this.get<GetHookEventsResponse>(this.baseURL + '/hook/events', params);
+  }
+
   _addChannelConfig({ cid, config }: ChannelResponse) {
     if (this._cacheEnabled()) {
       this.configs[cid] = config;
@@ -4584,11 +4606,11 @@ export class StreamChat {
   /**
    * updateLocation - Updates a location
    *
-   * @param location UserLocation the location data to update
+   * @param location SharedLocationRequest the location data to update
    *
-   * @returns {Promise<APIResponse>} The server response
+   * @returns {Promise<SharedLocationResponse>} The server response
    */
-  async updateLocation(location: SharedLocationRequest) {
+  async updateLocation(location: UpdateLocationPayload) {
     return await this.put<SharedLocationResponse>(
       this.baseURL + `/users/live_locations`,
       location,

package/src/events.ts

@@ -63,6 +63,8 @@ export const EVENT_MAP = {
   'connection.recovered': true,
   'transport.changed': true,
   'capabilities.changed': true,
+  'live_location_sharing.started': true,
+  'live_location_sharing.stopped': true,
 
   // Reminder events
   'reminder.created': true,

package/src/index.ts

@@ -32,6 +32,7 @@ export * from './token_manager';
 export * from './types';
 export * from './channel_manager';
 export * from './offline-support';
+export * from './LiveLocationManager';
 // Don't use * here, that can break module augmentation https://github.com/microsoft/TypeScript/issues/46617
 export type {
   CustomAttachmentData,

package/src/messageComposer/LocationComposer.ts

@@ -0,0 +1,94 @@
+import { StateStore } from '../store';
+import type { MessageComposer } from './messageComposer';
+import type {
+  DraftMessage,
+  LiveLocationPayload,
+  LocalMessage,
+  StaticLocationPayload,
+} from '../types';
+
+export type Coords = { latitude: number; longitude: number };
+
+export type LocationComposerOptions = {
+  composer: MessageComposer;
+  message?: DraftMessage | LocalMessage;
+};
+
+export type StaticLocationPreview = StaticLocationPayload;
+
+export type LiveLocationPreview = Omit<LiveLocationPayload, 'end_at'> & {
+  durationMs?: number;
+};
+
+export type LocationComposerState = {
+  location: StaticLocationPreview | LiveLocationPreview | null;
+};
+
+const MIN_LIVE_LOCATION_SHARE_DURATION = 60 * 1000; // 1 minute;
+
+const initState = ({
+  message,
+}: {
+  message?: DraftMessage | LocalMessage;
+}): LocationComposerState => ({
+  location: message?.shared_location ?? null,
+});
+
+export class LocationComposer {
+  readonly state: StateStore<LocationComposerState>;
+  readonly composer: MessageComposer;
+  private _deviceId: string;
+
+  constructor({ composer, message }: LocationComposerOptions) {
+    this.composer = composer;
+    this.state = new StateStore<LocationComposerState>(initState({ message }));
+    this._deviceId = this.config.getDeviceId();
+  }
+
+  get config() {
+    return this.composer.config.location;
+  }
+
+  get deviceId() {
+    return this._deviceId;
+  }
+
+  get location() {
+    return this.state.getLatestValue().location;
+  }
+
+  get validLocation(): StaticLocationPayload | LiveLocationPayload | null {
+    const { durationMs, ...location } = (this.location ?? {}) as LiveLocationPreview;
+    if (
+      !!location?.created_by_device_id &&
+      location.message_id &&
+      location.latitude &&
+      location.longitude &&
+      (typeof durationMs === 'undefined' ||
+        durationMs >= MIN_LIVE_LOCATION_SHARE_DURATION)
+    ) {
+      return {
+        ...location,
+        end_at: durationMs && new Date(Date.now() + durationMs).toISOString(),
+      } as StaticLocationPayload | LiveLocationPayload;
+    }
+    return null;
+  }
+
+  initState = ({ message }: { message?: DraftMessage | LocalMessage } = {}) => {
+    this.state.next(initState({ message }));
+  };
+
+  setData = (data: { durationMs?: number } & Coords) => {
+    if (!this.config.enabled) return;
+    if (!data.latitude || !data.longitude) return;
+
+    this.state.partialNext({
+      location: {
+        ...data,
+        message_id: this.composer.id,
+        created_by_device_id: this.deviceId,
+      },
+    });
+  };
+}

package/src/messageComposer/attachmentIdentity.ts

@@ -1,4 +1,4 @@
-import type { Attachment } from '../types';
+import type { Attachment, SharedLocationResponse } from '../types';
 import type {
   AudioAttachment,
   FileAttachment,
@@ -90,3 +90,10 @@ export const isUploadedAttachment = (
   isImageAttachment(attachment) ||
   isVideoAttachment(attachment) ||
   isVoiceRecordingAttachment(attachment);
+
+export const isSharedLocationResponse = (
+  location: unknown,
+): location is SharedLocationResponse =>
+  !!(location as SharedLocationResponse).latitude &&
+  !!(location as SharedLocationResponse).longitude &&
+  !!(location as SharedLocationResponse).channel_cid;

package/src/messageComposer/configuration/configuration.ts

@@ -3,9 +3,11 @@ import { API_MAX_FILES_ALLOWED_PER_MESSAGE } from '../../constants';
 import type {
   AttachmentManagerConfig,
   LinkPreviewsManagerConfig,
+  LocationComposerConfig,
   MessageComposerConfig,
 } from './types';
 import type { TextComposerConfig } from './types';
+import { generateUUIDv4 } from '../../utils';
 
 export const DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: LinkPreviewsManagerConfig = {
   debounceURLEnrichmentMs: 1500,
@@ -36,9 +38,15 @@ export const DEFAULT_TEXT_COMPOSER_CONFIG: TextComposerConfig = {
   publishTypingEvents: true,
 };
 
+export const DEFAULT_LOCATION_COMPOSER_CONFIG: LocationComposerConfig = {
+  enabled: true,
+  getDeviceId: () => generateUUIDv4(),
+};
+
 export const DEFAULT_COMPOSER_CONFIG: MessageComposerConfig = {
   attachments: DEFAULT_ATTACHMENT_MANAGER_CONFIG,
   drafts: { enabled: false },
   linkPreviews: DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
+  location: DEFAULT_LOCATION_COMPOSER_CONFIG,
   text: DEFAULT_TEXT_COMPOSER_CONFIG,
 };