Paths

Table of Contentst

-
lib/
-
reducers/
-
master-reducer.js
-
message-reducer.test.js
-
synced-metadata-reducer.js
-
types/
-
redux-types.js
-
store-ops-types.js
-
utils/
-
reducers-utils.test.js
-
native/redux/
-
redux/
-
default-state.js
-
redux-setup.js
-
redux-utils.js
-
state-types.js
-
web/
-
redux/
-
default-state.js
-
initial-state-gate.js
-
redux-setup.js
-
shared-worker/utils/
-
utils/
-
store.js

web] introduce synced metadata reducer
ClosedPublic
Actions

Authored by will on Mar 27 2024, 4:18 PM.

Details

Reviewers

ginsu
atul
kamil

Commits

rCOMM9ce16932b467: [lib/native/web] introduce synced metadata reducer

Summary

Introduces the synced metadata reducer which handles replace, remove, and remove all ops.

Depends on D11421

Test Plan

Ran the following code:

const onPressSave = React.useCallback(async () => {
  dispatch({
    type: addSyncedMetadataEntryActionType,
    payload: {
      name: 'Test_1_name',
      data: 'Test_1_data',
    },
  });

  dispatch({
    type: addSyncedMetadataEntryActionType,
    payload: {
      name: 'Test_2_name',
      data: 'Test_2_data',
    },
  });

  dispatch({
    type: addSyncedMetadataEntryActionType,
    payload: {
      name: 'Test_1_name',
      data: 'Test_1_update',
    },
  });

  dispatch({
    type: removeSyncedMetadataEntryActionType,
    payload: {
      name: 'Test_2_name',
    },
  });
}, [dispatch]);

Screenshot 2024-03-27 at 8.07.39 PM.png (778×848 px, 139 KB)

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

will created this revision.Mar 27 2024, 4:18 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptMar 27 2024, 4:19 PM

Harbormaster completed remote builds in B27740: Diff 38403.Mar 27 2024, 4:33 PM

will requested review of this revision.Mar 27 2024, 4:33 PM

will planned changes to this revision.Mar 27 2024, 5:05 PM

will edited the test plan for this revision. (Show Details)Mar 27 2024, 5:10 PM

add support for the remove synced metadata action type

will edited the summary of this revision. (Show Details)Mar 27 2024, 5:15 PM

will added a parent revision: D11421: [lib] introduce sync metadata add and remove action types.

Harbormaster completed remote builds in B27742: Diff 38405.Mar 27 2024, 5:30 PM

will added a child revision: D11424: [native][web] read synced metadata on app startup.Mar 27 2024, 5:31 PM

LGTM - requesting changes to address this blacklist comment because this is important

lib/reducers/synced-metadata-reducer.js
14
30–33
lib/types/redux-types.js
165	This will be persisted only on SQL database so you should add this to persistBlacklist. Because there is no migration (and no need to do it) you should've seen alerts with `EXPECTED KEYS NOT REHYDRATED`. Separately - this started to be annoying, we have `blacklist` on native and `whitelist` on the web and it's easy to oversight this - could you create a follow-up task to address it anytime in the future?

This revision now requires changes to proceed.Mar 28 2024, 5:04 AM

review feedback

will marked 2 inline comments as done.Mar 28 2024, 4:56 PM

will added inline comments.Mar 28 2024, 5:03 PM

lib/types/redux-types.js
165	Included as part of blacklist in latest rebase. Created the follow-up task on linear: https://linear.app/comm/issue/ENG-7602/rethink-redux-persist-blacklist-and-native-whitelist Left a question on what I should put as the parent

Harbormaster completed remote builds in B27800: Diff 38516.Mar 28 2024, 5:10 PM

atul accepted this revision.Apr 1 2024, 1:15 PM

kamil accepted this revision.Apr 2 2024, 1:34 AM

This revision is now accepted and ready to land.Apr 2 2024, 1:34 AM

Closed by commit rCOMM9ce16932b467: [lib/native/web] introduce synced metadata reducer (authored by will). · Explain WhyApr 2 2024, 11:22 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM9ce16932b467: [lib/native/web] introduce synced metadata reducer.

will mentioned this in D11566: [native] Add auxUserStore to persist blacklist.Apr 5 2024, 3:26 PM

Revision Contents
Changeset List

Path

Size

lib/

reducers/

master-reducer.js

6 lines

message-reducer.test.js

1 line

synced-metadata-reducer.js

79 lines

types/

redux-types.js

2 lines

store-ops-types.js

3 lines

utils/

reducers-utils.test.js

3 lines

native/

redux/

3 lines

2 lines

13 lines

2 lines

web/

redux/

default-state.js

3 lines

initial-state-gate.js

1 line

redux-setup.js

3 lines

shared-worker/

utils/

store.js

11 lines

Diff 38405

View Options

lib/reducers/master-reducer.js

	// @flow			// @flow

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

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
	import { connectionSelector } from '../selectors/keyserver-selectors.js';			import {
				connectionSelector,
				cookieSelector,
				} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
				import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
				const cookie = useSelector(cookieSelector(keyserverID));

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityClient = React.useContext(			const identityClient = React.useContext(
	IdentityClientContext,			IdentityClientContext,
	)?.identityClient;			)?.identityClient;
	invariant(identityClient, 'Identity client should be set');			invariant(identityClient, 'Identity client should be set');

				const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
				invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
				const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

				await olmSessionCreator.notificationsSessionCreator(
				cookie,
				keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
				keyserverKeys.notifInitializationInfo,
				keyserverID,
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error getting keys for keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient]);			}, [keyserverID, identityClient, olmSessionCreator, cookie]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;

View Options

lib/reducers/message-reducer.test.js

	// @flow			// @flow

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

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
	import { connectionSelector } from '../selectors/keyserver-selectors.js';			import {
				connectionSelector,
				cookieSelector,
				} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
				import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
				const cookie = useSelector(cookieSelector(keyserverID));

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityClient = React.useContext(			const identityClient = React.useContext(
	IdentityClientContext,			IdentityClientContext,
	)?.identityClient;			)?.identityClient;
	invariant(identityClient, 'Identity client should be set');			invariant(identityClient, 'Identity client should be set');

				const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
				invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
				const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

				await olmSessionCreator.notificationsSessionCreator(
				cookie,
				keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
				keyserverKeys.notifInitializationInfo,
				keyserverID,
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error getting keys for keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient]);			}, [keyserverID, identityClient, olmSessionCreator, cookie]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;

View Options

lib/reducers/synced-metadata-reducer.js

	// @flow			// @flow

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

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
	import { connectionSelector } from '../selectors/keyserver-selectors.js';			import {
				connectionSelector,
				cookieSelector,
				} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
				import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
				const cookie = useSelector(cookieSelector(keyserverID));

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityClient = React.useContext(			const identityClient = React.useContext(
	IdentityClientContext,			IdentityClientContext,
	)?.identityClient;			)?.identityClient;
	invariant(identityClient, 'Identity client should be set');			invariant(identityClient, 'Identity client should be set');

				const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
				invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
				const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

				await olmSessionCreator.notificationsSessionCreator(
				cookie,
				keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
				keyserverKeys.notifInitializationInfo,
				keyserverID,
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error getting keys for keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient]);			}, [keyserverID, identityClient, olmSessionCreator, cookie]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;

View Options

lib/types/redux-types.js

	// @flow			// @flow

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

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
	import { connectionSelector } from '../selectors/keyserver-selectors.js';			import {
				connectionSelector,
				cookieSelector,
				} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
				import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
				const cookie = useSelector(cookieSelector(keyserverID));

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityClient = React.useContext(			const identityClient = React.useContext(
	IdentityClientContext,			IdentityClientContext,
	)?.identityClient;			)?.identityClient;
	invariant(identityClient, 'Identity client should be set');			invariant(identityClient, 'Identity client should be set');

				const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
				invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
				const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

				await olmSessionCreator.notificationsSessionCreator(
				cookie,
				keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
				keyserverKeys.notifInitializationInfo,
				keyserverID,
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error getting keys for keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient]);			}, [keyserverID, identityClient, olmSessionCreator, cookie]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;

View Options

lib/types/store-ops-types.js

	// @flow			// @flow

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

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
	import { connectionSelector } from '../selectors/keyserver-selectors.js';			import {
				connectionSelector,
				cookieSelector,
				} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
				import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
				const cookie = useSelector(cookieSelector(keyserverID));

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityClient = React.useContext(			const identityClient = React.useContext(
	IdentityClientContext,			IdentityClientContext,
	)?.identityClient;			)?.identityClient;
	invariant(identityClient, 'Identity client should be set');			invariant(identityClient, 'Identity client should be set');

				const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
				invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
				const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

				await olmSessionCreator.notificationsSessionCreator(
				cookie,
				keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
				keyserverKeys.notifInitializationInfo,
				keyserverID,
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error getting keys for keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient]);			}, [keyserverID, identityClient, olmSessionCreator, cookie]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;