signal-desktop/ts/sql/Server.ts

6570 lines
165 KiB
TypeScript
Raw Normal View History

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
/* eslint-disable camelcase */
import { mkdirSync } from 'fs';
import { join } from 'path';
import rimraf from 'rimraf';
import { randomBytes } from 'crypto';
2022-12-14 20:48:36 +00:00
import type { Database, Statement } from '@signalapp/better-sqlite3';
import SQL from '@signalapp/better-sqlite3';
import pProps from 'p-props';
import { v4 as generateUuid } from 'uuid';
2023-08-09 00:53:06 +00:00
import { z } from 'zod';
import type { Dictionary } from 'lodash';
import {
forEach,
fromPairs,
groupBy,
isBoolean,
isNil,
isNumber,
isString,
last,
map,
mapValues,
omit,
2021-05-07 21:50:14 +00:00
pick,
} from 'lodash';
import * as Errors from '../types/errors';
import { ReadStatus } from '../messages/MessageReadStatus';
import type { GroupV2MemberType } from '../model-types.d';
import type { ReactionType } from '../types/Reactions';
import { STORAGE_UI_KEYS } from '../types/StorageUIKeys';
import type { StoryDistributionIdString } from '../types/StoryDistributionId';
import type { ServiceIdString, AciString } from '../types/ServiceId';
import { isServiceIdString } from '../types/ServiceId';
import type { StoredJob } from '../jobs/types';
import { assertDev, assertSync, strictAssert } from '../util/assert';
import { combineNames } from '../util/combineNames';
import { consoleLogger } from '../util/consoleLogger';
2021-07-09 19:36:10 +00:00
import { dropNull } from '../util/dropNull';
import { isNormalNumber } from '../util/isNormalNumber';
2021-04-29 23:02:27 +00:00
import { isNotNil } from '../util/isNotNil';
import { parseIntOrThrow } from '../util/parseIntOrThrow';
import * as durations from '../util/durations';
import { formatCountForLogging } from '../logging/formatCountForLogging';
import type { ConversationColorType, CustomColorType } from '../types/Colors';
2021-11-02 23:01:13 +00:00
import type { BadgeType, BadgeImageType } from '../badges/types';
import { parseBadgeCategory } from '../badges/BadgeCategory';
import { parseBadgeImageTheme } from '../badges/BadgeImageTheme';
import type { LoggerType } from '../types/Logging';
import * as log from '../logging/log';
2023-03-20 22:23:53 +00:00
import type {
EmptyQuery,
ArrayQuery,
Query,
JSONRows,
QueryFragment,
} from './util';
2021-10-26 22:59:08 +00:00
import {
2023-08-09 00:53:06 +00:00
sqlConstant,
2023-03-20 22:23:53 +00:00
sqlJoin,
sqlFragment,
sql,
2021-10-26 22:59:08 +00:00
jsonToObject,
objectToJSON,
batchMultiVarQuery,
getCountFromTable,
removeById,
removeAllFromTable,
getAllFromTable,
getById,
bulkAdd,
createOrUpdate,
setUserVersion,
getUserVersion,
getSchemaVersion,
} from './util';
import { updateSchema } from './migrations';
import type {
2023-03-04 03:03:15 +00:00
AdjacentMessagesByConversationOptionsType,
2022-07-28 16:35:29 +00:00
StoredAllItemsType,
AttachmentDownloadJobType,
ConversationMetricsType,
ConversationType,
2021-08-31 21:35:01 +00:00
DeleteSentProtoRecipientOptionsType,
2022-08-15 21:53:33 +00:00
DeleteSentProtoRecipientResultType,
2023-03-27 23:48:57 +00:00
EditedMessageType,
EmojiType,
2023-10-10 23:55:32 +00:00
FTSOptimizationStateType,
2022-11-28 17:19:48 +00:00
GetAllStoriesResultType,
2022-07-28 16:35:29 +00:00
GetConversationRangeCenteredOnMessageResultType,
GetKnownMessageAttachmentsResultType,
GetRecentStoryRepliesOptionsType,
2022-07-28 16:35:29 +00:00
GetUnreadByConversationAndMarkReadResultType,
IdentityKeyIdType,
2022-07-28 16:35:29 +00:00
StoredIdentityKeyType,
2022-08-03 17:10:49 +00:00
InstalledStickerPackType,
ItemKeyType,
2022-07-28 16:35:29 +00:00
StoredItemType,
ConversationMessageStatsType,
MessageAttachmentsCursorType,
MessageMetricsType,
MessageType,
MessageTypeUnhydrated,
PreKeyIdType,
2022-07-28 16:35:29 +00:00
ReactionResultType,
StoredPreKeyType,
ServerSearchResultMessageType,
SenderKeyIdType,
SenderKeyType,
SentMessageDBType,
SentMessagesType,
SentProtoType,
SentProtoWithMessageIdsType,
SentRecipientsDBType,
SentRecipientsType,
ServerInterface,
SessionIdType,
SessionType,
SignedPreKeyIdType,
2022-07-28 16:35:29 +00:00
StoredSignedPreKeyType,
2022-08-03 17:10:49 +00:00
StickerPackInfoType,
StickerPackStatusType,
StickerPackType,
StickerType,
StoryDistributionMemberType,
StoryDistributionType,
StoryDistributionWithMembersType,
StoryReadType,
2022-08-03 17:10:49 +00:00
UninstalledStickerPackType,
UnprocessedType,
UnprocessedUpdateType,
2023-03-20 22:23:53 +00:00
GetNearbyMessageFromDeletedSetOptionsType,
StoredKyberPreKeyType,
} from './Interface';
import { SeenStatus } from '../MessageSeenStatus';
import {
SNIPPET_LEFT_PLACEHOLDER,
SNIPPET_RIGHT_PLACEHOLDER,
SNIPPET_TRUNCATION_PLACEHOLDER,
} from '../util/search';
2023-08-09 00:53:06 +00:00
import type {
CallHistoryDetails,
CallHistoryFilter,
CallHistoryGroup,
CallHistoryPagination,
} from '../types/CallDisposition';
import {
DirectCallStatus,
callHistoryGroupSchema,
CallHistoryFilterStatus,
callHistoryDetailsSchema,
CallDirection,
2023-08-09 00:53:06 +00:00
} from '../types/CallDisposition';
type ConversationRow = Readonly<{
json: string;
profileLastFetchedAt: null | number;
}>;
type ConversationRows = Array<ConversationRow>;
type StickerRow = Readonly<{
id: number;
packId: string;
emoji: string | null;
height: number;
isCoverOnly: number;
lastUsed: number;
path: string;
width: number;
}>;
// 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: ServerInterface = {
close,
removeDB,
removeIndexedDBFiles,
2018-10-18 01:01:21 +00:00
createOrUpdateIdentityKey,
getIdentityKeyById,
bulkAddIdentityKeys,
removeIdentityKeyById,
removeAllIdentityKeys,
getAllIdentityKeys,
2018-10-18 01:01:21 +00:00
createOrUpdateKyberPreKey,
getKyberPreKeyById,
bulkAddKyberPreKeys,
removeKyberPreKeyById,
removeKyberPreKeysByServiceId,
removeAllKyberPreKeys,
getAllKyberPreKeys,
2018-10-18 01:01:21 +00:00
createOrUpdatePreKey,
getPreKeyById,
bulkAddPreKeys,
removePreKeyById,
removePreKeysByServiceId,
2018-10-18 01:01:21 +00:00
removeAllPreKeys,
getAllPreKeys,
2018-10-18 01:01:21 +00:00
createOrUpdateSignedPreKey,
getSignedPreKeyById,
bulkAddSignedPreKeys,
removeSignedPreKeyById,
removeSignedPreKeysByServiceId,
2018-10-18 01:01:21 +00:00
removeAllSignedPreKeys,
getAllSignedPreKeys,
2018-10-18 01:01:21 +00:00
createOrUpdateItem,
getItemById,
removeItemById,
removeAllItems,
getAllItems,
2018-10-18 01:01:21 +00:00
createOrUpdateSenderKey,
getSenderKeyById,
removeAllSenderKeys,
getAllSenderKeys,
2021-05-25 22:40:04 +00:00
removeSenderKeyById,
insertSentProto,
deleteSentProtosOlderThan,
deleteSentProtoByMessageId,
insertProtoRecipients,
deleteSentProtoRecipient,
getSentProtoByRecipient,
removeAllSentProtos,
getAllSentProtos,
_getAllSentProtoRecipients,
_getAllSentProtoMessageIds,
2018-10-18 01:01:21 +00:00
createOrUpdateSession,
2019-09-26 19:56:31 +00:00
createOrUpdateSessions,
commitDecryptResult,
2018-10-18 01:01:21 +00:00
bulkAddSessions,
removeSessionById,
removeSessionsByConversation,
removeSessionsByServiceId,
2018-10-18 01:01:21 +00:00
removeAllSessions,
getAllSessions,
2018-10-18 01:01:21 +00:00
2018-09-21 01:47:19 +00:00
getConversationCount,
saveConversation,
saveConversations,
getConversationById,
updateConversation,
2019-09-26 19:56:31 +00:00
updateConversations,
2018-09-21 01:47:19 +00:00
removeConversation,
_removeAllConversations,
updateAllConversationColors,
2022-07-08 20:46:25 +00:00
removeAllProfileKeyCredentials,
2018-09-21 01:47:19 +00:00
getAllConversations,
getAllConversationIds,
getAllGroupsInvolvingServiceId,
2019-01-14 21:47:19 +00:00
searchMessages,
2018-09-21 01:47:19 +00:00
getMessageCount,
2022-03-29 01:10:08 +00:00
getStoryCount,
getRecentStoryReplies,
saveMessage,
saveMessages,
removeMessage,
2021-01-13 00:42:15 +00:00
removeMessages,
getUnreadByConversationAndMarkRead,
getUnreadReactionsAndMarkRead,
markReactionAsRead,
addReaction,
removeReactionFromConversation,
_getAllReactions,
_removeAllReactions,
getMessageBySender,
getMessageById,
getMessagesById,
_getAllMessages,
2023-03-27 23:48:57 +00:00
_getAllEditedMessages,
_removeAllMessages,
getAllMessageIds,
getMessagesBySentAt,
2023-03-27 23:48:57 +00:00
getUnreadEditedMessagesAndMarkRead,
getExpiredMessages,
getMessagesUnexpectedlyMissingExpirationStartTimestamp,
2021-06-16 22:20:17 +00:00
getSoonestMessageExpiry,
getNextTapToViewMessageTimestampToAgeOut,
2019-06-26 19:33:13 +00:00
getTapToViewMessagesNeedingErase,
getOlderMessagesByConversation,
getAllStories,
getNewerMessagesByConversation,
getOldestUnreadMentionOfMeForConversation,
getTotalUnreadForConversation,
getTotalUnreadMentionsOfMeForConversation,
getMessageMetricsForConversation,
getConversationRangeCenteredOnMessage,
getConversationMessageStats,
getLastConversationMessage,
2023-08-09 00:53:06 +00:00
getAllCallHistory,
clearCallHistory,
cleanupCallHistoryMessages,
getCallHistoryUnreadCount,
markCallHistoryRead,
markAllCallHistoryRead,
2023-01-10 00:52:01 +00:00
getCallHistoryMessageByCallId,
2023-08-09 00:53:06 +00:00
getCallHistory,
getCallHistoryGroupsCount,
getCallHistoryGroups,
saveCallHistory,
hasGroupCallHistoryMessage,
migrateConversationMessages,
2023-03-20 22:23:53 +00:00
getMessagesBetween,
getNearbyMessageFromDeletedSet,
2023-03-27 23:48:57 +00:00
saveEditedMessage,
getUnprocessedCount,
getUnprocessedByIdsAndIncrementAttempts,
getAllUnprocessedIds,
updateUnprocessedWithData,
2019-09-26 19:56:31 +00:00
updateUnprocessedsWithData,
getUnprocessedById,
removeUnprocessed,
removeAllUnprocessed,
getAttachmentDownloadJobById,
getNextAttachmentDownloadJobs,
saveAttachmentDownloadJob,
resetAttachmentDownloadPending,
setAttachmentDownloadJobPending,
removeAttachmentDownloadJob,
removeAllAttachmentDownloadJobs,
createOrUpdateStickerPack,
updateStickerPackStatus,
2022-08-03 17:10:49 +00:00
updateStickerPackInfo,
createOrUpdateSticker,
updateStickerLastUsed,
addStickerPackReference,
deleteStickerPackReference,
getStickerCount,
deleteStickerPack,
getAllStickerPacks,
2022-08-03 17:10:49 +00:00
addUninstalledStickerPack,
removeUninstalledStickerPack,
getInstalledStickerPacks,
getUninstalledStickerPacks,
installStickerPack,
uninstallStickerPack,
getStickerPackInfo,
getAllStickers,
getRecentStickers,
2021-01-27 22:39:45 +00:00
clearAllErrorStickerPackAttempts,
2019-05-24 23:58:27 +00:00
updateEmojiUsage,
getRecentEmojis,
2021-11-02 23:01:13 +00:00
getAllBadges,
updateOrCreateBadges,
badgeImageFileDownloaded,
_getAllStoryDistributions,
_getAllStoryDistributionMembers,
_deleteAllStoryDistributions,
createNewStoryDistribution,
getAllStoryDistributionsWithMembers,
2022-03-04 21:14:52 +00:00
getStoryDistributionWithMembers,
modifyStoryDistribution,
modifyStoryDistributionMembers,
2022-07-01 00:52:03 +00:00
modifyStoryDistributionWithMembers,
deleteStoryDistribution,
_getAllStoryReads,
_deleteAllStoryReads,
addNewStoryRead,
getLastStoryReadsForAuthor,
2022-03-29 01:10:08 +00:00
countStoryReadsByConversation,
removeAll,
2018-10-18 01:01:21 +00:00
removeAllConfiguration,
eraseStorageServiceState,
getMessagesNeedingUpgrade,
getMessagesWithVisualMediaAttachments,
getMessagesWithFileAttachments,
getMessageServerGuidsForSpam,
2021-04-29 23:02:27 +00:00
getJobsInQueue,
insertJob,
deleteJob,
wasGroupCallRingPreviouslyCanceled,
processGroupCallRingCancellation,
cleanExpiredGroupCallRingCancellations,
2021-08-20 16:06:15 +00:00
2021-09-15 18:45:22 +00:00
getMaxMessageCounter,
getStatisticsForLogging,
2023-10-10 23:55:32 +00:00
optimizeFTS,
// Server-only
initialize,
getKnownMessageAttachments,
finishGetKnownMessageAttachments,
getKnownConversationAttachments,
removeKnownStickers,
2019-08-07 00:40:25 +00:00
removeKnownDraftAttachments,
2021-11-02 23:01:13 +00:00
getAllBadgeImageFileLocalPaths,
runCorruptionChecks,
};
export default dataInterface;
2021-10-26 22:59:08 +00:00
type DatabaseQueryCache = Map<string, Statement<Array<unknown>>>;
const statementCache = new WeakMap<Database, DatabaseQueryCache>();
2022-11-14 19:35:37 +00:00
function prepare<T extends Array<unknown> | Record<string, unknown>>(
db: Database,
query: string,
{ pluck = false }: { pluck?: boolean } = {}
2022-11-14 19:35:37 +00:00
): Statement<T> {
let dbCache = statementCache.get(db);
if (!dbCache) {
dbCache = new Map();
statementCache.set(db, dbCache);
}
const cacheKey = `${pluck}:${query}`;
let result = dbCache.get(cacheKey) as Statement<T>;
if (!result) {
result = db.prepare<T>(query);
if (pluck === true) {
result.pluck();
}
dbCache.set(cacheKey, result);
}
return result;
}
function rowToConversation(row: ConversationRow): ConversationType {
const parsedJson = JSON.parse(row.json);
let profileLastFetchedAt: undefined | number;
if (isNormalNumber(row.profileLastFetchedAt)) {
profileLastFetchedAt = row.profileLastFetchedAt;
} else {
assertDev(
isNil(row.profileLastFetchedAt),
'profileLastFetchedAt contained invalid data; defaulting to undefined'
);
profileLastFetchedAt = undefined;
}
return {
...parsedJson,
profileLastFetchedAt,
};
}
function rowToSticker(row: StickerRow): StickerType {
return {
...row,
isCoverOnly: Boolean(row.isCoverOnly),
2021-07-09 19:36:10 +00:00
emoji: dropNull(row.emoji),
};
2021-10-26 22:59:08 +00:00
}
2021-10-26 22:59:08 +00:00
function keyDatabase(db: Database, key: string): void {
// https://www.zetetic.net/sqlcipher/sqlcipher-api/#key
db.pragma(`key = "x'${key}'"`);
}
2021-10-26 22:59:08 +00:00
function switchToWAL(db: Database): void {
// https://sqlite.org/wal.html
db.pragma('journal_mode = WAL');
db.pragma('synchronous = FULL');
}
2021-10-26 22:59:08 +00:00
function migrateSchemaVersion(db: Database): void {
const userVersion = getUserVersion(db);
if (userVersion > 0) {
return;
}
2021-10-26 22:59:08 +00:00
const schemaVersion = getSchemaVersion(db);
const newUserVersion = schemaVersion > 18 ? 16 : schemaVersion;
logger.info(
'migrateSchemaVersion: Migrating from schema_version ' +
`${schemaVersion} to user_version ${newUserVersion}`
);
2021-10-26 22:59:08 +00:00
setUserVersion(db, newUserVersion);
}
2023-10-03 00:27:02 +00:00
function openAndMigrateDatabase(
filePath: string,
key: string,
readonly: boolean
) {
2021-10-26 22:59:08 +00:00
let db: Database | undefined;
2021-10-26 22:59:08 +00:00
// First, we try to open the database without any cipher changes
try {
2023-10-03 00:27:02 +00:00
db = new SQL(filePath, {
readonly,
});
2021-10-26 22:59:08 +00:00
keyDatabase(db, key);
switchToWAL(db);
migrateSchemaVersion(db);
2021-10-26 22:59:08 +00:00
return db;
} catch (error) {
if (db) {
db.close();
}
2021-10-26 22:59:08 +00:00
logger.info('migrateDatabase: Migration without cipher change failed');
}
2021-10-26 22:59:08 +00:00
// If that fails, we try to open the database with 3.x compatibility to extract the
// user_version (previously stored in schema_version, blown away by cipher_migrate).
db = new SQL(filePath);
keyDatabase(db, key);
2021-10-26 22:59:08 +00:00
// https://www.zetetic.net/blog/2018/11/30/sqlcipher-400-release/#compatability-sqlcipher-4-0-0
db.pragma('cipher_compatibility = 3');
migrateSchemaVersion(db);
db.close();
2021-10-26 22:59:08 +00:00
// After migrating user_version -> schema_version, we reopen database, because we can't
// migrate to the latest ciphers after we've modified the defaults.
db = new SQL(filePath);
keyDatabase(db, key);
2021-10-26 22:59:08 +00:00
db.pragma('cipher_migrate');
switchToWAL(db);
2021-10-26 22:59:08 +00:00
return db;
}
2021-10-26 22:59:08 +00:00
const INVALID_KEY = /[^0-9A-Fa-f]/;
2023-10-03 00:27:02 +00:00
function openAndSetUpSQLCipher(
filePath: string,
{ key, readonly }: { key: string; readonly: boolean }
) {
2021-10-26 22:59:08 +00:00
const match = INVALID_KEY.exec(key);
if (match) {
throw new Error(`setupSQLCipher: key '${key}' is not valid`);
}
2023-10-03 00:27:02 +00:00
const db = openAndMigrateDatabase(filePath, key, readonly);
2021-10-26 22:59:08 +00:00
// Because foreign key support is not enabled by default!
db.pragma('foreign_keys = ON');
2021-10-26 22:59:08 +00:00
return db;
}
2023-10-03 00:27:02 +00:00
let globalWritableInstance: Database | undefined;
let globalReadonlyInstance: Database | undefined;
let logger = consoleLogger;
let databaseFilePath: string | undefined;
let indexedDBPath: string | undefined;
2023-01-18 22:12:33 +00:00
SQL.setLogHandler((code, value) => {
logger.warn(`Database log code=${code}: ${value}`);
});
async function initialize({
configDir,
key,
logger: suppliedLogger,
}: {
2023-10-10 23:55:32 +00:00
appVersion: string;
configDir: string;
key: string;
logger: LoggerType;
2021-10-26 22:59:08 +00:00
}): Promise<void> {
2023-10-03 00:27:02 +00:00
if (globalWritableInstance || globalReadonlyInstance) {
throw new Error('Cannot initialize more than once!');
}
if (!isString(configDir)) {
throw new Error('initialize: configDir is required!');
}
if (!isString(key)) {
throw new Error('initialize: key is required!');
}
logger = suppliedLogger;
indexedDBPath = join(configDir, 'IndexedDB');
const dbDir = join(configDir, 'sql');
mkdirSync(dbDir, { recursive: true });
databaseFilePath = join(dbDir, 'db.sqlite');
2023-10-03 00:27:02 +00:00
let writable: Database | undefined;
let readonly: Database | undefined;
2019-08-19 22:26:45 +00:00
try {
2023-10-03 00:27:02 +00:00
writable = openAndSetUpSQLCipher(databaseFilePath, {
key,
readonly: false,
});
// For profiling use:
// db.pragma('cipher_profile=\'sqlcipher.log\'');
updateSchema(writable, logger);
2023-10-03 00:27:02 +00:00
readonly = openAndSetUpSQLCipher(databaseFilePath, { key, readonly: true });
2019-08-19 22:26:45 +00:00
// At this point we can allow general access to the database
2023-10-03 00:27:02 +00:00
globalWritableInstance = writable;
globalReadonlyInstance = readonly;
2019-08-19 22:26:45 +00:00
// test database
2021-10-26 22:59:08 +00:00
getMessageCountSync();
} catch (error) {
logger.error('Database startup error:', error.stack);
2023-10-03 00:27:02 +00:00
readonly?.close();
writable?.close();
2021-03-04 21:44:57 +00:00
throw error;
}
}
async function close(): Promise<void> {
2023-05-04 17:59:02 +00:00
// SQLLite documentation suggests that we run `PRAGMA optimize` right
// before closing the database connection.
2023-10-03 00:27:02 +00:00
globalWritableInstance?.pragma('optimize');
2021-04-06 17:29:22 +00:00
2023-10-03 00:27:02 +00:00
globalWritableInstance?.close();
globalWritableInstance = undefined;
globalReadonlyInstance?.close();
globalReadonlyInstance = undefined;
}
async function removeDB(): Promise<void> {
2023-10-03 00:27:02 +00:00
if (globalWritableInstance) {
try {
2023-10-03 00:27:02 +00:00
globalWritableInstance.close();
} catch (error) {
logger.error('removeDB: Failed to close database:', error.stack);
}
2023-10-03 00:27:02 +00:00
globalWritableInstance = undefined;
}
if (globalReadonlyInstance) {
try {
globalReadonlyInstance.close();
} catch (error) {
logger.error('removeDB: Failed to close readonly database:', error.stack);
}
globalReadonlyInstance = undefined;
}
if (!databaseFilePath) {
throw new Error(
'removeDB: Cannot erase database without a databaseFilePath!'
);
}
logger.warn('removeDB: Removing all database files');
rimraf.sync(databaseFilePath);
rimraf.sync(`${databaseFilePath}-shm`);
rimraf.sync(`${databaseFilePath}-wal`);
}
async function removeIndexedDBFiles(): Promise<void> {
if (!indexedDBPath) {
throw new Error(
'removeIndexedDBFiles: Need to initialize and set indexedDBPath first!'
);
}
const pattern = join(indexedDBPath, '*.leveldb');
rimraf.sync(pattern);
indexedDBPath = undefined;
}
2023-10-03 00:27:02 +00:00
function getReadonlyInstance(): Database {
if (!globalReadonlyInstance) {
throw new Error('getReadonlyInstance: globalReadonlyInstance not set!');
}
return globalReadonlyInstance;
}
async function getWritableInstance(): Promise<Database> {
if (!globalWritableInstance) {
throw new Error('getWritableInstance: globalWritableInstance not set!');
}
2023-10-03 00:27:02 +00:00
return globalWritableInstance;
}
// This is okay to use for queries that:
//
// - Don't modify persistent tables, but create and do work in temporary
// tables
// - Integrity checks
//
function getUnsafeWritableInstance(
reason: 'only temp table use' | 'integrity check'
): Database {
// Not actually used
void reason;
if (!globalWritableInstance) {
throw new Error(
'getUnsafeWritableInstance: globalWritableInstance not set!'
);
}
return globalWritableInstance;
}
2018-10-18 01:01:21 +00:00
const IDENTITY_KEYS_TABLE = 'identityKeys';
2022-07-28 16:35:29 +00:00
async function createOrUpdateIdentityKey(
data: StoredIdentityKeyType
): Promise<void> {
2023-10-03 00:27:02 +00:00
return createOrUpdate(await getWritableInstance(), IDENTITY_KEYS_TABLE, data);
2018-10-18 01:01:21 +00:00
}
async function getIdentityKeyById(
id: IdentityKeyIdType
2022-07-28 16:35:29 +00:00
): Promise<StoredIdentityKeyType | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), IDENTITY_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
2021-10-26 22:59:08 +00:00
async function bulkAddIdentityKeys(
2022-07-28 16:35:29 +00:00
array: Array<StoredIdentityKeyType>
2021-10-26 22:59:08 +00:00
): Promise<void> {
2023-10-03 00:27:02 +00:00
return bulkAdd(await getWritableInstance(), IDENTITY_KEYS_TABLE, array);
2018-10-18 01:01:21 +00:00
}
async function removeIdentityKeyById(id: IdentityKeyIdType): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), IDENTITY_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
async function removeAllIdentityKeys(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), IDENTITY_KEYS_TABLE);
2018-10-18 01:01:21 +00:00
}
2022-07-28 16:35:29 +00:00
async function getAllIdentityKeys(): Promise<Array<StoredIdentityKeyType>> {
2023-10-03 00:27:02 +00:00
return getAllFromTable(getReadonlyInstance(), IDENTITY_KEYS_TABLE);
}
2018-10-18 01:01:21 +00:00
const KYBER_PRE_KEYS_TABLE = 'kyberPreKeys';
async function createOrUpdateKyberPreKey(
data: StoredKyberPreKeyType
): Promise<void> {
2023-10-03 00:27:02 +00:00
return createOrUpdate(
await getWritableInstance(),
KYBER_PRE_KEYS_TABLE,
data
);
}
async function getKyberPreKeyById(
id: PreKeyIdType
): Promise<StoredKyberPreKeyType | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), KYBER_PRE_KEYS_TABLE, id);
}
async function bulkAddKyberPreKeys(
array: Array<StoredKyberPreKeyType>
): Promise<void> {
2023-10-03 00:27:02 +00:00
return bulkAdd(await getWritableInstance(), KYBER_PRE_KEYS_TABLE, array);
}
async function removeKyberPreKeyById(
id: PreKeyIdType | Array<PreKeyIdType>
): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), KYBER_PRE_KEYS_TABLE, id);
}
async function removeKyberPreKeysByServiceId(
serviceId: ServiceIdString
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-08-16 20:54:39 +00:00
db.prepare<Query>(
'DELETE FROM kyberPreKeys WHERE ourServiceId IS $serviceId;'
).run({
serviceId,
});
}
async function removeAllKyberPreKeys(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), KYBER_PRE_KEYS_TABLE);
}
async function getAllKyberPreKeys(): Promise<Array<StoredKyberPreKeyType>> {
2023-10-03 00:27:02 +00:00
return getAllFromTable(getReadonlyInstance(), KYBER_PRE_KEYS_TABLE);
}
2018-10-18 01:01:21 +00:00
const PRE_KEYS_TABLE = 'preKeys';
2022-07-28 16:35:29 +00:00
async function createOrUpdatePreKey(data: StoredPreKeyType): Promise<void> {
2023-10-03 00:27:02 +00:00
return createOrUpdate(await getWritableInstance(), PRE_KEYS_TABLE, data);
2018-10-18 01:01:21 +00:00
}
async function getPreKeyById(
id: PreKeyIdType
2022-07-28 16:35:29 +00:00
): Promise<StoredPreKeyType | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), PRE_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
2022-07-28 16:35:29 +00:00
async function bulkAddPreKeys(array: Array<StoredPreKeyType>): Promise<void> {
2023-10-03 00:27:02 +00:00
return bulkAdd(await getWritableInstance(), PRE_KEYS_TABLE, array);
2018-10-18 01:01:21 +00:00
}
async function removePreKeyById(
id: PreKeyIdType | Array<PreKeyIdType>
): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), PRE_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
async function removePreKeysByServiceId(
serviceId: ServiceIdString
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-08-16 20:54:39 +00:00
db.prepare<Query>(
'DELETE FROM preKeys WHERE ourServiceId IS $serviceId;'
).run({
serviceId,
2022-07-28 16:35:29 +00:00
});
}
async function removeAllPreKeys(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), PRE_KEYS_TABLE);
2018-10-18 01:01:21 +00:00
}
2022-07-28 16:35:29 +00:00
async function getAllPreKeys(): Promise<Array<StoredPreKeyType>> {
2023-10-03 00:27:02 +00:00
return getAllFromTable(getReadonlyInstance(), PRE_KEYS_TABLE);
}
2018-10-18 01:01:21 +00:00
const SIGNED_PRE_KEYS_TABLE = 'signedPreKeys';
2021-10-26 22:59:08 +00:00
async function createOrUpdateSignedPreKey(
2022-07-28 16:35:29 +00:00
data: StoredSignedPreKeyType
2021-10-26 22:59:08 +00:00
): Promise<void> {
2023-10-03 00:27:02 +00:00
return createOrUpdate(
await getWritableInstance(),
SIGNED_PRE_KEYS_TABLE,
data
);
2018-10-18 01:01:21 +00:00
}
async function getSignedPreKeyById(
id: SignedPreKeyIdType
2022-07-28 16:35:29 +00:00
): Promise<StoredSignedPreKeyType | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), SIGNED_PRE_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
2021-10-26 22:59:08 +00:00
async function bulkAddSignedPreKeys(
2022-07-28 16:35:29 +00:00
array: Array<StoredSignedPreKeyType>
2021-10-26 22:59:08 +00:00
): Promise<void> {
2023-10-03 00:27:02 +00:00
return bulkAdd(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE, array);
2018-10-18 01:01:21 +00:00
}
async function removeSignedPreKeyById(
id: SignedPreKeyIdType | Array<SignedPreKeyIdType>
): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
async function removeSignedPreKeysByServiceId(
serviceId: ServiceIdString
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-08-16 20:54:39 +00:00
db.prepare<Query>(
'DELETE FROM signedPreKeys WHERE ourServiceId IS $serviceId;'
).run({
serviceId,
2022-07-28 16:35:29 +00:00
});
}
async function removeAllSignedPreKeys(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE);
2018-10-18 01:01:21 +00:00
}
2022-07-28 16:35:29 +00:00
async function getAllSignedPreKeys(): Promise<Array<StoredSignedPreKeyType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<EmptyQuery>(
`
SELECT json
FROM signedPreKeys
ORDER BY id ASC;
`
)
.all();
return rows.map(row => jsonToObject(row.json));
}
2018-10-18 01:01:21 +00:00
const ITEMS_TABLE = 'items';
2021-10-26 22:59:08 +00:00
async function createOrUpdateItem<K extends ItemKeyType>(
2022-07-28 16:35:29 +00:00
data: StoredItemType<K>
): Promise<void> {
2023-10-03 00:27:02 +00:00
return createOrUpdate(await getWritableInstance(), ITEMS_TABLE, data);
2018-10-18 01:01:21 +00:00
}
async function getItemById<K extends ItemKeyType>(
id: K
2022-07-28 16:35:29 +00:00
): Promise<StoredItemType<K> | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), ITEMS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
2022-07-28 16:35:29 +00:00
async function getAllItems(): Promise<StoredAllItemsType> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<EmptyQuery>('SELECT json FROM items ORDER BY id ASC;')
.all();
2021-10-26 22:59:08 +00:00
type RawItemType = { id: ItemKeyType; value: unknown };
const items = rows.map(row => jsonToObject<RawItemType>(row.json));
2021-10-26 22:59:08 +00:00
const result: Record<ItemKeyType, unknown> = Object.create(null);
for (const { id, value } of items) {
2021-10-26 22:59:08 +00:00
result[id] = value;
}
2022-07-28 16:35:29 +00:00
return result as unknown as StoredAllItemsType;
2018-10-18 01:01:21 +00:00
}
async function removeItemById(
id: ItemKeyType | Array<ItemKeyType>
): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), ITEMS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
async function removeAllItems(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), ITEMS_TABLE);
2018-10-18 01:01:21 +00:00
}
async function createOrUpdateSenderKey(key: SenderKeyType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
createOrUpdateSenderKeySync(db, key);
}
2023-10-03 00:27:02 +00:00
function createOrUpdateSenderKeySync(db: Database, key: SenderKeyType): void {
prepare(
db,
`
INSERT OR REPLACE INTO senderKeys (
id,
senderId,
distributionId,
data,
lastUpdatedDate
) values (
$id,
$senderId,
$distributionId,
$data,
$lastUpdatedDate
)
`
).run(key);
}
async function getSenderKeyById(
id: SenderKeyIdType
): Promise<SenderKeyType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = prepare(db, 'SELECT * FROM senderKeys WHERE id = $id').get({
id,
});
return row;
}
async function removeAllSenderKeys(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
prepare<EmptyQuery>(db, 'DELETE FROM senderKeys').run();
}
async function getAllSenderKeys(): Promise<Array<SenderKeyType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = prepare<EmptyQuery>(db, 'SELECT * FROM senderKeys').all();
return rows;
}
async function removeSenderKeyById(id: SenderKeyIdType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-05-25 22:40:04 +00:00
prepare(db, 'DELETE FROM senderKeys WHERE id = $id').run({ id });
}
async function insertSentProto(
proto: SentProtoType,
options: {
recipients: SentRecipientsType;
messageIds: SentMessagesType;
}
): Promise<number> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const { recipients, messageIds } = options;
// Note: we use `pluck` in this function to fetch only the first column of returned row.
return db.transaction(() => {
// 1. Insert the payload, fetching its primary key id
const info = prepare(
db,
`
INSERT INTO sendLogPayloads (
contentHint,
proto,
timestamp,
2022-08-15 21:53:33 +00:00
urgent,
hasPniSignatureMessage
) VALUES (
$contentHint,
$proto,
$timestamp,
2022-08-15 21:53:33 +00:00
$urgent,
$hasPniSignatureMessage
);
`
).run({
...proto,
urgent: proto.urgent ? 1 : 0,
2022-08-15 21:53:33 +00:00
hasPniSignatureMessage: proto.hasPniSignatureMessage ? 1 : 0,
});
const id = parseIntOrThrow(
info.lastInsertRowid,
'insertSentProto/lastInsertRowid'
);
// 2. Insert a record for each recipient device.
const recipientStatement = prepare(
db,
`
INSERT INTO sendLogRecipients (
payloadId,
2023-08-16 20:54:39 +00:00
recipientServiceId,
deviceId
) VALUES (
$id,
2023-08-16 20:54:39 +00:00
$recipientServiceId,
$deviceId
);
`
);
const recipientServiceIds = Object.keys(recipients);
for (const recipientServiceId of recipientServiceIds) {
strictAssert(
isServiceIdString(recipientServiceId),
'Recipient must be a service id'
);
const deviceIds = recipients[recipientServiceId];
for (const deviceId of deviceIds) {
recipientStatement.run({
id,
2023-08-16 20:54:39 +00:00
recipientServiceId,
deviceId,
});
}
}
// 2. Insert a record for each message referenced by this payload.
const messageStatement = prepare(
db,
`
INSERT INTO sendLogMessageIds (
payloadId,
messageId
) VALUES (
$id,
$messageId
);
`
);
for (const messageId of new Set(messageIds)) {
messageStatement.run({
id,
messageId,
});
}
return id;
})();
}
async function deleteSentProtosOlderThan(timestamp: number): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
prepare(
db,
`
DELETE FROM sendLogPayloads
WHERE
timestamp IS NULL OR
timestamp < $timestamp;
`
).run({
timestamp,
});
}
async function deleteSentProtoByMessageId(messageId: string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
prepare(
db,
`
DELETE FROM sendLogPayloads WHERE id IN (
SELECT payloadId FROM sendLogMessageIds
WHERE messageId = $messageId
);
`
).run({
messageId,
});
}
async function insertProtoRecipients({
id,
recipientServiceId,
deviceIds,
}: {
id: number;
recipientServiceId: ServiceIdString;
deviceIds: Array<number>;
}): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.transaction(() => {
const statement = prepare(
db,
`
INSERT INTO sendLogRecipients (
payloadId,
2023-08-16 20:54:39 +00:00
recipientServiceId,
deviceId
) VALUES (
$id,
2023-08-16 20:54:39 +00:00
$recipientServiceId,
$deviceId
);
`
);
for (const deviceId of deviceIds) {
statement.run({
id,
2023-08-16 20:54:39 +00:00
recipientServiceId,
deviceId,
});
}
})();
}
2021-08-31 21:35:01 +00:00
async function deleteSentProtoRecipient(
options:
| DeleteSentProtoRecipientOptionsType
| ReadonlyArray<DeleteSentProtoRecipientOptionsType>
2022-08-15 21:53:33 +00:00
): Promise<DeleteSentProtoRecipientResultType> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-08-31 21:35:01 +00:00
const items = Array.isArray(options) ? options : [options];
// Note: we use `pluck` in this function to fetch only the first column of
// returned row.
2022-08-15 21:53:33 +00:00
return db.transaction(() => {
2023-08-16 20:54:39 +00:00
const successfulPhoneNumberShares = new Array<ServiceIdString>();
2022-08-15 21:53:33 +00:00
2021-08-31 21:35:01 +00:00
for (const item of items) {
const { timestamp, recipientServiceId, deviceId } = item;
2021-08-31 21:35:01 +00:00
// 1. Figure out what payload we're talking about.
const rows = prepare(
db,
`
2022-08-15 21:53:33 +00:00
SELECT sendLogPayloads.id, sendLogPayloads.hasPniSignatureMessage
FROM sendLogPayloads
2021-08-31 21:35:01 +00:00
INNER JOIN sendLogRecipients
ON sendLogRecipients.payloadId = sendLogPayloads.id
WHERE
sendLogPayloads.timestamp = $timestamp AND
2023-08-16 20:54:39 +00:00
sendLogRecipients.recipientServiceId = $recipientServiceId AND
2021-08-31 21:35:01 +00:00
sendLogRecipients.deviceId = $deviceId;
`
2023-08-16 20:54:39 +00:00
).all({ timestamp, recipientServiceId, deviceId });
2021-08-31 21:35:01 +00:00
if (!rows.length) {
continue;
}
if (rows.length > 1) {
logger.warn(
2021-08-31 21:35:01 +00:00
'deleteSentProtoRecipient: More than one payload matches ' +
`recipient and timestamp ${timestamp}. Using the first.`
);
}
2022-08-15 21:53:33 +00:00
const { id, hasPniSignatureMessage } = rows[0];
2021-08-31 21:35:01 +00:00
// 2. Delete the recipient/device combination in question.
prepare(
db,
`
DELETE FROM sendLogRecipients
WHERE
payloadId = $id AND
2023-08-16 20:54:39 +00:00
recipientServiceId = $recipientServiceId AND
2021-08-31 21:35:01 +00:00
deviceId = $deviceId;
`
2023-08-16 20:54:39 +00:00
).run({ id, recipientServiceId, deviceId });
2021-08-31 21:35:01 +00:00
// 3. See how many more recipient devices there were for this payload.
2022-08-15 21:53:33 +00:00
const remainingDevices = prepare(
db,
`
2023-01-17 21:07:21 +00:00
SELECT count(1) FROM sendLogRecipients
2023-08-16 20:54:39 +00:00
WHERE payloadId = $id AND recipientServiceId = $recipientServiceId;
`,
{ pluck: true }
2023-08-16 20:54:39 +00:00
).get({ id, recipientServiceId });
2022-08-15 21:53:33 +00:00
// 4. If there are no remaining devices for this recipient and we included
// the pni signature in the proto - return the recipient to the caller.
if (remainingDevices === 0 && hasPniSignatureMessage) {
logger.info(
'deleteSentProtoRecipient: ' +
`Successfully shared phone number with ${recipientServiceId} ` +
2022-08-15 21:53:33 +00:00
`through message ${timestamp}`
);
successfulPhoneNumberShares.push(recipientServiceId);
2022-08-15 21:53:33 +00:00
}
strictAssert(
isNumber(remainingDevices),
'deleteSentProtoRecipient: select count() returned non-number!'
);
// 5. See how many more recipients there were for this payload.
const remainingTotal = prepare(
2021-08-31 21:35:01 +00:00
db,
'SELECT count(1) FROM sendLogRecipients WHERE payloadId = $id;',
{ pluck: true }
).get({ id });
2022-08-15 21:53:33 +00:00
strictAssert(
isNumber(remainingTotal),
'deleteSentProtoRecipient: select count() returned non-number!'
);
2022-08-15 21:53:33 +00:00
if (remainingTotal > 0) {
2021-08-31 21:35:01 +00:00
continue;
}
2022-08-15 21:53:33 +00:00
// 6. Delete the entire payload if there are no more recipients left.
logger.info(
2021-08-31 21:35:01 +00:00
'deleteSentProtoRecipient: ' +
`Deleting proto payload for timestamp ${timestamp}`
);
2022-08-15 21:53:33 +00:00
2021-08-31 21:35:01 +00:00
prepare(db, 'DELETE FROM sendLogPayloads WHERE id = $id;').run({
id,
});
}
2022-08-15 21:53:33 +00:00
return { successfulPhoneNumberShares };
})();
}
async function getSentProtoByRecipient({
now,
recipientServiceId,
timestamp,
}: {
now: number;
recipientServiceId: ServiceIdString;
timestamp: number;
}): Promise<SentProtoWithMessageIdsType | undefined> {
const HOUR = 1000 * 60 * 60;
const oneDayAgo = now - HOUR * 24;
await deleteSentProtosOlderThan(oneDayAgo);
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = prepare(
db,
`
SELECT
sendLogPayloads.*,
GROUP_CONCAT(DISTINCT sendLogMessageIds.messageId) AS messageIds
FROM sendLogPayloads
INNER JOIN sendLogRecipients ON sendLogRecipients.payloadId = sendLogPayloads.id
LEFT JOIN sendLogMessageIds ON sendLogMessageIds.payloadId = sendLogPayloads.id
WHERE
sendLogPayloads.timestamp = $timestamp AND
2023-08-16 20:54:39 +00:00
sendLogRecipients.recipientServiceId = $recipientServiceId
GROUP BY sendLogPayloads.id;
`
).get({
timestamp,
2023-08-16 20:54:39 +00:00
recipientServiceId,
});
if (!row) {
return undefined;
}
const { messageIds } = row;
return {
...row,
urgent: isNumber(row.urgent) ? Boolean(row.urgent) : true,
2022-08-15 21:53:33 +00:00
hasPniSignatureMessage: isNumber(row.hasPniSignatureMessage)
? Boolean(row.hasPniSignatureMessage)
: true,
messageIds: messageIds ? messageIds.split(',') : [],
};
}
async function removeAllSentProtos(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
prepare<EmptyQuery>(db, 'DELETE FROM sendLogPayloads;').run();
}
async function getAllSentProtos(): Promise<Array<SentProtoType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = prepare<EmptyQuery>(db, 'SELECT * FROM sendLogPayloads;').all();
return rows.map(row => ({
...row,
urgent: isNumber(row.urgent) ? Boolean(row.urgent) : true,
2022-08-15 21:53:33 +00:00
hasPniSignatureMessage: isNumber(row.hasPniSignatureMessage)
? Boolean(row.hasPniSignatureMessage)
: true,
}));
}
async function _getAllSentProtoRecipients(): Promise<
Array<SentRecipientsDBType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = prepare<EmptyQuery>(
db,
'SELECT * FROM sendLogRecipients;'
).all();
return rows;
}
async function _getAllSentProtoMessageIds(): Promise<Array<SentMessageDBType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = prepare<EmptyQuery>(
db,
'SELECT * FROM sendLogMessageIds;'
).all();
return rows;
}
2018-10-18 01:01:21 +00:00
const SESSIONS_TABLE = 'sessions';
2023-10-03 00:27:02 +00:00
function createOrUpdateSessionSync(db: Database, data: SessionType): void {
2023-08-16 20:54:39 +00:00
const { id, conversationId, ourServiceId, serviceId } = data;
2018-10-18 01:01:21 +00:00
if (!id) {
throw new Error(
'createOrUpdateSession: Provided data did not have a truthy id'
);
}
if (!conversationId) {
2018-10-18 01:01:21 +00:00
throw new Error(
'createOrUpdateSession: Provided data did not have a truthy conversationId'
2018-10-18 01:01:21 +00:00
);
}
prepare(
db,
`
INSERT OR REPLACE INTO sessions (
2018-10-18 01:01:21 +00:00
id,
conversationId,
2023-08-16 20:54:39 +00:00
ourServiceId,
serviceId,
2018-10-18 01:01:21 +00:00
json
) values (
$id,
$conversationId,
2023-08-16 20:54:39 +00:00
$ourServiceId,
$serviceId,
2018-10-18 01:01:21 +00:00
$json
)
`
).run({
id,
conversationId,
2023-08-16 20:54:39 +00:00
ourServiceId,
serviceId,
json: objectToJSON(data),
});
2018-10-18 01:01:21 +00:00
}
async function createOrUpdateSession(data: SessionType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return createOrUpdateSessionSync(db, data);
}
async function createOrUpdateSessions(
array: Array<SessionType>
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2019-09-26 19:56:31 +00:00
db.transaction(() => {
for (const item of array) {
2023-10-03 00:27:02 +00:00
assertSync(createOrUpdateSessionSync(db, item));
}
})();
2019-09-26 19:56:31 +00:00
}
async function commitDecryptResult({
senderKeys,
sessions,
unprocessed,
}: {
senderKeys: Array<SenderKeyType>;
sessions: Array<SessionType>;
unprocessed: Array<UnprocessedType>;
}): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.transaction(() => {
for (const item of senderKeys) {
2023-10-03 00:27:02 +00:00
assertSync(createOrUpdateSenderKeySync(db, item));
}
for (const item of sessions) {
2023-10-03 00:27:02 +00:00
assertSync(createOrUpdateSessionSync(db, item));
}
for (const item of unprocessed) {
2023-10-03 00:27:02 +00:00
assertSync(saveUnprocessedSync(db, item));
}
})();
}
2021-10-26 22:59:08 +00:00
async function bulkAddSessions(array: Array<SessionType>): Promise<void> {
2023-10-03 00:27:02 +00:00
return bulkAdd(await getWritableInstance(), SESSIONS_TABLE, array);
2018-10-18 01:01:21 +00:00
}
async function removeSessionById(id: SessionIdType): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeById(await getWritableInstance(), SESSIONS_TABLE, id);
2018-10-18 01:01:21 +00:00
}
async function removeSessionsByConversation(
conversationId: string
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>(
`
DELETE FROM sessions
WHERE conversationId = $conversationId;
`
).run({
conversationId,
2018-10-18 01:01:21 +00:00
});
}
async function removeSessionsByServiceId(
serviceId: ServiceIdString
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>(
`
DELETE FROM sessions
2023-08-16 20:54:39 +00:00
WHERE serviceId = $serviceId;
`
).run({
2023-08-16 20:54:39 +00:00
serviceId,
});
}
async function removeAllSessions(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(await getWritableInstance(), SESSIONS_TABLE);
}
2021-10-26 22:59:08 +00:00
async function getAllSessions(): Promise<Array<SessionType>> {
2023-10-03 00:27:02 +00:00
return getAllFromTable(getReadonlyInstance(), SESSIONS_TABLE);
2018-10-18 01:01:21 +00:00
}
2021-10-26 22:59:08 +00:00
// Conversations
2018-10-18 01:01:21 +00:00
2021-10-26 22:59:08 +00:00
async function getConversationCount(): Promise<number> {
2023-10-03 00:27:02 +00:00
return getCountFromTable(getReadonlyInstance(), 'conversations');
2018-10-18 01:01:21 +00:00
}
2021-10-26 22:59:08 +00:00
function getConversationMembersList({ members, membersV2 }: ConversationType) {
if (membersV2) {
2023-08-16 20:54:39 +00:00
return membersV2.map((item: GroupV2MemberType) => item.aci).join(' ');
2018-10-18 01:01:21 +00:00
}
2021-10-26 22:59:08 +00:00
if (members) {
return members.join(' ');
2018-09-21 01:47:19 +00:00
}
2021-10-26 22:59:08 +00:00
return null;
2018-09-21 01:47:19 +00:00
}
2023-10-03 00:27:02 +00:00
function saveConversationSync(db: Database, data: ConversationType): void {
const {
active_at,
e164,
groupId,
id,
name,
profileFamilyName,
profileName,
profileLastFetchedAt,
type,
2023-08-16 20:54:39 +00:00
serviceId,
} = data;
2018-09-21 01:47:19 +00:00
2021-10-26 22:59:08 +00:00
const membersList = getConversationMembersList(data);
2020-09-09 02:25:05 +00:00
db.prepare<Query>(
`
INSERT INTO conversations (
id,
json,
e164,
2023-08-16 20:54:39 +00:00
serviceId,
groupId,
active_at,
type,
members,
name,
profileName,
profileFamilyName,
profileFullName,
profileLastFetchedAt
) values (
$id,
$json,
$e164,
2023-08-16 20:54:39 +00:00
$serviceId,
$groupId,
$active_at,
$type,
$members,
$name,
$profileName,
$profileFamilyName,
$profileFullName,
$profileLastFetchedAt
);
`
).run({
2018-09-21 01:47:19 +00:00
id,
json: objectToJSON(
omit(data, ['profileLastFetchedAt', 'unblurredAvatarPath'])
),
2018-09-21 01:47:19 +00:00
e164: e164 || null,
2023-08-16 20:54:39 +00:00
serviceId: serviceId || null,
groupId: groupId || null,
active_at: active_at || null,
2018-09-21 01:47:19 +00:00
type,
members: membersList,
name: name || null,
profileName: profileName || null,
profileFamilyName: profileFamilyName || null,
profileFullName: combineNames(profileName, profileFamilyName) || null,
profileLastFetchedAt: profileLastFetchedAt || null,
});
2018-09-21 01:47:19 +00:00
}
2023-10-03 00:27:02 +00:00
async function saveConversation(data: ConversationType): Promise<void> {
const db = await getWritableInstance();
return saveConversationSync(db, data);
}
async function saveConversations(
arrayOfConversations: Array<ConversationType>
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2018-09-21 01:47:19 +00:00
db.transaction(() => {
for (const conversation of arrayOfConversations) {
2023-10-03 00:27:02 +00:00
assertSync(saveConversationSync(db, conversation));
}
})();
2018-09-21 01:47:19 +00:00
}
2023-10-03 00:27:02 +00:00
function updateConversationSync(db: Database, data: ConversationType): void {
const {
id,
active_at,
type,
name,
profileName,
profileFamilyName,
profileLastFetchedAt,
e164,
2023-08-16 20:54:39 +00:00
serviceId,
} = data;
2018-09-21 01:47:19 +00:00
2021-10-26 22:59:08 +00:00
const membersList = getConversationMembersList(data);
2020-09-09 02:25:05 +00:00
db.prepare(
`
UPDATE conversations SET
json = $json,
e164 = $e164,
2023-08-16 20:54:39 +00:00
serviceId = $serviceId,
active_at = $active_at,
type = $type,
members = $members,
name = $name,
profileName = $profileName,
profileFamilyName = $profileFamilyName,
profileFullName = $profileFullName,
profileLastFetchedAt = $profileLastFetchedAt
WHERE id = $id;
`
).run({
id,
json: objectToJSON(
omit(data, ['profileLastFetchedAt', 'unblurredAvatarPath'])
),
e164: e164 || null,
2023-08-16 20:54:39 +00:00
serviceId: serviceId || null,
active_at: active_at || null,
type,
members: membersList,
name: name || null,
profileName: profileName || null,
profileFamilyName: profileFamilyName || null,
profileFullName: combineNames(profileName, profileFamilyName) || null,
profileLastFetchedAt: profileLastFetchedAt || null,
});
2018-09-21 01:47:19 +00:00
}
2021-03-04 21:44:57 +00:00
async function updateConversation(data: ConversationType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return updateConversationSync(db, data);
}
async function updateConversations(
array: Array<ConversationType>
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2019-09-26 19:56:31 +00:00
db.transaction(() => {
for (const item of array) {
2023-10-03 00:27:02 +00:00
assertSync(updateConversationSync(db, item));
}
})();
2019-09-26 19:56:31 +00:00
}
2018-09-21 01:47:19 +00:00
2023-10-03 00:27:02 +00:00
function removeConversationsSync(
db: Database,
ids: ReadonlyArray<string>
): void {
// Our node interface doesn't seem to allow you to replace one single ? with an array
db.prepare<ArrayQuery>(
`
DELETE FROM conversations
WHERE id IN ( ${ids.map(() => '?').join(', ')} );
`
).run(ids);
}
async function removeConversation(id: Array<string> | string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-10-26 22:59:08 +00:00
2018-09-21 01:47:19 +00:00
if (!Array.isArray(id)) {
db.prepare<Query>('DELETE FROM conversations WHERE id = $id;').run({
id,
});
2018-09-21 01:47:19 +00:00
return;
}
if (!id.length) {
throw new Error('removeConversation: No ids to delete!');
}
2023-10-03 00:27:02 +00:00
batchMultiVarQuery(db, id, ids => removeConversationsSync(db, ids));
2018-09-21 01:47:19 +00:00
}
async function _removeAllConversations(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>('DELETE from conversations;').run();
}
async function getConversationById(
id: string
): Promise<ConversationType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row: { json: string } = db
.prepare<Query>('SELECT json FROM conversations WHERE id = $id;')
.get({ id });
2018-09-21 01:47:19 +00:00
if (!row) {
return undefined;
2018-09-21 01:47:19 +00:00
}
return jsonToObject(row.json);
}
2023-10-03 00:27:02 +00:00
function getAllConversationsSync(
db = getReadonlyInstance()
): Array<ConversationType> {
const rows: ConversationRows = db
.prepare<EmptyQuery>(
`
SELECT json, profileLastFetchedAt
FROM conversations
ORDER BY id ASC;
`
)
.all();
return rows.map(row => rowToConversation(row));
2018-09-21 01:47:19 +00:00
}
2021-10-26 22:59:08 +00:00
async function getAllConversations(): Promise<Array<ConversationType>> {
return getAllConversationsSync();
}
async function getAllConversationIds(): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: Array<{ id: string }> = db
.prepare<EmptyQuery>(
`
SELECT id FROM conversations ORDER BY id ASC;
`
)
.all();
return rows.map(row => row.id);
2018-09-21 01:47:19 +00:00
}
async function getAllGroupsInvolvingServiceId(
serviceId: ServiceIdString
): Promise<Array<ConversationType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: ConversationRows = db
.prepare<Query>(
`
SELECT json, profileLastFetchedAt
FROM conversations WHERE
type = 'group' AND
2023-08-16 20:54:39 +00:00
members LIKE $serviceId
ORDER BY id ASC;
`
)
.all({
2023-08-16 20:54:39 +00:00
serviceId: `%${serviceId}%`,
});
2018-09-21 01:47:19 +00:00
return rows.map(row => rowToConversation(row));
2018-09-21 01:47:19 +00:00
}
async function searchMessages({
query,
options,
conversationId,
2023-08-16 20:54:39 +00:00
contactServiceIdsMatchingQuery,
}: {
query: string;
options?: { limit?: number };
conversationId?: string;
2023-08-16 20:54:39 +00:00
contactServiceIdsMatchingQuery?: Array<ServiceIdString>;
}): Promise<Array<ServerSearchResultMessageType>> {
const { limit = conversationId ? 100 : 500 } = options ?? {};
const db = getUnsafeWritableInstance('only temp table use');
// sqlite queries with a join on a virtual table (like FTS5) are de-optimized
// and can't use indices for ordering results. Instead an in-memory index of
// the join rows is sorted on the fly, and this becomes substantially
// slower when there are large columns in it (like `messages.json`).
//
// Thus here we take an indirect approach and store `rowid`s in a temporary
// table for all messages that match the FTS query. Then we create another
// table to sort and limit the results, and finally join on it when fetch
// the snippets and json. The benefit of this is that the `ORDER BY` and
// `LIMIT` happen without virtual table and are thus covered by
// `messages_searchOrder` index.
return db.transaction(() => {
db.exec(
`
CREATE TEMP TABLE tmp_results(rowid INTEGER PRIMARY KEY ASC);
CREATE TEMP TABLE tmp_filtered_results(rowid INTEGER PRIMARY KEY ASC);
`
);
db.prepare<Query>(
`
INSERT INTO tmp_results (rowid)
SELECT
rowid
FROM
messages_fts
WHERE
messages_fts.body MATCH $query;
`
).run({ query });
2019-01-14 21:47:19 +00:00
if (conversationId === undefined) {
db.prepare<Query>(
`
INSERT INTO tmp_filtered_results (rowid)
SELECT
tmp_results.rowid
FROM
tmp_results
INNER JOIN
messages ON messages.rowid = tmp_results.rowid
ORDER BY messages.received_at DESC, messages.sent_at DESC
LIMIT $limit;
`
).run({ limit });
} else {
db.prepare<Query>(
`
INSERT INTO tmp_filtered_results (rowid)
SELECT
tmp_results.rowid
FROM
tmp_results
INNER JOIN
messages ON messages.rowid = tmp_results.rowid
WHERE
messages.conversationId = $conversationId
ORDER BY messages.received_at DESC, messages.sent_at DESC
LIMIT $limit;
`
).run({ conversationId, limit });
}
// The `MATCH` is necessary in order to for `snippet()` helper function to
// give us the right results. We can't call `snippet()` in the query above
// because it would bloat the temporary table with text data and we want
// to keep its size minimal for `ORDER BY` + `LIMIT` to be fast.
const ftsFragment = sqlFragment`
SELECT
messages.rowid,
messages.json,
messages.sent_at,
messages.received_at,
snippet(messages_fts, -1, ${SNIPPET_LEFT_PLACEHOLDER}, ${SNIPPET_RIGHT_PLACEHOLDER}, ${SNIPPET_TRUNCATION_PLACEHOLDER}, 10) AS ftsSnippet
FROM tmp_filtered_results
INNER JOIN messages_fts
ON messages_fts.rowid = tmp_filtered_results.rowid
INNER JOIN messages
ON messages.rowid = tmp_filtered_results.rowid
WHERE
messages_fts.body MATCH ${query}
ORDER BY messages.received_at DESC, messages.sent_at DESC
LIMIT ${limit}
`;
let result: Array<ServerSearchResultMessageType>;
2023-08-16 20:54:39 +00:00
if (!contactServiceIdsMatchingQuery?.length) {
const [sqlQuery, params] = sql`${ftsFragment};`;
result = db.prepare(sqlQuery).all(params);
} else {
2023-08-16 20:54:39 +00:00
// If contactServiceIdsMatchingQuery is not empty, we due an OUTER JOIN between:
// 1) the messages that mention at least one of contactServiceIdsMatchingQuery, and
// 2) the messages that match all the search terms via FTS
//
// 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`
2023-08-09 00:53:06 +00:00
SELECT
messages.rowid as rowid,
2023-08-09 00:53:06 +00:00
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,
2023-08-09 00:53:06 +00:00
ftsResults.ftsSnippet,
2023-08-16 20:54:39 +00:00
mentionAci,
2023-08-09 00:53:06 +00:00
start as mentionStart,
length as mentionLength
FROM mentions
2023-08-09 00:53:06 +00:00
INNER JOIN messages
ON
messages.id = mentions.messageId
2023-08-16 20:54:39 +00:00
AND mentions.mentionAci IN (
${sqlJoin(contactServiceIdsMatchingQuery, ', ')}
2023-08-09 00:53:06 +00:00
)
AND ${
conversationId
? sqlFragment`messages.conversationId = ${conversationId}`
: '1 IS 1'
}
2023-08-09 00:53:06 +00:00
AND messages.isViewOnce IS NOT 1
AND messages.storyId IS NULL
FULL OUTER JOIN (
${ftsFragment}
2023-08-09 00:53:06 +00:00
) as ftsResults
USING (rowid)
GROUP BY rowid
ORDER BY received_at DESC, sent_at DESC
LIMIT ${limit};
`;
result = db.prepare(sqlQuery).all(params);
}
db.exec(
`
DROP TABLE tmp_results;
DROP TABLE tmp_filtered_results;
`
);
return result;
})();
2019-01-14 21:47:19 +00:00
}
2021-10-26 22:59:08 +00:00
function getMessageCountSync(
conversationId?: string,
2023-10-03 00:27:02 +00:00
db = getReadonlyInstance()
2021-10-26 22:59:08 +00:00
): number {
if (conversationId === undefined) {
2021-10-26 22:59:08 +00:00
return getCountFromTable(db, 'messages');
}
2021-10-26 22:59:08 +00:00
const count = db
.prepare<Query>(
`
2023-01-17 21:07:21 +00:00
SELECT count(1)
FROM messages
WHERE conversationId = $conversationId;
`
)
2021-10-26 22:59:08 +00:00
.pluck()
.get({ conversationId });
2021-10-26 22:59:08 +00:00
return count;
}
2022-03-29 01:10:08 +00:00
async function getStoryCount(conversationId: string): Promise<number> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-03-29 01:10:08 +00:00
return db
.prepare<Query>(
`
2023-01-17 21:07:21 +00:00
SELECT count(1)
2022-03-29 01:10:08 +00:00
FROM messages
WHERE conversationId = $conversationId AND isStory = 1;
`
)
.pluck()
.get({ conversationId });
}
2021-10-26 22:59:08 +00:00
async function getMessageCount(conversationId?: string): Promise<number> {
return getMessageCountSync(conversationId);
}
// Note: we really only use this in 1:1 conversations, where story replies are always
// shown, so this has no need to be story-aware.
function hasUserInitiatedMessages(conversationId: string): boolean {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-11-28 17:19:48 +00:00
const exists: number = db
.prepare<Query>(
`
2022-11-28 17:19:48 +00:00
SELECT EXISTS(
SELECT 1 FROM messages
2023-01-17 21:07:21 +00:00
INDEXED BY message_user_initiated
2022-11-28 17:19:48 +00:00
WHERE
2023-01-17 21:07:21 +00:00
conversationId IS $conversationId AND
isUserInitiatedMessage IS 1
2022-11-28 17:19:48 +00:00
);
`
)
2022-11-28 17:19:48 +00:00
.pluck()
.get({ conversationId });
2022-11-28 17:19:48 +00:00
return exists !== 0;
}
function saveMessageSync(
2023-10-03 00:27:02 +00:00
db: Database,
data: MessageType,
2021-10-26 22:59:08 +00:00
options: {
alreadyInTransaction?: boolean;
2021-12-20 21:04:02 +00:00
forceSave?: boolean;
jobToInsert?: StoredJob;
ourAci: AciString;
2021-12-20 21:04:02 +00:00
}
): string {
2023-10-03 00:27:02 +00:00
const { alreadyInTransaction, forceSave, jobToInsert, ourAci } = options;
if (!alreadyInTransaction) {
return db.transaction(() => {
return assertSync(
2023-10-03 00:27:02 +00:00
saveMessageSync(db, data, {
...options,
alreadyInTransaction: true,
})
);
})();
}
const {
2019-01-14 21:47:19 +00:00
body,
conversationId,
2021-12-20 21:04:02 +00:00
groupV2Change,
hasAttachments,
hasFileAttachments,
hasVisualMediaAttachments,
id,
2019-06-26 19:33:13 +00:00
isErased,
2019-08-05 20:53:15 +00:00
isViewOnce,
mentionsMe,
received_at,
schemaVersion,
sent_at,
serverGuid,
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
storyId,
type,
readStatus,
expireTimer,
expirationStartTimestamp,
attachments,
} = data;
let { seenStatus } = data;
if (attachments) {
strictAssert(
attachments.every(
attachment =>
!attachment.data &&
!attachment.screenshotData &&
!attachment.screenshot?.data &&
!attachment.thumbnail?.data
),
'Attempting to save a message with binary attachment data'
);
}
if (readStatus === ReadStatus.Unread && seenStatus !== SeenStatus.Unseen) {
log.warn(
`saveMessage: Message ${id}/${type} is unread but had seenStatus=${seenStatus}. Forcing to UnseenStatus.Unseen.`
);
// eslint-disable-next-line no-param-reassign
data = {
...data,
seenStatus: SeenStatus.Unseen,
};
seenStatus = SeenStatus.Unseen;
}
const payload = {
id,
json: objectToJSON(data),
body: body || null,
conversationId,
expirationStartTimestamp: expirationStartTimestamp || null,
expireTimer: expireTimer || null,
hasAttachments: hasAttachments ? 1 : 0,
hasFileAttachments: hasFileAttachments ? 1 : 0,
hasVisualMediaAttachments: hasVisualMediaAttachments ? 1 : 0,
isChangeCreatedByUs: groupV2Change?.from === ourAci ? 1 : 0,
isErased: isErased ? 1 : 0,
isViewOnce: isViewOnce ? 1 : 0,
mentionsMe: mentionsMe ? 1 : 0,
received_at: received_at || null,
schemaVersion: schemaVersion || 0,
serverGuid: serverGuid || null,
sent_at: sent_at || null,
source: source || null,
2023-08-16 20:54:39 +00:00
sourceServiceId: sourceServiceId || null,
sourceDevice: sourceDevice || null,
storyId: storyId || null,
type: type || null,
readStatus: readStatus ?? null,
seenStatus: seenStatus ?? SeenStatus.NotApplicable,
};
if (id && !forceSave) {
prepare(
db,
`
UPDATE messages SET
id = $id,
json = $json,
body = $body,
conversationId = $conversationId,
expirationStartTimestamp = $expirationStartTimestamp,
expireTimer = $expireTimer,
hasAttachments = $hasAttachments,
hasFileAttachments = $hasFileAttachments,
hasVisualMediaAttachments = $hasVisualMediaAttachments,
2021-12-20 21:04:02 +00:00
isChangeCreatedByUs = $isChangeCreatedByUs,
isErased = $isErased,
isViewOnce = $isViewOnce,
mentionsMe = $mentionsMe,
received_at = $received_at,
schemaVersion = $schemaVersion,
serverGuid = $serverGuid,
sent_at = $sent_at,
source = $source,
2023-08-16 20:54:39 +00:00
sourceServiceId = $sourceServiceId,
sourceDevice = $sourceDevice,
storyId = $storyId,
type = $type,
readStatus = $readStatus,
seenStatus = $seenStatus
WHERE id = $id;
`
).run(payload);
if (jobToInsert) {
insertJobSync(db, jobToInsert);
}
return id;
}
const toCreate = {
...data,
id: id || generateUuid(),
};
prepare(
db,
`
INSERT INTO messages (
id,
json,
body,
conversationId,
expirationStartTimestamp,
expireTimer,
hasAttachments,
hasFileAttachments,
hasVisualMediaAttachments,
2021-12-20 21:04:02 +00:00
isChangeCreatedByUs,
isErased,
isViewOnce,
mentionsMe,
received_at,
schemaVersion,
serverGuid,
sent_at,
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
storyId,
type,
readStatus,
seenStatus
) values (
$id,
$json,
$body,
$conversationId,
$expirationStartTimestamp,
$expireTimer,
$hasAttachments,
$hasFileAttachments,
$hasVisualMediaAttachments,
2021-12-20 21:04:02 +00:00
$isChangeCreatedByUs,
$isErased,
$isViewOnce,
$mentionsMe,
$received_at,
$schemaVersion,
$serverGuid,
$sent_at,
$source,
2023-08-16 20:54:39 +00:00
$sourceServiceId,
$sourceDevice,
$storyId,
$type,
$readStatus,
$seenStatus
2021-07-09 21:38:51 +00:00
);
`
).run({
...payload,
id: toCreate.id,
json: objectToJSON(toCreate),
});
if (jobToInsert) {
insertJobSync(db, jobToInsert);
}
return toCreate.id;
}
async function saveMessage(
data: MessageType,
2021-12-20 21:04:02 +00:00
options: {
jobToInsert?: StoredJob;
forceSave?: boolean;
alreadyInTransaction?: boolean;
ourAci: AciString;
}
): Promise<string> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return saveMessageSync(db, data, options);
}
async function saveMessages(
arrayOfMessages: ReadonlyArray<MessageType>,
options: { forceSave?: boolean; ourAci: AciString }
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.transaction(() => {
for (const message of arrayOfMessages) {
assertSync(
2023-10-03 00:27:02 +00:00
saveMessageSync(db, message, { ...options, alreadyInTransaction: true })
);
}
})();
}
async function removeMessage(id: string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-02-04 20:46:55 +00:00
db.prepare<Query>('DELETE FROM messages WHERE id = $id;').run({ id });
2021-01-13 00:42:15 +00:00
}
2023-10-03 00:27:02 +00:00
function removeMessagesSync(db: Database, ids: ReadonlyArray<string>): void {
db.prepare<ArrayQuery>(
`
DELETE FROM messages
WHERE id IN ( ${ids.map(() => '?').join(', ')} );
`
).run(ids);
}
async function removeMessages(ids: ReadonlyArray<string>): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
batchMultiVarQuery(db, ids, batch => removeMessagesSync(db, batch));
}
async function getMessageById(id: string): Promise<MessageType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-02-16 18:36:21 +00:00
return getMessageByIdSync(db, id);
}
export function getMessageByIdSync(
db: Database,
id: string
): MessageType | undefined {
const row = db
.prepare<Query>('SELECT json FROM messages WHERE id = $id;')
.get({
id,
});
if (!row) {
return undefined;
}
return jsonToObject(row.json);
}
async function getMessagesById(
2023-03-20 22:23:53 +00:00
messageIds: ReadonlyArray<string>
): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return batchMultiVarQuery(
2021-10-26 22:59:08 +00:00
db,
messageIds,
(batch: ReadonlyArray<string>): Array<MessageType> => {
const query = db.prepare<ArrayQuery>(
`SELECT json FROM messages WHERE id IN (${Array(batch.length)
.fill('?')
.join(',')});`
);
const rows: JSONRows = query.all(batch);
return rows.map(row => jsonToObject(row.json));
}
);
}
async function _getAllMessages(): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<EmptyQuery>('SELECT json FROM messages ORDER BY id ASC;')
.all();
return rows.map(row => jsonToObject(row.json));
2018-09-21 01:47:19 +00:00
}
async function _removeAllMessages(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-01-26 23:53:22 +00:00
db.exec(`
DELETE FROM messages;
2023-10-10 23:55:32 +00:00
INSERT INTO messages_fts(messages_fts) VALUES('optimize');
2023-01-26 23:53:22 +00:00
`);
}
2018-09-21 01:47:19 +00:00
async function getAllMessageIds(): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: Array<{ id: string }> = db
.prepare<EmptyQuery>('SELECT id FROM messages ORDER BY id ASC;')
.all();
return rows.map(row => row.id);
}
async function getMessageBySender({
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
sent_at,
}: {
source?: string;
2023-08-16 20:54:39 +00:00
sourceServiceId?: ServiceIdString;
sourceDevice?: number;
sent_at: number;
}): Promise<MessageType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = prepare(
db,
`
SELECT json FROM messages WHERE
2023-08-16 20:54:39 +00:00
(source = $source OR sourceServiceId = $sourceServiceId) AND
sourceDevice = $sourceDevice AND
sent_at = $sent_at
LIMIT 2;
`
).all({
source: source || null,
2023-08-16 20:54:39 +00:00
sourceServiceId: sourceServiceId || null,
sourceDevice: sourceDevice || null,
sent_at,
});
if (rows.length > 1) {
log.warn('getMessageBySender: More than one message found for', {
sent_at,
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
});
}
if (rows.length < 1) {
return undefined;
}
return jsonToObject(rows[0].json);
}
2022-04-20 23:33:38 +00:00
export function _storyIdPredicate(
storyId: string | undefined,
includeStoryReplies: boolean
2023-03-20 22:23:53 +00:00
): QueryFragment {
// This is unintuitive, but 'including story replies' means that we need replies to
// lots of different stories. So, we remove the storyId check with a clause that will
// always be true. We don't just return TRUE because we want to use our passed-in
// $storyId parameter.
if (includeStoryReplies && storyId === undefined) {
2023-03-20 22:23:53 +00:00
return sqlFragment`${storyId} IS NULL`;
}
2023-01-01 11:41:40 +00:00
// In contrast to: replies to a specific story
2023-03-20 22:23:53 +00:00
return sqlFragment`storyId IS ${storyId}`;
}
async function getUnreadByConversationAndMarkRead({
conversationId,
includeStoryReplies,
newestUnreadAt,
storyId,
readAt,
now = Date.now(),
}: {
conversationId: string;
includeStoryReplies: boolean;
newestUnreadAt: number;
2023-03-04 03:03:15 +00:00
storyId?: string;
readAt?: number;
now?: number;
2022-07-28 16:35:29 +00:00
}): Promise<GetUnreadByConversationAndMarkReadResultType> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return db.transaction(() => {
const expirationStartTimestamp = Math.min(now, readAt ?? Infinity);
2023-03-20 22:23:53 +00:00
const expirationJsonPatch = JSON.stringify({ expirationStartTimestamp });
const [updateExpirationQuery, updateExpirationParams] = sql`
2021-06-16 22:20:17 +00:00
UPDATE messages
2021-06-29 16:45:31 +00:00
INDEXED BY expiring_message_by_conversation_and_received_at
2021-06-16 22:20:17 +00:00
SET
2023-03-20 22:23:53 +00:00
expirationStartTimestamp = ${expirationStartTimestamp},
json = json_patch(json, ${expirationJsonPatch})
2021-06-16 22:20:17 +00:00
WHERE
2023-03-20 22:23:53 +00:00
conversationId = ${conversationId} AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
isStory IS 0 AND
type IS 'incoming' AND
2021-06-16 22:20:17 +00:00
(
expirationStartTimestamp IS NULL OR
2023-03-20 22:23:53 +00:00
expirationStartTimestamp > ${expirationStartTimestamp}
2021-06-16 22:20:17 +00:00
) AND
2021-12-20 21:04:02 +00:00
expireTimer > 0 AND
2023-03-20 22:23:53 +00:00
received_at <= ${newestUnreadAt};
`;
2021-06-16 22:20:17 +00:00
2023-03-20 22:23:53 +00:00
db.prepare(updateExpirationQuery).run(updateExpirationParams);
const [selectQuery, selectParams] = sql`
SELECT id, json FROM messages
2021-06-29 16:45:31 +00:00
WHERE
2023-03-20 22:23:53 +00:00
conversationId = ${conversationId} AND
seenStatus = ${SeenStatus.Unseen} AND
isStory = 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
2023-03-20 22:23:53 +00:00
received_at <= ${newestUnreadAt}
ORDER BY received_at DESC, sent_at DESC;
2023-03-20 22:23:53 +00:00
`;
2023-03-20 22:23:53 +00:00
const rows = db.prepare(selectQuery).all(selectParams);
const statusJsonPatch = JSON.stringify({
readStatus: ReadStatus.Read,
seenStatus: SeenStatus.Seen,
});
const [updateStatusQuery, updateStatusParams] = sql`
UPDATE messages
2021-05-07 21:50:14 +00:00
SET
readStatus = ${ReadStatus.Read},
seenStatus = ${SeenStatus.Seen},
2023-03-20 22:23:53 +00:00
json = json_patch(json, ${statusJsonPatch})
2021-05-07 21:50:14 +00:00
WHERE
2023-03-20 22:23:53 +00:00
conversationId = ${conversationId} AND
seenStatus = ${SeenStatus.Unseen} AND
isStory = 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
2023-03-20 22:23:53 +00:00
received_at <= ${newestUnreadAt};
`;
db.prepare(updateStatusQuery).run(updateStatusParams);
return rows.map(row => {
2021-10-26 22:59:08 +00:00
const json = jsonToObject<MessageType>(row.json);
return {
originalReadStatus: json.readStatus,
readStatus: ReadStatus.Read,
seenStatus: SeenStatus.Seen,
2021-06-16 22:20:17 +00:00
...pick(json, [
'expirationStartTimestamp',
'id',
'sent_at',
'source',
2023-08-16 20:54:39 +00:00
'sourceServiceId',
2021-06-16 22:20:17 +00:00
'type',
]),
};
});
})();
}
async function getUnreadReactionsAndMarkRead({
conversationId,
newestUnreadAt,
storyId,
}: {
conversationId: string;
newestUnreadAt: number;
2023-03-04 03:03:15 +00:00
storyId?: string;
}): Promise<Array<ReactionResultType>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return db.transaction(() => {
const unreadMessages: Array<ReactionResultType> = db
.prepare<Query>(
`
2023-08-16 20:54:39 +00:00
SELECT reactions.rowid, targetAuthorAci, targetTimestamp, messageId
FROM reactions
2023-01-17 21:07:21 +00:00
INDEXED BY reactions_unread
JOIN messages on messages.id IS reactions.messageId
WHERE
2023-01-17 21:07:21 +00:00
reactions.conversationId IS $conversationId AND
reactions.unread > 0 AND
messages.received_at <= $newestUnreadAt AND
messages.storyId IS $storyId
ORDER BY messageReceivedAt DESC;
`
)
.all({
conversationId,
newestUnreadAt,
storyId: storyId || null,
});
const idsToUpdate = unreadMessages.map(item => item.rowid);
batchMultiVarQuery(db, idsToUpdate, (ids: ReadonlyArray<number>): void => {
db.prepare<ArrayQuery>(
`
2023-01-17 21:07:21 +00:00
UPDATE reactions
SET unread = 0
WHERE rowid IN ( ${ids.map(() => '?').join(', ')} );
`
).run(ids);
});
return unreadMessages;
})();
}
async function markReactionAsRead(
targetAuthorServiceId: ServiceIdString,
targetTimestamp: number
): Promise<ReactionType | undefined> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return db.transaction(() => {
const readReaction = db
.prepare(
`
SELECT *
FROM reactions
WHERE
2023-08-16 20:54:39 +00:00
targetAuthorAci = $targetAuthorAci AND
targetTimestamp = $targetTimestamp AND
unread = 1
ORDER BY rowId DESC
LIMIT 1;
`
)
.get({
2023-08-16 20:54:39 +00:00
targetAuthorAci: targetAuthorServiceId,
targetTimestamp,
});
db.prepare(
`
UPDATE reactions SET
unread = 0 WHERE
2023-08-16 20:54:39 +00:00
targetAuthorAci = $targetAuthorAci AND
targetTimestamp = $targetTimestamp;
`
).run({
2023-08-16 20:54:39 +00:00
targetAuthorAci: targetAuthorServiceId,
targetTimestamp,
});
return readReaction;
})();
}
async function addReaction({
conversationId,
emoji,
fromId,
messageId,
messageReceivedAt,
2023-08-16 20:54:39 +00:00
targetAuthorAci,
targetTimestamp,
}: ReactionType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
await db
.prepare(
`INSERT INTO reactions (
conversationId,
emoji,
fromId,
messageId,
messageReceivedAt,
2023-08-16 20:54:39 +00:00
targetAuthorAci,
targetTimestamp,
unread
) VALUES (
$conversationId,
$emoji,
$fromId,
$messageId,
$messageReceivedAt,
2023-08-16 20:54:39 +00:00
$targetAuthorAci,
$targetTimestamp,
$unread
);`
)
.run({
conversationId,
emoji,
fromId,
messageId,
messageReceivedAt,
2023-08-16 20:54:39 +00:00
targetAuthorAci,
targetTimestamp,
unread: 1,
});
}
async function removeReactionFromConversation({
emoji,
fromId,
targetAuthorServiceId,
targetTimestamp,
}: {
emoji: string;
fromId: string;
targetAuthorServiceId: ServiceIdString;
targetTimestamp: number;
}): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
await db
.prepare(
`DELETE FROM reactions WHERE
emoji = $emoji AND
fromId = $fromId AND
2023-08-16 20:54:39 +00:00
targetAuthorAci = $targetAuthorAci AND
targetTimestamp = $targetTimestamp;`
)
.run({
emoji,
fromId,
2023-08-16 20:54:39 +00:00
targetAuthorAci: targetAuthorServiceId,
targetTimestamp,
});
}
async function _getAllReactions(): Promise<Array<ReactionType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db.prepare<EmptyQuery>('SELECT * from reactions;').all();
}
async function _removeAllReactions(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>('DELETE from reactions;').run();
}
2023-03-04 03:03:15 +00:00
enum AdjacentDirection {
Older = 'Older',
Newer = 'Newer',
}
2023-03-04 03:03:15 +00:00
async function getRecentStoryReplies(
storyId: string,
options?: GetRecentStoryRepliesOptionsType
): Promise<Array<MessageTypeUnhydrated>> {
return getRecentStoryRepliesSync(storyId, options);
}
// This function needs to pull story replies from all conversations, because when we send
// a story to one or more distribution lists, each reply to it will be in the sender's
// 1:1 conversation with us.
function getRecentStoryRepliesSync(
storyId: string,
{
limit = 100,
messageId,
receivedAt = Number.MAX_VALUE,
sentAt = Number.MAX_VALUE,
}: GetRecentStoryRepliesOptionsType = {}
): Array<MessageTypeUnhydrated> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const timeFilters = {
first: sqlFragment`received_at = ${receivedAt} AND sent_at < ${sentAt}`,
second: sqlFragment`received_at < ${receivedAt}`,
};
const createQuery = (timeFilter: QueryFragment): QueryFragment => sqlFragment`
SELECT json FROM messages WHERE
(${messageId} IS NULL OR id IS NOT ${messageId}) AND
isStory IS 0 AND
storyId IS ${storyId} AND
(
${timeFilter}
)
ORDER BY received_at DESC, sent_at DESC
`;
const template = sqlFragment`
SELECT first.json FROM (${createQuery(timeFilters.first)}) as first
UNION ALL
SELECT second.json FROM (${createQuery(timeFilters.second)}) as second
`;
const [query, params] = sql`${template} LIMIT ${limit}`;
return db.prepare(query).all(params);
}
2023-03-04 03:03:15 +00:00
function getAdjacentMessagesByConversationSync(
direction: AdjacentDirection,
{
2023-03-04 03:03:15 +00:00
conversationId,
includeStoryReplies,
limit = 100,
messageId,
2023-03-04 03:03:15 +00:00
receivedAt = direction === AdjacentDirection.Older ? Number.MAX_VALUE : 0,
sentAt = direction === AdjacentDirection.Older ? Number.MAX_VALUE : 0,
requireVisualMediaAttachments,
storyId,
2023-03-04 03:03:15 +00:00
}: AdjacentMessagesByConversationOptionsType
): Array<MessageTypeUnhydrated> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
let timeFilters: { first: QueryFragment; second: QueryFragment };
let timeOrder: QueryFragment;
2023-03-04 03:03:15 +00:00
if (direction === AdjacentDirection.Older) {
timeFilters = {
first: sqlFragment`received_at = ${receivedAt} AND sent_at < ${sentAt}`,
second: sqlFragment`received_at < ${receivedAt}`,
};
timeOrder = sqlFragment`DESC`;
} else {
timeFilters = {
first: sqlFragment`received_at = ${receivedAt} AND sent_at > ${sentAt}`,
second: sqlFragment`received_at > ${receivedAt}`,
};
timeOrder = sqlFragment`ASC`;
}
2023-03-04 03:03:15 +00:00
const requireDifferentMessage =
direction === AdjacentDirection.Older || requireVisualMediaAttachments;
const createQuery = (timeFilter: QueryFragment): QueryFragment => sqlFragment`
2023-03-04 03:03:15 +00:00
SELECT json FROM messages WHERE
2023-03-20 22:23:53 +00:00
conversationId = ${conversationId} AND
2023-03-04 03:03:15 +00:00
${
requireDifferentMessage
2023-03-20 22:23:53 +00:00
? sqlFragment`(${messageId} IS NULL OR id IS NOT ${messageId}) AND`
: sqlFragment``
2023-03-04 03:03:15 +00:00
}
${
requireVisualMediaAttachments
2023-03-20 22:23:53 +00:00
? sqlFragment`hasVisualMediaAttachments IS 1 AND`
: sqlFragment``
2023-03-04 03:03:15 +00:00
}
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
(
${timeFilter}
)
ORDER BY received_at ${timeOrder}, sent_at ${timeOrder}
`;
let template = sqlFragment`
SELECT first.json FROM (${createQuery(timeFilters.first)}) as first
UNION ALL
SELECT second.json FROM (${createQuery(timeFilters.second)}) as second
2023-03-04 03:03:15 +00:00
`;
// See `filterValidAttachments` in ts/state/ducks/lightbox.ts
if (requireVisualMediaAttachments) {
2023-03-20 22:23:53 +00:00
template = sqlFragment`
2023-03-04 03:03:15 +00:00
SELECT json
2023-03-20 22:23:53 +00:00
FROM (${template}) as messages
2023-03-04 03:03:15 +00:00
WHERE
(
2023-03-04 03:03:15 +00:00
SELECT COUNT(*)
FROM json_each(messages.json ->> 'attachments') AS attachment
WHERE
attachment.value ->> 'thumbnail' IS NOT NULL AND
attachment.value ->> 'pending' IS NOT 1 AND
attachment.value ->> 'error' IS NULL
) > 0
2023-03-20 22:23:53 +00:00
LIMIT ${limit};
2023-03-04 03:03:15 +00:00
`;
} else {
2023-03-20 22:23:53 +00:00
template = sqlFragment`${template} LIMIT ${limit}`;
2023-03-04 03:03:15 +00:00
}
2023-03-20 22:23:53 +00:00
const [query, params] = sql`${template}`;
const results = db.prepare(query).all(params);
2023-03-04 03:03:15 +00:00
if (direction === AdjacentDirection.Older) {
results.reverse();
}
return results;
}
async function getOlderMessagesByConversation(
options: AdjacentMessagesByConversationOptionsType
): Promise<Array<MessageTypeUnhydrated>> {
return getAdjacentMessagesByConversationSync(
AdjacentDirection.Older,
options
);
}
async function getAllStories({
conversationId,
2023-08-16 20:54:39 +00:00
sourceServiceId,
}: {
conversationId?: string;
2023-08-16 20:54:39 +00:00
sourceServiceId?: ServiceIdString;
2022-11-28 17:19:48 +00:00
}): Promise<GetAllStoriesResultType> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-11-28 17:19:48 +00:00
const rows: ReadonlyArray<{
json: string;
hasReplies: number;
hasRepliesFromSelf: number;
}> = db
.prepare<Query>(
`
2022-11-28 17:19:48 +00:00
SELECT
json,
(SELECT EXISTS(
SELECT 1
FROM messages as replies
WHERE replies.storyId IS messages.id
)) as hasReplies,
(SELECT EXISTS(
SELECT 1
FROM messages AS selfReplies
WHERE
selfReplies.storyId IS messages.id AND
selfReplies.type IS 'outgoing'
)) as hasRepliesFromSelf
FROM messages
WHERE
type IS 'story' AND
($conversationId IS NULL OR conversationId IS $conversationId) AND
2023-08-16 20:54:39 +00:00
($sourceServiceId IS NULL OR sourceServiceId IS $sourceServiceId)
ORDER BY received_at ASC, sent_at ASC;
`
)
.all({
conversationId: conversationId || null,
2023-08-16 20:54:39 +00:00
sourceServiceId: sourceServiceId || null,
});
2022-11-28 17:19:48 +00:00
return rows.map(row => ({
...jsonToObject(row.json),
hasReplies: row.hasReplies !== 0,
hasRepliesFromSelf: row.hasRepliesFromSelf !== 0,
}));
}
async function getNewerMessagesByConversation(
2023-03-04 03:03:15 +00:00
options: AdjacentMessagesByConversationOptionsType
): Promise<Array<MessageTypeUnhydrated>> {
2023-03-04 03:03:15 +00:00
return getAdjacentMessagesByConversationSync(
AdjacentDirection.Newer,
options
);
}
function getOldestMessageForConversation(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
2023-03-04 03:03:15 +00:00
storyId?: string;
includeStoryReplies: boolean;
}
): MessageMetricsType | undefined {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
const [query, params] = sql`
SELECT received_at, sent_at, id FROM messages WHERE
conversationId = ${conversationId} AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
ORDER BY received_at ASC, sent_at ASC
LIMIT 1;
2023-03-20 22:23:53 +00:00
`;
const row = db.prepare(query).get(params);
if (!row) {
return undefined;
}
return row;
}
function getNewestMessageForConversation(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
2023-03-04 03:03:15 +00:00
storyId?: string;
includeStoryReplies: boolean;
}
): MessageMetricsType | undefined {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
const [query, params] = sql`
SELECT received_at, sent_at, id FROM messages WHERE
conversationId = ${conversationId} AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
ORDER BY received_at DESC, sent_at DESC
LIMIT 1;
2023-03-20 22:23:53 +00:00
`;
const row = db.prepare(query).get(params);
if (!row) {
return undefined;
}
return row;
}
2020-08-07 00:50:54 +00:00
2023-03-20 22:23:53 +00:00
export type GetMessagesBetweenOptions = Readonly<{
after: { received_at: number; sent_at: number };
before: { received_at: number; sent_at: number };
includeStoryReplies: boolean;
}>;
async function getMessagesBetween(
conversationId: string,
options: GetMessagesBetweenOptions
): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
// In the future we could accept this as an option, but for now we just
// use it for the story predicate.
const storyId = undefined;
const { after, before, includeStoryReplies } = options;
const [query, params] = sql`
SELECT id
FROM messages
WHERE
conversationId = ${conversationId} AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
isStory IS 0 AND
(
received_at > ${after.received_at}
OR (received_at = ${after.received_at} AND sent_at > ${after.sent_at})
) AND (
received_at < ${before.received_at}
OR (received_at = ${before.received_at} AND sent_at < ${before.sent_at})
)
ORDER BY received_at ASC, sent_at ASC;
`;
const rows = db.prepare(query).all(params);
return rows.map(row => row.id);
}
/**
* Given a set of deleted message IDs, find a message in the conversation that
* is close to the set. Searching from the last selected message as a starting
* point.
*/
async function getNearbyMessageFromDeletedSet({
conversationId,
lastSelectedMessage,
deletedMessageIds,
storyId,
includeStoryReplies,
}: GetNearbyMessageFromDeletedSetOptionsType): Promise<string | null> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
function runQuery(after: boolean) {
const dir = after ? sqlFragment`ASC` : sqlFragment`DESC`;
const compare = after ? sqlFragment`>` : sqlFragment`<`;
const { received_at, sent_at } = lastSelectedMessage;
const [query, params] = sql`
SELECT id FROM messages WHERE
conversationId = ${conversationId} AND
(${_storyIdPredicate(storyId, includeStoryReplies)}) AND
isStory IS 0 AND
id NOT IN (${sqlJoin(deletedMessageIds, ', ')}) AND
type IN ('incoming', 'outgoing')
AND (
(received_at = ${received_at} AND sent_at ${compare} ${sent_at}) OR
received_at ${compare} ${received_at}
)
ORDER BY received_at ${dir}, sent_at ${dir}
LIMIT 1
`;
return db.prepare(query).pluck().get(params);
}
const after = runQuery(true);
if (after != null) {
return after;
}
const before = runQuery(false);
if (before != null) {
return before;
}
return null;
}
function getLastConversationActivity({
conversationId,
includeStoryReplies,
}: {
conversationId: string;
includeStoryReplies: boolean;
}): MessageType | undefined {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = prepare(
db,
`
SELECT json FROM messages
2023-01-17 21:07:21 +00:00
INDEXED BY messages_activity
WHERE
2023-01-17 21:07:21 +00:00
conversationId IS $conversationId AND
2021-12-20 21:04:02 +00:00
shouldAffectActivity IS 1 AND
isTimerChangeFromSync IS 0 AND
${includeStoryReplies ? '' : 'storyId IS NULL AND'}
2021-12-20 21:04:02 +00:00
isGroupLeaveEventFromOther IS 0
ORDER BY received_at DESC, sent_at DESC
LIMIT 1;
`
).get({
conversationId,
});
2020-08-07 00:50:54 +00:00
if (!row) {
return undefined;
2020-08-07 00:50:54 +00:00
}
return jsonToObject(row.json);
2020-08-07 00:50:54 +00:00
}
function getLastConversationPreview({
conversationId,
includeStoryReplies,
}: {
conversationId: string;
includeStoryReplies: boolean;
}): MessageType | undefined {
type Row = Readonly<{
json: string;
}>;
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-01-27 17:47:24 +00:00
const index = includeStoryReplies
? 'messages_preview'
: 'messages_preview_without_story';
const row: Row | undefined = prepare(
db,
`
2023-01-27 17:47:24 +00:00
SELECT json FROM (
SELECT json, expiresAt FROM messages
INDEXED BY ${index}
WHERE
conversationId IS $conversationId AND
shouldAffectPreview IS 1 AND
isGroupLeaveEventFromOther IS 0
${includeStoryReplies ? '' : 'AND storyId IS NULL'}
ORDER BY received_at DESC, sent_at DESC
)
WHERE likely(expiresAt > $now)
LIMIT 1
`
).get({
conversationId,
now: Date.now(),
});
2020-08-07 00:50:54 +00:00
return row ? jsonToObject(row.json) : undefined;
2020-08-07 00:50:54 +00:00
}
async function getConversationMessageStats({
conversationId,
includeStoryReplies,
}: {
conversationId: string;
includeStoryReplies: boolean;
}): Promise<ConversationMessageStatsType> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db.transaction(() => {
return {
activity: getLastConversationActivity({
conversationId,
includeStoryReplies,
}),
preview: getLastConversationPreview({
conversationId,
includeStoryReplies,
}),
hasUserInitiatedMessages: hasUserInitiatedMessages(conversationId),
};
})();
}
async function getLastConversationMessage({
conversationId,
}: {
conversationId: string;
}): Promise<MessageType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = db
.prepare<Query>(
`
2023-01-27 17:47:24 +00:00
SELECT json FROM messages WHERE
conversationId = $conversationId
ORDER BY received_at DESC, sent_at DESC
LIMIT 1;
`
)
.get({
conversationId,
});
if (!row) {
return undefined;
}
return jsonToObject(row.json);
}
function getOldestUnseenMessageForConversation(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
2023-03-04 03:03:15 +00:00
storyId?: string;
includeStoryReplies: boolean;
}
): MessageMetricsType | undefined {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
const [query, params] = sql`
SELECT received_at, sent_at, id FROM messages WHERE
conversationId = ${conversationId} AND
seenStatus = ${SeenStatus.Unseen} AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
ORDER BY received_at ASC, sent_at ASC
LIMIT 1;
`;
const row = db.prepare(query).get(params);
if (!row) {
return undefined;
}
return row;
}
async function getOldestUnreadMentionOfMeForConversation(
conversationId: string,
options: {
storyId?: string;
includeStoryReplies: boolean;
}
): Promise<MessageMetricsType | undefined> {
return getOldestUnreadMentionOfMeForConversationSync(conversationId, options);
}
export function getOldestUnreadMentionOfMeForConversationSync(
conversationId: string,
options: {
storyId?: string;
includeStoryReplies: boolean;
}
): MessageMetricsType | undefined {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const [query, params] = sql`
SELECT received_at, sent_at, id FROM messages WHERE
conversationId = ${conversationId} AND
readStatus = ${ReadStatus.Unread} AND
mentionsMe IS 1 AND
isStory IS 0 AND
(${_storyIdPredicate(options.storyId, options.includeStoryReplies)})
ORDER BY received_at ASC, sent_at ASC
LIMIT 1;
`;
return db.prepare(query).get(params);
}
async function getTotalUnreadForConversation(
conversationId: string,
options: {
2023-03-04 03:03:15 +00:00
storyId: string | undefined;
includeStoryReplies: boolean;
}
): Promise<number> {
return getTotalUnreadForConversationSync(conversationId, options);
}
function getTotalUnreadForConversationSync(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
2023-03-04 03:03:15 +00:00
storyId: string | undefined;
includeStoryReplies: boolean;
}
): number {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
const [query, params] = sql`
SELECT count(1)
FROM messages
WHERE
conversationId = ${conversationId} AND
readStatus = ${ReadStatus.Unread} AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
`;
const row = db.prepare(query).pluck().get(params);
2023-01-17 21:07:21 +00:00
return row;
}
async function getTotalUnreadMentionsOfMeForConversation(
conversationId: string,
options: {
storyId?: string;
includeStoryReplies: boolean;
}
): Promise<number> {
return getTotalUnreadMentionsOfMeForConversationSync(conversationId, options);
}
function getTotalUnreadMentionsOfMeForConversationSync(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
storyId?: string;
includeStoryReplies: boolean;
}
): number {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const [query, params] = sql`
SELECT count(1)
FROM messages
WHERE
conversationId = ${conversationId} AND
readStatus = ${ReadStatus.Unread} AND
mentionsMe IS 1 AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
`;
const row = db.prepare(query).pluck().get(params);
return row;
}
function getTotalUnseenForConversationSync(
conversationId: string,
{
storyId,
includeStoryReplies,
}: {
2023-03-04 03:03:15 +00:00
storyId?: string;
includeStoryReplies: boolean;
}
): number {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-20 22:23:53 +00:00
const [query, params] = sql`
SELECT count(1)
FROM messages
WHERE
2023-03-20 22:23:53 +00:00
conversationId = ${conversationId} AND
seenStatus = ${SeenStatus.Unseen} AND
isStory IS 0 AND
(${_storyIdPredicate(storyId, includeStoryReplies)})
2023-03-20 22:23:53 +00:00
`;
const row = db.prepare(query).pluck().get(params);
2023-01-17 21:07:21 +00:00
return row;
}
2023-03-04 03:03:15 +00:00
async function getMessageMetricsForConversation(options: {
conversationId: string;
storyId?: string;
includeStoryReplies: boolean;
}): Promise<ConversationMetricsType> {
return getMessageMetricsForConversationSync(options);
}
2023-03-04 03:03:15 +00:00
function getMessageMetricsForConversationSync(options: {
conversationId: string;
storyId?: string;
includeStoryReplies: boolean;
}): ConversationMetricsType {
const { conversationId } = options;
const oldest = getOldestMessageForConversation(conversationId, options);
const newest = getNewestMessageForConversation(conversationId, options);
const oldestUnseen = getOldestUnseenMessageForConversation(
conversationId,
options
);
const totalUnseen = getTotalUnseenForConversationSync(
conversationId,
options
);
return {
oldest: oldest ? pick(oldest, ['received_at', 'sent_at', 'id']) : undefined,
newest: newest ? pick(newest, ['received_at', 'sent_at', 'id']) : undefined,
oldestUnseen: oldestUnseen
? pick(oldestUnseen, ['received_at', 'sent_at', 'id'])
: undefined,
totalUnseen,
};
}
2023-03-04 03:03:15 +00:00
async function getConversationRangeCenteredOnMessage(
options: AdjacentMessagesByConversationOptionsType
): Promise<
2022-07-28 16:35:29 +00:00
GetConversationRangeCenteredOnMessageResultType<MessageTypeUnhydrated>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db.transaction(() => {
return {
2023-03-04 03:03:15 +00:00
older: getAdjacentMessagesByConversationSync(
AdjacentDirection.Older,
options
),
newer: getAdjacentMessagesByConversationSync(
AdjacentDirection.Newer,
options
),
metrics: getMessageMetricsForConversationSync(options),
};
})();
}
2023-08-09 00:53:06 +00:00
async function getAllCallHistory(): Promise<ReadonlyArray<CallHistoryDetails>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-08-09 00:53:06 +00:00
const [query] = sql`
SELECT * FROM callsHistory;
`;
return db.prepare(query).all();
}
2023-01-10 00:52:01 +00:00
2023-08-09 00:53:06 +00:00
async function clearCallHistory(
beforeTimestamp: number
): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-08-09 00:53:06 +00:00
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 cleanupCallHistoryMessages(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return db
.transaction(() => {
const [query, params] = sql`
DELETE FROM messages
WHERE messages.id IN (
SELECT messages.id FROM messages
LEFT JOIN callsHistory ON callsHistory.callId IS messages.callId
WHERE messages.type IS 'call-history'
AND callsHistory.status IS ${CALL_STATUS_DELETED}
)
`;
db.prepare(query).run(params);
})
.immediate();
}
2023-08-09 00:53:06 +00:00
async function getCallHistoryMessageByCallId(options: {
conversationId: string;
callId: string;
}): Promise<MessageType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-08-09 00:53:06 +00:00
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: ServiceIdString | string
2023-08-09 00:53:06 +00:00
): Promise<CallHistoryDetails | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-08-09 00:53:06 +00:00
const [query, params] = sql`
SELECT * FROM callsHistory
WHERE callId IS ${callId}
AND peerId IS ${peerId};
`;
const row = db.prepare(query).get(params);
if (row == null) {
return;
}
return callHistoryDetailsSchema.parse(row);
}
const READ_STATUS_UNREAD = sqlConstant(ReadStatus.Unread);
const READ_STATUS_READ = sqlConstant(ReadStatus.Read);
const CALL_STATUS_MISSED = sqlConstant(DirectCallStatus.Missed);
const CALL_STATUS_DELETED = sqlConstant(DirectCallStatus.Deleted);
const CALL_STATUS_INCOMING = sqlConstant(CallDirection.Incoming);
2023-08-09 00:53:06 +00:00
const FOUR_HOURS_IN_MS = sqlConstant(4 * 60 * 60 * 1000);
async function getCallHistoryUnreadCount(): Promise<number> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const [query, params] = sql`
SELECT count(*) FROM messages
LEFT JOIN callsHistory ON callsHistory.callId = messages.callId
WHERE messages.type IS 'call-history'
AND messages.readStatus IS ${READ_STATUS_UNREAD}
AND callsHistory.status IS ${CALL_STATUS_MISSED}
AND callsHistory.direction IS ${CALL_STATUS_INCOMING}
`;
const row = db.prepare(query).pluck().get(params);
return row;
}
async function markCallHistoryRead(callId: string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const [query, params] = sql`
UPDATE messages
SET readStatus = ${READ_STATUS_READ}
WHERE type IS 'call-history'
AND callId IS ${callId}
`;
db.prepare(query).run(params);
}
async function markAllCallHistoryRead(): Promise<ReadonlyArray<string>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return db.transaction(() => {
const where = sqlFragment`
WHERE messages.type IS 'call-history'
AND messages.readStatus IS ${READ_STATUS_UNREAD}
`;
const [selectQuery, selectParams] = sql`
SELECT DISTINCT conversationId
FROM messages
${where};
`;
const conversationIds = db.prepare(selectQuery).pluck().all(selectParams);
const [updateQuery, updateParams] = sql`
UPDATE messages
SET readStatus = ${READ_STATUS_READ}
${where};
`;
db.prepare(updateQuery).run(updateParams);
return conversationIds;
})();
}
2023-08-09 00:53:06 +00:00
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 (
id TEXT,
2023-08-16 20:54:39 +00:00
serviceId TEXT,
2023-08-09 00:53:06 +00:00
groupId TEXT
);
`;
db.exec(createTempTable);
batchMultiVarQuery(db, conversationIds, ids => {
const idList = sqlJoin(
ids.map(id => sqlFragment`${id}`),
2023-08-09 00:53:06 +00:00
','
);
const [insertQuery, insertParams] = sql`
INSERT INTO temp_callHistory_filtered_conversations
2023-08-16 20:54:39 +00:00
(id, serviceId, groupId)
SELECT id, serviceId, groupId
2023-08-09 00:53:06 +00:00
FROM conversations
WHERE conversations.id IN (${idList});
`;
db.prepare(insertQuery).run(insertParams);
});
}
const innerJoin =
conversationIds != null
2023-08-16 20:54:39 +00:00
? // peerId can be a conversation id (legacy), a serviceId, or a groupId
sqlFragment`
2023-08-09 00:53:06 +00:00
INNER JOIN temp_callHistory_filtered_conversations ON (
temp_callHistory_filtered_conversations.id IS c.peerId
2023-08-16 20:54:39 +00:00
OR temp_callHistory_filtered_conversations.serviceId IS c.peerId
2023-08-09 00:53:06 +00:00
OR temp_callHistory_filtered_conversations.groupId IS c.peerId
)
`
: sqlFragment``;
const filterClause =
status === CallHistoryFilterStatus.All
? sqlFragment`status IS NOT ${CALL_STATUS_DELETED}`
: sqlFragment`
direction IS ${CALL_STATUS_INCOMING} AND
status IS ${CALL_STATUS_MISSED} AND status IS NOT ${CALL_STATUS_DELETED}
`;
2023-08-09 00:53:06 +00:00
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 ${CALL_STATUS_MISSED}) OR
(callsHistory.status IS NOT ${CALL_STATUS_MISSED} AND c.status IS NOT ${CALL_STATUS_MISSED})
2023-08-09 00:53:06 +00:00
)
-- 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 ${CALL_STATUS_MISSED}) OR
(callsHistory.status IS NOT ${CALL_STATUS_MISSED} AND c.status IS NOT ${CALL_STATUS_MISSED})
2023-08-09 00:53:06 +00:00
)
-- 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> {
2023-10-03 00:27:02 +00:00
// getCallHistoryGroupDataSync creates a temporary table and thus requires
// write access.
const db = getUnsafeWritableInstance('only temp table use');
2023-08-09 00:53:06 +00:00
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>> {
2023-10-03 00:27:02 +00:00
// getCallHistoryGroupDataSync creates a temporary table and thus requires
// write access.
const db = getUnsafeWritableInstance('only temp table use');
2023-08-09 00:53:06 +00:00
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> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-08-09 00:53:06 +00:00
const [insertQuery, insertParams] = sql`
INSERT OR REPLACE INTO callsHistory (
2023-01-10 00:52:01 +00:00
callId,
2023-08-09 00:53:06 +00:00
peerId,
ringerId,
mode,
type,
direction,
status,
timestamp
) VALUES (
${callHistory.callId},
${callHistory.peerId},
${callHistory.ringerId},
${callHistory.mode},
${callHistory.type},
${callHistory.direction},
${callHistory.status},
${callHistory.timestamp}
);
`;
2023-01-10 00:52:01 +00:00
2023-08-09 00:53:06 +00:00
db.prepare(insertQuery).run(insertParams);
2023-01-10 00:52:01 +00:00
}
async function hasGroupCallHistoryMessage(
conversationId: string,
eraId: string
): Promise<boolean> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-11-28 17:19:48 +00:00
const exists: number = db
.prepare<Query>(
`
2022-11-28 17:19:48 +00:00
SELECT EXISTS(
SELECT 1 FROM messages
WHERE conversationId = $conversationId
AND type = 'call-history'
AND json_extract(json, '$.callHistoryDetails.callMode') = 'Group'
AND json_extract(json, '$.callHistoryDetails.eraId') = $eraId
);
`
)
2022-11-28 17:19:48 +00:00
.pluck()
.get({
conversationId,
eraId,
});
2022-11-28 17:19:48 +00:00
return exists !== 0;
}
async function migrateConversationMessages(
obsoleteId: string,
currentId: string
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>(
`
UPDATE messages SET
conversationId = $currentId,
json = json_set(json, '$.conversationId', $currentId)
WHERE conversationId = $obsoleteId;
`
).run({
obsoleteId,
currentId,
});
}
async function getMessagesBySentAt(
sentAt: number
): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const [query, params] = sql`
SELECT messages.json, received_at, sent_at FROM edited_messages
INNER JOIN messages ON
messages.id = edited_messages.messageId
WHERE edited_messages.sentAt = ${sentAt}
UNION
SELECT json, received_at, sent_at FROM messages
WHERE sent_at = ${sentAt}
ORDER BY messages.received_at DESC, messages.sent_at DESC;
`;
const rows = db.prepare(query).all(params);
return rows.map(row => jsonToObject(row.json));
}
async function getExpiredMessages(): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const now = Date.now();
const rows: JSONRows = db
.prepare<Query>(
`
SELECT json FROM messages WHERE
2021-06-16 22:20:17 +00:00
expiresAt <= $now
ORDER BY expiresAt ASC;
`
)
2021-06-16 22:20:17 +00:00
.all({ now });
return rows.map(row => jsonToObject(row.json));
}
async function getMessagesUnexpectedlyMissingExpirationStartTimestamp(): Promise<
2021-06-16 22:20:17 +00:00
Array<MessageType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<EmptyQuery>(
`
SELECT json FROM messages
INDEXED BY messages_unexpectedly_missing_expiration_start_timestamp
WHERE
expireTimer > 0 AND
2021-06-16 22:20:17 +00:00
expirationStartTimestamp IS NULL AND
(
type IS 'outgoing' OR
(type IS 'incoming' AND (
readStatus = ${ReadStatus.Read} OR
readStatus = ${ReadStatus.Viewed} OR
readStatus IS NULL
))
);
`
)
.all();
return rows.map(row => jsonToObject(row.json));
}
2021-06-16 22:20:17 +00:00
async function getSoonestMessageExpiry(): Promise<undefined | number> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2021-06-16 22:20:17 +00:00
// Note: we use `pluck` to only get the first column.
const result: null | number = db
.prepare<EmptyQuery>(
`
2021-06-16 22:20:17 +00:00
SELECT MIN(expiresAt)
FROM messages;
`
)
2021-06-16 22:20:17 +00:00
.pluck(true)
.get();
2023-01-27 17:47:24 +00:00
if (result != null && result >= Number.MAX_SAFE_INTEGER) {
return undefined;
}
2021-06-16 22:20:17 +00:00
return result || undefined;
}
async function getNextTapToViewMessageTimestampToAgeOut(): Promise<
undefined | number
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = db
.prepare<EmptyQuery>(
`
SELECT json FROM messages
WHERE
isViewOnce = 1
AND (isErased IS NULL OR isErased != 1)
ORDER BY received_at ASC, sent_at ASC
LIMIT 1;
`
)
.get();
2019-06-26 19:33:13 +00:00
if (!row) {
return undefined;
2019-06-26 19:33:13 +00:00
}
2021-10-26 22:59:08 +00:00
const data = jsonToObject<MessageType>(row.json);
const result = data.received_at_ms || data.received_at;
return isNormalNumber(result) ? result : undefined;
2019-06-26 19:33:13 +00:00
}
async function getTapToViewMessagesNeedingErase(): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2019-06-26 19:33:13 +00:00
const THIRTY_DAYS_AGO = Date.now() - 30 * 24 * 60 * 60 * 1000;
const rows: JSONRows = db
.prepare<Query>(
`
SELECT json
FROM messages
WHERE
isViewOnce = 1
AND (isErased IS NULL OR isErased != 1)
AND received_at <= $THIRTY_DAYS_AGO
ORDER BY received_at ASC, sent_at ASC;
`
)
.all({
THIRTY_DAYS_AGO,
});
2019-06-26 19:33:13 +00:00
return rows.map(row => jsonToObject(row.json));
2019-06-26 19:33:13 +00:00
}
const MAX_UNPROCESSED_ATTEMPTS = 10;
2021-09-17 23:11:24 +00:00
2023-10-03 00:27:02 +00:00
function saveUnprocessedSync(db: Database, data: UnprocessedType): string {
const {
id,
timestamp,
receivedAtCounter,
version,
attempts,
envelope,
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
serverGuid,
serverTimestamp,
decrypted,
urgent,
story,
} = data;
if (!id) {
2021-05-27 15:45:45 +00:00
throw new Error('saveUnprocessedSync: id was falsey');
}
prepare(
db,
`
INSERT OR REPLACE INTO unprocessed (
id,
timestamp,
receivedAtCounter,
version,
attempts,
envelope,
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
serverGuid,
serverTimestamp,
decrypted,
urgent,
story
) values (
$id,
$timestamp,
$receivedAtCounter,
$version,
$attempts,
$envelope,
$source,
2023-08-16 20:54:39 +00:00
$sourceServiceId,
$sourceDevice,
$serverGuid,
$serverTimestamp,
$decrypted,
$urgent,
$story
);
`
).run({
id,
timestamp,
receivedAtCounter: receivedAtCounter ?? null,
version,
attempts,
envelope: envelope || null,
source: source || null,
2023-08-16 20:54:39 +00:00
sourceServiceId: sourceServiceId || null,
sourceDevice: sourceDevice || null,
serverGuid: serverGuid || null,
serverTimestamp: serverTimestamp || null,
decrypted: decrypted || null,
urgent: urgent || !isBoolean(urgent) ? 1 : 0,
story: story ? 1 : 0,
});
return id;
}
function updateUnprocessedWithDataSync(
2023-10-03 00:27:02 +00:00
db: Database,
id: string,
data: UnprocessedUpdateType
): void {
const {
source,
2023-08-16 20:54:39 +00:00
sourceServiceId,
sourceDevice,
serverGuid,
serverTimestamp,
decrypted,
} = data;
prepare(
db,
`
UPDATE unprocessed SET
source = $source,
2023-08-16 20:54:39 +00:00
sourceServiceId = $sourceServiceId,
sourceDevice = $sourceDevice,
serverGuid = $serverGuid,
serverTimestamp = $serverTimestamp,
decrypted = $decrypted
WHERE id = $id;
`
).run({
id,
source: source || null,
2023-08-16 20:54:39 +00:00
sourceServiceId: sourceServiceId || null,
sourceDevice: sourceDevice || null,
serverGuid: serverGuid || null,
serverTimestamp: serverTimestamp || null,
decrypted: decrypted || null,
});
}
async function updateUnprocessedWithData(
id: string,
data: UnprocessedUpdateType
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return updateUnprocessedWithDataSync(db, id, data);
}
async function updateUnprocessedsWithData(
arrayOfUnprocessed: Array<{ id: string; data: UnprocessedUpdateType }>
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2019-09-26 19:56:31 +00:00
db.transaction(() => {
for (const { id, data } of arrayOfUnprocessed) {
2023-10-03 00:27:02 +00:00
assertSync(updateUnprocessedWithDataSync(db, id, data));
}
})();
2019-09-26 19:56:31 +00:00
}
async function getUnprocessedById(
id: string
): Promise<UnprocessedType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const row = db
.prepare<Query>('SELECT * FROM unprocessed WHERE id = $id;')
.get({
id,
});
return {
...row,
urgent: isNumber(row.urgent) ? Boolean(row.urgent) : true,
story: Boolean(row.story),
};
}
async function getUnprocessedCount(): Promise<number> {
2023-10-03 00:27:02 +00:00
return getCountFromTable(getReadonlyInstance(), 'unprocessed');
}
async function getAllUnprocessedIds(): Promise<Array<string>> {
log.info('getAllUnprocessedIds');
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-12-14 01:25:44 +00:00
return db.transaction(() => {
// cleanup first
const { changes: deletedStaleCount } = db
.prepare<Query>('DELETE FROM unprocessed WHERE timestamp < $monthAgo')
.run({
monthAgo: Date.now() - durations.MONTH,
});
2021-12-14 01:25:44 +00:00
if (deletedStaleCount !== 0) {
logger.warn(
'getAllUnprocessedAndIncrementAttempts: ' +
`deleting ${deletedStaleCount} old unprocessed envelopes`
);
}
2021-12-14 01:25:44 +00:00
const { changes: deletedInvalidCount } = db
.prepare<Query>(
`
DELETE FROM unprocessed
WHERE attempts >= $MAX_UNPROCESSED_ATTEMPTS
`
)
.run({ MAX_UNPROCESSED_ATTEMPTS });
if (deletedInvalidCount !== 0) {
logger.warn(
'getAllUnprocessedAndIncrementAttempts: ' +
`deleting ${deletedInvalidCount} invalid unprocessed envelopes`
);
}
return db
.prepare<EmptyQuery>(
`
2023-03-20 22:23:53 +00:00
SELECT id
FROM unprocessed
ORDER BY receivedAtCounter ASC
`
)
.pluck()
.all();
})();
}
async function getUnprocessedByIdsAndIncrementAttempts(
ids: ReadonlyArray<string>
): Promise<Array<UnprocessedType>> {
log.info('getUnprocessedByIdsAndIncrementAttempts', { totalIds: ids.length });
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
batchMultiVarQuery(db, ids, batch => {
return db
.prepare<ArrayQuery>(
`
UPDATE unprocessed
SET attempts = attempts + 1
WHERE id IN (${batch.map(() => '?').join(', ')})
`
)
.run(batch);
});
return batchMultiVarQuery(db, ids, batch => {
return db
.prepare<ArrayQuery>(
`
SELECT *
FROM unprocessed
WHERE id IN (${batch.map(() => '?').join(', ')})
ORDER BY receivedAtCounter ASC;
`
)
.all(batch)
.map(row => ({
...row,
urgent: isNumber(row.urgent) ? Boolean(row.urgent) : true,
story: Boolean(row.story),
}));
});
}
2023-10-03 00:27:02 +00:00
function removeUnprocessedsSync(
db: Database,
ids: ReadonlyArray<string>
): void {
log.info('removeUnprocessedsSync', { totalIds: ids.length });
db.prepare<ArrayQuery>(
`
DELETE FROM unprocessed
WHERE id IN ( ${ids.map(() => '?').join(', ')} );
`
).run(ids);
}
2023-10-03 00:27:02 +00:00
function removeUnprocessedSync(db: Database, id: string | Array<string>): void {
log.info('removeUnprocessedSync', { id });
2021-10-26 22:59:08 +00:00
if (!Array.isArray(id)) {
prepare(db, 'DELETE FROM unprocessed WHERE id = $id;').run({ id });
return;
}
// This can happen normally due to flushing of `cacheRemoveBatcher` in
// MessageReceiver.
if (!id.length) {
return;
}
2023-10-03 00:27:02 +00:00
assertSync(
batchMultiVarQuery(db, id, batch => removeUnprocessedsSync(db, batch))
);
2021-09-17 23:11:24 +00:00
}
async function removeUnprocessed(id: string | Array<string>): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
removeUnprocessedSync(db, id);
}
async function removeAllUnprocessed(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>('DELETE FROM unprocessed;').run();
}
// Attachment Downloads
const ATTACHMENT_DOWNLOADS_TABLE = 'attachment_downloads';
async function getAttachmentDownloadJobById(
id: string
): Promise<AttachmentDownloadJobType | undefined> {
2023-10-03 00:27:02 +00:00
return getById(getReadonlyInstance(), ATTACHMENT_DOWNLOADS_TABLE, id);
}
async function getNextAttachmentDownloadJobs(
limit?: number,
options: { timestamp?: number } = {}
): Promise<Array<AttachmentDownloadJobType>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const timestamp =
options && options.timestamp ? options.timestamp : Date.now();
const rows: Array<{ json: string; id: string }> = db
.prepare<Query>(
`
SELECT id, json
FROM attachment_downloads
2021-06-01 17:13:10 +00:00
WHERE pending = 0 AND timestamp <= $timestamp
ORDER BY timestamp DESC
LIMIT $limit;
`
)
.all({
limit: limit || 3,
timestamp,
});
const INNER_ERROR = 'jsonToObject error';
try {
return rows.map(row => {
try {
return jsonToObject(row.json);
} catch (error) {
logger.error(
`getNextAttachmentDownloadJobs: Error with job '${row.id}', deleting. ` +
`JSON: '${row.json}' ` +
`Error: ${Errors.toLogFormat(error)}`
);
2023-10-03 00:27:02 +00:00
removeAttachmentDownloadJobSync(db, row.id);
throw new Error(INNER_ERROR);
}
});
} catch (error) {
if ('message' in error && error.message === INNER_ERROR) {
return getNextAttachmentDownloadJobs(limit, { timestamp });
}
throw error;
}
}
async function saveAttachmentDownloadJob(
job: AttachmentDownloadJobType
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const { id, pending, timestamp } = job;
if (!id) {
throw new Error(
'saveAttachmentDownloadJob: Provided job did not have a truthy id'
);
}
db.prepare<Query>(
`
INSERT OR REPLACE INTO attachment_downloads (
id,
pending,
timestamp,
json
) values (
$id,
$pending,
$timestamp,
$json
)
`
).run({
id,
pending,
timestamp,
json: objectToJSON(job),
});
}
async function setAttachmentDownloadJobPending(
id: string,
pending: boolean
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>(
`
UPDATE attachment_downloads
SET pending = $pending
WHERE id = $id;
`
).run({
id,
pending: pending ? 1 : 0,
});
}
async function resetAttachmentDownloadPending(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>(
`
UPDATE attachment_downloads
SET pending = 0
WHERE pending != 0;
`
).run();
}
function removeAttachmentDownloadJobSync(db: Database, id: string): number {
2023-10-03 00:27:02 +00:00
return removeById(db, ATTACHMENT_DOWNLOADS_TABLE, id);
}
async function removeAttachmentDownloadJob(id: string): Promise<number> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return removeAttachmentDownloadJobSync(db, id);
}
async function removeAllAttachmentDownloadJobs(): Promise<number> {
2023-10-03 00:27:02 +00:00
return removeAllFromTable(
await getWritableInstance(),
ATTACHMENT_DOWNLOADS_TABLE
);
}
// Stickers
async function createOrUpdateStickerPack(pack: StickerPackType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const {
attemptedStatus,
author,
coverStickerId,
createdAt,
downloadAttempts,
id,
installedAt,
key,
lastUsed,
status,
stickerCount,
title,
2022-08-03 17:10:49 +00:00
storageID,
storageVersion,
storageUnknownFields,
storageNeedsSync,
} = pack;
if (!id) {
throw new Error(
'createOrUpdateStickerPack: Provided data did not have a truthy id'
);
}
2022-08-03 17:10:49 +00:00
let { position } = pack;
// Assign default position
if (!isNumber(position)) {
position = db
.prepare<EmptyQuery>(
`
SELECT IFNULL(MAX(position) + 1, 0)
FROM sticker_packs
`
)
.pluck()
.get();
}
const row = db
.prepare<Query>(
`
SELECT id
FROM sticker_packs
WHERE id = $id;
`
)
2022-08-03 17:10:49 +00:00
.get({ id });
const payload = {
2021-07-09 19:36:10 +00:00
attemptedStatus: attemptedStatus ?? null,
author,
coverStickerId,
createdAt: createdAt || Date.now(),
downloadAttempts: downloadAttempts || 1,
id,
2021-07-09 19:36:10 +00:00
installedAt: installedAt ?? null,
key,
lastUsed: lastUsed || null,
status,
stickerCount,
title,
2022-08-03 17:10:49 +00:00
position: position ?? 0,
storageID: storageID ?? null,
storageVersion: storageVersion ?? null,
storageUnknownFields: storageUnknownFields ?? null,
storageNeedsSync: storageNeedsSync ? 1 : 0,
};
2022-08-03 17:10:49 +00:00
if (row) {
db.prepare<Query>(
`
UPDATE sticker_packs SET
attemptedStatus = $attemptedStatus,
author = $author,
coverStickerId = $coverStickerId,
createdAt = $createdAt,
downloadAttempts = $downloadAttempts,
installedAt = $installedAt,
key = $key,
lastUsed = $lastUsed,
status = $status,
stickerCount = $stickerCount,
2022-08-03 17:10:49 +00:00
title = $title,
position = $position,
storageID = $storageID,
storageVersion = $storageVersion,
storageUnknownFields = $storageUnknownFields,
storageNeedsSync = $storageNeedsSync
WHERE id = $id;
`
).run(payload);
return;
}
db.prepare<Query>(
`
INSERT INTO sticker_packs (
attemptedStatus,
author,
coverStickerId,
createdAt,
downloadAttempts,
id,
installedAt,
key,
lastUsed,
status,
stickerCount,
2022-08-03 17:10:49 +00:00
title,
position,
storageID,
storageVersion,
storageUnknownFields,
storageNeedsSync
) values (
$attemptedStatus,
$author,
$coverStickerId,
$createdAt,
$downloadAttempts,
$id,
$installedAt,
$key,
$lastUsed,
$status,
$stickerCount,
2022-08-03 17:10:49 +00:00
$title,
$position,
$storageID,
$storageVersion,
$storageUnknownFields,
$storageNeedsSync
)
`
).run(payload);
}
2022-08-03 17:10:49 +00:00
function updateStickerPackStatusSync(
2023-10-03 00:27:02 +00:00
db: Database,
id: string,
status: StickerPackStatusType,
options?: { timestamp: number }
2022-08-03 17:10:49 +00:00
): void {
const timestamp = options ? options.timestamp || Date.now() : Date.now();
const installedAt = status === 'installed' ? timestamp : null;
db.prepare<Query>(
`
UPDATE sticker_packs
SET status = $status, installedAt = $installedAt
WHERE id = $id;
`
).run({
id,
status,
installedAt,
});
}
2022-08-03 17:10:49 +00:00
async function updateStickerPackStatus(
id: string,
status: StickerPackStatusType,
options?: { timestamp: number }
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return updateStickerPackStatusSync(db, id, status, options);
2022-08-03 17:10:49 +00:00
}
async function updateStickerPackInfo({
id,
storageID,
storageVersion,
storageUnknownFields,
storageNeedsSync,
uninstalledAt,
}: StickerPackInfoType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-08-03 17:10:49 +00:00
if (uninstalledAt) {
db.prepare<Query>(
`
UPDATE uninstalled_sticker_packs
SET
storageID = $storageID,
storageVersion = $storageVersion,
storageUnknownFields = $storageUnknownFields,
storageNeedsSync = $storageNeedsSync
WHERE id = $id;
`
).run({
id,
storageID: storageID ?? null,
storageVersion: storageVersion ?? null,
storageUnknownFields: storageUnknownFields ?? null,
storageNeedsSync: storageNeedsSync ? 1 : 0,
});
} else {
db.prepare<Query>(
`
UPDATE sticker_packs
SET
storageID = $storageID,
storageVersion = $storageVersion,
storageUnknownFields = $storageUnknownFields,
storageNeedsSync = $storageNeedsSync
WHERE id = $id;
`
).run({
id,
storageID: storageID ?? null,
storageVersion: storageVersion ?? null,
storageUnknownFields: storageUnknownFields ?? null,
storageNeedsSync: storageNeedsSync ? 1 : 0,
});
}
}
2021-01-27 22:39:45 +00:00
async function clearAllErrorStickerPackAttempts(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-01-27 22:39:45 +00:00
db.prepare<EmptyQuery>(
`
UPDATE sticker_packs
SET downloadAttempts = 0
WHERE status = 'error';
`
).run();
2021-01-27 22:39:45 +00:00
}
async function createOrUpdateSticker(sticker: StickerType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-11-11 22:43:05 +00:00
const { emoji, height, id, isCoverOnly, lastUsed, packId, path, width } =
sticker;
if (!isNumber(id)) {
throw new Error(
'createOrUpdateSticker: Provided data did not have a numeric id'
);
}
if (!packId) {
throw new Error(
'createOrUpdateSticker: Provided data did not have a truthy id'
);
}
db.prepare<Query>(
`
INSERT OR REPLACE INTO stickers (
emoji,
height,
id,
isCoverOnly,
lastUsed,
packId,
path,
width
) values (
$emoji,
$height,
$id,
$isCoverOnly,
$lastUsed,
$packId,
$path,
$width
)
`
).run({
2021-07-09 19:36:10 +00:00
emoji: emoji ?? null,
height,
id,
isCoverOnly: isCoverOnly ? 1 : 0,
lastUsed: lastUsed || null,
packId,
path,
width,
});
}
async function updateStickerLastUsed(
packId: string,
stickerId: number,
lastUsed: number
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>(
`
UPDATE stickers
SET lastUsed = $lastUsed
WHERE id = $id AND packId = $packId;
`
).run({
id: stickerId,
packId,
lastUsed,
});
db.prepare<Query>(
`
UPDATE sticker_packs
SET lastUsed = $lastUsed
WHERE id = $id;
`
).run({
id: packId,
lastUsed,
});
}
async function addStickerPackReference(
messageId: string,
packId: string
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
if (!messageId) {
throw new Error(
'addStickerPackReference: Provided data did not have a truthy messageId'
);
}
if (!packId) {
throw new Error(
'addStickerPackReference: Provided data did not have a truthy packId'
);
}
db.prepare<Query>(
`
INSERT OR REPLACE INTO sticker_references (
messageId,
packId
) values (
$messageId,
$packId
)
`
2021-04-09 00:50:25 +00:00
).run({
messageId,
packId,
});
}
async function deleteStickerPackReference(
messageId: string,
packId: string
): Promise<ReadonlyArray<string> | undefined> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
if (!messageId) {
throw new Error(
'addStickerPackReference: Provided data did not have a truthy messageId'
);
}
if (!packId) {
throw new Error(
'addStickerPackReference: Provided data did not have a truthy packId'
);
}
return db
.transaction(() => {
// We use an immediate transaction here to immediately acquire an exclusive lock,
// which would normally only happen when we did our first write.
// We need this to ensure that our five queries are all atomic, with no
// other changes happening while we do it:
// 1. Delete our target messageId/packId references
// 2. Check the number of references still pointing at packId
// 3. If that number is zero, get pack from sticker_packs database
// 4. If it's not installed, then grab all of its sticker paths
// 5. If it's not installed, then sticker pack (which cascades to all
// stickers and references)
db.prepare<Query>(
`
DELETE FROM sticker_references
WHERE messageId = $messageId AND packId = $packId;
`
).run({
messageId,
packId,
});
2023-01-17 21:07:21 +00:00
const count = db
.prepare<Query>(
`
2023-01-17 21:07:21 +00:00
SELECT count(1) FROM sticker_references
WHERE packId = $packId;
`
)
2023-01-17 21:07:21 +00:00
.pluck()
.get({ packId });
if (count > 0) {
return undefined;
}
const packRow: { status: StickerPackStatusType } = db
.prepare<Query>(
`
SELECT status FROM sticker_packs
WHERE id = $packId;
`
)
.get({ packId });
if (!packRow) {
logger.warn('deleteStickerPackReference: did not find referenced pack');
return undefined;
}
const { status } = packRow;
if (status === 'installed') {
return undefined;
}
const stickerPathRows: Array<{ path: string }> = db
.prepare<Query>(
`
SELECT path FROM stickers
WHERE packId = $packId;
`
)
.all({
packId,
});
db.prepare<Query>(
`
DELETE FROM sticker_packs
WHERE id = $packId;
`
).run({
packId,
});
return (stickerPathRows || []).map(row => row.path);
})
.immediate();
}
async function deleteStickerPack(packId: string): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
if (!packId) {
throw new Error(
'deleteStickerPack: Provided data did not have a truthy packId'
);
}
return db
.transaction(() => {
// We use an immediate transaction here to immediately acquire an exclusive lock,
// which would normally only happen when we did our first write.
// We need this to ensure that our two queries are atomic, with no other changes
// happening while we do it:
// 1. Grab all of target pack's sticker paths
// 2. Delete sticker pack (which cascades to all stickers and references)
const stickerPathRows: Array<{ path: string }> = db
.prepare<Query>(
`
SELECT path FROM stickers
WHERE packId = $packId;
`
)
.all({
packId,
});
db.prepare<Query>(
`
DELETE FROM sticker_packs
WHERE id = $packId;
`
).run({ packId });
return (stickerPathRows || []).map(row => row.path);
})
.immediate();
}
async function getStickerCount(): Promise<number> {
2023-10-03 00:27:02 +00:00
return getCountFromTable(getReadonlyInstance(), 'stickers');
}
async function getAllStickerPacks(): Promise<Array<StickerPackType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = db
.prepare<EmptyQuery>(
`
SELECT * FROM sticker_packs
2022-08-03 17:10:49 +00:00
ORDER BY position ASC, id ASC
`
)
.all();
2023-05-04 18:36:17 +00:00
return rows.map(row => {
return {
...row,
// The columns have STRING type so if they have numeric value, sqlite
// will return integers.
author: String(row.author),
title: String(row.title),
};
});
2022-08-03 17:10:49 +00:00
}
2023-10-03 00:27:02 +00:00
function addUninstalledStickerPackSync(
db: Database,
pack: UninstalledStickerPackType
): void {
2022-08-03 17:10:49 +00:00
db.prepare<Query>(
`
INSERT OR REPLACE INTO uninstalled_sticker_packs
(
id, uninstalledAt, storageID, storageVersion, storageUnknownFields,
storageNeedsSync
)
VALUES
(
$id, $uninstalledAt, $storageID, $storageVersion, $unknownFields,
$storageNeedsSync
)
`
).run({
id: pack.id,
uninstalledAt: pack.uninstalledAt,
storageID: pack.storageID ?? null,
storageVersion: pack.storageVersion ?? null,
unknownFields: pack.storageUnknownFields ?? null,
storageNeedsSync: pack.storageNeedsSync ? 1 : 0,
});
}
async function addUninstalledStickerPack(
pack: UninstalledStickerPackType
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return addUninstalledStickerPackSync(db, pack);
2022-08-03 17:10:49 +00:00
}
2023-10-03 00:27:02 +00:00
function removeUninstalledStickerPackSync(db: Database, packId: string): void {
2022-08-03 17:10:49 +00:00
db.prepare<Query>(
'DELETE FROM uninstalled_sticker_packs WHERE id IS $id'
).run({ id: packId });
}
async function removeUninstalledStickerPack(packId: string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return removeUninstalledStickerPackSync(db, packId);
2022-08-03 17:10:49 +00:00
}
async function getUninstalledStickerPacks(): Promise<
Array<UninstalledStickerPackType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-08-03 17:10:49 +00:00
const rows = db
.prepare<EmptyQuery>(
'SELECT * FROM uninstalled_sticker_packs ORDER BY id ASC'
)
.all();
return rows || [];
}
async function getInstalledStickerPacks(): Promise<Array<StickerPackType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-08-03 17:10:49 +00:00
// If sticker pack has a storageID - it is being downloaded and about to be
// installed so we better sync it back to storage service if asked.
const rows = db
.prepare<EmptyQuery>(
`
SELECT *
FROM sticker_packs
WHERE
2023-01-18 22:12:33 +00:00
status IS 'installed' OR
2022-08-03 17:10:49 +00:00
storageID IS NOT NULL
ORDER BY id ASC
`
)
.all();
return rows || [];
}
2022-08-03 17:10:49 +00:00
async function getStickerPackInfo(
packId: string
): Promise<StickerPackInfoType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-08-03 17:10:49 +00:00
return db.transaction(() => {
const uninstalled = db
.prepare<Query>(
`
SELECT * FROM uninstalled_sticker_packs
WHERE id IS $packId
`
)
.get({ packId });
if (uninstalled) {
return uninstalled as UninstalledStickerPackType;
}
const installed = db
.prepare<Query>(
`
SELECT
id, key, position, storageID, storageVersion, storageUnknownFields
FROM sticker_packs
WHERE id IS $packId
`
)
.get({ packId });
if (installed) {
return installed as InstalledStickerPackType;
}
return undefined;
})();
}
async function installStickerPack(
packId: string,
timestamp: number
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-08-03 17:10:49 +00:00
return db.transaction(() => {
const status = 'installed';
2023-10-03 00:27:02 +00:00
updateStickerPackStatusSync(db, packId, status, { timestamp });
2022-08-03 17:10:49 +00:00
2023-10-03 00:27:02 +00:00
removeUninstalledStickerPackSync(db, packId);
2022-08-03 17:10:49 +00:00
})();
}
async function uninstallStickerPack(
packId: string,
timestamp: number
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-08-03 17:10:49 +00:00
return db.transaction(() => {
const status = 'downloaded';
2023-10-03 00:27:02 +00:00
updateStickerPackStatusSync(db, packId, status);
2022-08-03 17:10:49 +00:00
db.prepare<Query>(
`
UPDATE sticker_packs SET
storageID = NULL,
storageVersion = NULL,
storageUnknownFields = NULL,
storageNeedsSync = 0
WHERE id = $packId;
`
).run({ packId });
2023-10-03 00:27:02 +00:00
addUninstalledStickerPackSync(db, {
2022-08-03 17:10:49 +00:00
id: packId,
uninstalledAt: timestamp,
storageNeedsSync: true,
});
})();
}
async function getAllStickers(): Promise<Array<StickerType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = db
.prepare<EmptyQuery>(
`
SELECT * FROM stickers
ORDER BY packId ASC, id ASC
`
)
.all();
return (rows || []).map(row => rowToSticker(row));
}
async function getRecentStickers({ limit }: { limit?: number } = {}): Promise<
Array<StickerType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
// Note: we avoid 'IS NOT NULL' here because it does seem to bypass our index
const rows = db
.prepare<Query>(
`
SELECT stickers.* FROM stickers
JOIN sticker_packs on stickers.packId = sticker_packs.id
WHERE stickers.lastUsed > 0 AND sticker_packs.status = 'installed'
ORDER BY stickers.lastUsed DESC
LIMIT $limit
`
)
.all({
limit: limit || 24,
});
return (rows || []).map(row => rowToSticker(row));
}
2019-05-24 23:58:27 +00:00
// Emojis
async function updateEmojiUsage(
shortName: string,
timeUsed: number = Date.now()
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2019-05-24 23:58:27 +00:00
db.transaction(() => {
const rows = db
.prepare<Query>(
`
SELECT * FROM emojis
WHERE shortName = $shortName;
`
)
.get({
shortName,
});
if (rows) {
db.prepare<Query>(
`
UPDATE emojis
SET lastUsage = $timeUsed
WHERE shortName = $shortName;
`
).run({ shortName, timeUsed });
} else {
db.prepare<Query>(
`
INSERT INTO emojis(shortName, lastUsage)
VALUES ($shortName, $timeUsed);
`
).run({ shortName, timeUsed });
2019-05-24 23:58:27 +00:00
}
})();
2019-05-24 23:58:27 +00:00
}
async function getRecentEmojis(limit = 32): Promise<Array<EmojiType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = db
.prepare<Query>(
`
SELECT *
FROM emojis
ORDER BY lastUsage DESC
LIMIT $limit;
`
)
.all({ limit });
2019-05-24 23:58:27 +00:00
return rows || [];
}
2021-11-02 23:01:13 +00:00
async function getAllBadges(): Promise<Array<BadgeType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2021-11-02 23:01:13 +00:00
const [badgeRows, badgeImageFileRows] = db.transaction(() => [
db.prepare<EmptyQuery>('SELECT * FROM badges').all(),
db.prepare<EmptyQuery>('SELECT * FROM badgeImageFiles').all(),
])();
const badgeImagesByBadge = new Map<
string,
Array<undefined | BadgeImageType>
>();
for (const badgeImageFileRow of badgeImageFileRows) {
const { badgeId, order, localPath, url, theme } = badgeImageFileRow;
const badgeImages = badgeImagesByBadge.get(badgeId) || [];
badgeImages[order] = {
...(badgeImages[order] || {}),
[parseBadgeImageTheme(theme)]: {
localPath: dropNull(localPath),
url,
},
};
badgeImagesByBadge.set(badgeId, badgeImages);
}
return badgeRows.map(badgeRow => ({
id: badgeRow.id,
category: parseBadgeCategory(badgeRow.category),
name: badgeRow.name,
descriptionTemplate: badgeRow.descriptionTemplate,
images: (badgeImagesByBadge.get(badgeRow.id) || []).filter(isNotNil),
}));
}
// This should match the logic in the badges Redux reducer.
async function updateOrCreateBadges(
badges: ReadonlyArray<BadgeType>
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-11-02 23:01:13 +00:00
const insertBadge = prepare<Query>(
db,
`
INSERT OR REPLACE INTO badges (
id,
category,
name,
descriptionTemplate
) VALUES (
$id,
$category,
$name,
$descriptionTemplate
);
`
);
const getImageFilesForBadge = prepare<Query>(
db,
'SELECT url, localPath FROM badgeImageFiles WHERE badgeId = $badgeId'
);
const insertBadgeImageFile = prepare<Query>(
db,
`
INSERT INTO badgeImageFiles (
badgeId,
'order',
url,
localPath,
theme
) VALUES (
$badgeId,
$order,
$url,
$localPath,
$theme
);
`
);
db.transaction(() => {
badges.forEach(badge => {
const { id: badgeId } = badge;
const oldLocalPaths = new Map<string, string>();
for (const { url, localPath } of getImageFilesForBadge.all({ badgeId })) {
if (localPath) {
oldLocalPaths.set(url, localPath);
}
}
insertBadge.run({
id: badgeId,
category: badge.category,
name: badge.name,
descriptionTemplate: badge.descriptionTemplate,
});
for (const [order, image] of badge.images.entries()) {
for (const [theme, imageFile] of Object.entries(image)) {
insertBadgeImageFile.run({
badgeId,
localPath:
imageFile.localPath || oldLocalPaths.get(imageFile.url) || null,
order,
theme,
url: imageFile.url,
});
}
}
});
})();
}
async function badgeImageFileDownloaded(
url: string,
localPath: string
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-11-02 23:01:13 +00:00
prepare<Query>(
db,
'UPDATE badgeImageFiles SET localPath = $localPath WHERE url = $url'
).run({ url, localPath });
}
async function getAllBadgeImageFileLocalPaths(): Promise<Set<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2021-11-02 23:01:13 +00:00
const localPaths = db
.prepare<EmptyQuery>(
'SELECT localPath FROM badgeImageFiles WHERE localPath IS NOT NULL'
)
.pluck()
.all();
return new Set(localPaths);
}
function runCorruptionChecks(): void {
let db: Database;
try {
db = getUnsafeWritableInstance('integrity check');
} catch (error) {
logger.error(
'runCorruptionChecks: not running the check, no writable instance',
Errors.toLogFormat(error)
);
return;
}
try {
const result = db.pragma('integrity_check');
if (result.length === 1 && result.at(0)?.integrity_check === 'ok') {
logger.info('runCorruptionChecks: general integrity is ok');
} else {
logger.error('runCorruptionChecks: general integrity is not ok', result);
}
} catch (error) {
logger.error(
'runCorruptionChecks: general integrity check error',
Errors.toLogFormat(error)
);
}
try {
db.exec("INSERT INTO messages_fts(messages_fts) VALUES('integrity-check')");
logger.info('runCorruptionChecks: FTS5 integrity ok');
} catch (error) {
logger.error(
'runCorruptionChecks: FTS5 integrity check error.',
Errors.toLogFormat(error)
);
}
}
type StoryDistributionForDatabase = Readonly<
{
2022-07-01 00:52:03 +00:00
allowsReplies: 0 | 1;
deletedAtTimestamp: number | null;
isBlockList: 0 | 1;
senderKeyInfoJson: string | null;
storageID: string | null;
storageVersion: number | null;
2022-07-01 00:52:03 +00:00
storageNeedsSync: 0 | 1;
} & Omit<
StoryDistributionType,
| 'allowsReplies'
| 'deletedAtTimestamp'
| 'isBlockList'
| 'senderKeyInfo'
| 'storageID'
| 'storageVersion'
2022-07-01 00:52:03 +00:00
| 'storageNeedsSync'
>
>;
function hydrateStoryDistribution(
fromDatabase: StoryDistributionForDatabase
): StoryDistributionType {
return {
...omit(fromDatabase, 'senderKeyInfoJson'),
2022-07-01 00:52:03 +00:00
allowsReplies: Boolean(fromDatabase.allowsReplies),
deletedAtTimestamp: fromDatabase.deletedAtTimestamp || undefined,
isBlockList: Boolean(fromDatabase.isBlockList),
senderKeyInfo: fromDatabase.senderKeyInfoJson
? JSON.parse(fromDatabase.senderKeyInfoJson)
: undefined,
storageID: fromDatabase.storageID || undefined,
storageVersion: fromDatabase.storageVersion || undefined,
2022-07-01 00:52:03 +00:00
storageNeedsSync: Boolean(fromDatabase.storageNeedsSync),
storageUnknownFields: fromDatabase.storageUnknownFields || undefined,
};
}
function freezeStoryDistribution(
story: StoryDistributionType
): StoryDistributionForDatabase {
return {
...omit(story, 'senderKeyInfo'),
2022-07-01 00:52:03 +00:00
allowsReplies: story.allowsReplies ? 1 : 0,
deletedAtTimestamp: story.deletedAtTimestamp || null,
isBlockList: story.isBlockList ? 1 : 0,
senderKeyInfoJson: story.senderKeyInfo
? JSON.stringify(story.senderKeyInfo)
: null,
storageID: story.storageID || null,
storageVersion: story.storageVersion || null,
2022-07-01 00:52:03 +00:00
storageNeedsSync: story.storageNeedsSync ? 1 : 0,
storageUnknownFields: story.storageUnknownFields || null,
};
}
async function _getAllStoryDistributions(): Promise<
Array<StoryDistributionType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const storyDistributions = db
.prepare<EmptyQuery>('SELECT * FROM storyDistributions;')
.all();
return storyDistributions.map(hydrateStoryDistribution);
}
async function _getAllStoryDistributionMembers(): Promise<
Array<StoryDistributionMemberType>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db
.prepare<EmptyQuery>('SELECT * FROM storyDistributionMembers;')
.all();
}
async function _deleteAllStoryDistributions(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>('DELETE FROM storyDistributions;').run();
}
async function createNewStoryDistribution(
distribution: StoryDistributionWithMembersType
): Promise<void> {
strictAssert(
distribution.name,
'Distribution list does not have a valid name'
);
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.transaction(() => {
const payload = freezeStoryDistribution(distribution);
prepare(
db,
`
INSERT INTO storyDistributions(
id,
name,
2022-07-01 00:52:03 +00:00
deletedAtTimestamp,
allowsReplies,
isBlockList,
senderKeyInfoJson,
storageID,
storageVersion,
storageUnknownFields,
storageNeedsSync
) VALUES (
$id,
$name,
2022-07-01 00:52:03 +00:00
$deletedAtTimestamp,
$allowsReplies,
$isBlockList,
$senderKeyInfoJson,
$storageID,
$storageVersion,
$storageUnknownFields,
$storageNeedsSync
);
`
).run(payload);
const { id: listId, members } = distribution;
const memberInsertStatement = prepare(
db,
`
INSERT OR REPLACE INTO storyDistributionMembers (
listId,
2023-08-16 20:54:39 +00:00
serviceId
) VALUES (
$listId,
2023-08-16 20:54:39 +00:00
$serviceId
);
`
);
2023-08-16 20:54:39 +00:00
for (const serviceId of members) {
memberInsertStatement.run({
listId,
2023-08-16 20:54:39 +00:00
serviceId,
});
}
})();
}
async function getAllStoryDistributionsWithMembers(): Promise<
Array<StoryDistributionWithMembersType>
> {
const allDistributions = await _getAllStoryDistributions();
const allMembers = await _getAllStoryDistributionMembers();
const byListId = groupBy(allMembers, member => member.listId);
return allDistributions.map(list => ({
...list,
2023-08-16 20:54:39 +00:00
members: (byListId[list.id] || []).map(member => member.serviceId),
}));
}
2022-03-04 21:14:52 +00:00
async function getStoryDistributionWithMembers(
id: string
): Promise<StoryDistributionWithMembersType | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const storyDistribution: StoryDistributionForDatabase | undefined = prepare(
2022-03-04 21:14:52 +00:00
db,
'SELECT * FROM storyDistributions WHERE id = $id;'
).get({
id,
});
if (!storyDistribution) {
return undefined;
}
const members = prepare(
db,
'SELECT * FROM storyDistributionMembers WHERE listId = $id;'
).all({
id,
});
return {
...hydrateStoryDistribution(storyDistribution),
2023-08-16 20:54:39 +00:00
members: members.map(({ serviceId }) => serviceId),
2022-03-04 21:14:52 +00:00
};
}
2022-07-01 00:52:03 +00:00
function modifyStoryDistributionSync(
db: Database,
payload: StoryDistributionForDatabase
): void {
if (payload.deletedAtTimestamp) {
strictAssert(
!payload.name,
'Attempt to delete distribution list but still has a name'
);
} else {
strictAssert(
payload.name,
'Cannot clear distribution list name without deletedAtTimestamp set'
);
}
prepare(
db,
`
UPDATE storyDistributions
SET
name = $name,
2022-07-01 00:52:03 +00:00
deletedAtTimestamp = $deletedAtTimestamp,
allowsReplies = $allowsReplies,
isBlockList = $isBlockList,
senderKeyInfoJson = $senderKeyInfoJson,
storageID = $storageID,
storageVersion = $storageVersion,
storageUnknownFields = $storageUnknownFields,
storageNeedsSync = $storageNeedsSync
WHERE id = $id
`
).run(payload);
}
2022-07-01 00:52:03 +00:00
function modifyStoryDistributionMembersSync(
db: Database,
listId: string,
{
toAdd,
toRemove,
}: { toAdd: Array<ServiceIdString>; toRemove: Array<ServiceIdString> }
2022-07-01 00:52:03 +00:00
) {
const memberInsertStatement = prepare(
db,
`
INSERT OR REPLACE INTO storyDistributionMembers (
listId,
2023-08-16 20:54:39 +00:00
serviceId
2022-07-01 00:52:03 +00:00
) VALUES (
$listId,
2023-08-16 20:54:39 +00:00
$serviceId
2022-07-01 00:52:03 +00:00
);
`
);
2023-08-16 20:54:39 +00:00
for (const serviceId of toAdd) {
2022-07-01 00:52:03 +00:00
memberInsertStatement.run({
listId,
2023-08-16 20:54:39 +00:00
serviceId,
2022-07-01 00:52:03 +00:00
});
}
2023-08-16 20:54:39 +00:00
batchMultiVarQuery(
db,
toRemove,
(serviceIds: ReadonlyArray<ServiceIdString>) => {
const serviceIdSet = sqlJoin(serviceIds, '?');
const [sqlQuery, sqlParams] = sql`
DELETE FROM storyDistributionMembers
WHERE listId = ${listId} AND serviceId IN (${serviceIdSet});
`;
db.prepare(sqlQuery).run(sqlParams);
}
);
2022-07-01 00:52:03 +00:00
}
async function modifyStoryDistributionWithMembers(
distribution: StoryDistributionType,
{
toAdd,
toRemove,
}: { toAdd: Array<ServiceIdString>; toRemove: Array<ServiceIdString> }
2022-07-01 00:52:03 +00:00
): Promise<void> {
const payload = freezeStoryDistribution(distribution);
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-07-01 00:52:03 +00:00
if (toAdd.length || toRemove.length) {
db.transaction(() => {
modifyStoryDistributionSync(db, payload);
modifyStoryDistributionMembersSync(db, payload.id, { toAdd, toRemove });
})();
} else {
modifyStoryDistributionSync(db, payload);
}
}
async function modifyStoryDistribution(
distribution: StoryDistributionType
): Promise<void> {
const payload = freezeStoryDistribution(distribution);
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-07-01 00:52:03 +00:00
modifyStoryDistributionSync(db, payload);
}
async function modifyStoryDistributionMembers(
listId: string,
{
toAdd,
toRemove,
}: { toAdd: Array<ServiceIdString>; toRemove: Array<ServiceIdString> }
2022-07-01 00:52:03 +00:00
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-07-01 00:52:03 +00:00
db.transaction(() => {
modifyStoryDistributionMembersSync(db, listId, { toAdd, toRemove });
})();
}
async function deleteStoryDistribution(
id: StoryDistributionIdString
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<Query>('DELETE FROM storyDistributions WHERE id = $id;').run({
id,
});
}
async function _getAllStoryReads(): Promise<Array<StoryReadType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db.prepare<EmptyQuery>('SELECT * FROM storyReads;').all();
}
async function _deleteAllStoryReads(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.prepare<EmptyQuery>('DELETE FROM storyReads;').run();
}
async function addNewStoryRead(read: StoryReadType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
prepare(
db,
`
INSERT OR REPLACE INTO storyReads(
authorId,
conversationId,
storyId,
storyReadDate
) VALUES (
$authorId,
$conversationId,
$storyId,
$storyReadDate
);
`
).run(read);
}
async function getLastStoryReadsForAuthor({
authorId,
conversationId,
limit: initialLimit,
}: {
authorId: ServiceIdString;
conversationId?: string;
limit?: number;
}): Promise<Array<StoryReadType>> {
const limit = initialLimit || 5;
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
return db
.prepare<Query>(
`
SELECT * FROM storyReads
WHERE
authorId = $authorId AND
($conversationId IS NULL OR conversationId = $conversationId)
ORDER BY storyReadDate DESC
LIMIT $limit;
`
)
.all({
authorId,
conversationId: conversationId || null,
limit,
});
}
2022-03-29 01:10:08 +00:00
async function countStoryReadsByConversation(
conversationId: string
): Promise<number> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-03-29 01:10:08 +00:00
return db
.prepare<Query>(
`
2023-01-17 21:07:21 +00:00
SELECT count(1) FROM storyReads
2022-03-29 01:10:08 +00:00
WHERE conversationId = $conversationId;
`
)
.pluck()
.get({ conversationId });
}
2018-10-18 01:01:21 +00:00
// All data in database
async function removeAll(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.transaction(() => {
db.exec(`
2023-08-25 16:29:42 +00:00
--- Remove messages delete trigger for performance
DROP TRIGGER messages_on_delete;
DELETE FROM attachment_downloads;
2021-11-02 23:01:13 +00:00
DELETE FROM badgeImageFiles;
DELETE FROM badges;
2023-08-09 00:53:06 +00:00
DELETE FROM callsHistory;
DELETE FROM conversations;
DELETE FROM emojis;
DELETE FROM groupCallRingCancellations;
DELETE FROM identityKeys;
DELETE FROM items;
DELETE FROM jobs;
DELETE FROM kyberPreKeys;
DELETE FROM messages_fts;
DELETE FROM messages;
DELETE FROM preKeys;
DELETE FROM reactions;
DELETE FROM senderKeys;
DELETE FROM sendLogMessageIds;
DELETE FROM sendLogPayloads;
DELETE FROM sendLogRecipients;
DELETE FROM sessions;
DELETE FROM signedPreKeys;
DELETE FROM sticker_packs;
DELETE FROM sticker_references;
DELETE FROM stickers;
DELETE FROM storyDistributionMembers;
DELETE FROM storyDistributions;
DELETE FROM storyReads;
DELETE FROM unprocessed;
DELETE FROM uninstalled_sticker_packs;
2023-01-26 23:53:22 +00:00
2023-10-10 23:55:32 +00:00
INSERT INTO messages_fts(messages_fts) VALUES('optimize');
2023-08-25 16:29:42 +00:00
--- Re-create the messages delete trigger
--- See migration 45
CREATE TRIGGER messages_on_delete AFTER DELETE ON messages BEGIN
DELETE FROM messages_fts WHERE rowid = old.rowid;
DELETE FROM sendLogPayloads WHERE id IN (
SELECT payloadId FROM sendLogMessageIds
WHERE messageId = old.id
);
DELETE FROM reactions WHERE rowid IN (
SELECT rowid FROM reactions
WHERE messageId = old.id
);
DELETE FROM storyReads WHERE storyId = old.storyId;
END;
`);
})();
2018-10-18 01:01:21 +00:00
}
// Anything that isn't user-visible data
async function removeAllConfiguration(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2018-10-18 01:01:21 +00:00
db.transaction(() => {
2021-05-27 20:47:39 +00:00
db.exec(
2021-05-25 22:40:04 +00:00
`
DELETE FROM identityKeys;
DELETE FROM jobs;
DELETE FROM kyberPreKeys;
DELETE FROM preKeys;
DELETE FROM senderKeys;
DELETE FROM sendLogMessageIds;
DELETE FROM sendLogPayloads;
DELETE FROM sendLogRecipients;
DELETE FROM sessions;
DELETE FROM signedPreKeys;
DELETE FROM unprocessed;
`
2021-05-27 20:47:39 +00:00
);
const itemIds: ReadonlyArray<string> = db
.prepare<EmptyQuery>('SELECT id FROM items')
.pluck(true)
.all();
const allowedSet = new Set<string>(STORAGE_UI_KEYS);
for (const id of itemIds) {
if (!allowedSet.has(id)) {
removeById(db, 'items', id);
}
}
db.exec(
2023-10-11 18:38:03 +00:00
`
UPDATE conversations SET json = json_remove(json, '$.senderKeyInfo');
UPDATE storyDistributions SET senderKeyInfoJson = NULL;
`
2021-05-27 20:47:39 +00:00
);
})();
}
async function eraseStorageServiceState(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
db.exec(`
-- Conversations
UPDATE conversations
SET
json = json_remove(json, '$.storageID', '$.needsStorageServiceSync', '$.storageUnknownFields');
-- Stickers
UPDATE sticker_packs
SET
storageID = null,
storageVersion = null,
storageUnknownFields = null,
storageNeedsSync = 0;
UPDATE uninstalled_sticker_packs
SET
storageID = null,
storageVersion = null,
storageUnknownFields = null,
storageNeedsSync = 0;
-- Story Distribution Lists
UPDATE storyDistributions
SET
storageID = null,
storageVersion = null,
storageUnknownFields = null,
storageNeedsSync = 0;
`);
}
const MAX_MESSAGE_MIGRATION_ATTEMPTS = 5;
async function getMessagesNeedingUpgrade(
limit: number,
{ maxVersion }: { maxVersion: number }
): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<Query>(
`
SELECT json
FROM messages
WHERE
(schemaVersion IS NULL OR schemaVersion < $maxVersion) AND
IFNULL(
json_extract(json, '$.schemaMigrationAttempts'),
0
) < $maxAttempts
LIMIT $limit;
`
)
.all({
maxVersion,
maxAttempts: MAX_MESSAGE_MIGRATION_ATTEMPTS,
limit,
});
return rows.map(row => jsonToObject(row.json));
}
async function getMessagesWithVisualMediaAttachments(
conversationId: string,
{ limit }: { limit: number }
): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows: JSONRows = db
.prepare<Query>(
`
2023-03-04 03:03:15 +00:00
SELECT json FROM messages
INDEXED BY messages_hasVisualMediaAttachments
WHERE
isStory IS 0 AND
storyId IS NULL AND
conversationId = $conversationId AND
2023-03-04 03:03:15 +00:00
-- Note that this check has to use 'IS' to utilize
-- 'messages_hasVisualMediaAttachments' INDEX
hasVisualMediaAttachments IS 1
ORDER BY received_at DESC, sent_at DESC
LIMIT $limit;
`
)
.all({
conversationId,
limit,
});
return rows.map(row => jsonToObject(row.json));
}
async function getMessagesWithFileAttachments(
conversationId: string,
{ limit }: { limit: number }
): Promise<Array<MessageType>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const rows = db
.prepare<Query>(
`
SELECT json FROM messages WHERE
isStory IS 0 AND
storyId IS NULL AND
conversationId = $conversationId AND
hasFileAttachments = 1
ORDER BY received_at DESC, sent_at DESC
LIMIT $limit;
`
)
.all({
conversationId,
limit,
});
return map(rows, row => jsonToObject(row.json));
}
async function getMessageServerGuidsForSpam(
conversationId: string
): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
// The server's maximum is 3, which is why you see `LIMIT 3` in this query. Note that we
// use `pluck` here to only get the first column!
return db
.prepare<Query>(
`
SELECT serverGuid
FROM messages
WHERE conversationId = $conversationId
AND type = 'incoming'
AND serverGuid IS NOT NULL
ORDER BY received_at DESC, sent_at DESC
LIMIT 3;
`
)
.pluck(true)
.all({ conversationId });
}
function getExternalFilesForMessage(message: MessageType): Array<string> {
const { attachments, contact, quote, preview, sticker } = message;
const files: Array<string> = [];
forEach(attachments, attachment => {
const { path: file, thumbnail, screenshot } = attachment;
if (file) {
files.push(file);
}
if (thumbnail && thumbnail.path) {
files.push(thumbnail.path);
}
if (screenshot && screenshot.path) {
files.push(screenshot.path);
}
});
if (quote && quote.attachments && quote.attachments.length) {
forEach(quote.attachments, attachment => {
const { thumbnail } = attachment;
if (thumbnail && thumbnail.path) {
files.push(thumbnail.path);
}
});
}
if (contact && contact.length) {
forEach(contact, item => {
const { avatar } = item;
if (avatar && avatar.avatar && avatar.avatar.path) {
files.push(avatar.avatar.path);
}
});
}
2019-01-16 03:03:56 +00:00
if (preview && preview.length) {
forEach(preview, item => {
const { image } = item;
if (image && image.path) {
files.push(image.path);
}
});
}
if (sticker && sticker.data && sticker.data.path) {
files.push(sticker.data.path);
if (sticker.data.thumbnail && sticker.data.thumbnail.path) {
files.push(sticker.data.thumbnail.path);
}
}
return files;
}
function getExternalFilesForConversation(
conversation: Pick<ConversationType, 'avatar' | 'profileAvatar'>
): Array<string> {
2018-09-21 01:47:19 +00:00
const { avatar, profileAvatar } = conversation;
const files: Array<string> = [];
2018-09-21 01:47:19 +00:00
if (avatar && avatar.path) {
files.push(avatar.path);
}
if (profileAvatar && profileAvatar.path) {
files.push(profileAvatar.path);
}
return files;
}
function getExternalDraftFilesForConversation(
conversation: Pick<ConversationType, 'draftAttachments'>
): Array<string> {
2019-08-07 00:40:25 +00:00
const draftAttachments = conversation.draftAttachments || [];
const files: Array<string> = [];
2019-08-07 00:40:25 +00:00
forEach(draftAttachments, attachment => {
2021-08-30 21:32:56 +00:00
if (attachment.pending) {
return;
}
2019-08-07 00:40:25 +00:00
const { path: file, screenshotPath } = attachment;
if (file) {
files.push(file);
}
if (screenshotPath) {
files.push(screenshotPath);
}
});
return files;
}
async function getKnownMessageAttachments(
cursor?: MessageAttachmentsCursorType
): Promise<GetKnownMessageAttachmentsResultType> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const result = new Set<string>();
const chunkSize = 1000;
return db.transaction(() => {
let count = cursor?.count ?? 0;
strictAssert(
!cursor?.done,
'getKnownMessageAttachments: iteration cannot be restarted'
);
let runId: string;
if (cursor === undefined) {
runId = randomBytes(8).toString('hex');
const total = getMessageCountSync();
logger.info(
`getKnownMessageAttachments(${runId}): ` +
`Starting iteration through ${total} messages`
);
db.exec(
`
CREATE TEMP TABLE tmp_${runId}_updated_messages
(rowid INTEGER PRIMARY KEY ASC);
INSERT INTO tmp_${runId}_updated_messages (rowid)
SELECT rowid FROM messages;
CREATE TEMP TRIGGER tmp_${runId}_message_updates
UPDATE OF json ON messages
BEGIN
INSERT OR IGNORE INTO tmp_${runId}_updated_messages (rowid)
VALUES (NEW.rowid);
END;
CREATE TEMP TRIGGER tmp_${runId}_message_inserts
AFTER INSERT ON messages
BEGIN
INSERT OR IGNORE INTO tmp_${runId}_updated_messages (rowid)
VALUES (NEW.rowid);
END;
`
);
} else {
({ runId } = cursor);
}
const rowids: Array<number> = db
.prepare<Query>(
`
DELETE FROM tmp_${runId}_updated_messages
RETURNING rowid
LIMIT $chunkSize;
`
)
.pluck()
.all({ chunkSize });
const messages = batchMultiVarQuery(
db,
rowids,
(batch: ReadonlyArray<number>): Array<MessageType> => {
const query = db.prepare<ArrayQuery>(
`SELECT json FROM messages WHERE rowid IN (${Array(batch.length)
.fill('?')
.join(',')});`
);
const rows: JSONRows = query.all(batch);
return rows.map(row => jsonToObject(row.json));
}
);
for (const message of messages) {
const externalFiles = getExternalFilesForMessage(message);
forEach(externalFiles, file => result.add(file));
count += 1;
}
2022-11-17 20:06:19 +00:00
const done = rowids.length < chunkSize;
return {
attachments: Array.from(result),
cursor: { runId, count, done },
};
})();
}
async function finishGetKnownMessageAttachments({
runId,
count,
done,
}: MessageAttachmentsCursorType): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const logId = `finishGetKnownMessageAttachments(${runId})`;
if (!done) {
logger.warn(`${logId}: iteration not finished`);
}
logger.info(`${logId}: reached the end after processing ${count} messages`);
db.exec(`
DROP TABLE tmp_${runId}_updated_messages;
DROP TRIGGER tmp_${runId}_message_updates;
DROP TRIGGER tmp_${runId}_message_inserts;
`);
}
async function getKnownConversationAttachments(): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const result = new Set<string>();
const chunkSize = 500;
2021-10-26 22:59:08 +00:00
let complete = false;
let id = '';
2018-09-21 01:47:19 +00:00
2021-04-14 15:50:45 +00:00
const conversationTotal = await getConversationCount();
logger.info(
'getKnownConversationAttachments: About to iterate through ' +
`${conversationTotal}`
2018-09-21 01:47:19 +00:00
);
2021-10-05 16:36:07 +00:00
const fetchConversations = db.prepare<Query>(
`
SELECT json FROM conversations
WHERE id > $id
ORDER BY id ASC
LIMIT $chunkSize;
`
);
2018-09-21 01:47:19 +00:00
while (!complete) {
2021-10-05 16:36:07 +00:00
const rows = fetchConversations.all({
id,
chunkSize,
});
2018-09-21 01:47:19 +00:00
const conversations: Array<ConversationType> = map(rows, row =>
jsonToObject(row.json)
);
conversations.forEach(conversation => {
2018-09-21 01:47:19 +00:00
const externalFiles = getExternalFilesForConversation(conversation);
externalFiles.forEach(file => result.add(file));
2018-09-21 01:47:19 +00:00
});
const lastMessage: ConversationType | undefined = last(conversations);
2018-09-21 01:47:19 +00:00
if (lastMessage) {
({ id } = lastMessage);
}
complete = conversations.length < chunkSize;
}
logger.info('getKnownConversationAttachments: Done processing');
2018-09-21 01:47:19 +00:00
return Array.from(result);
}
async function removeKnownStickers(
allStickers: ReadonlyArray<string>
): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const lookup: Dictionary<boolean> = fromPairs(
map(allStickers, file => [file, true])
);
const chunkSize = 50;
2021-09-07 16:12:26 +00:00
const total = await getStickerCount();
logger.info(
`removeKnownStickers: About to iterate through ${total} stickers`
);
let count = 0;
let complete = false;
let rowid = 0;
while (!complete) {
const rows: Array<{ rowid: number; path: string }> = db
.prepare<Query>(
`
SELECT rowid, path FROM stickers
WHERE rowid > $rowid
ORDER BY rowid ASC
LIMIT $chunkSize;
`
)
.all({
rowid,
chunkSize,
});
const files: Array<string> = rows.map(row => row.path);
files.forEach(file => {
delete lookup[file];
});
const lastSticker = last(rows);
if (lastSticker) {
({ rowid } = lastSticker);
}
complete = rows.length < chunkSize;
count += rows.length;
}
logger.info(`removeKnownStickers: Done processing ${count} stickers`);
return Object.keys(lookup);
}
2019-08-07 00:40:25 +00:00
async function removeKnownDraftAttachments(
allStickers: ReadonlyArray<string>
): Promise<Array<string>> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
const lookup: Dictionary<boolean> = fromPairs(
map(allStickers, file => [file, true])
);
2019-08-07 00:40:25 +00:00
const chunkSize = 50;
2021-04-14 15:50:45 +00:00
const total = await getConversationCount();
logger.info(
2019-08-07 00:40:25 +00:00
`removeKnownDraftAttachments: About to iterate through ${total} conversations`
);
let complete = false;
let count = 0;
// Though conversations.id is a string, this ensures that, when coerced, this
// value is still a string but it's smaller than every other string.
let id: number | string = 0;
2019-08-07 00:40:25 +00:00
while (!complete) {
const rows: JSONRows = db
.prepare<Query>(
`
SELECT json FROM conversations
WHERE id > $id
ORDER BY id ASC
LIMIT $chunkSize;
`
)
.all({
id,
chunkSize,
});
2019-08-07 00:40:25 +00:00
const conversations: Array<ConversationType> = rows.map(row =>
jsonToObject(row.json)
);
conversations.forEach(conversation => {
2019-08-07 00:40:25 +00:00
const externalFiles = getExternalDraftFilesForConversation(conversation);
externalFiles.forEach(file => {
2019-08-07 00:40:25 +00:00
delete lookup[file];
});
});
const lastMessage: ConversationType | undefined = last(conversations);
2019-08-07 00:40:25 +00:00
if (lastMessage) {
({ id } = lastMessage);
}
complete = conversations.length < chunkSize;
count += conversations.length;
}
logger.info(
2019-08-07 00:40:25 +00:00
`removeKnownDraftAttachments: Done processing ${count} conversations`
);
return Object.keys(lookup);
}
2021-04-29 23:02:27 +00:00
2023-10-10 23:55:32 +00:00
const OPTIMIZE_FTS_PAGE_COUNT = 64;
// This query is incremental. It gets the `state` from the return value of
// previous `optimizeFTS` call. When `state.done` is `true` - optimization is
// complete.
async function optimizeFTS(
state?: FTSOptimizationStateType
): Promise<FTSOptimizationStateType | undefined> {
// See https://www.sqlite.org/fts5.html#the_merge_command
let pageCount = OPTIMIZE_FTS_PAGE_COUNT;
if (state === undefined) {
pageCount = -pageCount;
}
const db = await getWritableInstance();
const getChanges = prepare(db, 'SELECT total_changes() as changes;', {
pluck: true,
});
const changeDifference = db.transaction(() => {
const before: number = getChanges.get({});
prepare(
db,
`
INSERT INTO messages_fts(messages_fts, rank) VALUES ('merge', $pageCount);
`
).run({ pageCount });
const after: number = getChanges.get({});
return after - before;
})();
const nextSteps = (state?.steps ?? 0) + 1;
// From documentation:
// "If the difference is less than 2, then the 'merge' command was a no-op"
const done = changeDifference < 2;
return { steps: nextSteps, done };
}
2021-04-29 23:02:27 +00:00
async function getJobsInQueue(queueType: string): Promise<Array<StoredJob>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2022-02-16 18:36:21 +00:00
return getJobsInQueueSync(db, queueType);
}
2021-04-29 23:02:27 +00:00
2022-02-16 18:36:21 +00:00
export function getJobsInQueueSync(
db: Database,
queueType: string
): Array<StoredJob> {
2021-04-29 23:02:27 +00:00
return db
.prepare<Query>(
`
SELECT id, timestamp, data
FROM jobs
WHERE queueType = $queueType
ORDER BY timestamp;
`
)
.all({ queueType })
.map(row => ({
id: row.id,
queueType,
timestamp: row.timestamp,
data: isNotNil(row.data) ? JSON.parse(row.data) : undefined,
}));
}
2022-02-16 18:36:21 +00:00
export function insertJobSync(db: Database, job: Readonly<StoredJob>): void {
2021-04-29 23:02:27 +00:00
db.prepare<Query>(
`
INSERT INTO jobs
(id, queueType, timestamp, data)
VALUES
($id, $queueType, $timestamp, $data);
`
).run({
id: job.id,
queueType: job.queueType,
timestamp: job.timestamp,
data: isNotNil(job.data) ? JSON.stringify(job.data) : null,
});
}
async function insertJob(job: Readonly<StoredJob>): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
return insertJobSync(db, job);
}
2021-04-29 23:02:27 +00:00
async function deleteJob(id: string): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-04-29 23:02:27 +00:00
db.prepare<Query>('DELETE FROM jobs WHERE id = $id').run({ id });
}
2021-05-28 16:15:17 +00:00
async function wasGroupCallRingPreviouslyCanceled(
2021-08-20 16:06:15 +00:00
ringId: bigint
): Promise<boolean> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2021-08-20 16:06:15 +00:00
return db
.prepare<Query>(
`
SELECT EXISTS (
SELECT 1 FROM groupCallRingCancellations
WHERE ringId = $ringId
AND createdAt >= $ringsOlderThanThisAreIgnored
2021-08-20 16:06:15 +00:00
);
`
)
.pluck()
.get({
ringId,
ringsOlderThanThisAreIgnored: Date.now() - MAX_GROUP_CALL_RING_AGE,
});
2021-08-20 16:06:15 +00:00
}
async function processGroupCallRingCancellation(ringId: bigint): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-08-20 16:06:15 +00:00
db.prepare<Query>(
`
INSERT INTO groupCallRingCancellations (ringId, createdAt)
VALUES ($ringId, $createdAt)
ON CONFLICT (ringId) DO NOTHING;
2021-08-20 16:06:15 +00:00
`
).run({ ringId, createdAt: Date.now() });
}
// This age, in milliseconds, should be longer than any group call ring duration. Beyond
// that, it doesn't really matter what the value is.
const MAX_GROUP_CALL_RING_AGE = 30 * durations.MINUTE;
2021-08-20 16:06:15 +00:00
async function cleanExpiredGroupCallRingCancellations(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-08-20 16:06:15 +00:00
db.prepare<Query>(
`
DELETE FROM groupCallRingCancellations
2021-08-20 16:06:15 +00:00
WHERE createdAt < $expiredRingTime;
`
).run({
expiredRingTime: Date.now() - MAX_GROUP_CALL_RING_AGE,
});
}
2021-09-15 18:45:22 +00:00
async function getMaxMessageCounter(): Promise<number | undefined> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2021-09-15 18:45:22 +00:00
return db
.prepare<EmptyQuery>(
`
SELECT MAX(counter)
FROM
(
SELECT MAX(received_at) AS counter FROM messages
UNION
SELECT MAX(timestamp) AS counter FROM unprocessed
)
`
)
.pluck()
.get();
}
async function getStatisticsForLogging(): Promise<Record<string, string>> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
const counts = await pProps({
messageCount: getMessageCount(),
conversationCount: getConversationCount(),
2021-10-26 22:59:08 +00:00
sessionCount: getCountFromTable(db, 'sessions'),
senderKeyCount: getCountFromTable(db, 'senderKeys'),
});
return mapValues(counts, formatCountForLogging);
}
2021-05-28 16:15:17 +00:00
async function updateAllConversationColors(
conversationColor?: ConversationColorType,
customColorData?: {
id: string;
value: CustomColorType;
}
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2021-05-28 16:15:17 +00:00
db.prepare<Query>(
`
UPDATE conversations
SET json = JSON_PATCH(json, $patch);
`
).run({
patch: JSON.stringify({
conversationColor: conversationColor || null,
customColor: customColorData?.value || null,
customColorId: customColorData?.id || null,
}),
});
}
2022-07-08 20:46:25 +00:00
async function removeAllProfileKeyCredentials(): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2022-07-08 20:46:25 +00:00
db.exec(
`
UPDATE conversations
SET
json = json_remove(json, '$.profileKeyCredential')
`
);
}
2023-03-27 23:48:57 +00:00
async function saveEditedMessage(
mainMessage: MessageType,
ourAci: AciString,
{ conversationId, messageId, readStatus, sentAt }: EditedMessageType
2023-03-27 23:48:57 +00:00
): Promise<void> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-03-27 23:48:57 +00:00
db.transaction(() => {
assertSync(
2023-10-03 00:27:02 +00:00
saveMessageSync(db, mainMessage, {
ourAci,
2023-03-27 23:48:57 +00:00
alreadyInTransaction: true,
})
);
const [query, params] = sql`
INSERT INTO edited_messages (
conversationId,
2023-03-27 23:48:57 +00:00
messageId,
sentAt,
readStatus
) VALUES (
${conversationId},
2023-03-27 23:48:57 +00:00
${messageId},
${sentAt},
${readStatus}
);
`;
db.prepare(query).run(params);
})();
}
async function _getAllEditedMessages(): Promise<
Array<{ messageId: string; sentAt: number }>
> {
2023-10-03 00:27:02 +00:00
const db = getReadonlyInstance();
2023-03-27 23:48:57 +00:00
return db
.prepare<Query>(
`
SELECT * FROM edited_messages;
`
)
.all({});
}
async function getUnreadEditedMessagesAndMarkRead({
conversationId,
2023-03-27 23:48:57 +00:00
newestUnreadAt,
}: {
conversationId: string;
2023-03-27 23:48:57 +00:00
newestUnreadAt: number;
}): Promise<GetUnreadByConversationAndMarkReadResultType> {
2023-10-03 00:27:02 +00:00
const db = await getWritableInstance();
2023-03-27 23:48:57 +00:00
return db.transaction(() => {
const [selectQuery, selectParams] = sql`
SELECT
messages.id,
messages.json,
edited_messages.sentAt,
edited_messages.readStatus
FROM edited_messages
JOIN messages
ON messages.id = edited_messages.messageId
WHERE
edited_messages.readStatus = ${ReadStatus.Unread} AND
edited_messages.conversationId = ${conversationId} AND
2023-03-27 23:48:57 +00:00
received_at <= ${newestUnreadAt}
ORDER BY messages.received_at DESC, messages.sent_at DESC;
`;
const rows = db.prepare(selectQuery).all(selectParams);
if (rows.length) {
const newestSentAt = rows[0].sentAt;
const [updateStatusQuery, updateStatusParams] = sql`
UPDATE edited_messages
SET
readStatus = ${ReadStatus.Read}
WHERE
readStatus = ${ReadStatus.Unread} AND
conversationId = ${conversationId} AND
2023-03-27 23:48:57 +00:00
sentAt <= ${newestSentAt};
`;
db.prepare(updateStatusQuery).run(updateStatusParams);
}
return rows.map(row => {
const json = jsonToObject<MessageType>(row.json);
return {
originalReadStatus: row.readStatus,
readStatus: ReadStatus.Read,
seenStatus: SeenStatus.Seen,
...pick(json, [
'expirationStartTimestamp',
'id',
'sent_at',
'source',
2023-08-16 20:54:39 +00:00
'sourceServiceId',
2023-03-27 23:48:57 +00:00
'type',
]),
// Use the edited message timestamp
sent_at: row.sentAt,
};
});
})();
}