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

package/src/store/SqliteClient.ts

@@ -4,16 +4,13 @@ let sqlite: OPSQLiteProxy;
 try {
   sqlite = require('@op-engineering/op-sqlite');
 } catch (e) {
-  // We want to throw the original error when remote debugger (e.g. Chrome) is enabled.
-  // SQLite can only be used when synchronous method invocations (JSI) are possible.
-  // e.g on-device debugger (e.g. Flipper).
+  // Rethrow when a remote debugger (e.g. Chrome) is attached: SQLite needs synchronous JSI calls.
   const isRemoteDebuggerError = e instanceof Error && e.message.includes('Failed to install');
   if (isRemoteDebuggerError) {
     throw e;
   }
-  // Reaching here will mean that QuickSQLite is not installed for one of the reasons
-  // 1. Running on regular expo, where we don't support offline storage yet.
-  // 2. Offline support is disabled, in which case this library is not installed.
+  // op-sqlite is not installed (regular Expo, which has no offline storage, or offline support is
+  // disabled), so `sqlite` stays undefined.
 }
 
 import type { Sink } from 'stream-chat';
@@ -24,9 +21,9 @@ import { createCreateTableQuery } from './sqlite-utils/createCreateTableQuery';
 import type { PreparedBatchQueries, PreparedQueries, Scalar, Table } from './types';
 
 /**
- * Why the offline database could not be opened. The first two only arise when
- * {@link SqliteClient.getEncryptionKey} is set; `OFFLINE_DB_UNREADABLE` can also mean
- * plain corruption, or a database left behind from the other encryption mode.
+ * Why the offline database could not be opened. The first two only occur when
+ * {@link SqliteClient.getEncryptionKey} is set; `OFFLINE_DB_UNREADABLE` can also mean corruption or
+ * a database left over from the other encryption mode.
  */
 export type SqliteClientErrorCode =
   | 'SQLCIPHER_BUILD_MISSING'
@@ -40,16 +37,12 @@ export class SqliteClientError extends Error {
     super(message);
     this.name = 'SqliteClientError';
     this.code = code;
-    // Assigned here rather than passed through `super(message, { cause })` because
-    // Hermes does not reliably honour the ErrorOptions overload.
+    // Assigned directly because Hermes does not reliably honor the `ErrorOptions` overload.
     this.cause = options?.cause;
   }
 }
 
-/**
- * SqliteClient takes care of any direct interaction with sqlite.
- * This way usage @op-engineering/op-sqlite package is scoped to a single class/file.
- */
+/** Wraps all direct use of `@op-engineering/op-sqlite`. */
 export class SqliteClient {
   static dbVersion = 18;
 
@@ -59,39 +52,33 @@ export class SqliteClient {
   static db: _InternalDB | undefined;
 
   /**
-   * Supplies the SQLCipher key the offline database is opened with; `undefined`
-   * opens it unencrypted, which is the default. The key must be stable for the
-   * lifetime of the database file - there is no rekey path, so a database this key
-   * cannot read raises `OFFLINE_DB_UNREADABLE` on the first page read. The file is
-   * left untouched; recovery is `SqliteClient.deleteDatabase()` and a re-mount.
+   * Supplies the SQLCipher key the offline database opens with. Defaults to `undefined`, which
+   * opens it unencrypted. The key must stay the same for the life of the database file (there is no
+   * rekey): a database this key cannot read raises `OFFLINE_DB_UNREADABLE` and is left untouched.
+   * Recover with `SqliteClient.deleteDatabase()` and a re-mount.
    */
   static getEncryptionKey: (() => Promise<string | undefined>) | undefined;
 
   /** Key resolved by {@link preflightEncryption}, consumed by the next {@link openDB}. */
   private static preflightedKey: string | undefined;
 
-  /** Busy/disk/memory failures. Checked first: wiping over these destroys a good db. */
+  /** Transient failures (busy, disk, memory). Checked first so they never read as unreadable. */
   private static TRANSIENT_ERROR =
     /database is locked|SQLITE_BUSY|SQLITE_LOCKED|disk i\/o|SQLITE_IOERR|unable to open|SQLITE_CANTOPEN|out of memory|readonly/i;
 
   /**
-   * The bytes on disk cannot be read with the key we have: wrong/rotated key,
-   * plaintext-encrypted mismatch or corruption. SQLCipher has no decrypt specific
-   * code and overloads NOTADB (26), occasionally CORRUPT (11).
+   * The file cannot be read with the current key: wrong or rotated key, an encrypted/plaintext
+   * mismatch, or corruption. SQLCipher has no decrypt-specific code, so it overloads NOTADB (26)
+   * and occasionally CORRUPT (11).
    */
   private static UNREADABLE_ERROR =
     /not a database|file is encrypted|malformed|disk image is malformed|SQLite (?:error )?code:?\s*(?:26|11)\b|NOTADB|SQLITE_CORRUPT/i;
 
   static getDbVersion = () => SqliteClient.dbVersion;
-  // Force a specific db version. This is mainly useful for testsuit.
+  // Overrides the DB version, mainly for tests.
   static setDbVersion = (version: number) => (SqliteClient.dbVersion = version);
 
-  /**
-   * Records and re-throws. Deliberately does not write to the console: the error is
-   * thrown, so logging it here would duplicate whatever the caller's error boundary
-   * reports - and in dev React already logs every boundary-caught error, which is what
-   * LogBox turns red.
-   */
+  /** Logs the error to the logger and re-throws it, without writing to the console. */
   private static recordError = (e: SqliteClientError) => {
     SqliteClient.logger?.('error', e.message, { tag: e.code });
 
@@ -99,13 +86,12 @@ export class SqliteClient {
   };
 
   /**
-   * Resolves the encryption key without opening the database, so callers can decide
-   * whether to attach an `OfflineDB` at all. Parts of the client write through
-   * `client.offlineDb` without checking that it initialized (`queryChannels` upserts
-   * into it), so attaching one we cannot open turns those writes into rejections.
+   * Resolves the encryption key without opening the database, so callers can decide whether to
+   * attach an `OfflineDB` at all: the client writes through `client.offlineDb` (for example in
+   * `queryChannels`) without checking it initialized, so one that cannot open rejects those writes.
+   * The next {@link openDB} reuses the key and does not call `getEncryptionKey` again.
    *
-   * Throws {@link SqliteClientError}. The key is handed to the next
-   * {@link openDB} rather than read from `getEncryptionKey` twice.
+   * @throws {SqliteClientError} When the key cannot be resolved.
    */
   static preflightEncryption = async () => {
     try {
@@ -119,10 +105,8 @@ export class SqliteClient {
   };
 
   /**
-   * The key to open with, or `undefined` when the database is meant to be
-   * unencrypted. Throws rather than silently falling back to an unencrypted
-   * database, which would hand an integration that asked for encryption a plaintext
-   * cache of its users' messages.
+   * The key to open with, or `undefined` when the database is meant to be unencrypted. Throws when
+   * encryption was requested but is unavailable, and never falls back to an unencrypted database.
    */
   private static resolveEncryptionKey = async () => {
     const { getEncryptionKey } = SqliteClient;
@@ -131,11 +115,8 @@ export class SqliteClient {
       return undefined;
     }
 
-    // A non-SQLCipher build accepts `encryptionKey` at the JSI boundary and then
-    // drops it - plaintext database, no error anywhere. `isSQLCipher` has existed
-    // since op-sqlite 9, well below the peer floor, so the typeof check is not really
-    // necessary but we'll keep it in case something changes in the future so that
-    // we at least have a clearer error.
+    // A non-SQLCipher build accepts `encryptionKey` and silently drops it, writing a plaintext
+    // database. The `typeof` check is defensive, for a clearer error if `isSQLCipher` is missing.
     if (sqlite === undefined) {
       throw new SqliteClientError(
         'SQLCIPHER_BUILD_MISSING',
@@ -165,8 +146,8 @@ export class SqliteClient {
       );
     }
 
-    // Not being handed a key is not the same as being handed the wrong one, so a locked
-    // keychain must not cost us a database we can still read later.
+    // A missing key is not a wrong key: throwing leaves the database untouched, so a locked
+    // keychain does not cost a database that is readable later.
     if (!encryptionKey) {
       throw new SqliteClientError(
         'ENCRYPTION_KEY_UNAVAILABLE',
@@ -195,10 +176,8 @@ export class SqliteClient {
         ...(encryptionKey ? { encryptionKey } : {}),
       });
 
-      // Note: this will not fail on an encryption key mismatch, as we do not read
-      // any pages, but rather look at a connection level flag. The first failure
-      // is going to be whatever actually reads something, which is going to be
-      // the user_version read in initializeDatabase.
+      // Does not fail on an encryption key mismatch because no pages are read here. The first
+      // failure comes from the first real read: the `user_version` read in `initializeDatabase`.
       await SqliteClient.db?.execute('PRAGMA foreign_keys = ON', []);
     } catch (e) {
       if (e instanceof SqliteClientError) {
@@ -235,8 +214,7 @@ export class SqliteClient {
       if (!SqliteClient.db) {
         throw new Error('DB is not open or initialized.');
       }
-      // This is a workaround to make the executeBatch method work.
-      // It expects an empty array as the second argument in the individual queries if nothing present.
+      // `executeBatch` expects an empty params array in queries that have none.
       // Discussion - https://discord.com/channels/1301463257722126357/1324262993780932688/1330846910596251711
       const finalQueries = queries.map((query) => {
         if (query.length === 1) {
@@ -306,10 +284,13 @@ export class SqliteClient {
   };
 
   /**
-   * Whether the file cannot be read with the key we have, as opposed to being
-   * temporarily unavailable (busy, locked, disk). Works off message text because
-   * op-sqlite rejects with a plain Error and this class re-wraps those messages, so
-   * no numeric code survives. Drives `OFFLINE_DB_UNREADABLE`.
+   * Whether the file cannot be read with the current key, as opposed to being temporarily
+   * unavailable (busy, locked, disk). Matches on the message text because op-sqlite rejects with a
+   * plain `Error` and this class re-wraps it, so no numeric code survives. Drives
+   * `OFFLINE_DB_UNREADABLE`.
+   *
+   * @param e The error thrown while opening or reading the database.
+   * @returns True when the database is unreadable rather than temporarily unavailable.
    */
   static isUnreadableDbError = (e: unknown) => {
     const message = String((e as Error)?.message ?? e);

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

@@ -1,4 +1,5 @@
 import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
+import { mapStorableToMember } from '../mappers/mapStorableToMember';
 import { mapStorableToMessage } from '../mappers/mapStorableToMessage';
 import { mapStorableToReaction } from '../mappers/mapStorableToReaction';
 import { mapStorableToUser } from '../mappers/mapStorableToUser';
@@ -61,4 +62,14 @@ describe('row -> model mappers keep required timestamps numeric', () => {
     expect(typeof result.channel?.created_at).toBe('number');
     expect(typeof result.channel?.updated_at).toBe('number');
   });
+
+  it('mapStorableToMember', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const member = mapStorableToMember({ ...nullDates, user: userRow, userId: null } as any);
+
+    expect(typeof member.created_at).toBe('number');
+    expect(typeof member.updated_at).toBe('number');
+    // `user_id` is required on `ChannelMemberResponse` but nullable in the column.
+    expect(member.user_id).toBe('u1');
+  });
 });

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

@@ -0,0 +1,39 @@
+import { generateChannelResponse } from '../../mock-builders/generator/channel';
+import { generateMessage } from '../../mock-builders/generator/message';
+import { BetterSqlite } from '../../test-utils/BetterSqlite';
+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.
+ */
+describe('selectMessagesForChannels', () => {
+  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) =>
+      generateMessage({ cid, timestamp: Date.UTC(2020, 0, 1, 0, i) }),
+    );
+    channelResponse.messages = messages as unknown as typeof channelResponse.messages;
+    await upsertChannels({
+      channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
+      isLatestMessagesSet: true,
+    });
+
+    const rows = await selectMessagesForChannels([cid]);
+
+    expect(rows.map((row) => row.id)).toEqual(messages.slice(-25).map((message) => message.id));
+  });
+});

package/src/store/apis/__tests__/upsertDraft.test.ts

@@ -0,0 +1,55 @@
+import type { DraftResponse, MessageResponse } from 'stream-chat';
+import { v4 as uuidv4 } from 'uuid';
+
+import { generateChannelResponse } from '../../../mock-builders/generator/channel';
+import { generateMessage } from '../../../mock-builders/generator/message';
+import { BetterSqlite } from '../../../test-utils/BetterSqlite';
+import { SqliteClient } from '../../SqliteClient';
+import { getDraft } from '../getDraft';
+import { upsertChannels } from '../upsertChannels';
+import { upsertDraft } from '../upsertDraft';
+
+describe('upsertDraft', () => {
+  beforeEach(async () => {
+    await SqliteClient.initializeDatabase();
+    await BetterSqlite.openDB();
+  });
+
+  afterEach(() => {
+    BetterSqlite.dropAllTables();
+    BetterSqlite.closeDB();
+    jest.clearAllMocks();
+  });
+
+  it('stores the quoted and parent messages so the draft can be read back with them', async () => {
+    const channelResponse = generateChannelResponse({ members: [], messages: [] });
+    const cid = channelResponse.channel.cid as string;
+    await upsertChannels({
+      channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
+    });
+
+    const parentMessage = generateMessage({ cid, id: uuidv4() }) as unknown as MessageResponse;
+    const quotedMessage = generateMessage({ cid, id: uuidv4() }) as unknown as MessageResponse;
+    const draft = {
+      channel_cid: cid,
+      created_at: new Date().toISOString(),
+      message: { id: uuidv4(), quoted_message_id: quotedMessage.id, text: 'draft text' },
+      parent_id: parentMessage.id,
+      parent_message: parentMessage,
+      quoted_message: quotedMessage,
+    } as unknown as DraftResponse;
+
+    const queries = await upsertDraft({ draft });
+
+    const messageUpserts = queries.filter(([query]) => query.includes('INTO messages'));
+    expect(messageUpserts).toHaveLength(2);
+
+    const messageIds = (await BetterSqlite.selectFromTable<{ id: string }>('messages')).map(
+      ({ id }) => id,
+    );
+    expect(messageIds).toEqual(expect.arrayContaining([parentMessage.id, quotedMessage.id]));
+
+    const storedDraft = await getDraft({ cid, parent_id: parentMessage.id, userId: uuidv4() });
+    expect(storedDraft?.quoted_message?.id).toBe(quotedMessage.id);
+  });
+});

package/src/store/apis/addPendingTask.ts

@@ -6,21 +6,19 @@ import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
 import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-/*
- * addPendingTask - Adds a pending task to the database
+/**
+ * Adds a pending task to the database.
  *
- * @param {PendingTask} task - The task to add
- *
- * @return {() => void} - A function that can be called to remove the task from the database
+ * @param task The task to add.
+ * @returns A function that removes the task from the database.
  */
 export const addPendingTask = async (task: PendingTask) => {
   const storable = mapTaskToStorable(task);
   const { channelId, channelType, threadId, payload, type } = storable;
   const queries: PreparedQueries[] = [];
   if (type === 'create-draft' || type === 'delete-draft') {
-    // Only one draft pending task is allowed per entity (i.e thread, channel etc).
-    // If multiple arrive, we'll simply take the last one (since deleteDraft does not
-    // fail as an API if a draft doesn't exist).
+    // One draft task is kept per entity (thread, channel, ...): the last one wins, since deleting a
+    // draft that does not exist does not fail.
     queries.push(
       createDeleteQuery('pendingTasks', {
         channelId,

package/src/store/apis/channelExists.ts

@@ -4,10 +4,11 @@ import { SqliteClient } from '../SqliteClient';
  * Whether a channel row exists, which callers use to avoid writing a row whose `cid` foreign key
  * would not resolve.
  *
- * Deliberately `SELECT 1 ... LIMIT 1` rather than `SELECT EXISTS(...)`: `EXISTS` always returns
- * exactly one row (holding `0` or `1`), so the row COUNT carries no information and the previous
- * implementation reported `true` for every cid, existing or not. Returning zero rows for a miss is
- * what makes the answer readable without depending on the result column's name.
+ * It selects `1 ... LIMIT 1` because `SELECT EXISTS(...)` always returns one row (`0` or `1`), so
+ * the row count could not tell a hit from a miss.
+ *
+ * @param params.cid The channel CID.
+ * @returns True when the channel exists.
  */
 export const channelExists = async ({ cid }: { cid: string }) => {
   const channels = await SqliteClient.executeSql('SELECT 1 FROM channels WHERE cid = ? LIMIT 1', [

package/src/store/apis/dropPendingTasks.ts

@@ -2,15 +2,12 @@ import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * dropPendingTasks - Drops all pending tasks from the DB given a specific messageId.
- * Useful for when we do some message actions on a failed message and then we decide to
- * delete it afterwards, removing it from the state.
+ * Drops all pending tasks of a message, for example when a failed message that had actions queued
+ * on it is deleted.
  *
- * @param {Object} param
- * @param {string} param.messageId The messageId for which we want to remove the pending tasks.
- * @param {boolean} param.execute Whether we should immediately execute the query or return it as a prepared one.
- *
- * @return {() => void} - A function that can be called to remove the task from the database
+ * @param params.messageId The ID of the message whose pending tasks are removed.
+ * @param params.execute Whether to run the query now or only return it. Defaults to true.
+ * @returns The prepared delete queries.
  */
 export const dropPendingTasks = async ({
   messageId,

package/src/store/apis/getChannelActiveLocations.ts

@@ -11,7 +11,7 @@ export const getChannelActiveLocations = async ({
 }): Promise<Record<string, SharedLocationResponseData[]>> => {
   const cidVsLiveLocations: Record<string, SharedLocationResponseData[]> = {};
 
-  // Query to select active live locations for the given channel ids where the end_at is not empty and it is greater than the current date.
+  // Active means `endAt` is set and in the future.
   const locations = await selectActiveLocationsForChannels(channelIds);
 
   locations.forEach((location) => {

package/src/store/apis/getChannelMessages.ts

@@ -23,7 +23,6 @@ export const getChannelMessages = async ({
   const messageRows = await selectMessagesForChannels(channelIds);
   const messageIds = messageRows.map(({ id }) => id);
 
-  // Populate the message reactions.
   const reactionRows = await selectReactionsForMessages(messageIds, null);
   const messageIdVsReactions: Record<string, TableRowJoinedUser<'reactions'>[]> = {};
   reactionRows.forEach((reaction) => {
@@ -33,7 +32,6 @@ export const getChannelMessages = async ({
     messageIdVsReactions[reaction.messageId].push(reaction);
   });
 
-  // Populate the polls.
   const messageIdsVsPolls: Record<string, TableRow<'poll'>> = {};
   const pollsById: Record<string, TableRow<'poll'>> = {};
   const messagesWithPolls = messageRows.filter((message) => !!message.poll_id);
@@ -74,7 +72,6 @@ export const getChannelMessages = async ({
     messageIdsVsLocations[location.messageId] = location;
   });
 
-  // Populate the messages.
   const cidVsMessages: Record<string, MessageResponse[]> = {};
   messageRows.forEach((m) => {
     if (!cidVsMessages[m.cid]) {

package/src/store/apis/getChannels.ts

@@ -11,13 +11,12 @@ import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * Returns the list of channels with state enriched for given channel ids.
+ * Returns the channels with the given IDs, including their members, reads, messages, draft and
+ * active live locations.
  *
- * @param {Object} param
- * @param {Array} param.channelIds List of channel ids to fetch.
- * @param {Array} param.userId Id of the current logged in user.
- *
- * @returns {Array} Channels with enriched state.
+ * @param params.channelIds The channel IDs to fetch.
+ * @param params.userId The ID of the current user.
+ * @returns The channels with their state.
  */
 export const getChannels = async ({
   channelIds,
@@ -41,7 +40,6 @@ export const getChannels = async ({
       getChannelActiveLocations({ channelIds }),
     ]);
 
-  // Enrich the channels with state
   return channels.map((c) => ({
     ...mapStorableToChannel(c),
     active_live_locations: cidVsActiveLocations[c.cid] || [],

package/src/store/apis/getChannelsForFilterSort.ts

@@ -11,15 +11,14 @@ import { selectChannelQueryForFilterSort } from './queries/selectChannelQueryFor
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * Gets the channels from database for given filter and sort query.
+ * Gets the cached channels for a filter, sort and options query.
  *
- * @param {Object} param
- * @param {string} param.userId Id of current logged in user
- * @param {Object} param.filters Filters for channels https://getstream.io/chat/docs/javascript/query_channels/?language=javascript&q=su#query-parameters
- * @param {Object} param.sort Sort for channels https://getstream.io/chat/docs/javascript/query_channels/?language=javascript&q=su#query-parameters
- *
- * @returns The channels corresponding to filters & sort, together with the predefined-filter metadata
- * they were cached with. Returns null if filters + sort query doesn't exist in "channelQueries" table.
+ * @param params.userId The ID of the current user.
+ * @param params.filters Channel filters: https://getstream.io/chat/docs/javascript/query_channels/
+ * @param params.options Query options, including `predefined_filter`.
+ * @param params.sort Channel sort: https://getstream.io/chat/docs/javascript/query_channels/
+ * @returns The channels with the predefined-filter metadata they were cached with, or null when
+ * no query is given or it is not in the `channelQueries` table.
  */
 export const getChannelsForFilterSort = async ({
   userId,

package/src/store/apis/getDraftsForChannels.ts

@@ -19,9 +19,8 @@ export const getDraftForChannels = async ({
 
   const draftRowsWithMessage = await selectDraftMessageFromDraftForChannels(channelIds);
 
-  /**
-   * Filter out drafts without a parent ID, as we will not show them in the channel.
-   * The above `createSelectQuery` was not able to filter out drafts without a parent ID.
+  /*
+   * Keeps only drafts without a parent ID: thread drafts are not shown in the channel.
    * TODO: Fix the query to filter out drafts without a parent ID. This can be a bit faster.
    */
   const rowsWithoutParentID = draftRowsWithMessage.filter((row) => row.parentId === null);

package/src/store/apis/getReactions.ts

@@ -11,7 +11,6 @@ export const getReactions = ({
 }): ReactionResponse[] => {
   SqliteClient.logger?.('info', 'getReactions', { reactions });
 
-  // Enrich the channels with state
   return reactions.map((reaction) => ({
     ...mapStorableToReaction(reaction),
   }));

package/src/store/apis/getReactionsforFilterSort.ts

@@ -6,11 +6,13 @@ import { selectReactionsForMessages } from './queries/selectReactionsForMessages
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * Fetches reactions for a message from the database based on the provided filters and sort.
- * @param currentMessageId The message ID for which reactions are to be fetched.
- * @param filters The filters to be applied while fetching reactions.
- * @param sort The sort to be applied while fetching reactions.
- * @param limit The limit of how many reactions should be returned.
+ * Fetches a message's reactions from the database, filtered and sorted.
+ *
+ * @param params.messageId The ID of the message to fetch reactions for.
+ * @param params.filters Filters to apply. Only `type` is supported.
+ * @param params.sort Sort to apply.
+ * @param params.limit Maximum number of reactions to return. Defaults to 25.
+ * @returns The reactions, or null when neither filters nor sort are given.
  */
 export const getReactionsForFilterSort = async ({
   messageId,
@@ -32,10 +34,6 @@ export const getReactionsForFilterSort = async ({
 
   const reactions = await selectReactionsForMessages([messageId], limit, filters, sort);
 
-  if (!reactions) {
-    return null;
-  }
-
   if (reactions.length === 0) {
     return [];
   }

package/src/store/apis/insertReaction.ts

@@ -19,10 +19,9 @@ export const insertReaction = async ({
 
   const storableReaction = mapReactionToStorable(reaction);
 
-  // Only a channel's cached window of messages is stored, so a reaction can arrive for a message
-  // this database has never held - an old one someone reacts to, or a `/sync` replay after a cold
-  // start. Writing it anyway violates the `reactions.messageId` foreign key and aborts the whole
-  // batch it travels in.
+  // A reaction can arrive for a message this database never held (only a channel's recent window
+  // is cached). Writing it would violate the `reactions.messageId` foreign key and abort the whole
+  // batch.
   queries.push(
     createUpsertQueryIfParentExists('reactions', storableReaction, {
       column: 'id',

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

@@ -10,8 +10,7 @@ export const selectActiveLocationsForChannels = async (
   SqliteClient.logger?.('info', 'selectActiveLocationsForChannels', {
     cids,
   });
-  // Active means `endAt` is set and still in the future. `endAt` is unix nanoseconds, so the
-  // cutoff is `nowNs()` and the comparison is plain numeric.
+  // Active means `endAt` is set and in the future. Both `endAt` and `nowNs()` are unix nanoseconds.
   const locations = await SqliteClient.executeSql(
     `SELECT * FROM locations WHERE channelCid IN (${questionMarks}) AND endAt IS NOT NULL AND endAt > ?`,
     [...cids, nowNs()],

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

@@ -11,17 +11,16 @@ import { SqliteClient } from '../../SqliteClient';
 import { convertFilterSortToQuery } from '../utils/convertFilterSortToQuery';
 
 export type CachedChannelQuery = {
-  /** Channel ids in the order the cached query produced them. */
+  /** Channel IDs in the order the cached query produced them. */
   cids: string[];
-  /** The backend-resolved predefined filter that order was produced by, when there was one. */
+  /** The server-resolved predefined filter that produced the order, if any. */
   predefinedFilter?: ParsedPredefinedFilterResponse;
 };
 
 /**
- * A stored `predefined_filter` response is only useful if it still describes a filter and,
- * optionally, a sort. Anything else in the column — a truncated write, a row left by an older
- * shape — is discarded rather than handed to the paginator, which would otherwise match and order
- * the whole list by a malformed rule.
+ * Whether a stored `predefined_filter` value still describes a filter and, optionally, a sort.
+ * Anything else (such as a truncated write) is discarded, so the paginator never matches and
+ * orders the list by a malformed rule.
  */
 const isPredefinedFilterResponse = (value: unknown): value is ParsedPredefinedFilterResponse => {
   if (typeof value !== 'object' || value === null) return false;
@@ -47,15 +46,14 @@ const parsePredefinedFilter = (
 };
 
 /**
- * Gets the cached result of a channel query from the database — the channel ids it produced and the
- * backend-resolved predefined filter that produced them.
+ * Gets the cached result of a channel query: the channel IDs it produced and the server-resolved
+ * predefined filter behind them, or null when the query is not in the `channelQueries` table. The
+ * full `options` are part of the query key, as they tell two predefined-filter queries apart.
  *
- * @param {Object} param
- * @param {Object} param.filters Filters for channels https://getstream.io/chat/docs/javascript/query_channels/?language=javascript&q=su#query-parameters
- * @param {Object} param.options Full query options, which is what tells two predefined-filter queries apart
- * @param {Object} param.sort Sort for channels https://getstream.io/chat/docs/javascript/query_channels/?language=javascript&q=su#query-parameters
- *
- * @returns The cached query, or null if it doesn't exist in the "channelQueries" table.
+ * @param params.filters Channel filters: https://getstream.io/chat/docs/javascript/query_channels/
+ * @param params.options Query options, including `predefined_filter`.
+ * @param params.sort Channel sort: https://getstream.io/chat/docs/javascript/query_channels/
+ * @returns The cached query, or null when it is not cached.
  */
 
 export const selectChannelQueryForFilterSort = async ({

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

@@ -38,7 +38,7 @@ export const selectMessagesForChannels = async (
     LEFT JOIN
       users b
     ON b.id = a.userId
-    WHERE RowNum < 25
+    WHERE RowNum <= 25
     ORDER BY a.createdAt ASC`,
     cids,
   );