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

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.10.0"
+  "version": "5.0.0-offline-support.0"
 }