How to fix anonymous_provider_disabled: Anonymous sign-ins are disabled in Supabase

# After enabling in dashboard, test with:
curl -X POST 'https://YOUR_PROJECT.supabase.co/auth/v1/signup'   -H 'apikey: YOUR_ANON_KEY'   -H 'Content-Type: application/json'   -d '{"provider": "anonymous"}'

// Check current auth configuration
const { data: settings, error } = await supabase.auth.getSettings();

if (!error && settings) {
  console.log('Anonymous auth enabled:', settings.anonymous_sign_in_enabled === true);
  console.log('External providers:', settings.external);

  // Anonymous should be enabled in settings
  const anonymousEnabled = settings.anonymous_sign_in_enabled === true;
  console.log('Anonymous provider enabled:', anonymousEnabled);
}

// Basic anonymous sign-in
async function signInAnonymously() {
  const { data, error } = await supabase.auth.signInAnonymously();

  if (error) {
    if (error.code === 'anonymous_provider_disabled') {
      console.error('Anonymous auth disabled. Enable in Supabase dashboard.');
      // Show user-friendly message or fallback
      return;
    }
    console.error('Anonymous auth error:', error.message);
    return;
  }

  console.log('Anonymous user created:', data.user.id);
  console.log('Session:', data.session);
  // User is now authenticated anonymously
}

// Anonymous user with custom data
async function createAnonymousUserWithData() {
  const { data, error } = await supabase.auth.signInAnonymously({
    options: {
      data: {
        display_name: 'Guest User',
        guest_type: 'trial',
        created_via: 'web_app'
      }
    }
  });

  if (error) {
    console.error('Error:', error);
    return;
  }

  // User created with additional metadata
  console.log('User metadata:', data.user.user_metadata);
}

// Upgrade anonymous user to permanent account
async function upgradeAnonymousUser(email, password) {
  const { data: { user } } = await supabase.auth.getUser();

  if (!user) {
    console.error('No user logged in');
    return;
  }

  // Check if user is anonymous
  if (user.is_anonymous) {
    const { data, error } = await supabase.auth.linkIdentity({
      identity: {
        provider: 'email',
        email: email
      }
    });

    if (error) {
      console.error('Upgrade failed:', error);
      return;
    }

    // Now set password to make account permanent
    const { error: updateError } = await supabase.auth.updateUser({
      password: password,
      email: email
    });

    if (updateError) {
      console.error('Password set failed:', updateError);
      return;
    }

    console.log('Anonymous user upgraded to email account');
  }
}

-- Example: Allow anonymous users to read public data
CREATE POLICY "Anonymous users can read public data"
ON public.products
FOR SELECT
TO anon, authenticated
USING (is_public = true);

-- Example: Allow anonymous users to create cart items
CREATE POLICY "Anonymous users can create their own cart items"
ON public.cart_items
FOR INSERT
TO anon, authenticated
WITH CHECK (auth.uid() = user_id);

-- Example: Allow anonymous users to update their own data
CREATE POLICY "Anonymous users can update their own profiles"
ON public.user_profiles
FOR UPDATE
TO anon, authenticated
USING (auth.uid() = user_id);

-- Check current RLS policies
SELECT schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check
FROM pg_policies
WHERE schemaname = 'public'
ORDER BY tablename, policyname;

// Automatic cleanup of old anonymous users
async function cleanupOldAnonymousUsers(daysOld = 30) {
  const cutoff = new Date();
  cutoff.setDate(cutoff.getDate() - daysOld);

  // Query for old anonymous users
  const { data: oldUsers, error } = await supabase
    .from('auth.users')
    .select('id, created_at, email, raw_user_meta_data')
    .eq('is_anonymous', true)
    .lt('created_at', cutoff.toISOString())
    .limit(100);

  if (error) {
    console.error('Error fetching old anonymous users:', error);
    return;
  }

  // Delete or mark as inactive
  for (const user of oldUsers) {
    // Option 1: Delete user (permanent)
    // await supabase.auth.admin.deleteUser(user.id);

    // Option 2: Mark as inactive
    await supabase
      .from('user_profiles')
      .update({ status: 'inactive' })
      .eq('user_id', user.id);

    console.log('Processed anonymous user: ' + user.id);
  }
}

// Monitor anonymous user activity
async function getAnonymousUserStats() {
  const { data: stats, error } = await supabase
    .from('auth.users')
    .select('count', { count: 'exact', head: true })
    .eq('is_anonymous', true);

  if (error) {
    console.error('Error getting stats:', error);
    return;
  }

  console.log('Total anonymous users: ' + stats.count);

  // Get recent activity
  const { data: recentActivity } = await supabase
    .from('user_sessions')
    .select('user_id, created_at, action')
    .eq('is_anonymous', true)
    .order('created_at', { ascending: false })
    .limit(10);

  return { total: stats.count, recentActivity };
}

// Anonymous user upgrade tracking
async function trackAnonymousUpgrades() {
  const { data: upgrades, error } = await supabase
    .from('user_upgrades')
    .select('anonymous_user_id, upgraded_to, upgraded_at, method')
    .order('upgraded_at', { ascending: false })
    .limit(50);

  if (error) {
    console.error('Error tracking upgrades:', error);
    return;
  }

  console.log('Recent upgrades: ' + upgrades.length);
  return upgrades;
}

// Client-side error handling for anonymous auth
async function handleAnonymousAuth() {
  try {
    const { error } = await supabase.auth.signInAnonymously();

    if (error) {
      if (error.code === 'anonymous_provider_disabled') {
        // Show user-friendly message
        showErrorMessage(
          'Guest access is currently unavailable. ' +
          'Please create an account or use an existing one.'
        );

        // Offer alternatives
        showAlternativeOptions(['email_signup', 'social_login', 'skip_for_now']);
        return;
      }
      throw error;
    }

    // Success - proceed with guest experience
    startGuestExperience();
  } catch (err) {
    console.error('Auth error:', err);
    showGenericError();
  }
}

// Alternative flows when anonymous auth is disabled
function showAlternativeOptions(options) {
  const availableFlows = {
    email_signup: () => supabase.auth.signUp({ email, password }),
    social_login: (provider) => supabase.auth.signInWithOAuth({ provider }),
    skip_for_now: () => {
      // Use localStorage for temporary data instead of authenticated user
      localStorage.setItem('guest_session', generateGuestId());
      proceedWithoutAuth();
    }
  };

  // Show buttons for available options
  options.forEach(option => {
    if (availableFlows[option]) {
      createOptionButton(option, availableFlows[option]);
    }
  });
}

// Feature detection for anonymous auth
async function checkAnonymousAuthAvailable() {
  try {
    // Try a test sign-in (will fail fast if disabled)
    const { error } = await supabase.auth.signInAnonymously();

    if (error && error.code === 'anonymous_provider_disabled') {
      return false;
    }

    // If we got here without that error, it's available
    // Cancel the test sign-in if it succeeded
    await supabase.auth.signOut();
    return true;
  } catch (err) {
    console.error('Check failed:', err);
    return false;
  }
}

// Use feature detection to adjust UI
async function initializeApp() {
  const anonymousAvailable = await checkAnonymousAuthAvailable();

  if (anonymousAvailable) {
    showGuestOption();
  } else {
    hideGuestOption();
    showMessage('Guest access unavailable - please sign up or log in');
  }
}