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

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

package/src/store/mappers/mapMessageToStorable.ts

@@ -0,0 +1,35 @@
+import type { MessageResponse } from 'stream-chat';
+
+import { mapDateTimeToStorable } from './mapDateTimeToStorable';
+
+import type { TableRow } from '../types';
+
+export const mapMessageToStorable = (message: MessageResponse): TableRow<'messages'> => {
+  const {
+    attachments,
+    cid,
+    created_at,
+    deleted_at,
+    id,
+    reaction_counts,
+    text,
+    type,
+    updated_at,
+    user,
+    ...extraData
+  } = message;
+
+  return {
+    attachments: JSON.stringify(attachments),
+    cid: cid || '',
+    createdAt: mapDateTimeToStorable(created_at),
+    deletedAt: mapDateTimeToStorable(deleted_at),
+    extraData: JSON.stringify(extraData),
+    id,
+    reactionCounts: JSON.stringify(reaction_counts),
+    text,
+    type,
+    updatedAt: mapDateTimeToStorable(updated_at),
+    userId: user?.id,
+  };
+};

package/src/store/mappers/mapReactionToStorable.ts

@@ -0,0 +1,19 @@
+import type { ReactionResponse } from 'stream-chat';
+
+import { mapDateTimeToStorable } from './mapDateTimeToStorable';
+
+import type { TableRow } from '../types';
+
+export const mapReactionToStorable = (reaction: ReactionResponse): TableRow<'reactions'> => {
+  const { created_at, message_id, score, type, updated_at, user, ...extraData } = reaction;
+
+  return {
+    createdAt: mapDateTimeToStorable(created_at),
+    extraData: JSON.stringify(extraData),
+    messageId: message_id,
+    score,
+    type: type || '',
+    updatedAt: mapDateTimeToStorable(updated_at),
+    userId: user?.id,
+  };
+};

package/src/store/mappers/mapReadToStorable.ts

@@ -0,0 +1,25 @@
+import type { ReadResponse } from 'stream-chat';
+
+import { mapDateTimeToStorable } from './mapDateTimeToStorable';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { TableRow } from '../types';
+
+export const mapReadToStorable = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  cid,
+  read,
+}: {
+  cid: string;
+  read: ReadResponse<StreamChatGenerics>;
+}): TableRow<'reads'> => {
+  const { last_read, unread_messages, user } = read;
+
+  return {
+    cid,
+    lastRead: mapDateTimeToStorable(last_read),
+    unreadMessages: unread_messages,
+    userId: user?.id,
+  };
+};

package/src/store/mappers/mapStorableToChannel.ts

@@ -0,0 +1,69 @@
+import type { ChannelAPIResponse } from 'stream-chat';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { TableRow } from '../types';
+
+export const mapStorableToChannel = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  channelRow: TableRow<'channels'>,
+): Omit<
+  ChannelAPIResponse<StreamChatGenerics>,
+  'duration' | 'messages' | 'members' | 'pinned_messages'
+> => {
+  const {
+    autoTranslationEnabled,
+    autoTranslationLanguage,
+    cid,
+    config,
+    cooldown,
+    createdAt,
+    createdById,
+    deletedAt,
+    disabled,
+    extraData,
+    frozen,
+    hidden,
+    id,
+    invites,
+    lastMessageAt,
+    memberCount,
+    muted,
+    ownCapabilities,
+    team,
+    truncatedAt,
+    truncatedBy,
+    truncatedById,
+    type,
+    updatedAt,
+  } = channelRow;
+
+  return {
+    channel: {
+      auto_translation_enabled: autoTranslationEnabled,
+      auto_translation_language: autoTranslationLanguage,
+      cid,
+      config: config && JSON.parse(config),
+      cooldown,
+      created_at: createdAt,
+      created_by_id: createdById,
+      deleted_at: deletedAt,
+      disabled,
+      frozen,
+      hidden,
+      id,
+      invites: invites && JSON.parse(invites),
+      last_message_at: lastMessageAt,
+      memberCount,
+      muted,
+      own_capabilities: ownCapabilities && JSON.parse(ownCapabilities),
+      team,
+      truncated_at: truncatedAt,
+      truncated_by: truncatedBy,
+      truncated_by_id: truncatedById,
+      type,
+      updated_at: updatedAt,
+      ...(extraData ? JSON.parse(extraData) : {}),
+    },
+  };
+};

package/src/store/mappers/mapStorableToMember.ts

@@ -0,0 +1,42 @@
+import type { ChannelMemberResponse } from 'stream-chat';
+
+import { mapStorableToUser } from './mapStorableToUser';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { TableRowJoinedUser } from '../types';
+
+export const mapStorableToMember = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  memberRow: TableRowJoinedUser<'members'>,
+): ChannelMemberResponse<StreamChatGenerics> => {
+  const {
+    banned,
+    channelRole,
+    createdAt,
+    inviteAcceptedAt,
+    invited,
+    inviteRejectedAt,
+    isModerator,
+    role,
+    shadowBanned,
+    updatedAt,
+    user,
+    userId,
+  } = memberRow;
+
+  return {
+    banned,
+    channel_role: channelRole,
+    created_at: createdAt,
+    invite_accepted_at: inviteAcceptedAt,
+    invite_rejected_at: inviteRejectedAt,
+    invited,
+    is_moderator: isModerator,
+    role,
+    shadow_banned: shadowBanned,
+    updated_at: updatedAt,
+    user: mapStorableToUser(user),
+    user_id: userId,
+  };
+};

package/src/store/mappers/mapStorableToMessage.ts

@@ -0,0 +1,40 @@
+import type { MessageResponse } from 'stream-chat';
+
+import { mapStorableToReaction } from './mapStorableToReaction';
+
+import { mapStorableToUser } from './mapStorableToUser';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+
+import type { TableRowJoinedUser } from '../types';
+
+export const mapStorableToMessage = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>({
+  currentUserId,
+  messageRow,
+  reactionRows,
+}: {
+  currentUserId: string;
+  messageRow: TableRowJoinedUser<'messages'>;
+  reactionRows: TableRowJoinedUser<'reactions'>[];
+}): MessageResponse<StreamChatGenerics> => {
+  const { createdAt, deletedAt, extraData, reactionCounts, updatedAt, user, ...rest } = messageRow;
+  const latestReactions =
+    reactionRows?.map((reaction) => mapStorableToReaction<StreamChatGenerics>(reaction)) || [];
+
+  const ownReactions = latestReactions.filter((reaction) => reaction.user?.id === currentUserId);
+
+  return {
+    ...rest,
+    attachments: messageRow.attachments ? JSON.parse(messageRow.attachments) : [],
+    created_at: createdAt,
+    deleted_at: deletedAt,
+    latest_reactions: latestReactions,
+    own_reactions: ownReactions,
+    reaction_counts: reactionCounts ? JSON.parse(reactionCounts) : {},
+    updated_at: updatedAt,
+    user: mapStorableToUser(user),
+    ...(extraData ? JSON.parse(extraData) : {}),
+  };
+};

package/src/store/mappers/mapStorableToReaction.ts

@@ -0,0 +1,25 @@
+import type { ReactionResponse } from 'stream-chat';
+
+import { mapStorableToUser } from './mapStorableToUser';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+
+import type { TableRowJoinedUser } from '../types';
+
+export const mapStorableToReaction = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  reactionRow: TableRowJoinedUser<'reactions'>,
+): ReactionResponse<StreamChatGenerics> => {
+  const { createdAt, extraData, messageId, score, type, updatedAt, user } = reactionRow;
+
+  return {
+    created_at: createdAt,
+    message_id: messageId,
+    score,
+    type,
+    updated_at: updatedAt,
+    user: mapStorableToUser(user),
+    ...(extraData ? JSON.parse(extraData) : {}),
+  };
+};

package/src/store/mappers/mapStorableToRead.ts

@@ -0,0 +1,21 @@
+import type { ReadResponse } from 'stream-chat';
+
+import { mapStorableToUser } from './mapStorableToUser';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+
+import type { TableRowJoinedUser } from '../types';
+
+export const mapStorableToRead = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  row: TableRowJoinedUser<'reads'>,
+): ReadResponse<StreamChatGenerics> => {
+  const { lastRead, unreadMessages, user } = row;
+
+  return {
+    last_read: lastRead,
+    unread_messages: unreadMessages,
+    user: mapStorableToUser(user),
+  };
+};

package/src/store/mappers/mapStorableToUser.ts

@@ -0,0 +1,23 @@
+import type { UserResponse } from 'stream-chat';
+
+import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { TableRow } from '../types';
+
+export const mapStorableToUser = <
+  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
+>(
+  userRow: TableRow<'users'>,
+): UserResponse<StreamChatGenerics> => {
+  const { banned, createdAt, extraData, id, lastActive, online, role, updatedAt } = userRow;
+
+  return {
+    banned: Boolean(banned),
+    created_at: createdAt,
+    id,
+    last_active: lastActive,
+    online: Boolean(online),
+    role,
+    updated_at: updatedAt,
+    ...(extraData ? JSON.parse(extraData) : {}),
+  };
+};

package/src/store/mappers/mapUserToStorable.ts

@@ -0,0 +1,18 @@
+import type { UserResponse } from 'stream-chat';
+
+import type { TableRow } from '../types';
+
+export const mapUserToStorable = (user: UserResponse): TableRow<'users'> => {
+  const { banned, created_at, id, last_active, online, role, updated_at, ...extraData } = user;
+
+  return {
+    banned,
+    createdAt: created_at,
+    extraData: JSON.stringify(extraData || {}),
+    id,
+    lastActive: last_active,
+    online,
+    role,
+    updatedAt: updated_at,
+  };
+};