stream-chat 9.50.3 → 10.0.0-rc.2

package/src/pagination/utility.search.ts

@@ -0,0 +1,80 @@
+/**
+ * Partition-point ("lower bound") binary search over the index range `[0, length)`.
+ *
+ * `predicate` must be **monotonic** over the range — `false` for a (possibly empty) prefix, then
+ * `true` for the remaining suffix. Returns the first index at which `predicate(index)` holds, or
+ * `length` if it never does. O(log length).
+ *
+ * Unlike `binarySearch`, this locates a *boundary* defined by a predicate rather than a specific
+ * item by identity — e.g. "first message at/after a timestamp" over a chronologically sorted array.
+ */
+export function lowerBound(
+  length: number,
+  predicate: (index: number) => boolean,
+): number {
+  let lo = 0;
+  let hi = length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (predicate(mid)) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
+
+export function locateOnPlateauAlternating<T>(
+  items: readonly T[],
+  needle: T,
+  compare: (left: T, right: T) => number,
+  getItemId: (x: T) => string,
+  insertionIndex: number,
+): number {
+  const targetId = getItemId(needle);
+  let leftIndex = insertionIndex - 1;
+  let rightIndex = insertionIndex;
+
+  for (let step = 0; ; step++) {
+    const searchRight = step % 2 === 0;
+
+    if (searchRight) {
+      if (rightIndex < items.length && compare(items[rightIndex], needle) === 0) {
+        if (getItemId(items[rightIndex]) === targetId) return rightIndex;
+        rightIndex++;
+        continue;
+      }
+    } else {
+      if (leftIndex >= 0 && compare(items[leftIndex], needle) === 0) {
+        if (getItemId(items[leftIndex]) === targetId) return leftIndex;
+        leftIndex--;
+        continue;
+      }
+    }
+
+    const rightOut =
+      rightIndex >= items.length || compare(items[rightIndex], needle) !== 0;
+    const leftOut = leftIndex < 0 || compare(items[leftIndex], needle) !== 0;
+    if (rightOut && leftOut) break; // plateau exhausted
+  }
+
+  return -1;
+}
+
+export function locateOnPlateauScanOneSide<T>(
+  items: readonly T[],
+  needle: T,
+  compare: (left: T, right: T) => number,
+  getItemId: (x: T) => string,
+  insertionIndex: number,
+): number {
+  const targetId = getItemId(needle);
+
+  // scan left
+  for (let i = insertionIndex - 1; i >= 0 && compare(items[i], needle) === 0; i--) {
+    if (getItemId(items[i]) === targetId) return i;
+  }
+  // scan right
+  for (let i = insertionIndex; i < items.length && compare(items[i], needle) === 0; i++) {
+    if (getItemId(items[i]) === targetId) return i;
+  }
+  return -1;
+}

package/src/permissions.ts

@@ -56,8 +56,7 @@ export const DenyAll = new Permission(
   Deny,
 );
 
-// Fixme: rename to RoleName with next major release
-export type Role =
+export type RoleName =
   | 'admin'
   | 'user'
   | 'guest'
@@ -79,25 +78,25 @@ export const BuiltinPermissions = {
   AddLinks: 'Add Links',
   BanUser: 'Ban User',
   CreateChannel: 'Create Channel',
-  CreateMessage: 'Create Message',
+  CreateMessage: 'Create MessageRequest',
   CreateReaction: 'Create Reaction',
   DeleteAnyAttachment: 'Delete Any Attachment',
   DeleteAnyChannel: 'Delete Any Channel',
-  DeleteAnyMessage: 'Delete Any Message',
+  DeleteAnyMessage: 'Delete Any MessageRequest',
   DeleteAnyReaction: 'Delete Any Reaction',
   DeleteOwnAttachment: 'Delete Own Attachment',
   DeleteOwnChannel: 'Delete Own Channel',
-  DeleteOwnMessage: 'Delete Own Message',
+  DeleteOwnMessage: 'Delete Own MessageRequest',
   DeleteOwnReaction: 'Delete Own Reaction',
   ReadAnyChannel: 'Read Any Channel',
   ReadOwnChannel: 'Read Own Channel',
-  RunMessageAction: 'Run Message Action',
+  RunMessageAction: 'Run MessageRequest Action',
   UpdateAnyChannel: 'Update Any Channel',
-  UpdateAnyMessage: 'Update Any Message',
+  UpdateAnyMessage: 'Update Any MessageRequest',
   UpdateMembersAnyChannel: 'Update Members Any Channel',
   UpdateMembersOwnChannel: 'Update Members Own Channel',
   UpdateOwnChannel: 'Update Own Channel',
-  UpdateOwnMessage: 'Update Own Message',
+  UpdateOwnMessage: 'Update Own MessageRequest',
   UploadAttachment: 'Upload Attachment',
   UseFrozenChannel: 'Send messages and reactions to frozen channels',
 };

package/src/poll.ts

@@ -1,64 +1,36 @@
 import { StateStore } from './store';
 import type { StreamChat } from './client';
 import type {
-  Event,
+  EventPayload,
   PartialPollUpdate,
-  PollAnswer,
-  PollData,
   PollEnrichData,
   PollOptionData,
-  PollResponse,
-  PollVote,
+  PollResponse_old,
+  PollVoteResponseData,
   QueryVotesFilters,
   QueryVotesOptions,
+  RequireLiteral,
+  UpdatePollRequest,
   VoteSort,
+  VotingVisibility,
 } from './types';
+import type { PollResponseData as Gen_PollResponseData, WSEvent } from './gen/models';
 
-type PollEvent = {
-  cid: string;
-  created_at: string;
-  poll: PollResponse;
-};
-
-type PollUpdatedEvent = PollEvent & {
-  type: 'poll.updated';
-};
-
-type PollClosedEvent = PollEvent & {
-  type: 'poll.closed';
-};
-
-type PollVoteEvent = {
-  cid: string;
-  created_at: string;
-  poll: PollResponse;
-  poll_vote: PollVote | PollAnswer;
-};
-
-type PollVoteCastedEvent = PollVoteEvent & {
-  type: 'poll.vote_casted';
-};
-
-type PollVoteCastedChanged = PollVoteEvent & {
-  type: 'poll.vote_removed';
-};
-
-type PollVoteCastedRemoved = PollVoteEvent & {
-  type: 'poll.vote_removed';
-};
-
-const isPollUpdatedEvent = (e: Event): e is PollUpdatedEvent => e.type === 'poll.updated';
-const isPollClosedEventEvent = (e: Event): e is PollClosedEvent =>
+const isPollUpdatedEvent = (e: WSEvent): e is EventPayload<'poll.updated'> =>
+  e.type === 'poll.updated';
+const isPollClosedEventEvent = (e: WSEvent): e is EventPayload<'poll.closed'> =>
   e.type === 'poll.closed';
-const isPollVoteCastedEvent = (e: Event): e is PollVoteCastedEvent =>
+const isPollVoteCastedEvent = (e: WSEvent): e is EventPayload<'poll.vote_casted'> =>
   e.type === 'poll.vote_casted';
-const isPollVoteChangedEvent = (e: Event): e is PollVoteCastedChanged =>
+const isPollVoteChangedEvent = (e: WSEvent): e is EventPayload<'poll.vote_changed'> =>
   e.type === 'poll.vote_changed';
-const isPollVoteRemovedEvent = (e: Event): e is PollVoteCastedRemoved =>
+const isPollVoteRemovedEvent = (e: WSEvent): e is EventPayload<'poll.vote_removed'> =>
   e.type === 'poll.vote_removed';
 
-export const isVoteAnswer = (vote: PollVote | PollAnswer): vote is PollAnswer =>
-  !!(vote as PollAnswer)?.answer_text;
+export const isVoteAnswer = (
+  vote: any | undefined,
+): vote is RequireLiteral<PollVoteResponseData, 'answer_text' | 'is_answer'> =>
+  !!vote?.answer_text;
 
 export type PollAnswersQueryParams = {
   filter?: QueryVotesFilters;
@@ -74,16 +46,16 @@ export type PollOptionVotesQueryParams = {
 
 type OptionId = string;
 
-export type PollState = Omit<PollResponse, 'own_votes' | 'id'> & {
+export type PollState = Omit<PollResponse_old, 'own_votes' | 'id'> & {
   lastActivityAt: Date; // todo: would be ideal to get this from the BE
   maxVotedOptionIds: OptionId[];
-  ownVotesByOptionId: Record<OptionId, PollVote>;
-  ownAnswer?: PollAnswer; // each user can have only one answer
+  ownVotesByOptionId: Record<OptionId, PollVoteResponseData>;
+  ownAnswer?: PollVoteResponseData; // each user can have only one answer
 };
 
 type PollInitOptions = {
   client: StreamChat;
-  poll: PollResponse;
+  poll: Gen_PollResponseData;
 };
 
 export class Poll {
@@ -99,11 +71,10 @@ export class Poll {
   }
 
   private getInitialStateFromPollResponse = (poll: PollInitOptions['poll']) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { own_votes, id, ...pollResponseForState } = poll;
+    const { own_votes, id: _id, ...pollResponseForState } = poll;
     const { ownAnswer, ownVotes } = own_votes?.reduce<{
-      ownVotes: PollVote[];
-      ownAnswer?: PollAnswer;
+      ownVotes: PollVoteResponseData[];
+      ownAnswer?: PollVoteResponseData;
     }>(
       (acc, voteOrAnswer) => {
         if (isVoteAnswer(voteOrAnswer)) {
@@ -119,9 +90,7 @@ export class Poll {
     return {
       ...pollResponseForState,
       lastActivityAt: new Date(),
-      maxVotedOptionIds: getMaxVotedOptionIds(
-        pollResponseForState.vote_counts_by_option as PollResponse['vote_counts_by_option'],
-      ),
+      maxVotedOptionIds: getMaxVotedOptionIds(pollResponseForState.vote_counts_by_option),
       ownAnswer,
       ownVotesByOptionId: getOwnVotesByOptionId(ownVotes),
     };
@@ -142,17 +111,17 @@ export class Poll {
     return this.state.getLatestValue();
   }
 
-  public handlePollUpdated = (event: Event) => {
+  public handlePollUpdated = (event: EventPayload<'poll.updated'>) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollUpdatedEvent(event)) return;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { id, ...pollData } = extractPollData(event.poll);
+
+    const { id: _id, ...pollData } = extractPollData(event.poll);
     // @ts-expect-error type mismatch
     this.state.partialNext({ ...pollData, lastActivityAt: new Date(event.created_at) });
     this.upsertOfflineDb();
   };
 
-  public handlePollClosed = (event: Event) => {
+  public handlePollClosed = (event: EventPayload<'poll.closed'>) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollClosedEventEvent(event)) return;
     this.state.partialNext({
@@ -162,12 +131,12 @@ export class Poll {
     this.upsertOfflineDb();
   };
 
-  public handleVoteCasted = (event: Event) => {
+  public handleVoteCasted = (event: EventPayload<'poll.vote_casted'>) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteCastedEvent(event)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.userID;
-    let latestAnswers = [...(currentState.latest_answers as PollAnswer[])];
+    const isOwnVote = event.poll_vote.user_id === this.client.userId;
+    let latestAnswers = [...(currentState.latest_answers as PollVoteResponseData[])];
     let ownAnswer = currentState.ownAnswer;
     const ownVotesByOptionId = currentState.ownVotesByOptionId;
     let maxVotedOptionIds = currentState.maxVotedOptionIds;
@@ -198,13 +167,13 @@ export class Poll {
     this.upsertOfflineDb();
   };
 
-  public handleVoteChanged = (event: Event) => {
+  public handleVoteChanged = (event: EventPayload<'poll.vote_changed'>) => {
     // this event is triggered only when event.poll.enforce_unique_vote === true
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteChangedEvent(event)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.userID;
-    let latestAnswers = [...(currentState.latest_answers as PollAnswer[])];
+    const isOwnVote = event.poll_vote.user_id === this.client.userId;
+    let latestAnswers = [...(currentState.latest_answers as PollVoteResponseData[])];
     let ownAnswer = currentState.ownAnswer;
     let ownVotesByOptionId = currentState.ownVotesByOptionId;
     let maxVotedOptionIds = currentState.maxVotedOptionIds;
@@ -221,7 +190,7 @@ export class Poll {
           ownVotesByOptionId = { [event.poll_vote.option_id]: event.poll_vote };
         } else {
           ownVotesByOptionId = Object.entries(ownVotesByOptionId).reduce<
-            Record<OptionId, PollVote>
+            Record<OptionId, PollVoteResponseData>
           >((acc, [optionId, vote]) => {
             if (
               optionId !== event.poll_vote.option_id &&
@@ -258,12 +227,12 @@ export class Poll {
     this.upsertOfflineDb();
   };
 
-  public handleVoteRemoved = (event: Event) => {
+  public handleVoteRemoved = (event: EventPayload<'poll.vote_removed'>) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteRemovedEvent(event)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.userID;
-    let latestAnswers = [...(currentState.latest_answers as PollAnswer[])];
+    const isOwnVote = event.poll_vote.user_id === this.client.userId;
+    let latestAnswers = [...(currentState.latest_answers as PollVoteResponseData[])];
     let ownAnswer = currentState.ownAnswer;
     const ownVotesByOptionId = { ...currentState.ownVotesByOptionId };
     let maxVotedOptionIds = currentState.maxVotedOptionIds;
@@ -293,29 +262,36 @@ export class Poll {
   };
 
   query = async (id: string) => {
-    const { poll } = await this.client.getPoll(id);
+    const { poll } = await this.client.getPoll({ poll_id: id });
     this.state.partialNext({ ...poll, lastActivityAt: new Date() });
     return poll;
   };
 
-  update = async (data: Exclude<PollData, 'id'>) =>
-    await this.client.updatePoll({ ...data, id: this.id });
+  update = async (data: Exclude<UpdatePollRequest, 'id'>) =>
+    await this.client.updatePoll({ ...data, id: this.id as string });
 
   partialUpdate = async (partialPollObject: PartialPollUpdate) =>
-    await this.client.partialUpdatePoll(this.id as string, partialPollObject);
+    await this.client.updatePollPartial({
+      poll_id: this.id as string,
+      ...partialPollObject,
+    });
 
-  close = async () => await this.client.closePoll(this.id as string);
+  close = async () =>
+    await this.client.updatePollPartial({
+      poll_id: this.id as string,
+      set: { is_closed: true },
+    });
 
-  delete = async () => await this.client.deletePoll(this.id as string);
+  delete = async () => await this.client.deletePoll({ poll_id: this.id as string });
 
   createOption = async (option: PollOptionData) =>
-    await this.client.createPollOption(this.id as string, option);
+    await this.client.createPollOption({ poll_id: this.id as string, ...option });
 
   updateOption = async (option: PollOptionData) =>
-    await this.client.updatePollOption(this.id as string, option);
+    await this.client.updatePollOption({ poll_id: this.id as string, ...option });
 
-  deleteOption = async (optionId: string) =>
-    await this.client.deletePollOption(this.id as string, optionId);
+  deleteOption = async (option_id: string) =>
+    await this.client.deletePollOption({ poll_id: this.id as string, option_id });
 
   castVote = async (optionId: string, messageId: string) => {
     const { max_votes_allowed, ownVotesByOptionId } = this.data;
@@ -336,38 +312,54 @@ export class Poll {
       });
       return;
     }
-    return await this.client.castPollVote(messageId, this.id as string, {
-      option_id: optionId,
+    return await this.client.castPollVote({
+      message_id: messageId,
+      poll_id: this.id as string,
+      vote: { option_id: optionId },
     });
   };
 
   removeVote = async (voteId: string, messageId: string) =>
-    await this.client.removePollVote(messageId, this.id as string, voteId);
+    await this.client.deletePollVote({
+      message_id: messageId,
+      poll_id: this.id as string,
+      vote_id: voteId,
+    });
 
   addAnswer = async (answerText: string, messageId: string) =>
-    await this.client.addPollAnswer(messageId, this.id as string, answerText);
+    await this.client.castPollVote({
+      message_id: messageId,
+      poll_id: this.id as string,
+      vote: { answer_text: answerText },
+    });
 
   removeAnswer = async (answerId: string, messageId: string) =>
-    await this.client.removePollVote(messageId, this.id as string, answerId);
+    await this.client.deletePollVote({
+      message_id: messageId,
+      poll_id: this.id as string,
+      vote_id: answerId,
+    });
 
   queryAnswers = async (params: PollAnswersQueryParams) =>
-    await this.client.queryPollAnswers(
-      this.id as string,
-      params.filter,
-      params.sort,
-      params.options,
-    );
+    await this.client.queryPollVotes({
+      poll_id: this.id as string,
+      sort: params.sort,
+      filter: { ...(params.filter ?? {}), is_answer: true },
+      ...(params.options ?? {}),
+    });
 
   queryOptionVotes = async (params: PollOptionVotesQueryParams) =>
-    await this.client.queryPollVotes(
-      this.id as string,
-      params.filter,
-      params.sort,
-      params.options,
-    );
+    await this.client.queryPollVotes({
+      poll_id: this.id as string,
+      sort: params.sort,
+      filter: params.filter,
+      ...(params.options ?? {}),
+    });
 }
 
-function getMaxVotedOptionIds(voteCountsByOption: PollResponse['vote_counts_by_option']) {
+function getMaxVotedOptionIds(
+  voteCountsByOption: PollResponse_old['vote_counts_by_option'],
+) {
   let maxVotes = 0;
   let winningOptions: string[] = [];
   for (const [id, count] of Object.entries(voteCountsByOption ?? {})) {
@@ -381,17 +373,17 @@ function getMaxVotedOptionIds(voteCountsByOption: PollResponse['vote_counts_by_o
   return winningOptions;
 }
 
-function getOwnVotesByOptionId(ownVotes: PollVote[]) {
+function getOwnVotesByOptionId(ownVotes: PollVoteResponseData[]) {
   return !ownVotes
-    ? ({} as Record<OptionId, PollVote>)
-    : ownVotes.reduce<Record<OptionId, PollVote>>((acc, vote) => {
+    ? ({} as Record<OptionId, PollVoteResponseData>)
+    : ownVotes.reduce<Record<OptionId, PollVoteResponseData>>((acc, vote) => {
         if (isVoteAnswer(vote) || !vote.option_id) return acc;
         acc[vote.option_id] = vote;
         return acc;
       }, {});
 }
 
-export function extractPollData(pollResponse: PollResponse): PollData {
+export function extractPollData(pollResponse: Gen_PollResponseData): UpdatePollRequest {
   return {
     allow_answers: pollResponse.allow_answers,
     allow_user_suggested_options: pollResponse.allow_user_suggested_options,
@@ -402,16 +394,15 @@ export function extractPollData(pollResponse: PollResponse): PollData {
     max_votes_allowed: pollResponse.max_votes_allowed,
     name: pollResponse.name,
     options: pollResponse.options,
-    voting_visibility: pollResponse.voting_visibility,
+    voting_visibility: pollResponse.voting_visibility as VotingVisibility,
   };
 }
 
-export function mapPollStateToResponse(poll: Poll): PollResponse {
+export function mapPollStateToResponse(poll: Poll): PollResponse_old {
   const {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    lastActivityAt,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    maxVotedOptionIds,
+    lastActivityAt: _lastActivityAt,
+
+    maxVotedOptionIds: _maxVotedOptionIds,
     ownVotesByOptionId,
     ownAnswer,
     ...restState
@@ -419,7 +410,7 @@ export function mapPollStateToResponse(poll: Poll): PollResponse {
   const ownVotes = [
     ...Object.values(ownVotesByOptionId),
     ...(ownAnswer ? [ownAnswer] : []),
-  ].sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+  ].sort((a, b) => a.created_at.getTime() - b.created_at.getTime());
 
   return {
     ...restState,
@@ -429,7 +420,7 @@ export function mapPollStateToResponse(poll: Poll): PollResponse {
 }
 
 export function extractPollEnrichedData(
-  pollResponse: PollResponse,
+  pollResponse: Gen_PollResponseData,
 ): Omit<PollEnrichData, 'own_votes' | 'latest_answers'> {
   return {
     answers_count: pollResponse.answers_count,

package/src/poll_manager.ts

@@ -1,9 +1,9 @@
 import type { StreamChat } from './client';
 import type {
-  CreatePollData,
+  CreatePollRequest,
   LocalMessage,
   MessageResponse,
-  PollResponse,
+  PollResponse_old,
   PollSort,
   QueryPollsFilters,
   QueryPollsOptions,
@@ -46,7 +46,7 @@ export class PollManager extends WithSubscriptions {
     this.addUnsubscribeFunction(this.subscribeVoteRemoved());
   };
 
-  public createPoll = async (poll: CreatePollData) => {
+  public createPoll = async (poll: CreatePollRequest) => {
     const { poll: createdPoll } = await this.client.createPoll(poll);
 
     if (!createdPoll.vote_counts_by_option) {
@@ -63,11 +63,13 @@ export class PollManager extends WithSubscriptions {
 
     // optimistically return the cached poll if it exists and update in the background
     if (cachedPoll) {
-      this.client.getPoll(id).then(({ poll }) => this.setOrOverwriteInCache(poll, true));
+      this.client
+        .getPoll({ poll_id: id })
+        .then(({ poll }) => this.setOrOverwriteInCache(poll, true));
       return cachedPoll;
     }
     // fetch it, write to the cache and return otherwise
-    const { poll } = await this.client.getPoll(id);
+    const { poll } = await this.client.getPoll({ poll_id: id });
 
     this.setOrOverwriteInCache(poll);
 
@@ -79,7 +81,11 @@ export class PollManager extends WithSubscriptions {
     sort: PollSort = [],
     options: QueryPollsOptions = {},
   ) => {
-    const { polls, next } = await this.client.queryPolls(filter, sort, options);
+    const { polls, next } = await this.client.queryPolls({
+      filter,
+      sort,
+      ...options,
+    });
 
     const pollInstances = polls.map((poll) => {
       this.setOrOverwriteInCache(poll, true);
@@ -101,13 +107,13 @@ export class PollManager extends WithSubscriptions {
       if (!message.poll) {
         continue;
       }
-      const pollResponse = message.poll as PollResponse;
+      const pollResponse = message.poll as PollResponse_old;
       this.setOrOverwriteInCache(pollResponse, overwriteState);
     }
   };
 
   private setOrOverwriteInCache = (
-    pollResponse: PollResponse,
+    pollResponse: PollResponse_old,
     overwriteState?: boolean,
   ) => {
     if (!this.client._cacheEnabled()) {

package/src/reminders/Reminder.ts

@@ -1,14 +1,11 @@
 import { ReminderTimer } from './ReminderTimer';
 import { StateStore } from '../store';
 import type { ReminderTimerConfig } from './ReminderTimer';
-import type { MessageResponse, ReminderResponseBase, UserResponse } from '../types';
+import type { MessageResponse, ReminderResponseData, UserResponse } from '../types';
 
 export const timeLeftMs = (remindAt: number) => remindAt - new Date().getTime();
 
-export type ReminderResponseBaseOrResponse = ReminderResponseBase & {
-  user?: UserResponse;
-  message?: MessageResponse;
-};
+export type ReminderResponseBaseOrResponse = ReminderResponseData;
 
 export type ReminderState = {
   channel_cid: string;