Page MenuHomePhabricator
Differential D12855

[SQLite] rename all QueryExecutor params to `camelCase`
ClosedPublic
Actions

Authored by kamil on Jul 23 2024, 3:18 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 17, 2:58 AM
Unknown Object (File)
Tue, Mar 11, 7:35 PM
Unknown Object (File)
Feb 24 2025, 12:04 PM
Unknown Object (File)
Feb 21 2025, 2:55 AM
Unknown Object (File)
Feb 21 2025, 2:55 AM
Unknown Object (File)
Feb 21 2025, 2:53 AM
Unknown Object (File)
Jan 21 2025, 11:06 PM
Unknown Object (File)
Jan 10 2025, 7:47 PM
View All 74 Files
Subscribers
ashoat

Details

Reviewers
tomek
inka
Commits
rCOMMdd5c4d502382: [SQLite] rename all QueryExecutor params to `camelCase`
Summary

There was a huge inconsistency in naming - using the same style for all.

Depends on D12854

Test Plan

yarn jest, build and run the native app

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

kamil created this revision.Jul 23 2024, 3:18 AM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptJul 23 2024, 3:18 AM
Harbormaster completed remote builds in B30601: Diff 42675.Jul 23 2024, 4:00 AM
kamil published this revision for review.Jul 23 2024, 5:04 AM
tomek accepted this revision.Jul 23 2024, 6:38 AM
This revision is now accepted and ready to land.Jul 23 2024, 6:38 AM
tomek added a comment.Jul 23 2024, 6:39 AM

We can also build and run the native app as a part of the test plan.

kamil edited the test plan for this revision. (Show Details)Jul 23 2024, 8:06 AM
Closed by commit rCOMMdd5c4d502382: [SQLite] rename all QueryExecutor params to `camelCase` (authored by kamil). · Explain WhyJul 23 2024, 8:18 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMMdd5c4d502382: [SQLite] rename all QueryExecutor params to `camelCase`.

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
DatabaseManagers/
36 lines
38 lines
92 lines

Diff 42711

View Options

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines