stream-chat-react-native-core 4.10.0 → 5.0.0-offline-support.0

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;
+};

package/src/store/apis/upsertMessages.ts

@@ -0,0 +1,43 @@
+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 { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import type { PreparedQueries } from '../types';
+
+export const upsertMessages = ({
+  flush = true,
+  messages,
+}: {
+  messages: MessageResponse[];
+  flush?: boolean;
+}) => {
+  const usersToUpsert: PreparedQueries[] = [];
+  const messagesToUpsert: PreparedQueries[] = [];
+  const reactionsToUpsert: PreparedQueries[] = [];
+
+  messages?.forEach((message: MessageResponse) => {
+    messagesToUpsert.push(createUpsertQuery('messages', mapMessageToStorable(message)));
+    if (message.user) {
+      usersToUpsert.push(createUpsertQuery('users', mapUserToStorable(message.user)));
+    }
+
+    [...(message.latest_reactions || []), ...(message.own_reactions || [])].forEach((r) => {
+      if (r.user) {
+        usersToUpsert.push(createUpsertQuery('users', mapUserToStorable(r.user)));
+      }
+
+      reactionsToUpsert.push(createUpsertQuery('reactions', mapReactionToStorable(r)));
+    });
+  });
+
+  const finalQueries = [...messagesToUpsert, ...reactionsToUpsert, ...usersToUpsert];
+
+  if (flush) {
+    QuickSqliteClient.executeSqlBatch(finalQueries);
+  }
+
+  return finalQueries;
+};

package/src/store/apis/upsertReads.ts

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

package/src/store/apis/utils/convertFilterSortToQuery.ts

@@ -0,0 +1,14 @@
+import type { ChannelFilters, ChannelSort } from 'stream-chat';
+
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+
+export const convertFilterSortToQuery = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  filters,
+  sort,
+}: {
+  filters?: ChannelFilters<StreamChatGenerics>;
+  sort?: ChannelSort<StreamChatGenerics>;
+}) =>
+  JSON.stringify(`${filters ? JSON.stringify(filters) : ''}-${sort ? JSON.stringify(sort) : ''}`);

package/src/store/constants.ts

@@ -0,0 +1,3 @@
+export const DB_NAME = 'stream-chat-react-native';
+export const DB_LOCATION = 'databases';
+export const DB_STATUS_ERROR = 1;

package/src/store/mappers/mapChannelDataToStorable.ts

@@ -0,0 +1,67 @@
+import type { ChannelResponse } from 'stream-chat';
+
+import { mapDateTimeToStorable } from './mapDateTimeToStorable';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+
+import type { TableRow } from '../types';
+
+export const mapChannelDataToStorable = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  channel: ChannelResponse<StreamChatGenerics>,
+): TableRow<'channels'> => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    auto_translation_enabled,
+    auto_translation_language,
+    cid,
+    config,
+    cooldown,
+    created_at,
+    deleted_at,
+    disabled,
+    frozen,
+    hidden,
+    id,
+    invites,
+    last_message_at,
+    member_count,
+    members,
+    muted,
+    own_capabilities,
+    team,
+    truncated_at,
+    truncated_by,
+    truncated_by_id,
+    type,
+    updated_at,
+    ...extraData
+  } = channel;
+
+  return {
+    autoTranslationEnabled: auto_translation_enabled,
+    autoTranslationLanguage: auto_translation_language,
+    cid,
+    config: config && JSON.stringify(config),
+    cooldown,
+    createdAt: mapDateTimeToStorable(created_at),
+    deletedAt: mapDateTimeToStorable(deleted_at),
+    disabled,
+    extraData: JSON.stringify(extraData),
+    frozen,
+    hidden,
+    id,
+    invites: invites && JSON.stringify(invites),
+    lastMessageAt: mapDateTimeToStorable(last_message_at),
+    memberCount: member_count,
+    muted,
+    ownCapabilities: own_capabilities && JSON.stringify(own_capabilities),
+    team,
+    truncatedAt: truncated_at,
+    truncatedBy: truncated_by && JSON.stringify(truncated_by),
+    truncatedById: truncated_by_id,
+    type,
+    updatedAt: updated_at,
+  };
+};

package/src/store/mappers/mapDateTimeToStorable.ts

@@ -0,0 +1,5 @@
+export const mapDateTimeToStorable = (datetime?: string) => {
+  if (!datetime) return '';
+
+  return new Date(datetime).toISOString();
+};

package/src/store/mappers/mapMemberToStorable.ts

@@ -0,0 +1,45 @@
+import type { ChannelMemberResponse } from 'stream-chat';
+
+import { mapDateTimeToStorable } from './mapDateTimeToStorable';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { TableRow } from '../types';
+
+export const mapMemberToStorable = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  cid,
+  member,
+}: {
+  cid: string;
+  member: ChannelMemberResponse<StreamChatGenerics>;
+}): TableRow<'members'> => {
+  const {
+    banned,
+    channel_role,
+    created_at,
+    invite_accepted_at,
+    invite_rejected_at,
+    invited,
+    is_moderator,
+    role,
+    shadow_banned,
+    updated_at,
+    user_id,
+  } = member;
+
+  return {
+    banned,
+    channelRole: channel_role,
+    cid,
+    createdAt: mapDateTimeToStorable(created_at),
+    inviteAcceptedAt: invite_accepted_at,
+    invited,
+    inviteRejectedAt: invite_rejected_at,
+    isModerator: is_moderator,
+    role,
+    shadowBanned: shadow_banned,
+    updatedAt: mapDateTimeToStorable(updated_at),
+    userId: user_id,
+  };
+};