Calls Tab & Group Call Disposition

2023-08-08 17:53:06 -07:00 · 2023-08-08 17:53:06 -07:00 · 1eaabb6734
commit 1eaabb6734
parent 620e85ca01
139 changed files with 9182 additions and 2721 deletions
--- a/ts/sql/Interface.ts
+++ b/ts/sql/Interface.ts
@ -21,6 +21,12 @@ import type { ReadStatus } from '../messages/MessageReadStatus';
 import type { RawBodyRange } from '../types/BodyRange';
 import type { GetMessagesBetweenOptions } from './Server';
 import type { MessageTimestamps } from '../state/ducks/conversations';
+import type {
+  CallHistoryDetails,
+  CallHistoryFilter,
+  CallHistoryGroup,
+  CallHistoryPagination,
+} from '../types/CallDisposition';

 export type AdjacentMessagesByConversationOptionsType = Readonly<{
  conversationId: string;
@ -628,10 +634,22 @@ export type DataInterface = {
  getLastConversationMessage(options: {
    conversationId: string;
  }): Promise<MessageType | undefined>;
-  getCallHistoryMessageByCallId(
-    conversationId: string,
-    callId: string
-  ): Promise<string | void>;
+  getAllCallHistory: () => Promise<ReadonlyArray<CallHistoryDetails>>;
+  clearCallHistory: (beforeTimestamp: number) => Promise<Array<string>>;
+  getCallHistoryMessageByCallId(options: {
+    conversationId: string;
+    callId: string;
+  }): Promise<MessageType | undefined>;
+  getCallHistory(
+    callId: string,
+    peerId: string
+  ): Promise<CallHistoryDetails | undefined>;
+  getCallHistoryGroupsCount(filter: CallHistoryFilter): Promise<number>;
+  getCallHistoryGroups(
+    filter: CallHistoryFilter,
+    pagination: CallHistoryPagination
+  ): Promise<Array<CallHistoryGroup>>;
+  saveCallHistory(callHistory: CallHistoryDetails): Promise<void>;
  hasGroupCallHistoryMessage: (
    conversationId: string,
    eraId: string
--- a/ts/sql/Server.ts
+++ b/ts/sql/Server.ts
@ -10,6 +10,7 @@ import { randomBytes } from 'crypto';
 import type { Database, Statement } from '@signalapp/better-sqlite3';
 import SQL from '@signalapp/better-sqlite3';
 import pProps from 'p-props';
+import { z } from 'zod';

 import type { Dictionary } from 'lodash';
 import {
@ -60,6 +61,7 @@ import type {
  QueryFragment,
 } from './util';
 import {
+  sqlConstant,
  sqlJoin,
  sqlFragment,
  sql,
@ -142,6 +144,18 @@ import {
  SNIPPET_RIGHT_PLACEHOLDER,
  SNIPPET_TRUNCATION_PLACEHOLDER,
 } from '../util/search';
+import type {
+  CallHistoryDetails,
+  CallHistoryFilter,
+  CallHistoryGroup,
+  CallHistoryPagination,
+} from '../types/CallDisposition';
+import {
+  DirectCallStatus,
+  callHistoryGroupSchema,
+  CallHistoryFilterStatus,
+  callHistoryDetailsSchema,
+} from '../types/CallDisposition';

 type ConversationRow = Readonly<{
  json: string;
@ -288,7 +302,13 @@ const dataInterface: ServerInterface = {
  getConversationRangeCenteredOnMessage,
  getConversationMessageStats,
  getLastConversationMessage,
+  getAllCallHistory,
+  clearCallHistory,
  getCallHistoryMessageByCallId,
+  getCallHistory,
+  getCallHistoryGroupsCount,
+  getCallHistoryGroups,
+  saveCallHistory,
  hasGroupCallHistoryMessage,
  migrateConversationMessages,
  getMessagesBetween,
@ -1755,32 +1775,32 @@ async function searchMessages({
      // Note: this groups the results by rowid, so even if one message mentions multiple
      // matching UUIDs, we only return one to be highlighted
      const [sqlQuery, params] = sql`
-        SELECT 
+        SELECT
          messages.rowid as rowid,
-          COALESCE(messages.json, ftsResults.json) as json, 
+          COALESCE(messages.json, ftsResults.json) as json,
          COALESCE(messages.sent_at, ftsResults.sent_at) as sent_at,
          COALESCE(messages.received_at, ftsResults.received_at) as received_at,
-          ftsResults.ftsSnippet, 
-          mentionUuid, 
-          start as mentionStart, 
+          ftsResults.ftsSnippet,
+          mentionUuid,
+          start as mentionStart,
          length as mentionLength
        FROM mentions
-        INNER JOIN messages 
-        ON 
-          messages.id = mentions.messageId 
+        INNER JOIN messages
+        ON
+          messages.id = mentions.messageId
          AND mentions.mentionUuid IN (
            ${sqlJoin(contactUuidsMatchingQuery, ', ')}
-          ) 
+          )
          AND ${
            conversationId
              ? sqlFragment`messages.conversationId = ${conversationId}`
              : '1 IS 1'
          }
-          AND messages.isViewOnce IS NOT 1 
+          AND messages.isViewOnce IS NOT 1
          AND messages.storyId IS NULL
        FULL OUTER JOIN (
          ${ftsFragment}
-        ) as ftsResults 
+        ) as ftsResults
        USING (rowid)
        GROUP BY rowid
        ORDER BY received_at DESC, sent_at DESC
@ -1910,6 +1930,7 @@ function saveMessageSync(
    sourceUuid,
    sourceDevice,
    storyId,
+    callId,
    type,
    readStatus,
    expireTimer,
@ -1967,6 +1988,7 @@ function saveMessageSync(
    sourceUuid: sourceUuid || null,
    sourceDevice: sourceDevice || null,
    storyId: storyId || null,
+    callId: callId || null,
    type: type || null,
    readStatus: readStatus ?? null,
    seenStatus: seenStatus ?? SeenStatus.NotApplicable,
@ -1999,6 +2021,7 @@ function saveMessageSync(
        sourceUuid = $sourceUuid,
        sourceDevice = $sourceDevice,
        storyId = $storyId,
+        callId = $callId,
        type = $type,
        readStatus = $readStatus,
        seenStatus = $seenStatus
@ -2044,6 +2067,7 @@ function saveMessageSync(
      sourceUuid,
      sourceDevice,
      storyId,
+      callId,
      type,
      readStatus,
      seenStatus
@ -2070,6 +2094,7 @@ function saveMessageSync(
      $sourceUuid,
      $sourceDevice,
      $storyId,
+      $callId,
      $type,
      $readStatus,
      $seenStatus
@ -3224,30 +3249,366 @@ async function getConversationRangeCenteredOnMessage(
  })();
 }

-async function getCallHistoryMessageByCallId(
-  conversationId: string,
-  callId: string
-): Promise<string | void> {
+async function getAllCallHistory(): Promise<ReadonlyArray<CallHistoryDetails>> {
+  const db = getInstance();
+  const [query] = sql`
+    SELECT * FROM callsHistory;
+  `;
+  return db.prepare(query).all();
+}
+
+async function clearCallHistory(
+  beforeTimestamp: number
+): Promise<Array<string>> {
+  const db = getInstance();
+  return db.transaction(() => {
+    const whereMessages = sqlFragment`
+      WHERE messages.type IS 'call-history'
+      AND messages.sent_at <= ${beforeTimestamp};
+    `;
+
+    const [selectMessagesQuery, selectMessagesParams] = sql`
+      SELECT id FROM messages ${whereMessages}
+    `;
+    const [clearMessagesQuery, clearMessagesParams] = sql`
+      DELETE FROM messages ${whereMessages}
+    `;
+    const [clearCallsHistoryQuery, clearCallsHistoryParams] = sql`
+      UPDATE callsHistory
+      SET
+        status = ${DirectCallStatus.Deleted},
+        timestamp = ${Date.now()}
+      WHERE callsHistory.timestamp <= ${beforeTimestamp};
+    `;
+
+    const messageIds = db
+      .prepare(selectMessagesQuery)
+      .pluck()
+      .all(selectMessagesParams);
+    db.prepare(clearMessagesQuery).run(clearMessagesParams);
+    try {
+      db.prepare(clearCallsHistoryQuery).run(clearCallsHistoryParams);
+    } catch (error) {
+      logger.error(error, error.message);
+      throw error;
+    }
+
+    return messageIds;
+  })();
+}
+
+async function getCallHistoryMessageByCallId(options: {
+  conversationId: string;
+  callId: string;
+}): Promise<MessageType | undefined> {
+  const db = getInstance();
+  const [query, params] = sql`
+    SELECT json
+    FROM messages
+    WHERE conversationId = ${options.conversationId}
+      AND type = 'call-history'
+      AND callId = ${options.callId}
+  `;
+  const row = db.prepare(query).get(params);
+  if (row == null) {
+    return;
+  }
+  return jsonToObject(row.json);
+}
+
+async function getCallHistory(
+  callId: string,
+  peerId: string
+): Promise<CallHistoryDetails | undefined> {
  const db = getInstance();

-  const id: string | void = db
-    .prepare<Query>(
-      `
-      SELECT id
-      FROM messages
-      WHERE conversationId = $conversationId
-        AND type = 'call-history'
-        AND callMode = 'Direct'
-        AND callId = $callId
-    `
-    )
-    .pluck()
-    .get({
-      conversationId,
-      callId,
-    });
+  const [query, params] = sql`
+    SELECT * FROM callsHistory
+    WHERE callId IS ${callId}
+    AND peerId IS ${peerId};
+  `;

-  return id;
+  const row = db.prepare(query).get(params);
+
+  if (row == null) {
+    return;
+  }
+
+  return callHistoryDetailsSchema.parse(row);
+}
+
+const MISSED = sqlConstant(DirectCallStatus.Missed);
+const DELETED = sqlConstant(DirectCallStatus.Deleted);
+const FOUR_HOURS_IN_MS = sqlConstant(4 * 60 * 60 * 1000);
+
+function getCallHistoryGroupDataSync(
+  db: Database,
+  isCount: boolean,
+  filter: CallHistoryFilter,
+  pagination: CallHistoryPagination
+): unknown {
+  return db.transaction(() => {
+    const { limit, offset } = pagination;
+    const { status, conversationIds } = filter;
+
+    if (conversationIds != null) {
+      strictAssert(conversationIds.length > 0, "can't filter by empty array");
+
+      const [createTempTable] = sql`
+        CREATE TEMP TABLE temp_callHistory_filtered_conversations (
+          uuid TEXT,
+          groupId TEXT
+        );
+      `;
+
+      db.exec(createTempTable);
+
+      batchMultiVarQuery(db, conversationIds, ids => {
+        const idList = sqlJoin(
+          ids.map(id => sqlFragment`(${id})`),
+          ','
+        );
+
+        const [insertQuery, insertParams] = sql`
+          INSERT INTO temp_callHistory_filtered_conversations
+            (uuid, groupId)
+          SELECT uuid, groupId
+          FROM conversations
+          WHERE conversations.id IN (${idList});
+        `;
+
+        db.prepare(insertQuery).run(insertParams);
+      });
+    }
+
+    const innerJoin =
+      conversationIds != null
+        ? sqlFragment`
+            INNER JOIN temp_callHistory_filtered_conversations ON (
+              temp_callHistory_filtered_conversations.uuid IS c.peerId
+              OR temp_callHistory_filtered_conversations.groupId IS c.peerId
+            )
+          `
+        : sqlFragment``;
+
+    const filterClause =
+      status === CallHistoryFilterStatus.All
+        ? sqlFragment`status IS NOT ${DELETED}`
+        : sqlFragment`status IS ${MISSED} AND status IS NOT ${DELETED}`;
+
+    const offsetLimit =
+      limit > 0 ? sqlFragment`LIMIT ${limit} OFFSET ${offset}` : sqlFragment``;
+
+    const projection = isCount
+      ? sqlFragment`COUNT(*) AS count`
+      : sqlFragment`peerId, ringerId, mode, type, direction, status, timestamp, possibleChildren, inPeriod`;
+
+    const [query, params] = sql`
+      SELECT
+        ${projection}
+      FROM (
+        -- 1. 'callAndGroupInfo': This section collects metadata to determine the
+        -- parent and children of each call. We can identify the real parents of calls
+        -- within the query, but we need to build the children at runtime.
+        WITH callAndGroupInfo AS (
+          SELECT
+            *,
+            -- 1a. 'possibleParent': This identifies the first call that _could_ be
+            -- considered the current call's parent. Note: The 'possibleParent' is not
+            -- necessarily the true parent if there is another call between them that
+            -- isn't a part of the group.
+            (
+              SELECT callId
+              FROM callsHistory
+              WHERE
+                callsHistory.direction IS c.direction
+                AND callsHistory.type IS c.type
+                AND callsHistory.peerId IS c.peerId
+                AND (callsHistory.timestamp - ${FOUR_HOURS_IN_MS}) <= c.timestamp
+                AND callsHistory.timestamp >= c.timestamp
+                -- Tracking Android & Desktop separately to make the queries easier to compare
+                -- Android Constraints:
+                AND (
+                  (callsHistory.status IS c.status AND callsHistory.status IS ${MISSED}) OR
+                  (callsHistory.status IS NOT ${MISSED} AND c.status IS NOT ${MISSED})
+                )
+                -- Desktop Constraints:
+                AND callsHistory.status IS c.status
+                AND ${filterClause}
+              ORDER BY timestamp DESC
+            ) as possibleParent,
+            -- 1b. 'possibleChildren': This identifies all possible calls that can
+            -- be grouped with the current call. Note: This current call is not
+            -- necessarily the parent, and not all possible children will end up as
+            -- children as they might have another parent
+            (
+              SELECT JSON_GROUP_ARRAY(
+                JSON_OBJECT(
+                  'callId', callId,
+                  'timestamp', timestamp
+                )
+              )
+              FROM callsHistory
+              WHERE
+                callsHistory.direction IS c.direction
+                AND callsHistory.type IS c.type
+                AND callsHistory.peerId IS c.peerId
+                AND (c.timestamp - ${FOUR_HOURS_IN_MS}) <= callsHistory.timestamp
+                AND c.timestamp >= callsHistory.timestamp
+                -- Tracking Android & Desktop separately to make the queries easier to compare
+                -- Android Constraints:
+                AND (
+                  (callsHistory.status IS c.status AND callsHistory.status IS ${MISSED}) OR
+                  (callsHistory.status IS NOT ${MISSED} AND c.status IS NOT ${MISSED})
+                )
+                -- Desktop Constraints:
+                AND callsHistory.status IS c.status
+                AND ${filterClause}
+              ORDER BY timestamp DESC
+            ) as possibleChildren,
+
+            -- 1c. 'inPeriod': This identifies all calls in a time period after the
+            -- current call. They may or may not be a part of the group.
+            (
+              SELECT GROUP_CONCAT(callId)
+              FROM callsHistory
+              WHERE
+                (c.timestamp - ${FOUR_HOURS_IN_MS}) <= callsHistory.timestamp
+                AND c.timestamp >= callsHistory.timestamp
+                AND ${filterClause}
+            ) AS inPeriod
+          FROM callsHistory AS c
+          ${innerJoin}
+          WHERE
+            ${filterClause}
+          ORDER BY timestamp DESC
+        )
+        -- 2. 'isParent': We need to identify the true parent of the group in cases
+        -- where the previous call is not a part of the group.
+        SELECT
+          *,
+          CASE
+            WHEN LAG (possibleParent, 1, 0) OVER (
+              -- Note: This is an optimization assuming that we've already got 'timestamp DESC' ordering
+              -- from the query above. If we find that ordering isn't always correct, we can uncomment this:
+              -- ORDER BY timestamp DESC
+            ) != possibleParent THEN callId
+            ELSE possibleParent
+          END AS parent
+        FROM callAndGroupInfo
+      ) AS parentCallAndGroupInfo
+      WHERE parent = parentCallAndGroupInfo.callId
+      ORDER BY parentCallAndGroupInfo.timestamp DESC
+      ${offsetLimit};
+    `;
+
+    const result = isCount
+      ? db.prepare(query).pluck(true).get(params)
+      : db.prepare(query).all(params);
+
+    if (conversationIds != null) {
+      const [dropTempTableQuery] = sql`
+        DROP TABLE temp_callHistory_filtered_conversations;
+      `;
+
+      db.exec(dropTempTableQuery);
+    }
+
+    return result;
+  })();
+}
+
+const countSchema = z.number().int().nonnegative();
+
+async function getCallHistoryGroupsCount(
+  filter: CallHistoryFilter
+): Promise<number> {
+  const db = getInstance();
+  const result = getCallHistoryGroupDataSync(db, true, filter, {
+    limit: 0,
+    offset: 0,
+  });
+  return countSchema.parse(result);
+}
+
+const groupsDataSchema = z.array(
+  callHistoryGroupSchema.omit({ children: true }).extend({
+    possibleChildren: z.string(),
+    inPeriod: z.string(),
+  })
+);
+
+const possibleChildrenSchema = z.array(
+  callHistoryDetailsSchema.pick({
+    callId: true,
+    timestamp: true,
+  })
+);
+
+async function getCallHistoryGroups(
+  filter: CallHistoryFilter,
+  pagination: CallHistoryPagination
+): Promise<Array<CallHistoryGroup>> {
+  const db = getInstance();
+  const groupsData = groupsDataSchema.parse(
+    getCallHistoryGroupDataSync(db, false, filter, pagination)
+  );
+
+  const taken = new Set<string>();
+
+  return groupsData
+    .map(groupData => {
+      return {
+        ...groupData,
+        possibleChildren: possibleChildrenSchema.parse(
+          JSON.parse(groupData.possibleChildren)
+        ),
+        inPeriod: new Set(groupData.inPeriod.split(',')),
+      };
+    })
+    .reverse()
+    .map(group => {
+      const { possibleChildren, inPeriod, ...rest } = group;
+      const children = [];
+
+      for (const child of possibleChildren) {
+        if (!taken.has(child.callId) && inPeriod.has(child.callId)) {
+          children.push(child);
+          taken.add(child.callId);
+        }
+      }
+
+      return callHistoryGroupSchema.parse({ ...rest, children });
+    })
+    .reverse();
+}
+
+async function saveCallHistory(callHistory: CallHistoryDetails): Promise<void> {
+  const db = getInstance();
+
+  const [insertQuery, insertParams] = sql`
+    INSERT OR REPLACE INTO callsHistory (
+      callId,
+      peerId,
+      ringerId,
+      mode,
+      type,
+      direction,
+      status,
+      timestamp
+    ) VALUES (
+      ${callHistory.callId},
+      ${callHistory.peerId},
+      ${callHistory.ringerId},
+      ${callHistory.mode},
+      ${callHistory.type},
+      ${callHistory.direction},
+      ${callHistory.status},
+      ${callHistory.timestamp}
+    );
+  `;
+
+  db.prepare(insertQuery).run(insertParams);
 }

 async function hasGroupCallHistoryMessage(
@ -5087,6 +5448,7 @@ async function removeAll(): Promise<void> {
      DELETE FROM attachment_downloads;
      DELETE FROM badgeImageFiles;
      DELETE FROM badges;
+      DELETE FROM callsHistory;
      DELETE FROM conversations;
      DELETE FROM emojis;
      DELETE FROM groupCallRingCancellations;
--- a/ts/sql/migrations/87-calls-history-table.ts
+++ b/ts/sql/migrations/87-calls-history-table.ts
@ -0,0 +1,196 @@
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import type { Database } from '@signalapp/better-sqlite3';
+
+import { callIdFromEra } from '@signalapp/ringrtc';
+import Long from 'long';
+
+import type { LoggerType } from '../../types/Logging';
+import { sql } from '../util';
+import { getOurUuid } from './41-uuid-keys';
+import type { CallHistoryDetails } from '../../types/CallDisposition';
+import {
+  DirectCallStatus,
+  CallDirection,
+  CallType,
+  GroupCallStatus,
+  callHistoryDetailsSchema,
+} from '../../types/CallDisposition';
+import { CallMode } from '../../types/Calling';
+
+export default function updateToSchemaVersion87(
+  currentVersion: number,
+  db: Database,
+  logger: LoggerType
+): void {
+  if (currentVersion >= 87) {
+    return;
+  }
+
+  db.transaction(() => {
+    const ourUuid = getOurUuid(db);
+
+    const [modifySchema] = sql`
+      DROP TABLE IF EXISTS callsHistory;
+
+      CREATE TABLE callsHistory (
+        callId TEXT PRIMARY KEY,
+        peerId TEXT NOT NULL, -- conversation uuid | groupId | roomId
+        ringerId TEXT DEFAULT NULL, -- ringer uuid
+        mode TEXT NOT NULL, -- enum "Direct" | "Group"
+        type TEXT NOT NULL, -- enum "Audio" | "Video" | "Group"
+        direction TEXT NOT NULL, -- enum "Incoming" | "Outgoing
+        -- Direct: enum "Pending" | "Missed" | "Accepted" | "Deleted"
+        -- Group: enum "GenericGroupCall" | "OutgoingRing" | "Ringing" | "Joined" | "Missed" | "Declined" | "Accepted" | "Deleted"
+        status TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        UNIQUE (callId, peerId) ON CONFLICT FAIL
+      );
+
+      CREATE INDEX callsHistory_order on callsHistory (timestamp DESC);
+      CREATE INDEX callsHistory_byConversation ON callsHistory (peerId);
+      -- For 'getCallHistoryGroupData':
+      -- This index should target the subqueries for 'possible_parent' and 'possible_children'
+      CREATE INDEX callsHistory_callAndGroupInfo_optimize on callsHistory (
+        direction,
+        peerId,
+        timestamp DESC,
+        status
+      );
+
+      DROP INDEX IF EXISTS messages_call;
+
+      ALTER TABLE messages
+        DROP COLUMN callId;
+      ALTER TABLE messages
+        ADD COLUMN callId TEXT;
+      ALTER TABLE messages
+        DROP COLUMN callMode;
+    `;
+
+    db.exec(modifySchema);
+
+    const [selectQuery] = sql`
+      SELECT * FROM messages WHERE type = 'call-history';
+    `;
+
+    const rows = db.prepare(selectQuery).all();
+
+    for (const row of rows) {
+      const json = JSON.parse(row.json);
+      const details = json.callHistoryDetails;
+
+      const { conversationId: peerId } = row;
+      const { callMode } = details;
+
+      let callId: string;
+      let type: CallType;
+      let direction: CallDirection;
+      let status: GroupCallStatus | DirectCallStatus;
+      let timestamp: number;
+      let ringerId: string | null = null;
+
+      if (details.callMode === CallMode.Direct) {
+        callId = details.callId;
+        type = details.wasVideoCall ? CallType.Video : CallType.Audio;
+        direction = details.wasIncoming
+          ? CallDirection.Incoming
+          : CallDirection.Outgoing;
+        if (details.acceptedTime != null) {
+          status = DirectCallStatus.Accepted;
+        } else {
+          status = details.wasDeclined
+            ? DirectCallStatus.Declined
+            : DirectCallStatus.Missed;
+        }
+        timestamp = details.endedTime ?? details.acceptedTime ?? null;
+      } else if (details.callMode === CallMode.Group) {
+        callId = Long.fromValue(callIdFromEra(details.eraId)).toString();
+        type = CallType.Group;
+        direction =
+          details.creatorUuid === ourUuid
+            ? CallDirection.Outgoing
+            : CallDirection.Incoming;
+        status = GroupCallStatus.GenericGroupCall;
+        timestamp = details.startedTime;
+        ringerId = details.creatorUuid;
+      } else {
+        logger.error(
+          `updateToSchemaVersion87: unknown callMode: ${details.callMode}`
+        );
+        continue;
+      }
+
+      if (callId == null) {
+        logger.error(
+          "updateToSchemaVersion87: callId doesn't exist, too old, skipping"
+        );
+        continue;
+      }
+
+      const callHistory: CallHistoryDetails = {
+        callId,
+        peerId,
+        ringerId,
+        mode: callMode,
+        type,
+        direction,
+        status,
+        timestamp,
+      };
+
+      const result = callHistoryDetailsSchema.safeParse(callHistory);
+
+      if (!result.success) {
+        logger.error(
+          `updateToSchemaVersion87: invalid callHistoryDetails (error: ${JSON.stringify(
+            result.error.format()
+          )}, input: ${JSON.stringify(json)}, output: ${JSON.stringify(
+            callHistory
+          )}))`
+        );
+        continue;
+      }
+
+      const [insertQuery, insertParams] = sql`
+        INSERT INTO callsHistory (
+          callId,
+          peerId,
+          ringerId,
+          mode,
+          type,
+          direction,
+          status,
+          timestamp
+        ) VALUES (
+          ${callHistory.callId},
+          ${callHistory.peerId},
+          ${callHistory.ringerId},
+          ${callHistory.mode},
+          ${callHistory.type},
+          ${callHistory.direction},
+          ${callHistory.status},
+          ${callHistory.timestamp}
+        )
+      `;
+
+      db.prepare(insertQuery).run(insertParams);
+
+      const [updateQuery, updateParams] = sql`
+        UPDATE messages
+        SET json = JSON_PATCH(json, ${JSON.stringify({
+          callHistoryDetails: null, // delete
+          callId,
+        })})
+        WHERE id = ${row.id}
+      `;
+
+      db.prepare(updateQuery).run(updateParams);
+    }
+
+    db.pragma('user_version = 87');
+  })();
+
+  logger.info('updateToSchemaVersion87: success!');
+}
--- a/ts/sql/migrations/index.ts
+++ b/ts/sql/migrations/index.ts
@ -62,6 +62,7 @@ import updateToSchemaVersion83 from './83-mentions';
 import updateToSchemaVersion84 from './84-all-mentions';
 import updateToSchemaVersion85 from './85-add-kyber-keys';
 import updateToSchemaVersion86 from './86-story-replies-index';
+import updateToSchemaVersion87 from './87-calls-history-table';

 function updateToSchemaVersion1(
  currentVersion: number,
@ -1994,6 +1995,7 @@ export const SCHEMA_VERSIONS = [
  updateToSchemaVersion84,
  updateToSchemaVersion85,
  updateToSchemaVersion86,
+  updateToSchemaVersion87,
 ];

 export function updateSchema(db: Database, logger: LoggerType): void {
--- a/ts/sql/util.ts
+++ b/ts/sql/util.ts
@ -36,7 +36,7 @@ export function jsonToObject<T>(json: string): T {
  return JSON.parse(json);
 }

-export type QueryTemplateParam = string | number | undefined;
+export type QueryTemplateParam = string | number | null | undefined;
 export type QueryFragmentValue = QueryFragment | QueryTemplateParam;

 export type QueryFragment = [
@ -66,7 +66,7 @@ export function sqlFragment(
  ...values: ReadonlyArray<QueryFragmentValue>
 ): QueryFragment {
  let query = '';
-  const params: Array<string | number | undefined> = [];
+  const params: Array<QueryTemplateParam> = [];

  strings.forEach((string, index) => {
    const value = values[index];
@ -88,6 +88,20 @@ export function sqlFragment(
  return [{ fragment: query }, params];
 }

+export function sqlConstant(value: QueryTemplateParam): QueryFragment {
+  let fragment;
+  if (value == null) {
+    fragment = 'NULL';
+  } else if (typeof value === 'number') {
+    fragment = `${value}`;
+  } else if (typeof value === 'boolean') {
+    fragment = `${value}`;
+  } else {
+    fragment = `'${value}'`;
+  }
+  return [{ fragment }, []];
+}
+
 /**
 * Like `Array.prototype.join`, but for SQL fragments.
 */
@ -96,7 +110,7 @@ export function sqlJoin(
  separator: string
 ): QueryFragment {
  let query = '';
-  const params: Array<string | number | undefined> = [];
+  const params: Array<QueryTemplateParam> = [];

  items.forEach((item, index) => {
    const [{ fragment }, fragmentParams] = sqlFragment`${item}`;
@ -111,10 +125,7 @@ export function sqlJoin(
  return [{ fragment: query }, params];
 }

-export type QueryTemplate = [
-  string,
-  ReadonlyArray<string | number | undefined>
-];
+export type QueryTemplate = [string, ReadonlyArray<QueryTemplateParam>];

 /**
 * You can use tagged template literals to build SQL queries
@ -137,7 +148,7 @@ export type QueryTemplate = [
 */
 export function sql(
  strings: TemplateStringsArray,
-  ...values: ReadonlyArray<QueryFragment | string | number | undefined>
+  ...values: ReadonlyArray<QueryFragment | QueryTemplateParam>
 ): QueryTemplate {
  const [{ fragment }, params] = sqlFragment(strings, ...values);
  return [fragment, params];