refactor: remove iframeLogin from meteor

apps/meteor/app/ui-utils/client/index.ts

@@ -2,5 +2,4 @@ export { messageBox } from './lib/messageBox';
 export { LegacyRoomManager } from './lib/LegacyRoomManager';
 export { upsertMessage, RoomHistoryManager } from './lib/RoomHistoryManager';
 export { mainReady } from './lib/mainReady';
-export { IframeLogin } from './lib/IframeLogin';
 export { MessageTypes, MessageType } from '../lib/MessageTypes';

apps/meteor/client/hooks/iframe/useIframe.ts

@@ -0,0 +1,76 @@
+import { useLoginWithIframe, useLoginWithToken, useSetting } from '@rocket.chat/ui-contexts';
+import { useCallback, useState } from 'react';
+
+export const useIframe = () => {
+	const [iframeLoginUrl, setIframeLoginUrl] = useState<string | undefined>(undefined);
+
+	const iframeEnabled = useSetting('Accounts_iframe_enabled', false);
+	const accountIframeUrl = useSetting('Accounts_iframe_url', '');
+	const apiUrl = useSetting('Accounts_Iframe_api_url', '');
+	const apiMethod = useSetting('Accounts_Iframe_api_method', '');
+
+	const iframeLogin = useLoginWithIframe();
+	const tokenLogin = useLoginWithToken();
+
+	const loginWithToken = useCallback(
+		(tokenData: string | { loginToken: string } | { token: string }, callback?: (error: Error | null | undefined) => void) => {
+			if (typeof tokenData === 'string') {
+				tokenData = {
+					token: tokenData,
+				};
+			}
+			if ('loginToken' in tokenData) {
+				tokenLogin(tokenData.loginToken);
+			}
+			if ('token' in tokenData) {
+				iframeLogin(tokenData.token, callback);
+			}
+		},
+		[iframeLogin, tokenLogin],
+	);
+
+	const tryLogin = useCallback(
+		async (callback?: (error: Error | null | undefined, result: unknown) => void) => {
+			let url = accountIframeUrl;
+			let separator = '?';
+			if (url.indexOf('?') > -1) {
+				separator = '&';
+			}
+
+			if (navigator.userAgent.indexOf('Electron') > -1) {
+				url += `${separator}client=electron`;
+			}
+
+			const result = await fetch(apiUrl, {
+				method: apiMethod,
+				headers: {
+					'Content-Type': 'application/json',
+				},
+				credentials: 'include',
+			});
+
+			if (!result.ok || result.status !== 200) {
+				setIframeLoginUrl(url);
+				callback?.(new Error(), null);
+				return;
+			}
+
+			loginWithToken(await result.json(), async (error: Meteor.Error | Meteor.TypedError | Error | null | undefined) => {
+				if (error) {
+					setIframeLoginUrl(url);
+				} else {
+					setIframeLoginUrl(undefined);
+				}
+				callback?.(error, await result.json());
+			});
+		},
+		[apiMethod, apiUrl, accountIframeUrl, loginWithToken],
+	);
+
+	return {
+		enabled: Boolean(iframeEnabled && accountIframeUrl && apiUrl && apiMethod),
+		tryLogin,
+		loginWithToken,
+		iframeLoginUrl,
+	};
+};

apps/meteor/client/hooks/iframe/useIframeLoginListener.ts

@@ -0,0 +1,64 @@
+import { useUnstoreLoginToken } from '@rocket.chat/ui-contexts';
+import { useEffect } from 'react';
+
+import { useIframe } from './useIframe';
+
+export const useIframeLoginListener = () => {
+	const { enabled: iframeEnabled, tryLogin, loginWithToken } = useIframe();
+	const unstoreLoginToken = useUnstoreLoginToken();
+
+	useEffect(() => {
+		if (!iframeEnabled) {
+			return;
+		}
+		tryLogin();
+	}, [iframeEnabled, tryLogin]);
+
+	useEffect(() => {
+		if (!iframeEnabled) {
+			return;
+		}
+		const messageListener = (e: MessageEvent) => {
+			if (!(typeof e.data === 'function' || (typeof e.data === 'object' && !!e.data))) {
+				return;
+			}
+
+			switch (e.data.event) {
+				case 'try-iframe-login':
+					tryLogin((error) => {
+						if (error) {
+							e.source?.postMessage(
+								{
+									event: 'login-error',
+									response: error.message,
+								},
+								{ targetOrigin: e.origin },
+							);
+						}
+					});
+					break;
+
+				case 'login-with-token':
+					loginWithToken(e.data, (error) => {
+						if (error) {
+							e.source?.postMessage(
+								{
+									event: 'login-error',
+									response: error.message,
+								},
+								{ targetOrigin: e.origin },
+							);
+						}
+					});
+					break;
+			}
+		};
+
+		window.addEventListener('message', messageListener);
+		return () => {
+			window.removeEventListener('message', messageListener);
+		};
+	}, [iframeEnabled, loginWithToken, tryLogin]);
+
+	useEffect(() => unstoreLoginToken(tryLogin), [tryLogin, unstoreLoginToken]);
+};

apps/meteor/client/importPackages.ts

@@ -4,7 +4,6 @@ import '../app/autotranslate/client';
 import '../app/emoji/client';
 import '../app/emoji-emojione/client';
 import '../app/gitlab/client';
-import '../app/iframe-login/client';
 import '../app/license/client';
 import '../app/lib/client';
 import '../app/livechat-enterprise/client';

apps/meteor/client/providers/AuthenticationProvider/AuthenticationProvider.tsx

@@ -1,6 +1,7 @@
 import type { LoginServiceConfiguration } from '@rocket.chat/core-typings';
 import { capitalize } from '@rocket.chat/string-helpers';
 import { AuthenticationContext, useSetting } from '@rocket.chat/ui-contexts';
+import { Accounts } from 'meteor/accounts-base';
 import { Meteor } from 'meteor/meteor';
 import type { ContextType, ReactElement, ReactNode } from 'react';
 import { useMemo } from 'react';
@@ -14,6 +15,16 @@ type AuthenticationProviderProps = {
 	children: ReactNode;
 };
 
+const callLoginMethod = (
+	options: { loginToken?: string; token?: string; iframe?: boolean },
+	userCallback: ((err?: any) => void) | undefined,
+) => {
+	Accounts.callLoginMethod({
+		methodArguments: [options],
+		userCallback,
+	});
+};
+
 const AuthenticationProvider = ({ children }: AuthenticationProviderProps): ReactElement => {
 	const isLdapEnabled = useSetting('LDAP_Enable', false);
 	const isCrowdEnabled = useSetting('CROWD_Enable', false);
@@ -71,6 +82,38 @@ const AuthenticationProvider = ({ children }: AuthenticationProviderProps): Reac
 						});
 					});
 			},
+			loginWithIframe: (token: string, callback) =>
+				new Promise<void>((resolve, reject) => {
+					callLoginMethod({ iframe: true, token }, (error) => {
+						if (error) {
+							console.error(error);
+							callback?.(error);
+							return reject(error);
+						}
+						resolve();
+					});
+				}),
+			loginWithTokenRoute: (token: string, callback) =>
+				new Promise<void>((resolve, reject) => {
+					callLoginMethod({ token }, (error) => {
+						if (error) {
+							console.error(error);
+							callback?.(error);
+							return reject(error);
+						}
+						resolve();
+					});
+				}),
+			unstoreLoginToken: (callback) => {
+				const { _unstoreLoginToken } = Accounts;
+				Accounts._unstoreLoginToken = function (...args) {
+					callback();
+					_unstoreLoginToken.apply(Accounts, args);
+				};
+				return () => {
+					Accounts._unstoreLoginToken = _unstoreLoginToken;
+				};
+			},
 
 			queryLoginServices: {
 				getCurrentValue: () => loginServices.getLoginServiceButtons(),