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

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

package/src/store/schema.ts

@@ -0,0 +1,284 @@
+import type { MessageLabel, Role } from 'stream-chat';
+
+type Tables = {
+  [P in keyof Schema]: {
+    columns: {
+      [K in keyof Schema[P]]: string;
+    };
+    primaryKey: Array<keyof Schema[P]>;
+    foreignKeys?: Array<{
+      column: `${Exclude<keyof Schema[P], symbol>}`;
+      referenceTable: `${keyof Schema}`;
+      referenceTableColumn: string;
+      // https://www.sqlite.org/foreignkeys.html#fk_actions
+      onDeleteAction?: 'NO ACTION' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | 'CASCADE';
+    }>;
+    indexes?: Array<{
+      columns: Array<keyof Schema[P]>;
+      name: string;
+      unique: boolean;
+    }>;
+  };
+};
+
+export const tables: Tables = {
+  channelQueries: {
+    columns: {
+      cids: 'TEXT',
+      id: 'TEXT',
+    },
+    primaryKey: ['id'],
+  },
+  channels: {
+    columns: {
+      autoTranslationEnabled: 'BOOLEAN',
+      autoTranslationLanguage: 'TEXT',
+      cid: 'TEXT',
+      config: 'TEXT',
+      cooldown: 'BOOLEAN',
+      createdAt: 'TEXT',
+      createdById: 'TEXT',
+      deletedAt: 'TEXT',
+      disabled: 'BOOLEAN DEFAULT FALSE',
+      extraData: 'TEXT',
+      frozen: 'BOOLEAN',
+      hidden: 'BOOLEAN',
+      id: 'TEXT',
+      invites: 'TEXT',
+      lastMessageAt: 'TEXT',
+      memberCount: 'INTEGER',
+      muted: 'BOOLEAN DEFAULT FALSE',
+      ownCapabilities: 'TEXT',
+      team: 'TEXT',
+      truncatedAt: 'TEXT',
+      truncatedBy: 'TEXT',
+      truncatedById: 'TEXT',
+      type: 'TEXT',
+      updatedAt: 'TEXT',
+    },
+    primaryKey: ['cid'],
+  },
+  members: {
+    columns: {
+      banned: 'BOOLEAN DEFAULT FALSE',
+      channelRole: 'TEXT',
+      cid: 'TEXT NOT NULL',
+      createdAt: 'TEXT',
+      inviteAcceptedAt: 'TEXT',
+      invited: 'BOOLEAN',
+      inviteRejectedAt: 'TEXT',
+      isModerator: 'BOOLEAN',
+      role: 'TEXT',
+      shadowBanned: 'BOOLEAN DEFAULT FALSE',
+      updatedAt: 'TEXT',
+      userId: 'TEXT',
+    },
+    foreignKeys: [
+      {
+        column: 'cid',
+        onDeleteAction: 'CASCADE',
+        referenceTable: 'channels',
+        referenceTableColumn: 'cid',
+      },
+    ],
+    indexes: [
+      {
+        columns: ['cid', 'userId'],
+        name: 'index_members',
+        unique: false,
+      },
+    ],
+    primaryKey: ['cid', 'userId'],
+  },
+  messages: {
+    columns: {
+      attachments: 'TEXT',
+      cid: 'TEXT NOT NULL',
+      createdAt: 'TEXT',
+      deletedAt: 'TEXT',
+      extraData: 'TEXT',
+      id: 'TEXT',
+      reactionCounts: 'TEXT',
+      text: "TEXT DEFAULT ''",
+      type: 'TEXT',
+      updatedAt: 'TEXT',
+      userId: 'TEXT',
+    },
+    foreignKeys: [
+      {
+        column: 'cid',
+        onDeleteAction: 'CASCADE',
+        referenceTable: 'channels',
+        referenceTableColumn: 'cid',
+      },
+    ],
+    indexes: [
+      {
+        columns: ['cid', 'userId'],
+        name: 'index_messages',
+        unique: false,
+      },
+    ],
+    primaryKey: ['id'],
+  },
+  reactions: {
+    columns: {
+      createdAt: 'TEXT',
+      extraData: 'TEXT',
+      messageId: 'TEXT',
+      score: 'INTEGER DEFAULT 0',
+      type: 'TEXT',
+      updatedAt: 'TEXT',
+      userId: 'TEXT',
+    },
+    foreignKeys: [
+      {
+        column: 'messageId',
+        onDeleteAction: 'CASCADE',
+        referenceTable: 'messages',
+        referenceTableColumn: 'id',
+      },
+    ],
+    indexes: [
+      {
+        columns: ['messageId', 'userId'],
+        name: 'index_reaction',
+        unique: false,
+      },
+    ],
+    primaryKey: ['messageId', 'userId', 'type'],
+  },
+  reads: {
+    columns: {
+      cid: 'TEXT NOT NULL',
+      lastRead: 'TEXT NOT NULL',
+      unreadMessages: 'INTEGER DEFAULT 0',
+      userId: 'TEXT',
+    },
+    indexes: [
+      {
+        columns: ['cid', 'userId'],
+        name: 'index_reads_cid',
+        unique: false,
+      },
+    ],
+    primaryKey: ['userId', 'cid'],
+  },
+  users: {
+    columns: {
+      banned: 'BOOLEAN DEFAULT FALSE',
+      createdAt: 'TEXT',
+      extraData: 'TEXT',
+      id: 'TEXT',
+      lastActive: 'TEXT',
+      online: 'INTEGER',
+      role: 'TEXT',
+      updatedAt: 'TEXT',
+    },
+    indexes: [
+      {
+        columns: ['id'],
+        name: 'index_users_id',
+        unique: true,
+      },
+    ],
+    primaryKey: ['id'],
+  },
+  userSyncStatus: {
+    columns: {
+      lastSyncedAt: 'TEXT',
+      userId: 'TEXT',
+    },
+    primaryKey: ['userId'],
+  },
+};
+
+// TODO: Checking the optionality of columns
+export type Schema = {
+  channelQueries: {
+    cids: string;
+    id: string;
+  };
+  channels: {
+    cid: string;
+    extraData: string;
+    id: string;
+    type: string;
+    autoTranslationEnabled?: boolean;
+    autoTranslationLanguage?: string;
+    config?: string;
+    cooldown?: number;
+    createdAt?: string;
+    createdById?: string;
+    deletedAt?: string;
+    disabled?: boolean;
+    frozen?: boolean;
+    hidden?: boolean;
+    invites?: string;
+    lastMessageAt?: string;
+    memberCount?: number;
+    muted?: boolean;
+    ownCapabilities?: string;
+    team?: string;
+    truncatedAt?: string;
+    truncatedBy?: string;
+    truncatedById?: string;
+    updatedAt?: string;
+  };
+  members: {
+    cid: string;
+    banned?: boolean;
+    channelRole?: Role;
+    createdAt?: string;
+    inviteAcceptedAt?: string;
+    invited?: boolean;
+    inviteRejectedAt?: string;
+    isModerator?: boolean;
+    role?: string;
+    shadowBanned?: boolean;
+    updatedAt?: string;
+    userId?: string;
+  };
+  messages: {
+    attachments: string;
+    cid: string;
+    createdAt: string;
+    deletedAt: string;
+    extraData: string;
+    id: string;
+    reactionCounts: string;
+    type: MessageLabel;
+    updatedAt: string;
+    text?: string;
+    userId?: string;
+  };
+  reactions: {
+    createdAt: string;
+    messageId: string;
+    type: string;
+    updatedAt: string;
+    extraData?: string;
+    score?: number;
+    userId?: string;
+  };
+  reads: {
+    cid: string;
+    lastRead: string;
+    unreadMessages?: number;
+    userId?: string;
+  };
+  users: {
+    id: string;
+    banned?: boolean;
+    createdAt?: string;
+    extraData?: string;
+    lastActive?: string;
+    online?: boolean;
+    role?: string;
+    updatedAt?: string;
+  };
+  userSyncStatus: {
+    lastSyncedAt: string;
+    userId: string;
+  };
+};

package/src/store/sqlite-utils/__tests__/createSelectQuery.test.ts

@@ -0,0 +1,21 @@
+import { createSelectQuery } from '../createSelectQuery';
+
+describe('createSelectQuery', () => {
+  it('should build a simple select query', () => {
+    const query = createSelectQuery('channels');
+
+    expect(query).toStrictEqual(['SELECT * FROM channels', []]);
+  });
+
+  it('should build select query with where clause', () => {
+    const query = createSelectQuery('channels', ['cid', 'id'], {
+      cid: 'messaging:1nj32k341nkn23',
+      id: ['123', '456'],
+    });
+
+    expect(query).toStrictEqual([
+      'SELECT cid, id FROM channels WHERE cid = ? AND id in (?,?)',
+      ['messaging:1nj32k341nkn23', '123', '456'],
+    ]);
+  });
+});

package/src/store/sqlite-utils/appendWhereCluase.ts

@@ -0,0 +1,31 @@
+import type { Schema } from '../schema';
+import type { PreparedQueries, TableColumnNames } from '../types';
+
+export const appendWhereClause = <T extends keyof Schema>(
+  selectQuery: string,
+  whereCondition?: Partial<{ [k in TableColumnNames<T>]: any }>,
+) => {
+  if (!whereCondition) return [selectQuery, []];
+
+  const whereClause = [];
+  const whereParams: unknown[] = [];
+
+  for (const key in whereCondition) {
+    const value: unknown = whereCondition[key];
+    if (Array.isArray(value)) {
+      if (!value || value.length === 0) continue;
+      const questionMarks = Array(Object.keys(value).length).fill('?').join(',');
+      whereClause.push(`${key} in (${questionMarks})`);
+      whereParams.push(...value);
+    } else {
+      whereClause.push(`${key} = ?`);
+      whereParams.push(value);
+    }
+  }
+
+  if (!whereParams.length) {
+    return [selectQuery, []];
+  }
+
+  return [`${selectQuery} WHERE ${whereClause.join(' AND ')}`, whereParams] as PreparedQueries;
+};