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

package/src/store/OfflineDB.ts

@@ -39,13 +39,11 @@ export class OfflineDB extends AbstractOfflineDB {
 
   upsertChannels = api.upsertChannels;
 
-  // TODO: Rename currentUserId -> userId in the next major version as it is technically breaking.
   upsertUserSyncStatus = ({ userId, lastSyncedAt, execute }: DBUpsertUserSyncStatusType) =>
-    api.upsertUserSyncStatus({ currentUserId: userId, execute, lastSyncedAt });
+    api.upsertUserSyncStatus({ execute, lastSyncedAt, userId });
 
-  // TODO: Rename currentUserId -> userId in the next major version as it is technically breaking.
   upsertAppSettings = ({ appSettings, userId, execute }: DBUpsertAppSettingsType) =>
-    api.upsertAppSettings({ appSettings, currentUserId: userId, execute });
+    api.upsertAppSettings({ appSettings, execute, userId });
 
   upsertPoll = api.upsertPoll;
 
@@ -65,22 +63,22 @@ export class OfflineDB extends AbstractOfflineDB {
 
   updateMessage = api.updateMessage;
 
-  // TODO: Rename currentUserId -> userId in the next major version as it is technically breaking.
   getChannels = ({ cids, userId }: DBGetChannelsType) =>
-    api.getChannels({ channelIds: cids, currentUserId: userId });
-
-  // TODO: Rename currentUserId -> userId in the next major version as it is technically breaking.
-  getChannelsForQuery = ({ userId, filters, options, sort }: DBGetChannelsForQueryType) =>
-    api.getChannelsForFilterSort({ currentUserId: userId, filters, options, sort });
+    api.getChannels({ channelIds: cids, userId });
+
+  getChannelsForQuery = ({ userId, options }: DBGetChannelsForQueryType) =>
+    api.getChannelsForFilterSort({
+      filters: options?.filter_conditions,
+      options,
+      sort: options?.sort,
+      userId,
+    });
 
   getAllChannelCids = api.getAllChannelIds;
 
-  // TODO: Rename currentUserId -> userId in the next major version as it is technically breaking.
-  getLastSyncedAt = ({ userId }: DBGetLastSyncedAtType) =>
-    api.getLastSyncedAt({ currentUserId: userId });
+  getLastSyncedAt = ({ userId }: DBGetLastSyncedAtType) => api.getLastSyncedAt({ userId });
 
-  getAppSettings = ({ userId }: DBGetAppSettingsType) =>
-    api.getAppSettings({ currentUserId: userId });
+  getAppSettings = ({ userId }: DBGetAppSettingsType) => api.getAppSettings({ userId });
 
   getReactions = api.getReactionsForFilterSort;
 

package/src/store/SqliteClient.ts

@@ -16,7 +16,7 @@ try {
   // 2. Offline support is disabled, in which case this library is not installed.
 }
 
-import { Logger } from 'stream-chat';
+import type { Sink } from 'stream-chat';
 
 import { DB_LOCATION, DB_NAME } from './constants';
 import { tables } from './schema';
@@ -51,11 +51,11 @@ export class SqliteClientError extends Error {
  * This way usage @op-engineering/op-sqlite package is scoped to a single class/file.
  */
 export class SqliteClient {
-  static dbVersion = 16;
+  static dbVersion = 18;
 
   static dbName = DB_NAME;
   static dbLocation = DB_LOCATION;
-  static logger: Logger | undefined;
+  static logger: Sink | undefined;
   static db: _InternalDB | undefined;
 
   /**

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

@@ -0,0 +1,44 @@
+import { generateChannelResponse } from '../../mock-builders/generator/channel';
+import { BetterSqlite } from '../../test-utils/BetterSqlite';
+import { channelExists } from '../apis/channelExists';
+import { upsertChannels } from '../apis/upsertChannels';
+import { SqliteClient } from '../SqliteClient';
+
+/**
+ * Runs against real SQLite rather than a mocked DB on purpose: the bug this guards was in the SQL
+ * itself, so a mock that answers `true`/`false` on command would have kept passing forever.
+ */
+describe('channelExists', () => {
+  beforeEach(async () => {
+    await SqliteClient.initializeDatabase();
+    await BetterSqlite.openDB();
+  });
+
+  afterEach(() => {
+    BetterSqlite.dropAllTables();
+    BetterSqlite.closeDB();
+  });
+
+  it('reports false for a channel the database does not have', async () => {
+    expect(await channelExists({ cid: 'messaging:never-persisted' })).toBe(false);
+  });
+
+  it('reports true for a channel the database does have', async () => {
+    const channelResponse = generateChannelResponse({ members: [], messages: [] });
+    await upsertChannels({
+      channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
+    });
+
+    expect(await channelExists({ cid: channelResponse.channel.cid as string })).toBe(true);
+  });
+
+  it('distinguishes one channel from another', async () => {
+    const persisted = generateChannelResponse({ members: [], messages: [] });
+    await upsertChannels({
+      channels: [persisted] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
+    });
+
+    expect(await channelExists({ cid: persisted.channel.cid as string })).toBe(true);
+    expect(await channelExists({ cid: 'messaging:some-other-channel' })).toBe(false);
+  });
+});

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

@@ -0,0 +1,107 @@
+import { generateChannelResponse } from '../../mock-builders/generator/channel';
+import { generateMessage } from '../../mock-builders/generator/message';
+import { generateReaction } from '../../mock-builders/generator/reaction';
+import { BetterSqlite } from '../../test-utils/BetterSqlite';
+import { insertReaction } from '../apis/insertReaction';
+import { updateReaction } from '../apis/updateReaction';
+import { upsertChannels } from '../apis/upsertChannels';
+import { upsertMessages } from '../apis/upsertMessages';
+import { SqliteClient } from '../SqliteClient';
+
+/**
+ * Runs against real SQLite rather than a mocked DB on purpose: what this guards is a foreign key
+ * declared in the schema, and a mocked `executeSqlBatch` accepts any statement you hand it.
+ */
+describe('reaction writes when the message is not cached', () => {
+  const cid = 'messaging:reaction-guard';
+
+  const cacheAMessage = async (id: string) => {
+    const channelResponse = generateChannelResponse({ members: [], messages: [] });
+    channelResponse.channel.cid = cid;
+    await upsertChannels({
+      channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
+    });
+    const message = generateMessage({ cid, id });
+    await upsertMessages({
+      messages: [message] as unknown as Parameters<typeof upsertMessages>[0]['messages'],
+    });
+    return message;
+  };
+
+  const storedReactions = () => BetterSqlite.selectFromTable('reactions');
+
+  beforeEach(async () => {
+    await SqliteClient.initializeDatabase();
+    await BetterSqlite.openDB();
+  });
+
+  afterEach(() => {
+    BetterSqlite.dropAllTables();
+    BetterSqlite.closeDB();
+  });
+
+  it('inserts the reaction when the message is cached', async () => {
+    const message = await cacheAMessage('cached-message');
+    const reaction = generateReaction({ message_id: message.id, type: 'love' });
+
+    await insertReaction({ message, reaction });
+
+    expect(await storedReactions()).toHaveLength(1);
+  });
+
+  // The failure this closes: a `/sync` replay carrying a reaction on a message outside the cached
+  // window aborted the whole batch with `FOREIGN KEY constraint failed`, so all 45 unrelated events
+  // in it were lost too.
+  it('skips the reaction, without throwing, when the message was never cached', async () => {
+    await cacheAMessage('some-other-message');
+    const reaction = generateReaction({ message_id: 'never-persisted', type: 'love' });
+
+    await expect(
+      insertReaction({
+        message: { id: 'never-persisted', reaction_groups: {} } as Parameters<
+          typeof insertReaction
+        >[0]['message'],
+        reaction,
+      }),
+    ).resolves.not.toThrow();
+
+    expect(await storedReactions()).toHaveLength(0);
+  });
+
+  it('does not abort the rest of the batch it shares', async () => {
+    const message = await cacheAMessage('cached-message');
+    const orphanQueries = await insertReaction({
+      execute: false,
+      message: { id: 'never-persisted', reaction_groups: {} } as Parameters<
+        typeof insertReaction
+      >[0]['message'],
+      reaction: generateReaction({ message_id: 'never-persisted', type: 'like' }),
+    });
+    const validQueries = await insertReaction({
+      execute: false,
+      message,
+      reaction: generateReaction({ message_id: message.id, type: 'love' }),
+    });
+
+    await SqliteClient.executeSqlBatch([...orphanQueries, ...validQueries]);
+
+    // The orphan is dropped and the reaction that had a parent still lands.
+    expect(await storedReactions()).toHaveLength(1);
+  });
+
+  it('applies the same guard to updateReaction', async () => {
+    await cacheAMessage('some-other-message');
+    const reaction = generateReaction({ message_id: 'never-persisted', type: 'love' });
+
+    await expect(
+      updateReaction({
+        message: { id: 'never-persisted', reaction_groups: {} } as Parameters<
+          typeof updateReaction
+        >[0]['message'],
+        reaction,
+      }),
+    ).resolves.not.toThrow();
+
+    expect(await storedReactions()).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,64 @@
+import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
+import { mapStorableToMessage } from '../mappers/mapStorableToMessage';
+import { mapStorableToReaction } from '../mappers/mapStorableToReaction';
+import { mapStorableToUser } from '../mappers/mapStorableToUser';
+
+/**
+ * Every date column is nullable, but `created_at` / `updated_at` are required on the response
+ * models. These four mappers end their object literal with `...JSON.parse(extraData)`, and
+ * spreading `any` disables assignability checking for the whole literal — so `tsc` cannot see a
+ * required field being handed `undefined`. The six sibling mappers already guard with `?? 0`.
+ */
+describe('row -> model mappers keep required timestamps numeric', () => {
+  const nullDates = { createdAt: null, updatedAt: null };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const userRow = { ...nullDates, id: 'u1' } as any;
+
+  it('mapStorableToMessage', () => {
+    const message = mapStorableToMessage({
+      userId: 'u1',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      messageRow: { ...nullDates, id: 'm1', type: 'regular', user: userRow } as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      pollRow: undefined as any,
+    });
+
+    expect(typeof message.created_at).toBe('number');
+    expect(typeof message.updated_at).toBe('number');
+  });
+
+  it('mapStorableToUser', () => {
+    const user = mapStorableToUser(userRow);
+
+    expect(typeof user.created_at).toBe('number');
+    expect(typeof user.updated_at).toBe('number');
+    // `role` is required on `UserResponse` but nullable in the column.
+    expect(typeof user.role).toBe('string');
+  });
+
+  it('mapStorableToReaction', () => {
+    const reaction = mapStorableToReaction({
+      ...nullDates,
+      messageId: 'm1',
+      type: 'like',
+      user: userRow,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    expect(typeof reaction.created_at).toBe('number');
+    expect(typeof reaction.updated_at).toBe('number');
+  });
+
+  it('mapStorableToChannel', () => {
+    const result = mapStorableToChannel({
+      ...nullDates,
+      cid: 'messaging:c1',
+      id: 'c1',
+      type: 'messaging',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    expect(typeof result.channel?.created_at).toBe('number');
+    expect(typeof result.channel?.updated_at).toBe('number');
+  });
+});

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

@@ -0,0 +1,146 @@
+import Database, { type Database as DatabaseType } from 'better-sqlite3';
+
+import { generateMessage } from '../../mock-builders/generator/message';
+import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
+import { mapStorableToTimestamp } from '../mappers/mapStorableToTimestamp';
+import { mapTimestampToStorable } from '../mappers/mapTimestampToStorable';
+import { tables } from '../schema';
+import { createCreateTableQuery } from '../sqlite-utils/createCreateTableQuery';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { Table } from '../types';
+
+/**
+ * Timestamps are stored exactly as the API sends them: every date column is `INTEGER` holding unix
+ * nanoseconds, with no conversion at either boundary. Nothing here is about formatting — it is
+ * about the two things `tsc` cannot see.
+ *
+ * 1. **Precision.** A nanosecond timestamp (~1.79e18) sits far above `Number.MAX_SAFE_INTEGER`, so
+ *    the obvious worry is that SQLite quantises it further. It does not: by the time `JSON.parse`
+ *    has read the HTTP response the value is already an integral `double`, and an integral double
+ *    below 2^63 round-trips through `INTEGER` storage exactly. The tables here are built from the
+ *    real `schema.ts`, so a column reverted to `TEXT` fails these assertions rather than silently
+ *    truncating every timestamp to the millisecond — which is what the ISO columns used to do.
+ * 2. **Absent means `NULL`, not `''`.** The ISO mapper this replaced wrote an empty string for an
+ *    absent date, which is why `selectActiveLocationsForChannels`' `endAt IS NOT NULL` guard never
+ *    actually filtered anything. `ORDER BY` placement and `IS NOT NULL` are invisible to the type
+ *    system too.
+ */
+describe('timestamp storage', () => {
+  /** A real on-device value, from the report that prompted the nanosecond work. */
+  const NANOS = 1786219962651957000;
+  const CID = 'messaging:general';
+
+  let db: DatabaseType;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    // Every table, from the real schema: better-sqlite3 enables `PRAGMA foreign_keys` by default,
+    // and `messages.cid` references `channels`.
+    for (const table of Object.keys(tables) as Table[]) {
+      for (const [query] of createCreateTableQuery(table)) {
+        db.exec(query);
+      }
+    }
+    db.prepare('INSERT INTO channels (cid) VALUES (?)').run([CID]);
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  const insertMessage = (message: ReturnType<typeof generateMessage>) => {
+    const [query, values] = createUpsertQuery('messages', mapMessageToStorable(message));
+    db.prepare(query).run(values ?? []);
+  };
+
+  it('round-trips a nanosecond timestamp through the real schema without losing a digit', () => {
+    const message = generateMessage({ cid: CID, timestamp: NANOS });
+
+    insertMessage(message);
+
+    const row = db
+      .prepare('SELECT createdAt, typeof(createdAt) AS storageClass FROM messages WHERE id = ?')
+      .get(message.id) as { createdAt: number; storageClass: string };
+
+    expect(row.storageClass).toBe('integer');
+    expect(row.createdAt).toBe(NANOS);
+
+    // `json_object` renders the integer SQLite actually holds; `toBe(NANOS)` alone cannot fail for
+    // a precision reason, since the literal is already the rounded double.
+    const { exact } = db
+      .prepare(`SELECT json_object('v', createdAt) AS exact FROM messages WHERE id = ?`)
+      .get(message.id) as { exact: string };
+    expect(Number(JSON.parse(exact).v)).toBe(NANOS);
+    expect(Math.abs(Number(JSON.parse(exact).v) - NANOS)).toBeLessThan(1e6 / 2);
+    // The whole point of the change: no truncation to the millisecond. ISO carried three decimal
+    // places, so this assertion is what the previous storage format could not satisfy.
+    expect(row.createdAt % 1e6).not.toBe(0);
+  });
+
+  it('survives the json_object projection the select queries read through', () => {
+    // `selectMessagesForChannels` and friends do not select columns, they select a `json_object(…)`
+    // blob and `JSON.parse` it — a second place precision could be lost, via SQLite's number
+    // formatting rather than via storage.
+    const message = generateMessage({ cid: CID, timestamp: NANOS });
+
+    insertMessage(message);
+
+    const { value } = db
+      .prepare(`SELECT json_object('createdAt', createdAt) AS value FROM messages WHERE id = ?`)
+      .get(message.id) as { value: string };
+
+    expect(JSON.parse(value).createdAt).toBe(NANOS);
+  });
+
+  it('writes an absent timestamp as NULL so IS NOT NULL means something', () => {
+    const message = generateMessage({ cid: CID, deleted_at: undefined, timestamp: NANOS });
+
+    insertMessage(message);
+
+    const row = db
+      .prepare('SELECT typeof(deletedAt) AS storageClass FROM messages WHERE id = ?')
+      .get(message.id) as { storageClass: string };
+
+    expect(row.storageClass).toBe('null');
+    expect(
+      db.prepare('SELECT count(*) AS c FROM messages WHERE deletedAt IS NOT NULL').get(),
+    ).toEqual({ c: 0 });
+  });
+
+  it('orders numerically, with a missing timestamp last', () => {
+    const older = generateMessage({ cid: CID, timestamp: NANOS });
+    const newer = generateMessage({ cid: CID, timestamp: NANOS + 1e9 });
+
+    insertMessage(older);
+    insertMessage(newer);
+    db.prepare('INSERT INTO messages (id, cid, createdAt) VALUES (?, ?, NULL)').run([
+      'no-timestamp',
+      CID,
+    ]);
+
+    const ordered = db.prepare('SELECT id FROM messages ORDER BY createdAt DESC').all() as {
+      id: string;
+    }[];
+
+    expect(ordered.map((r) => r.id)).toStrictEqual([newer.id, older.id, 'no-timestamp']);
+  });
+
+  describe('the null boundary the mappers exist for', () => {
+    it('passes a present timestamp through untouched in both directions', () => {
+      expect(mapTimestampToStorable(NANOS)).toBe(NANOS);
+      expect(mapStorableToTimestamp(NANOS)).toBe(NANOS);
+    });
+
+    it('writes NULL for an absent timestamp, so an upsert clears rather than keeps it', () => {
+      // `upsertStatementParts` drops `undefined` from the column list, which on an
+      // upsert-**update** would leave the previous value in place.
+      expect(mapTimestampToStorable(undefined)).toBeNull();
+      expect(mapTimestampToStorable(null)).toBeNull();
+    });
+
+    it('reads NULL back as undefined, which is what the response types use', () => {
+      expect(mapStorableToTimestamp(null)).toBeUndefined();
+      expect(mapStorableToTimestamp(undefined)).toBeUndefined();
+    });
+  });
+});

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

@@ -1,9 +1,15 @@
 import { BetterSqlite } from '../../../test-utils/BetterSqlite';
 import { SqliteClient } from '../../SqliteClient';
-import { selectChannelIdsForFilterSort } from '../queries/selectChannelIdsForFilterSort';
+import { selectChannelQueryForFilterSort } from '../queries/selectChannelQueryForFilterSort';
 import { upsertCidsForQuery } from '../upsertCidsForQuery';
 
 describe('channel query cids', () => {
+  const predefinedFilter = {
+    name: 'user_messaging',
+    filter: { archived: false },
+    sort: [{ direction: -1 as const, field: 'pinned_at' }],
+  };
+
   beforeEach(async () => {
     await SqliteClient.initializeDatabase();
     await BetterSqlite.openDB();
@@ -22,7 +28,7 @@ describe('channel query cids', () => {
       options: {
         predefined_filter: 'user_messaging',
       },
-      sort: {},
+      sort: [],
     });
     await upsertCidsForQuery({
       cids: ['messaging:channel-2'],
@@ -30,26 +36,80 @@ describe('channel query cids', () => {
       options: {
         predefined_filter: 'team_channels',
       },
-      sort: {},
+      sort: [],
     });
 
     await expect(
-      selectChannelIdsForFilterSort({
+      selectChannelQueryForFilterSort({
         filters: {},
         options: {
           predefined_filter: 'user_messaging',
         },
-        sort: {},
+        sort: [],
       }),
-    ).resolves.toEqual(['messaging:channel-1']);
+    ).resolves.toEqual({ cids: ['messaging:channel-1'], predefinedFilter: undefined });
     await expect(
-      selectChannelIdsForFilterSort({
+      selectChannelQueryForFilterSort({
         filters: {},
         options: {
           predefined_filter: 'team_channels',
         },
-        sort: {},
+        sort: [],
+      }),
+    ).resolves.toEqual({ cids: ['messaging:channel-2'], predefinedFilter: undefined });
+  });
+
+  it('round-trips the backend-resolved rule alongside the order it produced', async () => {
+    await upsertCidsForQuery({
+      cids: ['messaging:channel-1'],
+      filters: {},
+      options: { predefined_filter: 'user_messaging' },
+      predefinedFilter,
+      sort: [],
+    });
+
+    await expect(
+      selectChannelQueryForFilterSort({
+        filters: {},
+        options: { predefined_filter: 'user_messaging' },
+        sort: [],
       }),
-    ).resolves.toEqual(['messaging:channel-2']);
+    ).resolves.toEqual({ cids: ['messaging:channel-1'], predefinedFilter });
+  });
+
+  it('clears a stored rule when the same query is re-cached without one', async () => {
+    const query = {
+      filters: {},
+      options: { predefined_filter: 'user_messaging' },
+      sort: [],
+    };
+    await upsertCidsForQuery({ ...query, cids: ['messaging:channel-1'], predefinedFilter });
+
+    // The upsert builder drops undefined columns, so an omitted rule has to be written as an
+    // explicit null — otherwise it would outlive the order it described.
+    await upsertCidsForQuery({ ...query, cids: ['messaging:channel-2'] });
+
+    await expect(selectChannelQueryForFilterSort(query)).resolves.toEqual({
+      cids: ['messaging:channel-2'],
+      predefinedFilter: undefined,
+    });
+  });
+
+  it.each([
+    ['unparseable', '{"name":"user_messaging"'],
+    ['valid JSON of the wrong shape', '{"filter":{"archived":false}}'],
+  ])('surfaces the cid order but ignores a stored rule that is %s', async (_, stored) => {
+    const query = {
+      filters: {},
+      options: { predefined_filter: 'user_messaging' },
+      sort: [],
+    };
+    await upsertCidsForQuery({ ...query, cids: ['messaging:channel-1'], predefinedFilter });
+    await SqliteClient.executeSql('UPDATE channelQueries SET predefinedFilter = ?', [stored]);
+
+    await expect(selectChannelQueryForFilterSort(query)).resolves.toEqual({
+      cids: ['messaging:channel-1'],
+      predefinedFilter: undefined,
+    });
   });
 });

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

@@ -72,6 +72,8 @@ describe('updatePendingTask', () => {
     expect(JSON.parse(updatedRow.payload)[0].text).toBe('edited text');
     expect(updatedTask.id).toBe(originalTask.id);
     expect(updatedTask.type).toBe('send-message');
-    expect((updatedTask.payload as [{ text: string }, object])[0].text).toBe('edited text');
+    expect((updatedTask.payload as unknown as [{ text: string }, object])[0].text).toBe(
+      'edited text',
+    );
   });
 });

package/src/store/apis/channelExists.ts

@@ -1,10 +1,18 @@
 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.
+ */
 export const channelExists = async ({ cid }: { cid: string }) => {
-  const channels = await SqliteClient.executeSql(
-    'SELECT EXISTS(SELECT 1 FROM channels WHERE cid = ?)',
-    [cid],
-  );
+  const channels = await SqliteClient.executeSql('SELECT 1 FROM channels WHERE cid = ? LIMIT 1', [
+    cid,
+  ]);
 
   SqliteClient.logger?.('info', 'channelExists', {
     cid,

package/src/store/apis/deleteMessagesForChannel.ts

@@ -1,3 +1,6 @@
+import { nowNs } from 'stream-chat';
+import type { TimestampNS } from 'stream-chat';
+
 import { SqliteClient } from '../SqliteClient';
 
 export const deleteMessagesForChannel = async ({
@@ -6,10 +9,12 @@ export const deleteMessagesForChannel = async ({
   execute = true,
 }: {
   cid: string;
-  truncated_at?: string;
+  /** Unix nanoseconds, as the API sends it. */
+  truncated_at?: TimestampNS;
   execute?: boolean;
 }) => {
-  const timestamp = truncated_at ? new Date(truncated_at).toISOString() : new Date().toISOString();
+  // `createdAt` holds unix nanoseconds, so the cutoff is one too and the comparison is numeric.
+  const timestamp = truncated_at ?? nowNs();
   const query: [string, (string | number)[]] = [
     `DELETE FROM messages WHERE cid = ? AND createdAt <= ?`,
     [cid, timestamp],

package/src/store/apis/deleteReaction.ts

@@ -1,4 +1,4 @@
-import { FormatMessageResponse, MessageResponse, ReactionResponse } from 'stream-chat';
+import { LocalMessage, MessageResponse, ReactionResponse } from 'stream-chat';
 
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
@@ -11,7 +11,7 @@ export const deleteReaction = async ({
   reaction,
 }: {
   reaction: ReactionResponse;
-  message?: MessageResponse | FormatMessageResponse;
+  message?: MessageResponse | LocalMessage;
   execute?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];

package/src/store/apis/getAppSettings.ts

@@ -1,20 +1,20 @@
-import type { AppSettingsAPIResponse } from 'stream-chat';
+import type { GetApplicationResponse } from 'stream-chat';
 
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
 import { SqliteClient } from '../SqliteClient';
 
 export const getAppSettings = async ({
-  currentUserId,
+  userId,
 }: {
-  currentUserId: string;
-}): Promise<AppSettingsAPIResponse | null> => {
+  userId: string;
+}): Promise<GetApplicationResponse | null> => {
   SqliteClient.logger?.('info', 'getAppSettings', {
-    currentUserId,
+    userId,
   });
   const result = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('userSyncStatus', ['*'], {
-      userId: currentUserId,
+      userId,
     }),
   );
 

package/src/store/apis/getChannelActiveLocations.ts

@@ -1,4 +1,4 @@
-import { SharedLocationResponse } from 'stream-chat';
+import { SharedLocationResponseData } from 'stream-chat';
 
 import { selectActiveLocationsForChannels } from './queries/selectActiveLocationsForChannels';
 
@@ -8,8 +8,8 @@ export const getChannelActiveLocations = async ({
   channelIds,
 }: {
   channelIds: string[];
-}): Promise<Record<string, SharedLocationResponse[]>> => {
-  const cidVsLiveLocations: Record<string, SharedLocationResponse[]> = {};
+}): 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.
   const locations = await selectActiveLocationsForChannels(channelIds);