Page MenuHomePhabricator
Differential D14551

[lib] Don't show a deleted message in a preview
ClosedPublic
Actions

Authored by tomek on Fri, Apr 4, 11:46 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 16, 3:57 PM
Unknown Object (File)
Mon, Apr 14, 4:55 AM
Unknown Object (File)
Sun, Apr 13, 9:00 AM
Unknown Object (File)
Thu, Apr 10, 9:28 PM
Unknown Object (File)
Thu, Apr 10, 11:53 AM
Unknown Object (File)
Thu, Apr 10, 6:44 AM
Unknown Object (File)
Wed, Apr 9, 2:04 AM
Unknown Object (File)
Wed, Apr 9, 12:46 AM
View All 15 Files
Subscribers
None

Details

Reviewers
kamil
ashoat
Commits
rCOMM71415e97d251: [lib] Don't show a deleted message in a preview
Summary

Solve the issue in the most general way, where a message spec doesn't need to be aware of being deletable. We're checking messages in an order, which means we can build a set of deleted messages as we go. Then simply continue if a message was deleted by one of the already seen messages.

https://linear.app/comm/issue/ENG-10462/make-sure-that-deleted-messages-are-displayed-correctly-in-the-preview

Depends on D14550

Test Plan

Send two messages, delete the most recent one and check if the older one is displayed in the preview.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
hooks/
8 lines

Diff 47797

View Options

lib/hooks/message-hooks.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDebugLogs } from './debug-logs-context.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { qrCodeLinkURL } from '../facts/links.js'; import { qrCodeLinkURL } from '../facts/links.js';
import { useSecondaryDeviceLogIn } from '../hooks/login-hooks.js'; import { useSecondaryDeviceLogIn } from '../hooks/login-hooks.js';
import { uintArrayToHexString } from '../media/data-utils.js'; import { uintArrayToHexString } from '../media/data-utils.js';
import { isLoggedIn } from '../selectors/user-selectors.js'; import { isLoggedIn } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
import { platformToIdentityDeviceType } from '../types/identity-service-types.js'; import { platformToIdentityDeviceType } from '../types/identity-service-types.js';
import type { IdentityAuthResult } from '../types/identity-service-types.js';
import { import {
type TunnelbrokerToDeviceMessage, type TunnelbrokerToDeviceMessage,
tunnelbrokerToDeviceMessageTypes, tunnelbrokerToDeviceMessageTypes,
} from '../types/tunnelbroker/messages.js'; } from '../types/tunnelbroker/messages.js';
import { import {
peerToPeerMessageTypes, peerToPeerMessageTypes,
peerToPeerMessageValidator, peerToPeerMessageValidator,
type QRCodeAuthMessage, type QRCodeAuthMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js'; } from '../types/tunnelbroker/peer-to-peer-message-types.js';
import { import {
type QRCodeAuthMessagePayload, type QRCodeAuthMessagePayload,
qrCodeAuthMessageTypes, qrCodeAuthMessageTypes,
type QRAuthBackupData,
} from '../types/tunnelbroker/qr-code-auth-message-types.js'; } from '../types/tunnelbroker/qr-code-auth-message-types.js';
import { getConfig } from '../utils/config.js'; import { getConfig } from '../utils/config.js';
import { getContentSigningKey } from '../utils/crypto-utils.js'; import { getContentSigningKey } from '../utils/crypto-utils.js';
import { getMessageForException } from '../utils/errors.js'; import { getMessageForException } from '../utils/errors.js';
import { useSelector } from '../utils/redux-utils.js'; import { useDispatch, useSelector } from '../utils/redux-utils.js';
import { fullBackupSupport } from '../utils/services-utils.js';
type Props = { type Props = {
+children: React.Node, +children: React.Node,
+onLogInError: (error: mixed) => void, +onLogInError: (error: mixed) => void,
+generateAESKey: () => Promise<Uint8Array>, +generateAESKey: () => Promise<Uint8Array>,
+composeTunnelbrokerQRAuthMessage: ( +composeTunnelbrokerQRAuthMessage: (
encryptionKey: string, encryptionKey: string,
payload: QRCodeAuthMessagePayload, payload: QRCodeAuthMessagePayload,
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesfunction SecondaryDeviceQRAuthContextProvider(props: Props): React.Node {
}, [generateAESKey, setUnauthorizedDeviceID]); }, [generateAESKey, setUnauthorizedDeviceID]);
const closeSecondaryQRAuth = React.useCallback(() => { const closeSecondaryQRAuth = React.useCallback(() => {
setUnauthorizedDeviceID(null); setUnauthorizedDeviceID(null);
}, [setUnauthorizedDeviceID]); }, [setUnauthorizedDeviceID]);
const logInSecondaryDevice = useSecondaryDeviceLogIn(); const logInSecondaryDevice = useSecondaryDeviceLogIn();
const performLogIn = React.useCallback( const performLogIn = React.useCallback(
async (userID: string) => { async (userID: string): Promise<?IdentityAuthResult> => {
try { try {
await logInSecondaryDevice(userID); return await logInSecondaryDevice(userID);
} catch (err) { } catch (err) {
onLogInError(err); onLogInError(err);
void openSecondaryQRAuth(); void openSecondaryQRAuth();
return null;
} }
}, },
[logInSecondaryDevice, onLogInError, openSecondaryQRAuth], [logInSecondaryDevice, onLogInError, openSecondaryQRAuth],
); );
React.useEffect(() => { React.useEffect(() => {
if ( if (
!qrData || !qrData ||
Show All 19 Lines React.useEffect(() => {
sendMessageToDevice, sendMessageToDevice,
primaryDeviceID, primaryDeviceID,
qrData, qrData,
socketState, socketState,
composeTunnelbrokerQRAuthMessage, composeTunnelbrokerQRAuthMessage,
qrAuthFinished, qrAuthFinished,
]); ]);
const dispatch = useDispatch();
const { addLog } = useDebugLogs();
const restoreUserData = React.useCallback(
async (
backupData: ?QRAuthBackupData,
identityAuthResult: ?IdentityAuthResult,
) => {
if (!fullBackupSupport) {
return;
}
try {
const { sqliteAPI } = getConfig();
if (!identityAuthResult) {
throw new Error('Missing identityAuthResult');
}
if (!backupData) {
throw new Error('Missing backupData');
}
await sqliteAPI.restoreUserData(backupData, identityAuthResult);
const clientDBStore = await sqliteAPI.getClientDBStore(
identityAuthResult.userID,
);
dispatch({
type: setClientDBStoreActionType,
payload: clientDBStore,
});
} catch (e) {
addLog(
'Error when restoring User Data',
getMessageForException(e) ?? 'unknown error',
);
}
},
[addLog, dispatch],
);
const tunnelbrokerMessageListener = React.useCallback( const tunnelbrokerMessageListener = React.useCallback(
async (message: TunnelbrokerToDeviceMessage) => { async (message: TunnelbrokerToDeviceMessage) => {
invariant(identityClient, 'identity context not set'); invariant(identityClient, 'identity context not set');
if ( if (
!qrData?.aesKey || !qrData?.aesKey ||
message.type !== tunnelbrokerToDeviceMessageTypes.MESSAGE_TO_DEVICE || message.type !== tunnelbrokerToDeviceMessageTypes.MESSAGE_TO_DEVICE ||
socketState.isAuthorized || socketState.isAuthorized ||
loggedIn loggedIn
Show All 27 Lines async (message: TunnelbrokerToDeviceMessage) => {
if ( if (
!qrCodeAuthMessage || !qrCodeAuthMessage ||
qrCodeAuthMessage.type !== qrCodeAuthMessage.type !==
qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS
) { ) {
return; return;
} }
const { primaryDeviceID: receivedPrimaryDeviceID, userID } = const {
qrCodeAuthMessage; primaryDeviceID: receivedPrimaryDeviceID,
userID,
backupData,
} = qrCodeAuthMessage;
setPrimaryDeviceID(receivedPrimaryDeviceID); setPrimaryDeviceID(receivedPrimaryDeviceID);
try { try {
await confirmMessageToTunnelbroker(message.messageID); await confirmMessageToTunnelbroker(message.messageID);
} catch (e) { } catch (e) {
console.error( console.error(
'Error while confirming DEVICE_LIST_UPDATE_SUCCESS', 'Error while confirming DEVICE_LIST_UPDATE_SUCCESS',
getMessageForException(e), getMessageForException(e),
); );
} }
await performLogIn(userID); const identityAuthResult = await performLogIn(userID);
await restoreUserData(backupData, identityAuthResult);
setUnauthorizedDeviceID(null); setUnauthorizedDeviceID(null);
}, },
[ [
identityClient, identityClient,
qrData?.aesKey, qrData?.aesKey,
socketState.isAuthorized, socketState.isAuthorized,
loggedIn,
performLogIn, performLogIn,
restoreUserData,
setUnauthorizedDeviceID, setUnauthorizedDeviceID,
parseTunnelbrokerQRAuthMessage, parseTunnelbrokerQRAuthMessage,
confirmMessageToTunnelbroker, confirmMessageToTunnelbroker,
loggedIn,
], ],
); );
React.useEffect(() => { React.useEffect(() => {
if (!qrData?.deviceID || qrAuthFinished) { if (!qrData?.deviceID || qrAuthFinished) {
return undefined; return undefined;
} }
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines