stream-chat-react-native-core 4.12.2-beta.1 → 5.0.0-beta.0

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

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;