Page MenuHomePhabricator
Differential D11728

[web] decrypt and persist plaintext in SQL transaction
ClosedPublic
Actions

Authored by kamil on Apr 22 2024, 5:23 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 11, 8:04 PM
Unknown Object (File)
Mar 4 2025, 9:07 PM
Unknown Object (File)
Mar 1 2025, 11:37 PM
Unknown Object (File)
Feb 21 2025, 8:07 AM
Unknown Object (File)
Feb 21 2025, 8:07 AM
Unknown Object (File)
Feb 21 2025, 8:07 AM
Unknown Object (File)
Feb 21 2025, 8:07 AM
Unknown Object (File)
Jan 31 2025, 7:35 PM
View All 59 Files
Subscribers
ashoat

Details

Reviewers
tomek
marcin
Commits
rCOMM5cee836172c9: [web] decrypt and persist plaintext in SQL transaction
Summary

This code attempt to decrypt and on success in one transaction persist plaintext and crypto module state.

Depends on D11727

Test Plan

Decrypt some messages and then query DB to make sure content is persisted.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
web/
shared-worker/
worker/
41 lines

Diff 39632

View Options

web/shared-worker/worker/worker-crypto.js

// @flow // @flow
import * as React from 'react'; import * as React from 'react';
import { useGetMessageAuthor } from './message-author.js'; import { useGetMessageAuthor } from './message-author.js';
import { messageInfoSelector } from '../selectors/chat-selectors.js'; import { messageInfoSelector } from '../selectors/chat-selectors.js';
import { import {
getOldestNonLocalMessageID, getOldestNonLocalMessageID,
useFetchMessages, useFetchMessages,
} from '../shared/message-utils.js'; } from '../shared/message-utils.js';
import { messageSpecs } from '../shared/messages/message-specs.js'; import { messageSpecs } from '../shared/messages/message-specs.js';
import type { MessageInfo } from '../types/message-types.js'; import {
type MessageInfo,
defaultNumberPerThread,
} from '../types/message-types.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js'; import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
function useOldestMessageServerID(threadID: string): ?string { function useOldestMessageServerID(threadID: string): ?string {
return useSelector(state => return useSelector(state =>
getOldestNonLocalMessageID(threadID, state.messageStore), getOldestNonLocalMessageID(threadID, state.messageStore),
); );
} }
type MessageInfoForPreview = { type MessageInfoForPreview = {
+messageInfoForPreview: ?MessageInfo, +messageInfoForPreview: ?MessageInfo,
// If showInMessagePreview rejects all of the messages in the local store, // If showInMessagePreview rejects all of the messages in the local store,
// then we'll ignore it and return the most recent message (if there is one) // then we'll ignore it and return the most recent message (if there is one)
// as messageInfoForPreview. In this case, we'll also set // as messageInfoForPreview. In this case, we'll also set
// shouldFetchOlderMessages to tell the caller to fetch more messages. // numOlderMessagesToFetch to tell the caller how many more messages to fetch.
+shouldFetchOlderMessages: boolean, +numOlderMessagesToFetch: number,
}; };
const emptyMessageInfoForPreview = { const emptyMessageInfoForPreview = {
messageInfoForPreview: undefined, messageInfoForPreview: undefined,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
function useGetMessageInfoForPreview(): ( function useGetMessageInfoForPreview(): (
threadInfo: ThreadInfo, threadInfo: ThreadInfo,
) => Promise<MessageInfoForPreview> { ) => Promise<MessageInfoForPreview> {
const messageInfos = useSelector(messageInfoSelector); const messageInfos = useSelector(messageInfoSelector);
const messageStore = useSelector(state => state.messageStore); const messageStore = useSelector(state => state.messageStore);
const viewerID = useSelector(state => state.currentUserInfo?.id); const viewerID = useSelector(state => state.currentUserInfo?.id);
Show All 20 Lines async threadInfo => {
} }
if (!mostRecentMessageInfo) { if (!mostRecentMessageInfo) {
mostRecentMessageInfo = messageInfo; mostRecentMessageInfo = messageInfo;
} }
const { showInMessagePreview } = messageSpecs[messageInfo.type]; const { showInMessagePreview } = messageSpecs[messageInfo.type];
if (!showInMessagePreview) { if (!showInMessagePreview) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
let shouldShow = showInMessagePreview( let shouldShow = showInMessagePreview(
messageInfo, messageInfo,
showInMessagePreviewParams, showInMessagePreviewParams,
); );
if (shouldShow instanceof Promise) { if (shouldShow instanceof Promise) {
shouldShow = await shouldShow; shouldShow = await shouldShow;
} }
if (shouldShow) { if (shouldShow) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
} }
const numOlderMessagesToFetch = Math.max(
defaultNumberPerThread - thread.messageIDs.length,
0,
);
// If we get here, that means showInMessagePreview rejected all of the // If we get here, that means showInMessagePreview rejected all of the
// messages in the local store // messages in the local store
return { return {
messageInfoForPreview: mostRecentMessageInfo, messageInfoForPreview: mostRecentMessageInfo,
shouldFetchOlderMessages: true, numOlderMessagesToFetch,
}; };
}, },
[messageInfos, messageStore, viewerID, getMessageAuthor], [messageInfos, messageStore, viewerID, getMessageAuthor],
); );
} }
function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo { function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
const [messageInfoForPreview, setMessageInfoForPreview] = const [messageInfoForPreview, setMessageInfoForPreview] =
React.useState<?MessageInfoForPreview>(); React.useState<?MessageInfoForPreview>();
const getMessageInfoForPreview = useGetMessageInfoForPreview(); const getMessageInfoForPreview = useGetMessageInfoForPreview();
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const newMessageInfoForPreview = const newMessageInfoForPreview =
await getMessageInfoForPreview(threadInfo); await getMessageInfoForPreview(threadInfo);
setMessageInfoForPreview(newMessageInfoForPreview); setMessageInfoForPreview(newMessageInfoForPreview);
})(); })();
}, [threadInfo, getMessageInfoForPreview]); }, [threadInfo, getMessageInfoForPreview]);
const shouldFetchOlderMessages = const numOlderMessagesToFetch =
!!messageInfoForPreview?.shouldFetchOlderMessages; messageInfoForPreview?.numOlderMessagesToFetch ?? 0;
const [canFetchOlderMessages, setCanFetchOlderMessages] = const [canFetchOlderMessages, setCanFetchOlderMessages] =
React.useState(true); React.useState(true);
const fetchMessages = useFetchMessages(threadInfo); const fetchMessages = useFetchMessages(threadInfo);
React.useEffect(() => { React.useEffect(() => {
if (!canFetchOlderMessages || !shouldFetchOlderMessages) { if (!canFetchOlderMessages || numOlderMessagesToFetch === 0) {
return; return;
} }
setCanFetchOlderMessages(false); setCanFetchOlderMessages(false);
void (async () => { void (async () => {
await fetchMessages(); await fetchMessages({ numMessagesToFetch: numOlderMessagesToFetch });
await sleep(3000); await sleep(3000);
setCanFetchOlderMessages(true); setCanFetchOlderMessages(true);
})(); })();
}, [canFetchOlderMessages, shouldFetchOlderMessages, fetchMessages]); }, [canFetchOlderMessages, numOlderMessagesToFetch, fetchMessages]);
return messageInfoForPreview?.messageInfoForPreview; return messageInfoForPreview?.messageInfoForPreview;
} }
export { useOldestMessageServerID, useMessageInfoForPreview }; export { useOldestMessageServerID, useMessageInfoForPreview };