stream-chat-react-native-core 10.0.0-rc.2 → 10.0.0-rc.4

package/src/store/__tests__/selectMessagesForChannels.test.ts

@@ -1,29 +1,27 @@
 import { generateChannelResponse } from '../../mock-builders/generator/channel';
 import { generateMessage } from '../../mock-builders/generator/message';
 import { BetterSqlite } from '../../test-utils/BetterSqlite';
+import { getChannels } from '../apis/getChannels';
 import { selectMessagesForChannels } from '../apis/queries/selectMessagesForChannels';
 import { upsertChannels } from '../apis/upsertChannels';
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * The client treats the cached page as a `queryChannels` page of 25 messages, so a shorter one reads
- * as the start of the channel and older messages never load from the server.
+ * The client reads the cached page as a channel list page of `message_limit` messages, so a page of
+ * a different size makes it guess wrongly whether older messages exist, for example that a channel
+ * with a long history starts at its cached messages.
  */
 describe('selectMessagesForChannels', () => {
+  let cid: string;
+  let messages: ReturnType<typeof generateMessage>[];
+
   beforeEach(async () => {
     await SqliteClient.initializeDatabase();
     await BetterSqlite.openDB();
-  });
-
-  afterEach(() => {
-    BetterSqlite.dropAllTables();
-    BetterSqlite.closeDB();
-  });
 
-  it("returns a channel's newest 25 messages, oldest first", async () => {
     const channelResponse = generateChannelResponse({ members: [], messages: [] });
-    const cid = channelResponse.channel.cid as string;
-    const messages = Array.from({ length: 30 }, (_, i) =>
+    cid = channelResponse.channel.cid as string;
+    messages = Array.from({ length: 30 }, (_, i) =>
       generateMessage({ cid, timestamp: Date.UTC(2020, 0, 1, 0, i) }),
     );
     channelResponse.messages = messages as unknown as typeof channelResponse.messages;
@@ -31,9 +29,33 @@ describe('selectMessagesForChannels', () => {
       channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
       isLatestMessagesSet: true,
     });
+  });
+
+  afterEach(() => {
+    BetterSqlite.dropAllTables();
+    BetterSqlite.closeDB();
+  });
 
+  const ids = (rows: { id: string }[]) => rows.map((row) => row.id);
+
+  it("returns a channel's newest 25 messages, oldest first, by default", async () => {
     const rows = await selectMessagesForChannels([cid]);
 
-    expect(rows.map((row) => row.id)).toEqual(messages.slice(-25).map((message) => message.id));
+    expect(ids(rows)).toEqual(ids(messages.slice(-25)));
+  });
+
+  it("returns a channel's newest `messageLimit` messages", async () => {
+    expect(ids(await selectMessagesForChannels([cid], 10))).toEqual(ids(messages.slice(-10)));
+    expect(ids(await selectMessagesForChannels([cid], 50))).toEqual(ids(messages));
+  });
+
+  it('applies the limit that getChannels is given', async () => {
+    const [channel] = await getChannels({
+      channelIds: [cid],
+      messageLimit: 10,
+      userId: 'some-user',
+    });
+
+    expect(ids(channel.messages)).toEqual(ids(messages.slice(-10)));
   });
 });

package/src/store/apis/getChannelMessages.ts

@@ -12,15 +12,18 @@ import type { TableRow, TableRowJoinedUser } from '../types';
 export const getChannelMessages = async ({
   channelIds,
   userId,
+  messageLimit,
 }: {
   channelIds: string[];
   userId: string;
+  messageLimit?: number;
 }) => {
   SqliteClient.logger?.('info', 'getChannelMessages', {
     channelIds,
     userId,
+    messageLimit,
   });
-  const messageRows = await selectMessagesForChannels(channelIds);
+  const messageRows = await selectMessagesForChannels(channelIds, messageLimit);
   const messageIds = messageRows.map(({ id }) => id);
 
   const reactionRows = await selectReactionsForMessages(messageIds, null);

package/src/store/apis/getChannels.ts

@@ -16,16 +16,19 @@ import { SqliteClient } from '../SqliteClient';
  *
  * @param params.channelIds The channel IDs to fetch.
  * @param params.userId The ID of the current user.
+ * @param params.messageLimit How many of each channel's newest messages to return, 25 by default.
  * @returns The channels with their state.
  */
 export const getChannels = async ({
   channelIds,
   userId,
+  messageLimit,
 }: {
   channelIds: string[];
   userId: string;
+  messageLimit?: number;
 }): Promise<Omit<ChannelStateResponseFields, 'duration'>[]> => {
-  SqliteClient.logger?.('info', 'getChannels', { channelIds, userId });
+  SqliteClient.logger?.('info', 'getChannels', { channelIds, userId, messageLimit });
 
   const [channels, cidVsDraft, cidVsMembers, cidVsReads, cidVsMessages, cidVsActiveLocations] =
     await Promise.all([
@@ -36,6 +39,7 @@ export const getChannels = async ({
       getChannelMessages({
         channelIds,
         userId,
+        messageLimit,
       }),
       getChannelActiveLocations({ channelIds }),
     ]);

package/src/store/apis/getChannelsForFilterSort.ts

@@ -56,6 +56,7 @@ export const getChannelsForFilterSort = async ({
     channels: await getChannels({
       channelIds: cids,
       userId,
+      messageLimit: options?.message_limit,
     }),
     predefinedFilter,
   };

package/src/store/apis/queries/selectMessagesForChannels.ts

@@ -2,8 +2,12 @@ import { tables } from '../../schema';
 import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
+/** The `message_limit` the client assumes for a channel list query that sets none. */
+export const DEFAULT_CHANNEL_LIST_MESSAGE_LIMIT = 25;
+
 export const selectMessagesForChannels = async (
   cids: string[],
+  messageLimit: number = DEFAULT_CHANNEL_LIST_MESSAGE_LIMIT,
 ): Promise<TableRowJoinedUser<'messages'>[]> => {
   const questionMarks = Array(cids.length).fill('?').join(',');
   const messagesColumnNames = Object.keys(tables.messages.columns)
@@ -15,6 +19,7 @@ export const selectMessagesForChannels = async (
 
   SqliteClient.logger?.('info', 'selectMessagesForChannels', {
     cids,
+    messageLimit,
   });
 
   const result = await SqliteClient.executeSql(
@@ -38,9 +43,9 @@ export const selectMessagesForChannels = async (
     LEFT JOIN
       users b
     ON b.id = a.userId
-    WHERE RowNum <= 25
+    WHERE RowNum <= ?
     ORDER BY a.createdAt ASC`,
-    cids,
+    [...cids, messageLimit],
   );
 
   return result.map((r) => JSON.parse(r.value));

package/src/utils/__tests__/setupCommandUIMiddlewares.test.ts

@@ -0,0 +1,49 @@
+import type { MessageComposer } from 'stream-chat';
+
+import { initiateClientWithChannels } from '../../mock-builders/api/initiateClientWithChannels';
+import { setupCommandUIMiddlewares } from '../setupCommandUIMiddlewares';
+
+const countMiddleware = (composer: MessageComposer) => {
+  const count = (middleware: ReadonlyArray<{ id: string }>, id: string) =>
+    middleware.filter((md) => md.id === id).length;
+
+  return {
+    composition: count(
+      composer.compositionMiddlewareExecutor.installedMiddleware,
+      'stream-io/message-composer-middleware/command-string-injection',
+    ),
+    draftComposition: count(
+      composer.draftCompositionMiddlewareExecutor.installedMiddleware,
+      'stream-io/message-composer-middleware/draft-command-string-injection',
+    ),
+    textActiveCommandGuard: count(
+      composer.textComposer.middlewareExecutor.installedMiddleware,
+      'stream-io/text-composer/active-command-guard',
+    ),
+    textCommandStringExtraction: count(
+      composer.textComposer.middlewareExecutor.installedMiddleware,
+      'stream-io/text-composer/command-string-extraction',
+    ),
+  };
+};
+
+describe('setupCommandUIMiddlewares', () => {
+  it('inserts each command middleware once, however often it runs on the same composer', async () => {
+    const {
+      channels: [channel],
+    } = await initiateClientWithChannels();
+    const composer = channel.messageComposer;
+
+    // The `messageComposer` setup function re-runs on every config change and re-subscription.
+    setupCommandUIMiddlewares(composer);
+    setupCommandUIMiddlewares(composer);
+    setupCommandUIMiddlewares(composer);
+
+    expect(countMiddleware(composer)).toEqual({
+      composition: 1,
+      draftComposition: 1,
+      textActiveCommandGuard: 1,
+      textCommandStringExtraction: 1,
+    });
+  });
+});

package/src/utils/installNativeMultipartAdapter.ts

@@ -282,9 +282,11 @@ const createNativeMultipartAdapter =
  * Routes multipart file uploads through the native uploader by setting `adapter` on those requests
  * only. Does nothing when native multipart upload is unavailable or the client is already set up.
  *
- * The client's default adapter is left alone: replacing it would require importing axios here to
- * resolve the fallback, and a copy different from `stream-chat`'s would fail every request with an
- * `AxiosError` that `stream-chat` does not recognize.
+ * Uploads go native even when the app installed an axios adapter of its own, as they did in v9;
+ * every other request still goes through the app's adapter. `defaults.adapter` itself is not
+ * replaced: that would require importing axios here to resolve the fallback, and a copy different
+ * from `stream-chat`'s would fail every request with an `AxiosError` that `stream-chat` does not
+ * recognize.
  *
  * @param client The client to install the adapter on.
  */

package/src/utils/setupCommandUIMiddlewares.ts

@@ -17,15 +17,18 @@ export const setupCommandUIMiddlewares = (messageComposer: MessageComposer) => {
   messageComposer.draftCompositionMiddlewareExecutor.insert({
     middleware: [createDraftCommandInjectionMiddleware(messageComposer)],
     position: { after: 'stream-io/message-composer-middleware/draft-attachments' },
+    unique: true,
   });
 
   messageComposer.textComposer.middlewareExecutor.insert({
     middleware: [createActiveCommandGuardMiddleware() as TextComposerMiddleware],
     position: { before: 'stream-io/text-composer/commands-middleware' },
+    unique: true,
   });
 
   messageComposer.textComposer.middlewareExecutor.insert({
     middleware: [createCommandStringExtractionMiddleware() as TextComposerMiddleware],
     position: { after: 'stream-io/text-composer/commands-middleware' },
+    unique: true,
   });
 };

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "10.0.0-rc.2"
+  "version": "10.0.0-rc.4"
 }