[keyserver] simplify verifyUserLoggedIn
ClosedPublic
Actions

Authored by varun on Oct 9 2024, 12:53 PM.

Details

Reviewers

ashoat
inka

Commits

rCOMMc8a851f8be77: [keyserver] simplify verifyUserLoggedIn

Summary

in the next diff, i split out the auth and save parts of this function into a separate function, so rearranging the code here first

Depends on D13664

Test Plan

read the code carefully

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

varun created this revision.Oct 9 2024, 12:53 PM

Herald added a subscriber: tomek. · View Herald TranscriptOct 9 2024, 12:53 PM

varun added a child revision: D13666: [keyserver] factor out identity auth and saveIdentityInfo from verifyUserLoggedIn.Oct 9 2024, 12:55 PM

varun edited the summary of this revision. (Show Details)Oct 9 2024, 1:07 PM

Harbormaster completed remote builds in B32147: Diff 45020.Oct 9 2024, 1:11 PM

varun requested review of this revision.Oct 9 2024, 1:11 PM

ashoat accepted this revision.Oct 9 2024, 5:03 PM

This revision is now accepted and ready to land.Oct 9 2024, 5:03 PM

Closed by commit rCOMMc8a851f8be77: [keyserver] simplify verifyUserLoggedIn (authored by varun). · Explain WhyOct 10 2024, 12:07 PM

This revision was automatically updated to reflect the committed changes.

varun added a commit: rCOMMc8a851f8be77: [keyserver] simplify verifyUserLoggedIn.

Revision Contents
Changeset List

Path

Size

keyserver/

src/

user/

5 lines

Diff 45020

View Options

keyserver/src/user/login.js

// @flow		// @flow

		import invariant from 'invariant';
		import * as React from 'react';
import uuid from 'uuid';		import uuid from 'uuid';

import { dmOpSpecs } from './dm-op-specs.js';		import { dmOpSpecs } from './dm-op-specs.js';
import type { DMOperation } from '../../types/dm-ops.js';		import { useProcessAndSendDMOperation } from './process-dm-ops.js';
		import type {
		CreateThickRawThreadInfoInput,
		DMAddMembersOperation,
		DMAddViewerToThreadMembersOperation,
		DMOperation,
		} from '../../types/dm-ops.js';
		import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import type { InboundActionMetadata } from '../../types/redux-types.js';		import type { InboundActionMetadata } from '../../types/redux-types.js';
import {		import {
outboundP2PMessageStatuses,		outboundP2PMessageStatuses,
type OutboundP2PMessage,		type OutboundP2PMessage,
} from '../../types/sqlite-types.js';		} from '../../types/sqlite-types.js';
		import {
		assertThickThreadType,
		thickThreadTypes,
		} from '../../types/thread-types-enum.js';
import type { RawThreadInfos } from '../../types/thread-types.js';		import type { RawThreadInfos } from '../../types/thread-types.js';
import {		import {
type DMOperationP2PMessage,		type DMOperationP2PMessage,
userActionsP2PMessageTypes,		userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';		} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { CurrentUserInfo } from '../../types/user-types.js';		import type { CurrentUserInfo } from '../../types/user-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js';		import { getContentSigningKey } from '../../utils/crypto-utils.js';
		import { useSelector } from '../../utils/redux-utils.js';

function generateMessagesToPeers(		function generateMessagesToPeers(
message: DMOperation,		message: DMOperation,
peers: $ReadOnlyArray<{		peers: $ReadOnlyArray<{
+userID: string,		+userID: string,
+deviceID: string,		+deviceID: string,
}>,		}>,
): $ReadOnlyArray<OutboundP2PMessage> {		): $ReadOnlyArray<OutboundP2PMessage> {
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines	): Promise<$ReadOnlyArray<OutboundP2PMessage>> {

const thisDeviceID = await getContentSigningKey();		const thisDeviceID = await getContentSigningKey();
const targetPeers = peerUserIDAndDeviceIDs.filter(		const targetPeers = peerUserIDAndDeviceIDs.filter(
peer => peer.deviceID !== thisDeviceID,		peer => peer.deviceID !== thisDeviceID,
);		);
return generateMessagesToPeers(operation.op, targetPeers);		return generateMessagesToPeers(operation.op, targetPeers);
}		}

export { createMessagesToPeersFromDMOp };		function getCreateThickRawThreadInfoInputFromThreadInfo(
		threadInfo: ThreadInfo,
		): CreateThickRawThreadInfoInput {
		const roleID = Object.keys(threadInfo.roles).pop();
		const thickThreadType = assertThickThreadType(threadInfo.type);
		return {
		threadID: threadInfo.id,
		threadType: thickThreadType,
		creationTime: threadInfo.creationTime,
		parentThreadID: threadInfo.parentThreadID,
		allMemberIDs: threadInfo.members.map(member => member.id),
		roleID,
		unread: !!threadInfo.currentUser.unread,
		name: threadInfo.name,
		avatar: threadInfo.avatar,
		description: threadInfo.description,
		color: threadInfo.color,
		containingThreadID: threadInfo.containingThreadID,
		sourceMessageID: threadInfo.sourceMessageID,
		repliesCount: threadInfo.repliesCount,
		pinnedCount: threadInfo.pinnedCount,
		};
		}

		function useAddDMThreadMembers(): (
		newMemberIDs: $ReadOnlyArray<string>,
		threadInfo: ThreadInfo,
		) => Promise<void> {
		const viewerID = useSelector(
		state => state.currentUserInfo && state.currentUserInfo.id,
		);
		const processAndSendDMOperation = useProcessAndSendDMOperation();

		return React.useCallback(
		async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
		const existingThreadDetails =
		getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);

		invariant(viewerID, 'viewerID should be set');
		const viewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
		{
		type: 'add_viewer_to_thread_members',
		existingThreadDetails,
		editorID: viewerID,
		time: Date.now(),
		messageID: uuid.v4(),
		addedUserIDs: newMemberIDs,
		};
		const viewerOperationSpecification: OutboundDMOperationSpecification = {
		type: dmOperationSpecificationTypes.OUTBOUND,
		op: viewerToThreadMembersOperation,
		recipients: {
		type: 'all_thread_members',
		threadID:
		threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
		threadInfo.parentThreadID
		? threadInfo.parentThreadID
		: threadInfo.id,
		},
		sendOnly: true,
		};

		invariant(viewerID, 'viewerID should be set');
		const addMembersOperation: DMAddMembersOperation = {
		type: 'add_members',
		threadID: threadInfo.id,
		editorID: viewerID,
		time: Date.now(),
		messageID: uuid.v4(),
		addedUserIDs: newMemberIDs,
		};
		const newMemberIDsSet = new Set<string>(newMemberIDs);
		const addMembersOperationSpecification: OutboundDMOperationSpecification =
		{
		type: dmOperationSpecificationTypes.OUTBOUND,
		op: addMembersOperation,
		recipients: {
		type: 'some_users',
		userIDs: threadInfo.members
		.map(member => member.id)
		.filter(memberID => !newMemberIDsSet.has(memberID)),
		},
		};

		void Promise.all([
		processAndSendDMOperation(viewerOperationSpecification),
		processAndSendDMOperation(addMembersOperationSpecification),
		]);
		},
		[processAndSendDMOperation, viewerID],
		);
		}

		export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };

[keyserver] simplify verifyUserLoggedInClosedPublicActions