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

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

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

@@ -0,0 +1,39 @@
+import { tables } from '../schema';
+import type { PreparedQueries, Table } from '../types';
+
+export const createCreateTableQuery = (tableName: Table): PreparedQueries[] => {
+  const columnsWithDescriptors = Object.entries(tables[tableName].columns).map((entry) => {
+    const [key, value] = entry;
+    return `${key} ${value}`;
+  });
+
+  const primaryKeyConstraints =
+    tables[tableName].primaryKey.length > 0
+      ? [`PRIMARY KEY (${tables[tableName].primaryKey.join(', ')})`]
+      : [];
+  const foreignKeysConstraints =
+    tables[tableName].foreignKeys?.map(
+      (k) =>
+        `FOREIGN KEY (${k.column}) REFERENCES ${k.referenceTable}(${
+          k.referenceTableColumn
+        }) ON DELETE ${k.onDeleteAction || 'NO ACTION'}`,
+    ) || [];
+
+  const indexQueries: PreparedQueries[] =
+    tables[tableName].indexes?.map((index) => [
+      `CREATE ${index.unique ? 'UNIQUE' : ''} INDEX IF NOT EXISTS ${
+        index.name
+      } ON ${tableName}(${index.columns.join(',')})`,
+    ]) || [];
+
+  return [
+    [
+      `CREATE TABLE IF NOT EXISTS ${tableName}(
+          ${[...columnsWithDescriptors, ...primaryKeyConstraints, ...foreignKeysConstraints].join(
+            ',\n',
+          )}
+        );`,
+    ],
+    ...indexQueries,
+  ];
+};

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

@@ -0,0 +1,23 @@
+import { appendWhereClause } from './appendWhereCluase';
+
+import type { Schema } from '../schema';
+import type { PreparedQueries, TableColumnNames } from '../types';
+
+/**
+ * Creates a simple delete query for sqlite.
+ *
+ * @param {string} table Table name
+ * @param {Object} whereCondition Where condition for select query.
+ *  e.g., { id: 'vishal', cid: ['messaging:id1', 'messaging:id2'] }.
+ *  All the conditions will be joined with AND in final query.
+ * @returns {string} Final select query
+ */
+
+export const createDeleteQuery = <T extends keyof Schema>(
+  table: T,
+  whereCondition: Partial<{ [k in TableColumnNames<T>]: any }>,
+) => {
+  const deleteQuery = `DELETE FROM ${table}`;
+
+  return appendWhereClause(deleteQuery, whereCondition) as PreparedQueries;
+};

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

@@ -0,0 +1,25 @@
+import { appendWhereClause } from './appendWhereCluase';
+
+import type { Schema } from '../schema';
+import type { PreparedQueries, TableColumnNames } from '../types';
+
+/**
+ * Creates a simple select query for sqlite.
+ *
+ * @param {string} table Table name
+ * @param {Array} fields Array of columns which need to be selected e.g., ['*'] or ['id', 'name']
+ * @param {Object} whereCondition Where condition for select query.
+ *  e.g., { id: 'vishal', cid: ['messaging:id1', 'messaging:id2'] }.
+ *  All the conditions will be joined with AND in final query.
+ * @returns {string} Final select query
+ */
+export const createSelectQuery = <T extends keyof Schema>(
+  table: T,
+  fields: Array<'*'> | Array<TableColumnNames<T>> = ['*'],
+  whereCondition?: Partial<{ [k in TableColumnNames<T>]: any }>,
+) => {
+  const selectQuery = `SELECT ${fields.join(', ')} FROM ${table}`;
+  const [selectQueryWithWhere, whereParams] = appendWhereClause(selectQuery, whereCondition);
+
+  return [`${selectQueryWithWhere}`, whereParams] as PreparedQueries;
+};

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

@@ -0,0 +1,27 @@
+import { appendWhereClause } from './appendWhereCluase';
+
+import type { Schema } from '../schema';
+import type { PreparedQueries, TableColumnNames } from '../types';
+
+/**
+ * Creates a simple update query for sqlite.
+ *
+ * @param {string} table Table name
+ * @param {Object} set Set conditions for update query.
+ * @param {Object} whereCondition Where condition for select query.
+ *  e.g., { id: 'vishal', cid: ['messaging:id1', 'messaging:id2'] }.
+ *  All the conditions will be joined with AND in final query.
+ * @returns {string} Final update query for sqlite
+ */
+export const createUpdateQuery = <T extends keyof Schema>(
+  table: T,
+  set: Partial<{ [k in TableColumnNames<T>]: any }>,
+  whereCondition: Partial<{ [k in TableColumnNames<T>]: any }>,
+) => {
+  const fields = Object.keys(set).map((key) => `${key} = ?`);
+  const updateQuery = `UPDATE ${table} SET ${fields.join(',')}`;
+
+  const [updateQueryWithWhere, whereParams] = appendWhereClause(updateQuery, whereCondition);
+
+  return [updateQueryWithWhere, [...Object.values(set), ...whereParams]] as PreparedQueries;
+};

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

@@ -0,0 +1,48 @@
+import { Schema, tables } from '../schema';
+import type { PreparedQueries, TableColumnNames, TableRow } from '../types';
+
+/**
+ * Creates a simple upsert query for sqlite.
+ *
+ * @param {string} table Table name
+ * @param {Object} row Table row to insert or update.
+ * @param {Array} conflictCheckKeys Custom list of columns to check conflicts for - https://www.sqlite.org/lang_UPSERT.html. By default conflicts are checked on primary keys.
+ * @returns {string} Final upsert query for sqlite
+ */
+export const createUpsertQuery = <T extends keyof Schema>(
+  table: T,
+  row: Partial<TableRow<T>>,
+  conflictCheckKeys?: Array<TableColumnNames<T>>,
+) => {
+  const filteredRow: typeof row = {};
+
+  // In case of "DO UPDATE SET", we only want to update the properties which
+  // are provided, and not set undefined properties in database.
+  // E.g., channel date such as `own_capabilities` is only available in response of client.queryChannels or channel.query.
+  // But its not available in `event.channel`. And our mapper functions such as mapChannelToStorable will set fields which are not available as undefined.
+  // So when you execute upsert query for storable value of `event.channel` in `channels` table, it will
+  // unset ownCapabilities field for that channel in `channels` table.
+  for (const key in row) {
+    if (row[key] !== undefined) {
+      filteredRow[key] = row[key];
+    }
+  }
+  const fields = Object.keys(filteredRow) as (keyof typeof row)[];
+
+  const questionMarks = Array(Object.keys(fields).length).fill('?').join(',');
+  const conflictKeys = conflictCheckKeys || tables[table].primaryKey;
+  const conflictMatchersWithoutPK: string[] = (fields as string[])
+    .filter((f) => !(conflictKeys as string[]).includes(f))
+    .map((f) => `${f}=excluded.${f}`);
+
+  const conflictConstraint =
+    conflictKeys.length > 0
+      ? `ON CONFLICT(${conflictKeys.join(',')}) DO UPDATE SET
+  ${conflictMatchersWithoutPK.join(',')}`
+      : '';
+
+  return [
+    `INSERT INTO ${table} (${fields.join(',')}) VALUES (${questionMarks}) ${conflictConstraint}`,
+    Object.values(filteredRow),
+  ] as PreparedQueries;
+};

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

@@ -0,0 +1,28 @@
+import type { TableRow } from '../types';
+
+function isJson(str: string) {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+export const printRow = (row: TableRow<any>) => {
+  const prettyRow = {};
+  for (const key in row) {
+    // @ts-ignore
+    const value = row[key];
+
+    if (isJson(value)) {
+      // @ts-ignore
+      prettyRow[key] = JSON.parse(value);
+    } else {
+      // @ts-ignore
+      prettyRow[key] = value;
+    }
+  }
+
+  console.log(JSON.stringify(prettyRow, null, 2));
+};

package/src/store/types.ts

@@ -0,0 +1,11 @@
+import type { Schema } from './schema';
+
+export type Table = keyof Schema;
+export type TableRow<T extends Table> = Schema[T];
+export type TableRowJoinedUser<T extends Table> = Schema[T] & {
+  user: TableRow<'users'>;
+};
+
+export type TableColumnNames<T extends Table> = keyof Schema[T];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type PreparedQueries = [string] | [string, Array<any>];

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "4.11.0-beta.1"
+  "version": "5.0.0-offline-support.1"
 }