Paths

Table of Contentst

-
web/grpc/
-
grpc/
-
identity-service-client-proxy.js
2/2
identity-service-context-provider.react.js

[web] Use shared worker crypto store in identity client provider
ClosedPublic
Actions

Authored by michal on Mar 22 2024, 8:59 AM.

Details

Reviewers

kamil
tomek
bartek

Commits

rCOMMc95d85e89e2f: [web] Use shared worker crypto store in identity client provider

Summary

ENG-6656 : Update the web code to use new cryptoStore

Previously implemented in D11348 but some issues have been noticed and the required changes were large enough that I decided to split them into a separate diff. I'm taking a similar approach to native where I fetch the auth metadata on every call to identity. In case of web if the auth metadata changed between calls I then send the CREATE_IDENTITY_SERVICE_CLIENT worker message which should recreate the identity client with correct auth metadata. Thanks to D11299, this call will resolve before the actual call to the identity client.

Also decided to merge the previously created worker proxy inside of the IdentityServiceContextProvider as it simplified the code a lot (also now it's even more similar to native where the context just returns a plain JS object).

Depends on D11372

Test Plan

Called generateNonce (success), called getKeyserverKeys (failed because user wasn't logged in)
Logged in to identity
Called the two methods again. Now both of the succeeded

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

michal created this revision.Mar 22 2024, 8:59 AM

Herald added a subscriber: ashoat. · View Herald TranscriptMar 22 2024, 8:59 AM

michal mentioned this in D11348: [web] Use crypto store and olm from shared worker.Mar 22 2024, 9:02 AM

michal added a child revision: D11348: [web] Use crypto store and olm from shared worker.Mar 22 2024, 9:02 AM

Harbormaster completed remote builds in B27657: Diff 38278.Mar 22 2024, 9:14 AM

michal requested review of this revision.Mar 22 2024, 9:14 AM

michal added a child revision: D11386: [web/native] Add signMessage to olmAPI.Mar 26 2024, 7:02 AM

ashoat added inline comments.Mar 26 2024, 12:45 PM

web/grpc/identity-service-context-provider.react.js
52–53 ↗	(On Diff #38278)	Do these need to be sequential?

kamil accepted this revision.Mar 27 2024, 12:26 AM

kamil added inline comments.

web/grpc/identity-service-context-provider.react.js
55 ↗	(On Diff #38278)	can we reverse that and return early?

This revision is now accepted and ready to land.Mar 27 2024, 12:26 AM

bartek accepted this revision.Mar 27 2024, 1:00 AM

Fixes

Harbormaster completed remote builds in B27698: Diff 38355.Mar 27 2024, 4:29 AM

Closed by commit rCOMMc95d85e89e2f: [web] Use shared worker crypto store in identity client provider (authored by Michal Gniadek <michal.gniadek@swmansion.com>). · Explain WhyMar 28 2024, 3:58 AM

This revision was automatically updated to reflect the committed changes.

Michal Gniadek <michal.gniadek@swmansion.com> added a commit: rCOMMc95d85e89e2f: [web] Use shared worker crypto store in identity client provider.

Revision Contents
Changeset List

Path

Size

web/

grpc/

identity-service-client-proxy.js

identity-service-context-provider.react.js

162 lines

Diff 38355

View Options

web/grpc/identity-service-client-proxy.js

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };