2023-01-03 19:55:46 +00:00
|
|
|
// Copyright 2020 Signal Messenger, LLC
|
2020-10-30 20:34:04 +00:00
|
|
|
// SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
import { ipcRenderer as ipc } from 'electron';
|
|
|
|
import fs from 'fs-extra';
|
|
|
|
import pify from 'pify';
|
2022-08-25 05:04:42 +00:00
|
|
|
import PQueue from 'p-queue';
|
2018-09-21 01:47:19 +00:00
|
|
|
|
2021-03-10 22:25:57 +00:00
|
|
|
import {
|
|
|
|
compact,
|
|
|
|
fromPairs,
|
|
|
|
groupBy,
|
|
|
|
isFunction,
|
2022-07-18 20:01:43 +00:00
|
|
|
isTypedArray,
|
2021-03-10 22:25:57 +00:00
|
|
|
last,
|
|
|
|
map,
|
|
|
|
omit,
|
2021-07-15 23:48:09 +00:00
|
|
|
toPairs,
|
2021-03-10 22:25:57 +00:00
|
|
|
} from 'lodash';
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-12-10 22:51:54 +00:00
|
|
|
import { deleteExternalFiles } from '../types/Conversation';
|
2022-05-31 23:53:14 +00:00
|
|
|
import { expiringMessagesDeletionService } from '../services/expiringMessagesDeletion';
|
|
|
|
import { tapToViewMessagesDeletionService } from '../services/tapToViewMessagesDeletionService';
|
2021-09-24 00:49:05 +00:00
|
|
|
import * as Bytes from '../Bytes';
|
2020-04-01 18:59:11 +00:00
|
|
|
import { createBatcher } from '../util/batcher';
|
2022-11-17 00:29:15 +00:00
|
|
|
import { explodePromise } from '../util/explodePromise';
|
2022-09-15 19:17:15 +00:00
|
|
|
import { assertDev, softAssert, strictAssert } from '../util/assert';
|
2022-07-28 16:35:29 +00:00
|
|
|
import { mapObjectWithSpec } from '../util/mapObjectWithSpec';
|
|
|
|
import type { ObjectMappingSpecType } from '../util/mapObjectWithSpec';
|
2021-02-04 19:54:03 +00:00
|
|
|
import { cleanDataForIpc } from './cleanDataForIpc';
|
2021-10-26 22:59:08 +00:00
|
|
|
import type { UUIDStringType } from '../types/UUID';
|
2021-09-27 18:22:46 +00:00
|
|
|
import createTaskWithTimeout from '../textsecure/TaskWithTimeout';
|
2021-09-17 18:27:53 +00:00
|
|
|
import * as log from '../logging/log';
|
2022-08-11 21:02:25 +00:00
|
|
|
import { isValidUuid } from '../types/UUID';
|
2022-11-17 00:29:15 +00:00
|
|
|
import * as Errors from '../types/errors';
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-10-26 19:15:33 +00:00
|
|
|
import type { StoredJob } from '../jobs/types';
|
2021-08-31 20:58:39 +00:00
|
|
|
import { formatJobForInsert } from '../jobs/formatJobForInsert';
|
2021-12-10 22:51:54 +00:00
|
|
|
import { cleanupMessage } from '../util/cleanup';
|
2022-12-21 18:41:48 +00:00
|
|
|
import { drop } from '../util/drop';
|
2020-07-10 18:28:49 +00:00
|
|
|
|
2021-10-26 19:15:33 +00:00
|
|
|
import type {
|
2023-03-04 03:03:15 +00:00
|
|
|
AdjacentMessagesByConversationOptionsType,
|
2022-07-28 16:35:29 +00:00
|
|
|
AllItemsType,
|
2020-04-01 18:59:11 +00:00
|
|
|
AttachmentDownloadJobType,
|
|
|
|
ClientInterface,
|
2022-11-17 00:29:15 +00:00
|
|
|
ClientExclusiveInterface,
|
2021-07-15 23:48:09 +00:00
|
|
|
ClientSearchResultMessageType,
|
2020-04-01 18:59:11 +00:00
|
|
|
ConversationType,
|
2022-07-28 16:35:29 +00:00
|
|
|
GetConversationRangeCenteredOnMessageResultType,
|
2021-09-10 02:38:11 +00:00
|
|
|
IdentityKeyIdType,
|
2021-12-10 22:51:54 +00:00
|
|
|
IdentityKeyType,
|
2022-07-28 16:35:29 +00:00
|
|
|
StoredIdentityKeyType,
|
2021-06-15 00:09:37 +00:00
|
|
|
ItemKeyType,
|
2020-04-01 18:59:11 +00:00
|
|
|
ItemType,
|
2022-07-28 16:35:29 +00:00
|
|
|
StoredItemType,
|
2020-04-01 18:59:11 +00:00
|
|
|
MessageType,
|
2021-07-12 23:51:45 +00:00
|
|
|
MessageTypeUnhydrated,
|
2021-09-10 02:38:11 +00:00
|
|
|
PreKeyIdType,
|
2021-12-10 22:51:54 +00:00
|
|
|
PreKeyType,
|
2022-07-28 16:35:29 +00:00
|
|
|
StoredPreKeyType,
|
2021-03-10 22:25:57 +00:00
|
|
|
ServerInterface,
|
2021-12-10 22:51:54 +00:00
|
|
|
ServerSearchResultMessageType,
|
2021-09-10 02:38:11 +00:00
|
|
|
SignedPreKeyIdType,
|
2021-12-10 22:51:54 +00:00
|
|
|
SignedPreKeyType,
|
2022-07-28 16:35:29 +00:00
|
|
|
StoredSignedPreKeyType,
|
2020-04-01 18:59:11 +00:00
|
|
|
} from './Interface';
|
2021-03-04 21:44:57 +00:00
|
|
|
import Server from './Server';
|
2023-03-02 17:59:18 +00:00
|
|
|
import { parseSqliteError, SqliteErrorKind } from './errors';
|
2022-06-27 16:46:43 +00:00
|
|
|
import { MINUTE } from '../util/durations';
|
2022-07-18 20:01:43 +00:00
|
|
|
import { getMessageIdForLogging } from '../util/idForLogging';
|
2023-03-20 22:23:53 +00:00
|
|
|
import type { MessageAttributesType } from '../model-types';
|
2018-07-27 01:13:56 +00:00
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
const getRealPath = pify(fs.realpath);
|
|
|
|
|
2021-04-26 22:01:22 +00:00
|
|
|
const MIN_TRACE_DURATION = 10;
|
|
|
|
|
2021-03-10 22:25:57 +00:00
|
|
|
const SQL_CHANNEL_KEY = 'sql-channel';
|
2018-07-27 01:13:56 +00:00
|
|
|
const ERASE_SQL_KEY = 'erase-sql-key';
|
|
|
|
const ERASE_ATTACHMENTS_KEY = 'erase-attachments';
|
2019-05-16 22:32:11 +00:00
|
|
|
const ERASE_STICKERS_KEY = 'erase-stickers';
|
2019-05-24 01:27:42 +00:00
|
|
|
const ERASE_TEMP_KEY = 'erase-temp';
|
2019-08-07 00:40:25 +00:00
|
|
|
const ERASE_DRAFTS_KEY = 'erase-drafts';
|
2018-08-08 17:00:33 +00:00
|
|
|
const CLEANUP_ORPHANED_ATTACHMENTS_KEY = 'cleanup-orphaned-attachments';
|
2020-02-21 23:40:04 +00:00
|
|
|
const ENSURE_FILE_PERMISSIONS = 'ensure-file-permissions';
|
2018-07-27 01:13:56 +00:00
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
enum RendererState {
|
|
|
|
InMain = 'InMain',
|
|
|
|
Opening = 'Opening',
|
|
|
|
InRenderer = 'InRenderer',
|
|
|
|
Closing = 'Closing',
|
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
let activeJobCount = 0;
|
|
|
|
let resolveShutdown: (() => void) | undefined;
|
|
|
|
let shutdownPromise: Promise<void> | null = null;
|
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
let state = RendererState.InMain;
|
2021-04-26 22:01:22 +00:00
|
|
|
const startupQueries = new Map<string, number>();
|
2021-03-10 22:25:57 +00:00
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
async function startInRendererProcess(isTesting = false): Promise<void> {
|
|
|
|
strictAssert(
|
|
|
|
state === RendererState.InMain,
|
|
|
|
`startInRendererProcess: expected ${state} to be ${RendererState.InMain}`
|
|
|
|
);
|
|
|
|
|
|
|
|
log.info('data.startInRendererProcess: switching to renderer process');
|
|
|
|
state = RendererState.Opening;
|
|
|
|
|
|
|
|
if (!isTesting) {
|
2022-11-17 00:29:15 +00:00
|
|
|
await ipc.invoke('database-ready');
|
2021-04-05 22:18:19 +00:00
|
|
|
}
|
2021-04-01 18:34:28 +00:00
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
const configDir = await getRealPath(ipc.sendSync('get-user-data-path'));
|
|
|
|
const key = ipc.sendSync('user-config-key');
|
|
|
|
|
|
|
|
await Server.initializeRenderer({ configDir, key });
|
|
|
|
|
|
|
|
log.info('data.startInRendererProcess: switched to renderer process');
|
|
|
|
|
|
|
|
state = RendererState.InRenderer;
|
|
|
|
}
|
|
|
|
|
|
|
|
async function goBackToMainProcess(): Promise<void> {
|
2021-10-15 18:43:13 +00:00
|
|
|
if (state === RendererState.InMain) {
|
|
|
|
log.info('goBackToMainProcess: Already in the main process');
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-10-07 18:16:51 +00:00
|
|
|
strictAssert(
|
|
|
|
state === RendererState.InRenderer,
|
|
|
|
`goBackToMainProcess: expected ${state} to be ${RendererState.InRenderer}`
|
|
|
|
);
|
|
|
|
|
2021-04-05 22:18:19 +00:00
|
|
|
// We don't need to wait for pending queries since they are synchronous.
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info('data.goBackToMainProcess: switching to main process');
|
2022-11-17 00:29:15 +00:00
|
|
|
const closePromise = channels.close();
|
2021-05-13 20:54:54 +00:00
|
|
|
|
2021-09-07 21:21:55 +00:00
|
|
|
// It should be the last query we run in renderer process
|
2021-10-07 18:16:51 +00:00
|
|
|
state = RendererState.Closing;
|
2021-09-07 21:21:55 +00:00
|
|
|
await closePromise;
|
2021-10-07 18:16:51 +00:00
|
|
|
state = RendererState.InMain;
|
2021-09-07 21:21:55 +00:00
|
|
|
|
2021-04-26 22:01:22 +00:00
|
|
|
// Print query statistics for whole startup
|
|
|
|
const entries = Array.from(startupQueries.entries());
|
|
|
|
startupQueries.clear();
|
|
|
|
|
|
|
|
// Sort by decreasing duration
|
|
|
|
entries
|
|
|
|
.sort((a, b) => b[1] - a[1])
|
|
|
|
.filter(([_, duration]) => duration > MIN_TRACE_DURATION)
|
|
|
|
.forEach(([query, duration]) => {
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(`startup query: ${query} ${duration}ms`);
|
2021-04-26 22:01:22 +00:00
|
|
|
});
|
2021-10-07 18:16:51 +00:00
|
|
|
|
|
|
|
log.info('data.goBackToMainProcess: switched to main process');
|
2021-03-10 22:25:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const channelsAsUnknown = fromPairs(
|
|
|
|
compact(
|
2022-11-17 00:29:15 +00:00
|
|
|
map(toPairs(Server), ([name, value]: [string, unknown]) => {
|
2021-03-10 22:25:57 +00:00
|
|
|
if (isFunction(value)) {
|
2021-04-07 22:40:12 +00:00
|
|
|
return [name, makeChannel(name)];
|
2021-03-10 22:25:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
})
|
|
|
|
)
|
2022-07-28 16:35:29 +00:00
|
|
|
) as unknown;
|
2021-03-10 22:25:57 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const channels: ServerInterface = channelsAsUnknown as ServerInterface;
|
2021-03-10 22:25:57 +00:00
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
const exclusiveInterface: ClientExclusiveInterface = {
|
|
|
|
createOrUpdateIdentityKey,
|
|
|
|
getIdentityKeyById,
|
|
|
|
bulkAddIdentityKeys,
|
|
|
|
getAllIdentityKeys,
|
|
|
|
|
|
|
|
createOrUpdatePreKey,
|
|
|
|
getPreKeyById,
|
|
|
|
bulkAddPreKeys,
|
|
|
|
getAllPreKeys,
|
|
|
|
|
|
|
|
createOrUpdateSignedPreKey,
|
|
|
|
getSignedPreKeyById,
|
|
|
|
bulkAddSignedPreKeys,
|
|
|
|
getAllSignedPreKeys,
|
|
|
|
|
|
|
|
createOrUpdateItem,
|
|
|
|
getItemById,
|
|
|
|
getAllItems,
|
|
|
|
|
|
|
|
updateConversation,
|
|
|
|
removeConversation,
|
|
|
|
|
|
|
|
searchMessages,
|
|
|
|
searchMessagesInConversation,
|
|
|
|
|
|
|
|
getOlderMessagesByConversation,
|
|
|
|
getConversationRangeCenteredOnMessage,
|
|
|
|
getNewerMessagesByConversation,
|
|
|
|
|
|
|
|
// Client-side only
|
|
|
|
|
|
|
|
shutdown,
|
|
|
|
removeAllMessagesInConversation,
|
|
|
|
|
|
|
|
removeOtherData,
|
|
|
|
cleanupOrphanedAttachments,
|
|
|
|
ensureFilePermissions,
|
|
|
|
|
|
|
|
// Client-side only, and test-only
|
|
|
|
|
|
|
|
startInRendererProcess,
|
|
|
|
goBackToMainProcess,
|
|
|
|
};
|
|
|
|
|
|
|
|
// Because we can't force this module to conform to an interface, we narrow our exports
|
|
|
|
// to this one default export, which does conform to the interface.
|
|
|
|
// Note: In Javascript, you need to access the .default property when requiring it
|
|
|
|
// https://github.com/microsoft/TypeScript/issues/420
|
|
|
|
const dataInterface: ClientInterface = {
|
|
|
|
...channels,
|
|
|
|
...exclusiveInterface,
|
|
|
|
|
|
|
|
// Overrides
|
|
|
|
updateConversations,
|
|
|
|
saveMessage,
|
|
|
|
saveMessages,
|
|
|
|
removeMessage,
|
2023-03-20 22:23:53 +00:00
|
|
|
removeMessages,
|
2022-11-17 00:29:15 +00:00
|
|
|
saveAttachmentDownloadJob,
|
|
|
|
};
|
|
|
|
|
|
|
|
export default dataInterface;
|
|
|
|
|
2021-02-04 19:54:03 +00:00
|
|
|
function _cleanData(
|
|
|
|
data: unknown
|
|
|
|
): ReturnType<typeof cleanDataForIpc>['cleaned'] {
|
|
|
|
const { cleaned, pathsChanged } = cleanDataForIpc(data);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-02-04 19:54:03 +00:00
|
|
|
if (pathsChanged.length) {
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(
|
2021-02-04 19:54:03 +00:00
|
|
|
`_cleanData cleaned the following paths: ${pathsChanged.join(', ')}`
|
|
|
|
);
|
2020-03-19 17:57:50 +00:00
|
|
|
}
|
|
|
|
|
2021-02-04 19:54:03 +00:00
|
|
|
return cleaned;
|
|
|
|
}
|
2020-03-19 17:57:50 +00:00
|
|
|
|
2022-07-18 20:01:43 +00:00
|
|
|
export function _cleanMessageData(data: MessageType): MessageType {
|
2022-07-28 16:35:29 +00:00
|
|
|
const result = { ...data };
|
2021-03-04 21:44:57 +00:00
|
|
|
// Ensure that all messages have the received_at set properly
|
|
|
|
if (!data.received_at) {
|
2022-09-15 19:17:15 +00:00
|
|
|
assertDev(false, 'received_at was not set on the message');
|
2022-07-28 16:35:29 +00:00
|
|
|
result.received_at = window.Signal.Util.incrementMessageCounter();
|
2018-07-27 01:13:56 +00:00
|
|
|
}
|
2022-07-18 20:01:43 +00:00
|
|
|
if (data.attachments) {
|
|
|
|
const logId = getMessageIdForLogging(data);
|
2022-07-28 16:35:29 +00:00
|
|
|
result.attachments = data.attachments.map((attachment, index) => {
|
2022-07-18 20:01:43 +00:00
|
|
|
if (attachment.data && !isTypedArray(attachment.data)) {
|
|
|
|
log.warn(
|
|
|
|
`_cleanMessageData/${logId}: Attachment ${index} had non-array \`data\` field; deleting.`
|
|
|
|
);
|
|
|
|
return omit(attachment, ['data']);
|
|
|
|
}
|
|
|
|
|
|
|
|
return attachment;
|
|
|
|
});
|
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
return _cleanData(omit(result, ['dataMessage']));
|
2018-07-27 01:13:56 +00:00
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
async function doShutdown() {
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(
|
2022-11-17 00:29:15 +00:00
|
|
|
`data.shutdown: shutdown requested. ${activeJobCount} jobs outstanding`
|
2021-03-10 22:25:57 +00:00
|
|
|
);
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
if (shutdownPromise) {
|
|
|
|
return shutdownPromise;
|
2021-03-10 22:25:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// No outstanding jobs, return immediately
|
2022-11-17 00:29:15 +00:00
|
|
|
if (activeJobCount === 0) {
|
2021-03-10 22:25:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
({ promise: shutdownPromise, resolve: resolveShutdown } =
|
|
|
|
explodePromise<void>());
|
2021-03-10 22:25:57 +00:00
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
try {
|
|
|
|
await shutdownPromise;
|
|
|
|
} finally {
|
|
|
|
log.info('data.shutdown: process complete');
|
2021-03-10 22:25:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function makeChannel(fnName: string) {
|
2022-07-28 16:35:29 +00:00
|
|
|
return async (...args: ReadonlyArray<unknown>) => {
|
2021-03-10 22:25:57 +00:00
|
|
|
// During startup we want to avoid the high overhead of IPC so we utilize
|
|
|
|
// the db that exists in the renderer process to be able to boot up quickly
|
|
|
|
// once the app is running we switch back to the main process to avoid the
|
|
|
|
// UI from locking up whenever we do costly db operations.
|
2021-10-07 18:16:51 +00:00
|
|
|
if (state === RendererState.InRenderer) {
|
2021-03-10 22:25:57 +00:00
|
|
|
const serverFnName = fnName as keyof ServerInterface;
|
2022-07-28 16:35:29 +00:00
|
|
|
const serverFn = Server[serverFnName] as (
|
|
|
|
...fnArgs: ReadonlyArray<unknown>
|
|
|
|
) => unknown;
|
2021-04-26 22:01:22 +00:00
|
|
|
const start = Date.now();
|
|
|
|
|
2021-09-08 20:39:14 +00:00
|
|
|
try {
|
|
|
|
// Ignoring this error TS2556: Expected 3 arguments, but got 0 or more.
|
2022-07-28 16:35:29 +00:00
|
|
|
return await serverFn(...args);
|
2021-09-08 20:39:14 +00:00
|
|
|
} catch (error) {
|
2023-03-02 17:59:18 +00:00
|
|
|
const sqliteErrorKind = parseSqliteError(error);
|
|
|
|
if (sqliteErrorKind === SqliteErrorKind.Corrupted) {
|
2021-09-17 18:27:53 +00:00
|
|
|
log.error(
|
2021-09-08 20:39:14 +00:00
|
|
|
'Detected sql corruption in renderer process. ' +
|
|
|
|
`Restarting the application immediately. Error: ${error.message}`
|
|
|
|
);
|
2022-04-07 22:49:23 +00:00
|
|
|
ipc?.send('database-error', error.stack);
|
2023-03-02 17:59:18 +00:00
|
|
|
} else if (sqliteErrorKind === SqliteErrorKind.Readonly) {
|
|
|
|
log.error(`Detected readonly sql database: ${error.message}`);
|
|
|
|
ipc?.send('database-readonly');
|
2021-09-08 20:39:14 +00:00
|
|
|
}
|
2023-03-02 17:59:18 +00:00
|
|
|
|
2021-09-17 18:27:53 +00:00
|
|
|
log.error(
|
2021-09-08 20:39:14 +00:00
|
|
|
`Renderer SQL channel job (${fnName}) error ${error.message}`
|
|
|
|
);
|
|
|
|
throw error;
|
|
|
|
} finally {
|
|
|
|
const duration = Date.now() - start;
|
2021-04-26 22:01:22 +00:00
|
|
|
|
2021-09-08 20:39:14 +00:00
|
|
|
startupQueries.set(
|
|
|
|
serverFnName,
|
|
|
|
(startupQueries.get(serverFnName) || 0) + duration
|
2021-04-26 22:01:22 +00:00
|
|
|
);
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
if (duration > MIN_TRACE_DURATION) {
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(
|
2021-09-08 20:39:14 +00:00
|
|
|
`Renderer SQL channel job (${fnName}) completed in ${duration}ms`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2021-03-10 22:25:57 +00:00
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
if (shutdownPromise && fnName !== 'close') {
|
|
|
|
throw new Error(
|
|
|
|
`Rejecting SQL channel job (${fnName}); application is shutting down`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
activeJobCount += 1;
|
|
|
|
return createTaskWithTimeout(async () => {
|
|
|
|
try {
|
|
|
|
return await ipc.invoke(SQL_CHANNEL_KEY, fnName, ...args);
|
|
|
|
} finally {
|
|
|
|
activeJobCount -= 1;
|
|
|
|
if (activeJobCount === 0) {
|
|
|
|
resolveShutdown?.();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, `SQL channel call (${fnName})`)();
|
2021-03-10 22:25:57 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
function specToBytes<Input, Output>(
|
|
|
|
spec: ObjectMappingSpecType,
|
|
|
|
data: Input
|
|
|
|
): Output {
|
|
|
|
return mapObjectWithSpec<string, Uint8Array>(spec, data, x =>
|
|
|
|
Bytes.fromBase64(x)
|
|
|
|
);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
function specFromBytes<Input, Output>(
|
|
|
|
spec: ObjectMappingSpecType,
|
|
|
|
data: Input
|
|
|
|
): Output {
|
|
|
|
return mapObjectWithSpec<Uint8Array, string>(spec, data, x =>
|
|
|
|
Bytes.toBase64(x)
|
|
|
|
);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Top-level calls
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function shutdown(): Promise<void> {
|
2022-04-11 17:53:57 +00:00
|
|
|
log.info('Client.shutdown');
|
|
|
|
|
2021-03-10 22:25:57 +00:00
|
|
|
// Stop accepting new SQL jobs, flush outstanding queue
|
2022-11-17 00:29:15 +00:00
|
|
|
await doShutdown();
|
2021-03-10 22:25:57 +00:00
|
|
|
|
2018-11-05 19:06:12 +00:00
|
|
|
// Close database
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.close();
|
2018-07-27 01:13:56 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 01:01:21 +00:00
|
|
|
// Identity Keys
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const IDENTITY_KEY_SPEC = ['publicKey'];
|
|
|
|
async function createOrUpdateIdentityKey(data: IdentityKeyType): Promise<void> {
|
|
|
|
const updated: StoredIdentityKeyType = specFromBytes(IDENTITY_KEY_SPEC, data);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.createOrUpdateIdentityKey(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getIdentityKeyById(
|
|
|
|
id: IdentityKeyIdType
|
|
|
|
): Promise<IdentityKeyType | undefined> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const data = await channels.getIdentityKeyById(id);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return specToBytes(IDENTITY_KEY_SPEC, data);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function bulkAddIdentityKeys(
|
|
|
|
array: Array<IdentityKeyType>
|
|
|
|
): Promise<void> {
|
|
|
|
const updated: Array<StoredIdentityKeyType> = map(array, data =>
|
|
|
|
specFromBytes(IDENTITY_KEY_SPEC, data)
|
|
|
|
);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.bulkAddIdentityKeys(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getAllIdentityKeys(): Promise<Array<IdentityKeyType>> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const keys = await channels.getAllIdentityKeys();
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return keys.map(key => specToBytes(IDENTITY_KEY_SPEC, key));
|
2019-02-04 23:54:37 +00:00
|
|
|
}
|
2018-10-18 01:01:21 +00:00
|
|
|
|
|
|
|
// Pre Keys
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function createOrUpdatePreKey(data: PreKeyType): Promise<void> {
|
|
|
|
const updated: StoredPreKeyType = specFromBytes(PRE_KEY_SPEC, data);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.createOrUpdatePreKey(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getPreKeyById(
|
|
|
|
id: PreKeyIdType
|
|
|
|
): Promise<PreKeyType | undefined> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const data = await channels.getPreKeyById(id);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return specToBytes(PRE_KEY_SPEC, data);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function bulkAddPreKeys(array: Array<PreKeyType>): Promise<void> {
|
|
|
|
const updated: Array<StoredPreKeyType> = map(array, data =>
|
|
|
|
specFromBytes(PRE_KEY_SPEC, data)
|
|
|
|
);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.bulkAddPreKeys(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getAllPreKeys(): Promise<Array<PreKeyType>> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const keys = await channels.getAllPreKeys();
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return keys.map(key => specToBytes(PRE_KEY_SPEC, key));
|
2019-02-04 23:54:37 +00:00
|
|
|
}
|
2018-10-18 01:01:21 +00:00
|
|
|
|
|
|
|
// Signed Pre Keys
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const PRE_KEY_SPEC = ['privateKey', 'publicKey'];
|
|
|
|
async function createOrUpdateSignedPreKey(
|
|
|
|
data: SignedPreKeyType
|
|
|
|
): Promise<void> {
|
|
|
|
const updated: StoredSignedPreKeyType = specFromBytes(PRE_KEY_SPEC, data);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.createOrUpdateSignedPreKey(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getSignedPreKeyById(
|
|
|
|
id: SignedPreKeyIdType
|
|
|
|
): Promise<SignedPreKeyType | undefined> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const data = await channels.getSignedPreKeyById(id);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return specToBytes(PRE_KEY_SPEC, data);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getAllSignedPreKeys(): Promise<Array<SignedPreKeyType>> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const keys = await channels.getAllSignedPreKeys();
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return keys.map(key => specToBytes(PRE_KEY_SPEC, key));
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function bulkAddSignedPreKeys(
|
|
|
|
array: Array<SignedPreKeyType>
|
|
|
|
): Promise<void> {
|
|
|
|
const updated: Array<StoredSignedPreKeyType> = map(array, data =>
|
|
|
|
specFromBytes(PRE_KEY_SPEC, data)
|
|
|
|
);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.bulkAddSignedPreKeys(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Items
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const ITEM_SPECS: Partial<Record<ItemKeyType, ObjectMappingSpecType>> = {
|
|
|
|
identityKeyMap: {
|
|
|
|
key: 'value',
|
|
|
|
valueSpec: {
|
|
|
|
isMap: true,
|
|
|
|
valueSpec: ['privKey', 'pubKey'],
|
|
|
|
},
|
|
|
|
},
|
2022-08-18 20:44:53 +00:00
|
|
|
profileKey: ['value'],
|
|
|
|
senderCertificate: ['value.serialized'],
|
|
|
|
senderCertificateNoE164: ['value.serialized'],
|
|
|
|
subscriberId: ['value'],
|
2018-10-18 01:01:21 +00:00
|
|
|
};
|
2022-07-28 16:35:29 +00:00
|
|
|
async function createOrUpdateItem<K extends ItemKeyType>(
|
|
|
|
data: ItemType<K>
|
|
|
|
): Promise<void> {
|
2018-10-18 01:01:21 +00:00
|
|
|
const { id } = data;
|
|
|
|
if (!id) {
|
|
|
|
throw new Error(
|
|
|
|
'createOrUpdateItem: Provided data did not have a truthy id'
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const spec = ITEM_SPECS[id];
|
|
|
|
const updated: StoredItemType<K> = spec
|
|
|
|
? specFromBytes(spec, data)
|
|
|
|
: (data as unknown as StoredItemType<K>);
|
2018-10-18 01:01:21 +00:00
|
|
|
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.createOrUpdateItem(updated);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2021-09-10 02:38:11 +00:00
|
|
|
async function getItemById<K extends ItemKeyType>(
|
|
|
|
id: K
|
|
|
|
): Promise<ItemType<K> | undefined> {
|
2022-07-28 16:35:29 +00:00
|
|
|
const spec = ITEM_SPECS[id];
|
2021-03-10 22:25:57 +00:00
|
|
|
const data = await channels.getItemById(id);
|
2018-10-18 01:01:21 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
return spec ? specToBytes(spec, data) : (data as unknown as ItemType<K>);
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
async function getAllItems(): Promise<AllItemsType> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const items = await channels.getAllItems();
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-06-15 00:09:37 +00:00
|
|
|
const result = Object.create(null);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-06-15 00:09:37 +00:00
|
|
|
for (const id of Object.keys(items)) {
|
|
|
|
const key = id as ItemKeyType;
|
|
|
|
const value = items[key];
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const keys = ITEM_SPECS[key];
|
2021-06-15 00:09:37 +00:00
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
const deserializedValue = keys
|
|
|
|
? (specToBytes(keys, { value }) as ItemType<typeof key>).value
|
2021-06-15 00:09:37 +00:00
|
|
|
: value;
|
|
|
|
|
|
|
|
result[key] = deserializedValue;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2018-10-18 01:01:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Conversation
|
|
|
|
|
2020-04-01 18:59:11 +00:00
|
|
|
const updateConversationBatcher = createBatcher<ConversationType>({
|
2021-03-26 00:00:03 +00:00
|
|
|
name: 'sql.Client.updateConversationBatcher',
|
2019-09-26 19:56:31 +00:00
|
|
|
wait: 500,
|
|
|
|
maxSize: 20,
|
2020-04-01 18:59:11 +00:00
|
|
|
processBatch: async (items: Array<ConversationType>) => {
|
2019-09-26 19:56:31 +00:00
|
|
|
// We only care about the most recent update for each conversation
|
|
|
|
const byId = groupBy(items, item => item.id);
|
|
|
|
const ids = Object.keys(byId);
|
2021-11-11 22:43:05 +00:00
|
|
|
const mostRecent = ids.map((id: string): ConversationType => {
|
|
|
|
const maybeLast = last(byId[id]);
|
2022-09-15 19:17:15 +00:00
|
|
|
assertDev(maybeLast !== undefined, 'Empty array in `groupBy` result');
|
2021-11-11 22:43:05 +00:00
|
|
|
return maybeLast;
|
|
|
|
});
|
2018-09-21 01:47:19 +00:00
|
|
|
|
2019-09-26 19:56:31 +00:00
|
|
|
await updateConversations(mostRecent);
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
function updateConversation(data: ConversationType): void {
|
2019-09-26 19:56:31 +00:00
|
|
|
updateConversationBatcher.add(data);
|
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function updateConversations(
|
|
|
|
array: Array<ConversationType>
|
|
|
|
): Promise<void> {
|
2021-02-04 19:54:03 +00:00
|
|
|
const { cleaned, pathsChanged } = cleanDataForIpc(array);
|
2022-09-15 19:17:15 +00:00
|
|
|
assertDev(
|
2021-02-04 19:54:03 +00:00
|
|
|
!pathsChanged.length,
|
|
|
|
`Paths were cleaned: ${JSON.stringify(pathsChanged)}`
|
|
|
|
);
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.updateConversations(cleaned);
|
2018-09-21 01:47:19 +00:00
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function removeConversation(id: string): Promise<void> {
|
2022-11-17 00:29:15 +00:00
|
|
|
const existing = await channels.getConversationById(id);
|
2018-09-21 01:47:19 +00:00
|
|
|
|
|
|
|
// Note: It's important to have a fully database-hydrated model to delete here because
|
|
|
|
// it needs to delete all associated on-disk files along with the database delete.
|
|
|
|
if (existing) {
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.removeConversation(id);
|
2021-12-10 22:51:54 +00:00
|
|
|
await deleteExternalFiles(existing, {
|
|
|
|
deleteAttachmentData: window.Signal.Migrations.deleteAttachmentData,
|
|
|
|
});
|
2018-09-21 01:47:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-12 23:51:45 +00:00
|
|
|
function handleSearchMessageJSON(
|
2021-12-10 22:51:54 +00:00
|
|
|
messages: Array<ServerSearchResultMessageType>
|
2021-04-05 22:18:19 +00:00
|
|
|
): Array<ClientSearchResultMessageType> {
|
2021-07-12 23:51:45 +00:00
|
|
|
return messages.map(message => ({
|
|
|
|
json: message.json,
|
2021-04-15 20:46:09 +00:00
|
|
|
|
|
|
|
// Empty array is a default value. `message.json` has the real field
|
2021-04-05 22:18:19 +00:00
|
|
|
bodyRanges: [],
|
2021-04-15 20:46:09 +00:00
|
|
|
|
2021-07-12 23:51:45 +00:00
|
|
|
...JSON.parse(message.json),
|
|
|
|
snippet: message.snippet,
|
2019-08-09 23:12:29 +00:00
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
2020-04-01 18:59:11 +00:00
|
|
|
async function searchMessages(
|
|
|
|
query: string,
|
|
|
|
{ limit }: { limit?: number } = {}
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<Array<ClientSearchResultMessageType>> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const messages = await channels.searchMessages(query, { limit });
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-07-12 23:51:45 +00:00
|
|
|
return handleSearchMessageJSON(messages);
|
2019-01-14 21:49:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async function searchMessagesInConversation(
|
2020-04-01 18:59:11 +00:00
|
|
|
query: string,
|
|
|
|
conversationId: string,
|
|
|
|
{ limit }: { limit?: number } = {}
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<Array<ClientSearchResultMessageType>> {
|
2021-03-10 22:25:57 +00:00
|
|
|
const messages = await channels.searchMessagesInConversation(
|
2019-01-14 21:49:58 +00:00
|
|
|
query,
|
|
|
|
conversationId,
|
|
|
|
{ limit }
|
|
|
|
);
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2021-07-12 23:51:45 +00:00
|
|
|
return handleSearchMessageJSON(messages);
|
2018-09-21 01:47:19 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 01:01:21 +00:00
|
|
|
// Message
|
|
|
|
|
2020-04-01 18:59:11 +00:00
|
|
|
async function saveMessage(
|
|
|
|
data: MessageType,
|
2021-12-20 21:04:02 +00:00
|
|
|
options: {
|
|
|
|
jobToInsert?: Readonly<StoredJob>;
|
|
|
|
forceSave?: boolean;
|
|
|
|
ourUuid: UUIDStringType;
|
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<string> {
|
2021-08-31 20:58:39 +00:00
|
|
|
const id = await channels.saveMessage(_cleanMessageData(data), {
|
|
|
|
...options,
|
|
|
|
jobToInsert: options.jobToInsert && formatJobForInsert(options.jobToInsert),
|
|
|
|
});
|
2021-07-19 20:45:18 +00:00
|
|
|
|
2022-08-11 21:02:25 +00:00
|
|
|
softAssert(isValidUuid(id), 'saveMessage: messageId is not a UUID');
|
|
|
|
|
2022-12-21 18:41:48 +00:00
|
|
|
void expiringMessagesDeletionService.update();
|
|
|
|
void tapToViewMessagesDeletionService.update();
|
2018-10-18 01:01:21 +00:00
|
|
|
|
2020-04-01 18:59:11 +00:00
|
|
|
return id;
|
2018-08-01 19:38:48 +00:00
|
|
|
}
|
|
|
|
|
2020-04-01 18:59:11 +00:00
|
|
|
async function saveMessages(
|
2022-03-16 00:11:28 +00:00
|
|
|
arrayOfMessages: ReadonlyArray<MessageType>,
|
2021-12-20 21:04:02 +00:00
|
|
|
options: { forceSave?: boolean; ourUuid: UUIDStringType }
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<void> {
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.saveMessages(
|
2021-02-04 19:54:03 +00:00
|
|
|
arrayOfMessages.map(message => _cleanMessageData(message)),
|
2021-07-19 20:45:18 +00:00
|
|
|
options
|
2021-02-04 19:54:03 +00:00
|
|
|
);
|
2021-07-19 20:45:18 +00:00
|
|
|
|
2022-12-21 18:41:48 +00:00
|
|
|
void expiringMessagesDeletionService.update();
|
|
|
|
void tapToViewMessagesDeletionService.update();
|
2018-07-25 22:02:27 +00:00
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function removeMessage(id: string): Promise<void> {
|
2022-11-17 00:29:15 +00:00
|
|
|
const message = await channels.getMessageById(id);
|
2018-07-27 01:13:56 +00:00
|
|
|
|
2018-07-25 22:02:27 +00:00
|
|
|
// Note: It's important to have a fully database-hydrated model to delete here because
|
|
|
|
// it needs to delete all associated on-disk files along with the database delete.
|
|
|
|
if (message) {
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.removeMessage(id);
|
2021-12-10 22:51:54 +00:00
|
|
|
await cleanupMessage(message);
|
2018-07-25 22:02:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-20 22:23:53 +00:00
|
|
|
async function _cleanupMessages(
|
|
|
|
messages: ReadonlyArray<MessageAttributesType>
|
|
|
|
): Promise<void> {
|
|
|
|
const queue = new PQueue({ concurrency: 3, timeout: MINUTE * 30 });
|
|
|
|
drop(
|
|
|
|
queue.addAll(
|
|
|
|
messages.map(
|
|
|
|
(message: MessageAttributesType) => async () => cleanupMessage(message)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
await queue.onIdle();
|
|
|
|
}
|
|
|
|
|
|
|
|
async function removeMessages(
|
|
|
|
messageIds: ReadonlyArray<string>
|
|
|
|
): Promise<void> {
|
|
|
|
const messages = await channels.getMessagesById(messageIds);
|
|
|
|
await _cleanupMessages(messages);
|
|
|
|
await channels.removeMessages(messageIds);
|
|
|
|
}
|
|
|
|
|
2021-12-10 22:51:54 +00:00
|
|
|
function handleMessageJSON(
|
|
|
|
messages: Array<MessageTypeUnhydrated>
|
|
|
|
): Array<MessageType> {
|
2021-07-12 23:51:45 +00:00
|
|
|
return messages.map(message => JSON.parse(message.json));
|
2019-08-09 23:12:29 +00:00
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
async function getNewerMessagesByConversation(
|
2023-03-04 03:03:15 +00:00
|
|
|
options: AdjacentMessagesByConversationOptionsType
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<Array<MessageType>> {
|
2023-03-04 03:03:15 +00:00
|
|
|
const messages = await channels.getNewerMessagesByConversation(options);
|
2019-05-31 22:42:01 +00:00
|
|
|
|
2021-12-10 22:51:54 +00:00
|
|
|
return handleMessageJSON(messages);
|
2019-05-31 22:42:01 +00:00
|
|
|
}
|
2022-10-22 06:26:16 +00:00
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
async function getOlderMessagesByConversation(
|
2023-03-04 03:03:15 +00:00
|
|
|
options: AdjacentMessagesByConversationOptionsType
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<Array<MessageType>> {
|
2023-03-04 03:03:15 +00:00
|
|
|
const messages = await channels.getOlderMessagesByConversation(options);
|
2018-07-25 22:02:27 +00:00
|
|
|
|
2021-12-10 22:51:54 +00:00
|
|
|
return handleMessageJSON(messages);
|
2018-07-25 22:02:27 +00:00
|
|
|
}
|
2020-04-01 18:59:11 +00:00
|
|
|
|
2023-03-04 03:03:15 +00:00
|
|
|
async function getConversationRangeCenteredOnMessage(
|
|
|
|
options: AdjacentMessagesByConversationOptionsType
|
|
|
|
): Promise<GetConversationRangeCenteredOnMessageResultType<MessageType>> {
|
2021-12-20 21:05:13 +00:00
|
|
|
const result = await channels.getConversationRangeCenteredOnMessage(options);
|
|
|
|
|
|
|
|
return {
|
|
|
|
...result,
|
|
|
|
older: handleMessageJSON(result.older),
|
|
|
|
newer: handleMessageJSON(result.newer),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2018-07-25 22:02:27 +00:00
|
|
|
async function removeAllMessagesInConversation(
|
2020-04-01 18:59:11 +00:00
|
|
|
conversationId: string,
|
2020-07-10 18:28:49 +00:00
|
|
|
{
|
2021-01-13 00:42:15 +00:00
|
|
|
logId,
|
|
|
|
}: {
|
|
|
|
logId: string;
|
|
|
|
}
|
2022-07-28 16:35:29 +00:00
|
|
|
): Promise<void> {
|
2018-07-27 01:13:56 +00:00
|
|
|
let messages;
|
2018-07-25 22:02:27 +00:00
|
|
|
do {
|
2021-01-13 00:42:15 +00:00
|
|
|
const chunkSize = 20;
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(
|
2021-01-13 00:42:15 +00:00
|
|
|
`removeAllMessagesInConversation/${logId}: Fetching chunk of ${chunkSize} messages`
|
|
|
|
);
|
|
|
|
// Yes, we really want the await in the loop. We're deleting a chunk at a
|
2018-07-25 22:02:27 +00:00
|
|
|
// time so we don't use too much memory.
|
2022-11-17 00:29:15 +00:00
|
|
|
// eslint-disable-next-line no-await-in-loop
|
2023-03-04 03:03:15 +00:00
|
|
|
messages = await getOlderMessagesByConversation({
|
|
|
|
conversationId,
|
2021-01-13 00:42:15 +00:00
|
|
|
limit: chunkSize,
|
2022-09-30 00:57:11 +00:00
|
|
|
includeStoryReplies: true,
|
2022-05-11 22:20:47 +00:00
|
|
|
storyId: undefined,
|
2018-07-27 01:13:56 +00:00
|
|
|
});
|
2018-07-25 22:02:27 +00:00
|
|
|
|
2018-07-27 01:13:56 +00:00
|
|
|
if (!messages.length) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-12-10 22:51:54 +00:00
|
|
|
const ids = messages.map(message => message.id);
|
2018-07-25 22:02:27 +00:00
|
|
|
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(`removeAllMessagesInConversation/${logId}: Cleanup...`);
|
2022-11-17 00:29:15 +00:00
|
|
|
// eslint-disable-next-line no-await-in-loop
|
2023-03-20 22:23:53 +00:00
|
|
|
await _cleanupMessages(messages);
|
2018-07-27 01:13:56 +00:00
|
|
|
|
2021-09-17 18:27:53 +00:00
|
|
|
log.info(`removeAllMessagesInConversation/${logId}: Deleting...`);
|
2022-11-17 00:29:15 +00:00
|
|
|
// eslint-disable-next-line no-await-in-loop
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.removeMessages(ids);
|
2018-07-27 01:13:56 +00:00
|
|
|
} while (messages.length > 0);
|
2018-07-25 22:02:27 +00:00
|
|
|
}
|
|
|
|
|
2019-01-30 20:15:07 +00:00
|
|
|
// Attachment downloads
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function saveAttachmentDownloadJob(
|
|
|
|
job: AttachmentDownloadJobType
|
|
|
|
): Promise<void> {
|
2021-03-10 22:25:57 +00:00
|
|
|
await channels.saveAttachmentDownloadJob(_cleanData(job));
|
2019-01-30 20:15:07 +00:00
|
|
|
}
|
2021-12-08 19:52:46 +00:00
|
|
|
|
2018-10-18 01:01:21 +00:00
|
|
|
// Other
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function cleanupOrphanedAttachments(): Promise<void> {
|
2022-11-17 00:29:15 +00:00
|
|
|
try {
|
|
|
|
await invokeWithTimeout(CLEANUP_ORPHANED_ATTACHMENTS_KEY);
|
|
|
|
} catch (error) {
|
|
|
|
log.warn(
|
|
|
|
'sql/Client: cleanupOrphanedAttachments failure',
|
|
|
|
Errors.toLogFormat(error)
|
|
|
|
);
|
|
|
|
}
|
2018-08-08 17:00:33 +00:00
|
|
|
}
|
|
|
|
|
2022-07-28 16:35:29 +00:00
|
|
|
async function ensureFilePermissions(): Promise<void> {
|
2022-11-17 00:29:15 +00:00
|
|
|
await invokeWithTimeout(ENSURE_FILE_PERMISSIONS);
|
2020-02-21 23:40:04 +00:00
|
|
|
}
|
|
|
|
|
2018-07-27 01:13:56 +00:00
|
|
|
// Note: will need to restart the app after calling this, to set up afresh
|
2022-07-28 16:35:29 +00:00
|
|
|
async function removeOtherData(): Promise<void> {
|
2018-07-27 01:13:56 +00:00
|
|
|
await Promise.all([
|
2022-11-17 00:29:15 +00:00
|
|
|
invokeWithTimeout(ERASE_SQL_KEY),
|
|
|
|
invokeWithTimeout(ERASE_ATTACHMENTS_KEY),
|
|
|
|
invokeWithTimeout(ERASE_STICKERS_KEY),
|
|
|
|
invokeWithTimeout(ERASE_TEMP_KEY),
|
|
|
|
invokeWithTimeout(ERASE_DRAFTS_KEY),
|
2018-07-27 01:13:56 +00:00
|
|
|
]);
|
|
|
|
}
|
|
|
|
|
2022-11-17 00:29:15 +00:00
|
|
|
async function invokeWithTimeout(name: string): Promise<void> {
|
2021-09-27 18:22:46 +00:00
|
|
|
return createTaskWithTimeout(
|
2022-11-17 00:29:15 +00:00
|
|
|
() => ipc.invoke(name),
|
2021-09-27 18:22:46 +00:00
|
|
|
`callChannel call to ${name}`
|
|
|
|
)();
|
2018-07-27 01:13:56 +00:00
|
|
|
}
|