How to fix identity_already_exists: Identity already linked to a user in Supabase

// Listen for the deep link or redirect
useEffect(() => {
  const { data: authListener } = supabase.auth.onAuthStateChange((event, session) => {
    console.log('Auth event:', event);
  });

  // For mobile apps, listen to deep link
  const url = Linking.getInitialURL();
  url.then((deepLink) => {
    if (deepLink?.includes('error=identity_already_exists')) {
      console.log('Identity already linked to another user');
      // Handle error appropriately
    }
  });
}, []);

// Parse URL parameters after redirect
const params = new URLSearchParams(window.location.search);
const error = params.get('error');
const errorDescription = params.get('error_description');

if (error === 'identity_already_exists') {
  console.log('Error:', errorDescription);
  // Show user-friendly message
}

async function handleIdentityLink(provider: 'google' | 'github' | 'facebook') {
  try {
    const { data, error } = await supabase.auth.linkIdentity({
      provider: provider,
    });

    if (error) {
      throw error;
    }

    // Success - identity linked
    console.log('Identity linked successfully');
  } catch (error: any) {
    // Error is typically returned via redirect URL, not thrown
    // Check redirect URL in your auth callback handler
  }
}

// In your auth callback handler (after redirect)
function handleAuthCallback() {
  const params = new URLSearchParams(window.location.search);
  const error = params.get('error');

  if (error === 'identity_already_exists') {
    // Show user a message with options
    showErrorDialog({
      title: 'Account Already Exists',
      message: 'This account is already linked to another user. Would you like to sign in with that account instead?',
      actions: [
        {
          label: 'Sign In',
          onClick: () => signInWithProvider(provider)
        },
        {
          label: 'Use Different Account',
          onClick: () => resetAndRetry()
        }
      ]
    });
  }
}

async function checkExistingIdentities() {
  const { data: { user } } = await supabase.auth.getUser();

  if (!user) {
    throw new Error('No user signed in');
  }

  // Get all identities for current user
  const identities = user.identities || [];

  console.log('Existing identities:', identities.map(i => ({
    provider: i.provider,
    id: i.id,
    created_at: i.created_at
  })));

  // Check if specific provider is already linked
  const hasGoogleIdentity = identities.some(i => i.provider === 'google');

  if (hasGoogleIdentity) {
    console.log('Google identity already linked');
    return false; // Don't attempt to link
  }

  return true; // Safe to link
}

// Use before calling linkIdentity
async function safeLinkIdentity(provider: string) {
  const canLink = await checkExistingIdentities();

  if (!canLink) {
    console.log('Identity already exists for this provider');
    return;
  }

  // Proceed with linking
  const { error } = await supabase.auth.linkIdentity({ provider });
  // Handle result
}

async function convertAnonymousToVerified(provider: 'google' | 'github') {
  const { data: { user } } = await supabase.auth.getUser();

  if (!user) {
    throw new Error('No user session');
  }

  // Check if user is anonymous
  const isAnonymous = user.is_anonymous ||
    (user.identities && user.identities.length === 0);

  if (!isAnonymous) {
    console.log('User is already verified');
    return;
  }

  // Attempt to link identity
  const { data, error } = await supabase.auth.linkIdentity({ provider });

  // Since error comes via redirect, set up listener
  // In your redirect handler:
  const handleRedirect = () => {
    const params = new URLSearchParams(window.location.search);

    if (params.get('error') === 'identity_already_exists') {
      // Identity exists on another account
      // Option 1: Sign user out and redirect to sign in
      await supabase.auth.signOut();
      await supabase.auth.signInWithOAuth({ provider });

      // Option 2: Transfer anonymous user's data to existing account
      // (requires custom server-side logic)
    }
  };
}