stream-chat-react-native-core 4.11.0-beta.2 → 5.0.0-offline-support.2

package/src/store/apis/getChannelMessages.ts

@@ -0,0 +1,50 @@
+import type { MessageResponse } from 'stream-chat';
+
+import { selectMessagesForChannels } from './queries/selectMessagesForChannels';
+
+import { selectReactionsForMessages } from './queries/selectReactionsForMessages';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import { mapStorableToMessage } from '../mappers/mapStorableToMessage';
+import type { TableRowJoinedUser } from '../types';
+
+export const getMessages = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  channelIds,
+  currentUserId,
+}: {
+  channelIds: string[];
+  currentUserId: string;
+}) => {
+  const messageRows = selectMessagesForChannels(channelIds);
+  const messageIds = messageRows.map(({ id }) => id);
+
+  // Populate the message reactions.
+  const reactionRows = selectReactionsForMessages(messageIds);
+  const messageIdVsReactions: Record<string, TableRowJoinedUser<'reactions'>[]> = {};
+  reactionRows.forEach((reaction) => {
+    if (!messageIdVsReactions[reaction.messageId]) {
+      messageIdVsReactions[reaction.messageId] = [];
+    }
+    messageIdVsReactions[reaction.messageId].push(reaction);
+  });
+
+  // Populate the messages.
+  const cidVsMessages: Record<string, MessageResponse<StreamChatGenerics>[]> = {};
+  messageRows.forEach((m) => {
+    if (!cidVsMessages[m.cid]) {
+      cidVsMessages[m.cid] = [];
+    }
+
+    cidVsMessages[m.cid].push(
+      mapStorableToMessage<StreamChatGenerics>({
+        currentUserId,
+        messageRow: m,
+        reactionRows: messageIdVsReactions[m.id],
+      }),
+    );
+  });
+
+  return cidVsMessages;
+};

package/src/store/apis/getChannels.ts

@@ -0,0 +1,43 @@
+import type { DefaultStreamChatGenerics } from 'src/types/types';
+import type { ChannelAPIResponse, ChannelFilters, ChannelSort } from 'stream-chat';
+
+import { getMessages } from './getChannelMessages';
+import { getMembers } from './getMembers';
+import { getReads } from './getReads';
+import { selectChannelIdsForFilterSort } from './queries/selectChannelIdsForFilterSort';
+import { selectChannels } from './queries/selectChannels';
+
+import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
+
+export const getChannels = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  currentUserId,
+  filters,
+  sort,
+}: {
+  currentUserId: string;
+  filters?: ChannelFilters<StreamChatGenerics>;
+  sort?: ChannelSort<StreamChatGenerics>;
+}): Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[] => {
+  if (!filters && !sort) {
+    console.warn('Please provide the query (filters/sort) to fetch channels from DB');
+    return [];
+  }
+
+  const channelIds = selectChannelIdsForFilterSort({ filters, sort });
+  const channels = selectChannels({ channelIds });
+
+  const cidVsMembers = getMembers<StreamChatGenerics>({ channelIds });
+  const cidVsReads = getReads<StreamChatGenerics>({ channelIds });
+  const cidVsMessages = getMessages<StreamChatGenerics>({ channelIds, currentUserId });
+
+  // Enrich the channels with state
+  return channels.map((c) => ({
+    ...mapStorableToChannel<StreamChatGenerics>(c),
+    members: cidVsMembers[c.cid],
+    messages: cidVsMessages[c.cid],
+    pinned_messages: [],
+    read: cidVsReads[c.cid],
+  }));
+};

package/src/store/apis/getLastSyncedAt.ts

@@ -0,0 +1,13 @@
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+
+export const getLastSyncedAt = ({ currentUserId }: { currentUserId: string }) => {
+  const result = QuickSqliteClient.executeSql.apply(
+    null,
+    createSelectQuery('userSyncStatus', ['*'], {
+      userId: currentUserId,
+    }),
+  );
+
+  return result[0]?.lastSyncedAt;
+};

package/src/store/apis/getMembers.ts

@@ -0,0 +1,26 @@
+import type { ChannelMemberResponse } from 'stream-chat';
+
+import { selectMembersForChannels } from './queries/selectMembersForChannels';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import { mapStorableToMember } from '../mappers/mapStorableToMember';
+
+export const getMembers = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  channelIds,
+}: {
+  channelIds: string[];
+}) => {
+  const memberRows = selectMembersForChannels(channelIds);
+  const cidVsMembers: Record<string, ChannelMemberResponse<StreamChatGenerics>[]> = {};
+  memberRows.forEach((member) => {
+    if (!cidVsMembers[member.cid]) {
+      cidVsMembers[member.cid] = [];
+    }
+
+    cidVsMembers[member.cid].push(mapStorableToMember<StreamChatGenerics>(member));
+  });
+
+  return cidVsMembers;
+};

package/src/store/apis/getReads.ts

@@ -0,0 +1,26 @@
+import type { ReadResponse } from 'stream-chat';
+
+import { selectReadsForChannels } from './queries/selectReadsForChannels';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import { mapStorableToRead } from '../mappers/mapStorableToRead';
+
+export const getReads = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  channelIds,
+}: {
+  channelIds: string[];
+}) => {
+  const reads = selectReadsForChannels(channelIds);
+  const cidVsReads: Record<string, ReadResponse<StreamChatGenerics>[]> = {};
+
+  reads.forEach((read) => {
+    if (!cidVsReads[read.cid]) {
+      cidVsReads[read.cid] = [];
+    }
+    cidVsReads[read.cid].push(mapStorableToRead<StreamChatGenerics>(read));
+  });
+
+  return cidVsReads;
+};

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

@@ -0,0 +1,28 @@
+import type { ChannelFilters, ChannelSort } from 'stream-chat';
+
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { createSelectQuery } from '../../sqlite-utils/createSelectQuery';
+
+import { convertFilterSortToQuery } from '../utils/convertFilterSortToQuery';
+
+export const selectChannelIdsForFilterSort = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  filters,
+  sort,
+}: {
+  filters?: ChannelFilters<StreamChatGenerics>;
+  sort?: ChannelSort<StreamChatGenerics>;
+}): string[] => {
+  const query = convertFilterSortToQuery({ filters, sort });
+  const results = QuickSqliteClient.executeSql.apply(
+    null,
+    createSelectQuery('channelQueries', ['*'], {
+      id: query,
+    }),
+  );
+
+  const channelIdsStr = results?.[0]?.cids;
+  return channelIdsStr ? JSON.parse(channelIdsStr) : [];
+};

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

@@ -0,0 +1,19 @@
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { createSelectQuery } from '../../sqlite-utils/createSelectQuery';
+import type { TableRowJoinedUser } from '../../types';
+
+export const selectChannels = ({
+  channelIds,
+}: { channelIds?: string[] } = {}): TableRowJoinedUser<'channels'>[] => {
+  const query = createSelectQuery('channels', ['*'], {
+    cid: channelIds,
+  });
+
+  const result = QuickSqliteClient.executeSql.apply(null, query);
+
+  if (channelIds) {
+    return result.sort((a, b) => channelIds.indexOf(a.cid) - channelIds.indexOf(b.cid));
+  } else {
+    return result;
+  }
+};

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

@@ -0,0 +1,32 @@
+import type { TableRowJoinedUser } from 'src/store/types';
+
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { tables } from '../../schema';
+
+export const selectMembersForChannels = (cids: string[]): TableRowJoinedUser<'members'>[] => {
+  const questionMarks = Array(cids.length).fill('?').join(',');
+  const membersColumnNames = Object.keys(tables.members.columns)
+    .map((name) => `'${name}', a.${name}`)
+    .join(', ');
+  const userColumnNames = Object.keys(tables.users.columns)
+    .map((name) => `'${name}', b.${name}`)
+    .join(', ');
+
+  const result = QuickSqliteClient.executeSql(
+    `SELECT
+      json_object(
+        'user', json_object(
+          ${userColumnNames}
+        ),
+        ${membersColumnNames}
+      ) as value
+    FROM members a
+    LEFT JOIN
+      users b
+    ON b.id = a.userId 
+    WHERE cid in (${questionMarks}) ORDER BY datetime(a.createdAt) DESC`,
+    cids,
+  );
+
+  return result.map((r) => JSON.parse(r.value));
+};

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

@@ -0,0 +1,40 @@
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { tables } from '../../schema';
+import type { TableRowJoinedUser } from '../../types';
+
+export const selectMessagesForChannels = (cids: string[]): TableRowJoinedUser<'messages'>[] => {
+  const questionMarks = Array(cids.length).fill('?').join(',');
+  const messagesColumnNames = Object.keys(tables.messages.columns)
+    .map((name) => `'${name}', a.${name}`)
+    .join(', ');
+  const userColumnNames = Object.keys(tables.users.columns)
+    .map((name) => `'${name}', b.${name}`)
+    .join(', ');
+
+  const result = QuickSqliteClient.executeSql(
+    `SELECT
+      json_object(
+        'user', json_object(
+          ${userColumnNames}
+        ),
+        ${messagesColumnNames}
+      ) as value
+    FROM (
+      SELECT
+        *,
+        ROW_NUMBER() OVER (
+          PARTITION BY cid
+          ORDER BY datetime(createdAt) DESC
+        ) RowNum
+      FROM messages
+      WHERE cid in (${questionMarks})
+    ) a
+    LEFT JOIN
+      users b
+    ON b.id = a.userId 
+    WHERE RowNum < 200`,
+    cids,
+  );
+
+  return result.map((r) => JSON.parse(r.value));
+};

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

@@ -0,0 +1,33 @@
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { tables } from '../../schema';
+import type { TableRowJoinedUser } from '../../types';
+
+export const selectReactionsForMessages = (
+  messageIds: string[],
+): TableRowJoinedUser<'reactions'>[] => {
+  const questionMarks = Array(messageIds.length).fill('?').join(',');
+  const reactionsColumnNames = Object.keys(tables.reactions.columns)
+    .map((name) => `'${name}', a.${name}`)
+    .join(', ');
+  const userColumnNames = Object.keys(tables.users.columns)
+    .map((name) => `'${name}', b.${name}`)
+    .join(', ');
+
+  const result = QuickSqliteClient.executeSql(
+    `SELECT
+      json_object(
+        'user', json_object(
+          ${userColumnNames}
+        ),
+        ${reactionsColumnNames}
+      ) as value
+    FROM reactions a
+    LEFT JOIN
+      users b
+    ON b.id = a.userId 
+    WHERE a.messageId in (${questionMarks})`,
+    messageIds,
+  );
+
+  return result.map((r) => JSON.parse(r.value));
+};

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

@@ -0,0 +1,30 @@
+import { QuickSqliteClient } from '../../QuickSqliteClient';
+import { tables } from '../../schema';
+import type { TableRowJoinedUser } from '../../types';
+
+export const selectReadsForChannels = (cids: string[]): TableRowJoinedUser<'reads'>[] => {
+  const questionMarks = Array(cids.length).fill('?').join(',');
+  const readsColumnNames = Object.keys(tables.reads.columns)
+    .map((name) => `'${name}', a.${name}`)
+    .join(', ');
+  const userColumnNames = Object.keys(tables.users.columns)
+    .map((name) => `'${name}', b.${name}`)
+    .join(', ');
+  const result = QuickSqliteClient.executeSql(
+    `SELECT
+      json_object(
+        'user', json_object(
+          ${userColumnNames}
+        ),
+        ${readsColumnNames}
+      ) as value
+    FROM reads a
+    LEFT JOIN
+      users b
+    ON b.id = a.userId 
+    WHERE a.cid in (${questionMarks})`,
+    cids,
+  );
+
+  return result.map((r) => JSON.parse(r.value));
+};

package/src/store/apis/updateMessage.ts

@@ -0,0 +1,65 @@
+import type { MessageResponse } from 'stream-chat';
+
+import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
+import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
+import { mapUserToStorable } from '../mappers/mapUserToStorable';
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { PreparedQueries } from '../types';
+
+export const updateMessage = ({
+  flush = true,
+  message,
+}: {
+  message: MessageResponse;
+  flush?: boolean;
+}) => {
+  const queries: PreparedQueries[] = [];
+
+  const messages = QuickSqliteClient.executeSql.apply(
+    null,
+    createSelectQuery('messages', ['*'], {
+      id: message.id,
+    }),
+  );
+
+  if (messages.length === 0) {
+    return queries;
+  }
+
+  queries.push(
+    createUpdateQuery('messages', mapMessageToStorable(message), {
+      id: message.id,
+    }),
+  );
+
+  if (message.user) {
+    queries.push(createUpsertQuery('users', mapUserToStorable(message.user)));
+  }
+
+  queries.push(
+    createDeleteQuery('reactions', {
+      messageId: message.id,
+    }),
+  );
+
+  const latestReactions = message.latest_reactions || [];
+  const ownReactions = message.own_reactions || [];
+
+  [...latestReactions, ...ownReactions].forEach((r) => {
+    if (r.user) {
+      queries.push(createUpsertQuery('users', mapUserToStorable(r.user)));
+    }
+
+    queries.push(createUpsertQuery('reactions', mapReactionToStorable(r)));
+  });
+
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch(queries);
+  }
+
+  return queries;
+};

package/src/store/apis/updateReaction.ts

@@ -0,0 +1,54 @@
+import type { MessageResponse, ReactionResponse } from 'stream-chat';
+
+import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
+import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
+import { mapUserToStorable } from '../mappers/mapUserToStorable';
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { PreparedQueries } from '../types';
+
+export const updateReaction = ({
+  flush = true,
+  message,
+  reaction,
+}: {
+  message: MessageResponse;
+  reaction: ReactionResponse;
+  flush?: boolean;
+}) => {
+  const queries: PreparedQueries[] = [];
+
+  if (reaction.user) {
+    queries.push(createUpsertQuery('users', mapUserToStorable(reaction.user)));
+  }
+
+  queries.push(
+    createUpdateQuery('reactions', mapReactionToStorable(reaction), {
+      messageId: reaction.message_id,
+      userId: reaction.user_id,
+    }),
+  );
+
+  if (message.reaction_counts) {
+    const { reactionCounts } = mapMessageToStorable(message);
+
+    queries.push(
+      createUpdateQuery(
+        'messages',
+        {
+          reactionCounts,
+        },
+        {
+          id: message.id,
+        },
+      ),
+    );
+  }
+
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch(queries);
+  }
+
+  return queries;
+};

package/src/store/apis/upsertChannelData.ts

@@ -0,0 +1,20 @@
+import type { ChannelResponse } from 'stream-chat';
+
+import { mapChannelDataToStorable } from '../mappers/mapChannelDataToStorable';
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+
+export const upsertChannelData = ({
+  channel,
+  flush = true,
+}: {
+  channel: ChannelResponse;
+  flush?: boolean;
+}) => {
+  const query = createUpsertQuery('channels', mapChannelDataToStorable(channel));
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch([query]);
+  }
+
+  return [query];
+};

package/src/store/apis/upsertChannels.ts

@@ -0,0 +1,79 @@
+import type { ChannelAPIResponse, ChannelFilters, ChannelSort } from 'stream-chat';
+
+import { upsertCidsForQuery } from './upsertCidsForQuery';
+import { upsertMembers } from './upsertMembers';
+
+import { upsertMessages } from './upsertMessages';
+import { upsertReads } from './upsertReads';
+
+import { mapChannelDataToStorable } from '../mappers/mapChannelDataToStorable';
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { PreparedQueries } from '../types';
+
+export const upsertChannels = ({
+  channels,
+  filters,
+  flush = true,
+  isLatestMessagesSet,
+  sort,
+}: {
+  channels: ChannelAPIResponse[];
+  filters?: ChannelFilters;
+  flush?: boolean;
+  isLatestMessagesSet?: boolean;
+  sort?: ChannelSort;
+}) => {
+  // Update the database only if the query is provided.
+  let queries: PreparedQueries[] = [];
+
+  if (filters || sort) {
+    const channelIds = channels.map((channel) => channel.channel.cid);
+    queries = queries.concat(
+      upsertCidsForQuery({
+        cids: channelIds,
+        filters,
+        flush: false,
+        sort,
+      }),
+    );
+  }
+
+  for (const channel of channels) {
+    queries.push(createUpsertQuery('channels', mapChannelDataToStorable(channel.channel)));
+
+    const { members, messages, read } = channel;
+    queries = queries.concat(
+      upsertMembers({
+        cid: channel.channel.cid,
+        flush: false,
+        members,
+      }),
+    );
+
+    if (read) {
+      queries = queries.concat(
+        upsertReads({
+          cid: channel.channel.cid,
+          flush: false,
+          reads: read,
+        }),
+      );
+    }
+
+    if (isLatestMessagesSet) {
+      queries = queries.concat(
+        upsertMessages({
+          flush: false,
+          messages,
+        }),
+      );
+    }
+  }
+
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch(queries);
+  }
+
+  return queries;
+};

package/src/store/apis/upsertCidsForQuery.ts

@@ -0,0 +1,30 @@
+import type { ChannelFilters, ChannelSort } from 'stream-chat';
+
+import { convertFilterSortToQuery } from './utils/convertFilterSortToQuery';
+
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+
+export const upsertCidsForQuery = ({
+  cids,
+  filters,
+  flush = true,
+  sort,
+}: {
+  cids: string[];
+  filters?: ChannelFilters;
+  flush?: boolean;
+  sort?: ChannelSort;
+}) => {
+  // Update the database only if the query is provided.
+  const query = createUpsertQuery('channelQueries', {
+    cids: JSON.stringify(cids),
+    id: convertFilterSortToQuery({ filters, sort }),
+  });
+
+  if (flush) {
+    QuickSqliteClient.executeSql.apply(null, query);
+  }
+
+  return [query];
+};

package/src/store/apis/upsertLastSyncedAt.ts

@@ -0,0 +1,17 @@
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+
+export const upsertLastSyncedAt = ({
+  currentUserId,
+  lastSyncedAt,
+}: {
+  currentUserId: string;
+  lastSyncedAt: string;
+}) => {
+  const query = createUpsertQuery('userSyncStatus', {
+    lastSyncedAt,
+    userId: currentUserId,
+  });
+
+  QuickSqliteClient.executeSql.apply(null, query);
+};

package/src/store/apis/upsertMembers.ts

@@ -0,0 +1,41 @@
+import type { ChannelMemberResponse } from 'stream-chat';
+
+import { mapMemberToStorable } from '../mappers/mapMemberToStorable';
+import { mapUserToStorable } from '../mappers/mapUserToStorable';
+import { QuickSqliteClient } from '../QuickSqliteClient';
+import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { PreparedQueries } from '../types';
+
+export const upsertMembers = ({
+  cid,
+  flush = true,
+  members,
+}: {
+  cid: string;
+  members: ChannelMemberResponse[];
+  flush?: boolean;
+}) => {
+  const queries: PreparedQueries[] = [];
+
+  members?.forEach((member) => {
+    if (member.user) {
+      queries.push(createUpsertQuery('users', mapUserToStorable(member.user)));
+    }
+
+    queries.push(
+      createUpsertQuery(
+        'members',
+        mapMemberToStorable({
+          cid,
+          member,
+        }),
+      ),
+    );
+  });
+
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch(queries);
+  }
+
+  return queries;
+};