The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import {
useApolloClient,
useLazyQuery,
useMutation,
} from '@apollo/client/react';
import { useCallback } from 'react';
import { AppPath } from 'twenty-shared/types';
import { REACT_APP_SERVER_BASE_URL } from '~/config';
import {
type AuthToken,
CheckUserExistsDocument,
GetAuthTokensFromLoginTokenDocument,
GetAuthTokensFromOtpDocument,
GetAuthTokensFromTwoFactorAuthenticationRecoveryCodeDocument,
GetLoginTokenFromCredentialsDocument,
GetWorkspaceCreationDefaultsDocument,
SignInDocument,
SignOutDocument,
SignUpInWorkspaceDocument,
SignUpDocument,
VerifyEmailAndGetLoginTokenDocument,
VerifyEmailAndGetWorkspaceAgnosticTokenDocument,
} from '~/generated-metadata/graphql';
import { useMarkSessionActive } from '@/auth/hooks/useMarkSessionActive';
import { currentUserState } from '@/auth/states/currentUserState';
import { isCookieAuthActiveState } from '@/auth/states/isCookieAuthActiveState';
import { isPendingServerSignOutState } from '@/auth/states/isPendingServerSignOutState';
import { currentUserWorkspaceState } from '@/auth/states/currentUserWorkspaceState';
import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
import { returnToPathState } from '@/auth/states/returnToPathState';
import { clearSessionLocalStorageKeys } from '@/auth/utils/clearSessionLocalStorageKeys';
import { broadcastSignOutToOtherTabs } from '@/auth/utils/crossTabSignOut';
import { clearSessionGeneration } from '@/auth/utils/clearSessionGeneration';
import { isValidReturnToPath } from '@/auth/utils/isValidReturnToPath';
import { isNonEmptyString } from '@sniptt/guards';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { useSetAtomState } from '@/ui/utilities/state/jotai/hooks/useSetAtomState';
import { isAppEffectRedirectEnabledState } from '@/auth/states/isAppEffectRedirectEnabledState';
import { loginTokenState } from '@/auth/states/loginTokenState';
import {
SignInUpStep,
signInUpStepState,
} from '@/auth/states/signInUpStepState';
import { workspacePublicDataState } from '@/auth/states/workspacePublicDataState';
import { type BillingCheckoutSession } from '@/auth/types/BillingCheckoutSession';
import {
countAvailableWorkspaces,
getFirstAvailableWorkspaces,
} from '@/auth/utils/availableWorkspacesUtils';
import { isEmailVerificationRequiredState } from '@/client-config/states/isEmailVerificationRequiredState';
import { isMultiWorkspaceEnabledState } from '@/client-config/states/isMultiWorkspaceEnabledState';
import { useLastAuthenticatedWorkspaceDomain } from '@/domain-manager/hooks/useLastAuthenticatedWorkspaceDomain';
import { useOrigin } from '@/domain-manager/hooks/useOrigin';
import { useRedirect } from '@/domain-manager/hooks/useRedirect';
import { useRedirectToWorkspaceDomain } from '@/domain-manager/hooks/useRedirectToWorkspaceDomain';
import { isChooseWorkspaceActionRequested } from '@/auth/utils/isChooseWorkspaceActionRequested';
import { useLoadCurrentUser } from '@/users/hooks/useLoadCurrentUser';
import { i18n } from '@lingui/core';
import { useNavigate, useSearchParams } from 'react-router-dom';
import { SOURCE_LOCALE } from 'twenty-shared/translations';
import { isDefined } from 'twenty-shared/utils';
import { doNotTranslate } from 'twenty-shared/i18n';
import { getWorkspaceUrl } from '~/utils/getWorkspaceUrl';
import { isGraphqlErrorOfType } from '~/utils/is-graphql-error-of-type.util';
import { useStore } from 'jotai';
export const useAuth = () => {
const store = useStore();
const markSessionActive = useMarkSessionActive();
const setLoginToken = useSetAtomState(loginTokenState);
const setIsAppEffectRedirectEnabled = useSetAtomState(
isAppEffectRedirectEnabledState,
);
const { origin } = useOrigin();
const isMultiWorkspaceEnabled = useAtomStateValue(
isMultiWorkspaceEnabledState,
);
const isEmailVerificationRequired = useAtomStateValue(
isEmailVerificationRequiredState,
);
const { loadCurrentUser } = useLoadCurrentUser();
const apolloClient = useApolloClient();
const setSignInUpStep = useSetAtomState(signInUpStepState);
const { redirect } = useRedirect();
const { redirectToWorkspaceDomain } = useRedirectToWorkspaceDomain();
const [getLoginTokenFromCredentials] = useMutation(
GetLoginTokenFromCredentialsDocument,
);
const [signIn] = useMutation(SignInDocument);
const [signUp] = useMutation(SignUpDocument);
const [signUpInWorkspace] = useMutation(SignUpInWorkspaceDocument);
const [getAuthTokensFromLoginToken] = useMutation(
GetAuthTokensFromLoginTokenDocument,
);
const [verifyEmailAndGetLoginToken] = useMutation(
VerifyEmailAndGetLoginTokenDocument,
);
const [verifyEmailAndGetWorkspaceAgnosticToken] = useMutation(
VerifyEmailAndGetWorkspaceAgnosticTokenDocument,
);
const [getAuthTokensFromOtp] = useMutation(GetAuthTokensFromOtpDocument);
const [getAuthTokensFromTwoFactorAuthenticationRecoveryCode] = useMutation(
GetAuthTokensFromTwoFactorAuthenticationRecoveryCodeDocument,
);
const [signOutMutation] = useMutation(SignOutDocument);
const workspacePublicData = useAtomStateValue(workspacePublicDataState);
const { setLastAuthenticateWorkspaceDomain } =
useLastAuthenticatedWorkspaceDomain();
const [checkUserExistsQuery, { data: checkUserExistsData }] = useLazyQuery(
CheckUserExistsDocument,
);
const [, setSearchParams] = useSearchParams();
const navigate = useNavigate();
const clearSession = useCallback(() => {
// The assign below is the only navigation: keep the redirect effect from racing it to the sign-in page.
store.set(isAppEffectRedirectEnabledState.atom, false);
sessionStorage.clear();
store.set(isCookieAuthActiveState.atom, false);
store.set(currentUserState.atom, null);
store.set(currentWorkspaceState.atom, null);
store.set(currentWorkspaceMemberState.atom, null);
store.set(currentUserWorkspaceState.atom, null);
clearSessionGeneration();
clearSessionLocalStorageKeys();
setLastAuthenticateWorkspaceDomain(null);
window.location.assign(AppPath.SignInUp);
}, [store, setLastAuthenticateWorkspaceDomain]);
const navigateAfterMultiWorkspaceSignInUp = useCallback(
async (
availableWorkspaces: Parameters<typeof countAvailableWorkspaces>[0],
email: string,
) => {
const availableWorkspacesCount =
countAvailableWorkspaces(availableWorkspaces);
// Set by the in-app "Create Workspace" entry point to skip workspace selection.
const wantsToCreateNewWorkspace =
new URLSearchParams(window.location.search).get('action') ===
'create-new-workspace';
if (availableWorkspacesCount === 0 || wantsToCreateNewWorkspace) {
await apolloClient.query({
query: GetWorkspaceCreationDefaultsDocument,
});
setSignInUpStep(SignInUpStep.WorkspaceCreation);
return;
}
if (
availableWorkspacesCount === 1 &&
!isChooseWorkspaceActionRequested()
) {
const targetWorkspace =
getFirstAvailableWorkspaces(availableWorkspaces);
return await redirectToWorkspaceDomain(
getWorkspaceUrl(targetWorkspace.workspaceUrls),
targetWorkspace.loginToken ? AppPath.Verify : AppPath.SignInUp,
{
...(targetWorkspace.loginToken && {
loginToken: targetWorkspace.loginToken,
}),
email,
},
);
}
setSignInUpStep(SignInUpStep.WorkspaceSelection);
},
[apolloClient, redirectToWorkspaceDomain, setSignInUpStep],
);
const handleGetLoginTokenFromCredentials = useCallback(
async (email: string, password: string, captchaToken?: string) => {
try {
const getLoginTokenResult = await getLoginTokenFromCredentials({
variables: {
email,
password,
captchaToken,
origin,
},
});
if (isDefined(getLoginTokenResult.error)) {
throw getLoginTokenResult.error;
}
if (!getLoginTokenResult.data?.getLoginTokenFromCredentials) {
throw new Error(doNotTranslate('No login token'));
}
return getLoginTokenResult.data.getLoginTokenFromCredentials;
} catch (error) {
if (isGraphqlErrorOfType(error, 'EMAIL_NOT_VERIFIED')) {
setSearchParams({ email });
setSignInUpStep(SignInUpStep.EmailVerification);
throw error;
}
throw error;
}
},
[getLoginTokenFromCredentials, setSearchParams, setSignInUpStep, origin],
);
const handleverifyEmailAndGetLoginToken = useCallback(
async (
emailVerificationToken: string,
email: string,
captchaToken?: string,
) => {
const loginTokenResult = await verifyEmailAndGetLoginToken({
variables: {
email,
emailVerificationToken,
captchaToken,
origin,
},
});
if (isDefined(loginTokenResult.error)) {
throw loginTokenResult.error;
}
if (!loginTokenResult.data?.verifyEmailAndGetLoginToken) {
throw new Error(doNotTranslate('No login token'));
}
return loginTokenResult.data.verifyEmailAndGetLoginToken;
},
[verifyEmailAndGetLoginToken, origin],
);
const handleverifyEmailAndGetWorkspaceAgnosticToken = useCallback(
async (
emailVerificationToken: string,
email: string,
captchaToken?: string,
) => {
const { data, error } = await verifyEmailAndGetWorkspaceAgnosticToken({
variables: {
email,
emailVerificationToken,
captchaToken,
},
});
if (isDefined(error)) {
throw error;
}
if (!data?.verifyEmailAndGetWorkspaceAgnosticToken) {
throw new Error(
doNotTranslate('No workspace agnostic token in result'),
);
}
markSessionActive();
const { user } = await loadCurrentUser();
await navigateAfterMultiWorkspaceSignInUp(
user.availableWorkspaces,
user.email,
);
},
[
verifyEmailAndGetWorkspaceAgnosticToken,
markSessionActive,
loadCurrentUser,
navigateAfterMultiWorkspaceSignInUp,
],
);
const handleSetLoginToken = useCallback(
(token: AuthToken['token']) => {
setLoginToken(token);
},
[setLoginToken],
);
const handleLoadWorkspaceAfterAuthentication = useCallback(async () => {
markSessionActive();
setIsAppEffectRedirectEnabled(false);
try {
await loadCurrentUser();
} finally {
setIsAppEffectRedirectEnabled(true);
}
}, [loadCurrentUser, markSessionActive, setIsAppEffectRedirectEnabled]);
const handleGetAuthTokensFromLoginToken = useCallback(
async (loginToken: string) => {
try {
const getAuthTokensResult = await getAuthTokensFromLoginToken({
variables: {
loginToken: loginToken,
origin,
},
});
if (isDefined(getAuthTokensResult.error)) {
throw getAuthTokensResult.error;
}
if (!getAuthTokensResult.data?.getAuthTokensFromLoginToken) {
throw new Error(
doNotTranslate('No getAuthTokensFromLoginToken result'),
);
}
await handleLoadWorkspaceAfterAuthentication();
} catch (error) {
if (
isGraphqlErrorOfType(
error,
'TWO_FACTOR_AUTHENTICATION_PROVISION_REQUIRED',
)
) {
handleSetLoginToken(loginToken);
navigate(AppPath.SignInUp);
setSignInUpStep(SignInUpStep.TwoFactorAuthenticationProvision);
return;
}
if (
isGraphqlErrorOfType(
error,
'TWO_FACTOR_AUTHENTICATION_VERIFICATION_REQUIRED',
)
) {
handleSetLoginToken(loginToken);
navigate(AppPath.SignInUp);
setSignInUpStep(SignInUpStep.TwoFactorAuthenticationVerification);
return;
}
throw error;
}
},
[
handleSetLoginToken,
getAuthTokensFromLoginToken,
origin,
handleLoadWorkspaceAfterAuthentication,
setSignInUpStep,
navigate,
],
);
const handleCredentialsSignIn = useCallback(
async (email: string, password: string, captchaToken?: string) => {
await signIn({
variables: { email, password, captchaToken },
onCompleted: async () => {
markSessionActive();
const { user } = await loadCurrentUser();
await navigateAfterMultiWorkspaceSignInUp(
user.availableWorkspaces,
user.email,
);
},
onError: (error) => {
if (isGraphqlErrorOfType(error, 'EMAIL_NOT_VERIFIED')) {
setSearchParams({ email });
setSignInUpStep(SignInUpStep.EmailVerification);
throw error;
}
throw error;
},
});
},
[
markSessionActive,
signIn,
loadCurrentUser,
setSearchParams,
setSignInUpStep,
navigateAfterMultiWorkspaceSignInUp,
],
);
const handleCredentialsSignUp = useCallback(
async (email: string, password: string, captchaToken?: string) => {
const signUpResult = await signUp({
variables: {
email,
password,
captchaToken,
locale: i18n.locale ?? SOURCE_LOCALE,
},
});
if (isDefined(signUpResult.error)) {
throw signUpResult.error;
}
if (isEmailVerificationRequired) {
setSearchParams({ email });
setSignInUpStep(SignInUpStep.EmailVerification);
return null;
}
if (!signUpResult.data?.signUp) {
throw new Error(doNotTranslate('No signUp result'));
}
markSessionActive();
const { user } = await loadCurrentUser();
await navigateAfterMultiWorkspaceSignInUp(
user.availableWorkspaces,
user.email,
);
},
[
isEmailVerificationRequired,
setSearchParams,
markSessionActive,
signUp,
loadCurrentUser,
setSignInUpStep,
navigateAfterMultiWorkspaceSignInUp,
],
);
const handleCredentialsSignInInWorkspace = useCallback(
async (email: string, password: string, captchaToken?: string) => {
const { loginToken } = await handleGetLoginTokenFromCredentials(
email,
password,
captchaToken,
);
await handleGetAuthTokensFromLoginToken(loginToken.token);
},
[handleGetLoginTokenFromCredentials, handleGetAuthTokensFromLoginToken],
);
const handleSignOut = useCallback(async () => {
// Before clearSession, whose navigation kills in-flight requests.
store.set(isPendingServerSignOutState.atom, true);
try {
await signOutMutation();
store.set(isPendingServerSignOutState.atom, false);
} catch {}
broadcastSignOutToOtherTabs();
clearSession();
}, [clearSession, signOutMutation, store]);
const handleCredentialsSignUpInWorkspace = useCallback(
async ({
email,
password,
workspaceInviteHash,
workspacePersonalInviteToken,
captchaToken,
verifyEmailRedirectPath,
}: {
email: string;
password: string;
workspaceInviteHash?: string;
workspacePersonalInviteToken?: string;
captchaToken?: string;
verifyEmailRedirectPath?: string;
}) => {
const signUpInWorkspaceResult = await signUpInWorkspace({
variables: {
email,
password,
workspaceInviteHash,
workspacePersonalInviteToken,
captchaToken,
locale: i18n.locale ?? SOURCE_LOCALE,
...(workspacePublicData?.id
? { workspaceId: workspacePublicData.id }
: {}),
verifyEmailRedirectPath,
},
});
if (isDefined(signUpInWorkspaceResult.error)) {
throw signUpInWorkspaceResult.error;
}
if (!signUpInWorkspaceResult.data?.signUpInWorkspace) {
throw new Error(doNotTranslate('No login token'));
}
if (isEmailVerificationRequired) {
setSearchParams({ email });
setSignInUpStep(SignInUpStep.EmailVerification);
return null;
}
if (isMultiWorkspaceEnabled) {
return await redirectToWorkspaceDomain(
getWorkspaceUrl(
signUpInWorkspaceResult.data.signUpInWorkspace.workspace
.workspaceUrls,
),
isEmailVerificationRequired ? AppPath.SignInUp : AppPath.Verify,
{
...(!isEmailVerificationRequired && {
loginToken:
signUpInWorkspaceResult.data.signUpInWorkspace.loginToken.token,
}),
email,
},
);
}
await handleGetAuthTokensFromLoginToken(
signUpInWorkspaceResult.data?.signUpInWorkspace.loginToken.token,
);
},
[
signUpInWorkspace,
workspacePublicData,
isMultiWorkspaceEnabled,
handleGetAuthTokensFromLoginToken,
setSignInUpStep,
setSearchParams,
isEmailVerificationRequired,
redirectToWorkspaceDomain,
],
);
const buildRedirectUrl = useCallback(
(
path: string,
params: {
workspacePersonalInviteToken?: string;
workspaceInviteHash?: string;
billingCheckoutSession?: BillingCheckoutSession;
action?: string;
},
) => {
const url = new URL(`${REACT_APP_SERVER_BASE_URL}${path}`);
if (isDefined(params.workspaceInviteHash)) {
url.searchParams.set('workspaceInviteHash', params.workspaceInviteHash);
}
if (isDefined(params.workspacePersonalInviteToken)) {
url.searchParams.set(
'inviteToken',
params.workspacePersonalInviteToken,
);
}
if (isDefined(params.billingCheckoutSession)) {
url.searchParams.set(
'billingCheckoutSessionState',
JSON.stringify(params.billingCheckoutSession),
);
}
if (isDefined(params.action)) {
url.searchParams.set('action', params.action);
}
if (isDefined(workspacePublicData)) {
url.searchParams.set('workspaceId', workspacePublicData.id);
}
const returnToPath = store.get(returnToPathState.atom);
if (isNonEmptyString(returnToPath) && isValidReturnToPath(returnToPath)) {
url.searchParams.set('returnToPath', returnToPath);
}
return url.toString();
},
[workspacePublicData, store],
);
const handleGoogleLogin = useCallback(
(params: {
workspacePersonalInviteToken?: string;
workspaceInviteHash?: string;
billingCheckoutSession?: BillingCheckoutSession;
action: string;
}) => {
redirect(buildRedirectUrl('/auth/google', params));
},
[buildRedirectUrl, redirect],
);
const handleMicrosoftLogin = useCallback(
(params: {
workspacePersonalInviteToken?: string;
workspaceInviteHash?: string;
billingCheckoutSession?: BillingCheckoutSession;
action: string;
}) => {
redirect(buildRedirectUrl('/auth/microsoft', params));
},
[buildRedirectUrl, redirect],
);
const handleGetAuthTokensFromOTP = useCallback(
async (otp: string, loginToken: string, captchaToken?: string) => {
const getAuthTokensFromOtpResult = await getAuthTokensFromOtp({
variables: {
captchaToken,
origin,
otp,
loginToken,
},
});
if (isDefined(getAuthTokensFromOtpResult.error)) {
throw getAuthTokensFromOtpResult.error;
}
if (!getAuthTokensFromOtpResult.data?.getAuthTokensFromOTP) {
throw new Error(doNotTranslate('No getAuthTokensFromOTP result'));
}
await handleLoadWorkspaceAfterAuthentication();
},
[getAuthTokensFromOtp, origin, handleLoadWorkspaceAfterAuthentication],
);
const handleGetAuthTokensFromTwoFactorAuthenticationRecoveryCode =
useCallback(
async (
recoveryCode: string,
loginToken: string,
captchaToken?: string,
) => {
const result =
await getAuthTokensFromTwoFactorAuthenticationRecoveryCode({
variables: {
captchaToken,
origin,
recoveryCode,
loginToken,
},
});
if (isDefined(result.error)) {
throw result.error;
}
const redemption =
result.data?.getAuthTokensFromTwoFactorAuthenticationRecoveryCode;
if (!isDefined(redemption)) {
throw new Error(
doNotTranslate(
'No getAuthTokensFromTwoFactorAuthenticationRecoveryCode result',
),
);
}
if (isDefined(redemption.provisioningUri)) {
return { provisioningUri: redemption.provisioningUri };
}
await handleLoadWorkspaceAfterAuthentication();
return { provisioningUri: null };
},
[
getAuthTokensFromTwoFactorAuthenticationRecoveryCode,
origin,
handleLoadWorkspaceAfterAuthentication,
],
);
return {
getLoginTokenFromCredentials: handleGetLoginTokenFromCredentials,
verifyEmailAndGetWorkspaceAgnosticToken:
handleverifyEmailAndGetWorkspaceAgnosticToken,
verifyEmailAndGetLoginToken: handleverifyEmailAndGetLoginToken,
getAuthTokensFromLoginToken: handleGetAuthTokensFromLoginToken,
checkUserExists: { checkUserExistsData, checkUserExistsQuery },
clearSession,
signOut: handleSignOut,
signUpWithCredentials: handleCredentialsSignUp,
signUpWithCredentialsInWorkspace: handleCredentialsSignUpInWorkspace,
signInWithCredentialsInWorkspace: handleCredentialsSignInInWorkspace,
signInWithCredentials: handleCredentialsSignIn,
signInWithGoogle: handleGoogleLogin,
signInWithMicrosoft: handleMicrosoftLogin,
getAuthTokensFromOTP: handleGetAuthTokensFromOTP,
getAuthTokensFromTwoFactorAuthenticationRecoveryCode:
handleGetAuthTokensFromTwoFactorAuthenticationRecoveryCode,
navigateAfterMultiWorkspaceSignInUp,
};
};