Email Authentication fails

[Grayjack64]

I have not been able to get the email login function for my app to work at all. I created a python test script to debug the issue but am getting no closer to a solution. Below is the code from the test script:

import os
import requests
import json
from datetime import datetime

# Get environment variables
with open('.env', 'r') as f:
    for line in f:
        if line.strip() and not line.startswith('#'):
            key, value = line.strip().split('=', 1)
            os.environ[key] = value

SUPABASE_URL = os.getenv('NEXT_PUBLIC_SUPABASE_URL')
SUPABASE_ANON_KEY = os.getenv('NEXT_PUBLIC_SUPABASE_ANON_KEY')
SUPABASE_SERVICE_KEY = os.getenv('SUPABASE_SERVICE_ROLE_KEY')

def test_auth():
    try:
        print(f"\nConfiguration:")
        print(f"URL: {SUPABASE_URL}")
        print(f"Anon key prefix: {SUPABASE_ANON_KEY[:8]}...")
        print(f"Service key prefix: {SUPABASE_SERVICE_KEY[:8]}...")

        admin_headers = {
            'apikey': SUPABASE_SERVICE_KEY,
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {SUPABASE_SERVICE_KEY}',
            'Prefer': 'return=minimal'
        }

        # Check schema structure using direct table query
        print("\nChecking database structure...")
        schema_url = f"{SUPABASE_URL}/rest/v1/users?select=id"  # Simple query to test access
        schema_response = requests.get(schema_url, headers=admin_headers)
        print(f"Schema check status: {schema_response.status_code}")
        try:
            schema_data = schema_response.json()
            print(f"Schema access: {'Successful' if isinstance(schema_data, list) else 'Failed'}")
        except json.JSONDecodeError:
            print(f"Raw schema response: {schema_response.text}")

        # Check auth user directly
        print("\nChecking auth user...")
        auth_url = f"{SUPABASE_URL}/auth/v1/admin/users"
        auth_response = requests.get(auth_url, headers=admin_headers)
        print(f"Auth check status: {auth_response.status_code}")
        try:
            auth_data = auth_response.json()
            print(f"Auth users: {json.dumps(auth_data, indent=2)}")
        except json.JSONDecodeError:
            print(f"Raw auth response: {auth_response.text}")

        # Check public users table
        print("\nChecking public users...")
        public_url = f"{SUPABASE_URL}/rest/v1/users?select=id,email,role,created_at"
        public_response = requests.get(public_url, headers=admin_headers)
        print(f"Public users status: {public_response.status_code}")
        try:
            public_data = public_response.json()
            print(f"Public users: {json.dumps(public_data, indent=2)}")
        except json.JSONDecodeError:
            print(f"Raw public response: {public_response.text}")

        # Check auth settings
        print("\nChecking auth settings...")
        settings_url = f"{SUPABASE_URL}/auth/v1/settings"
        settings_response = requests.get(settings_url, headers=admin_headers)
        print(f"Settings status: {settings_response.status_code}")
        try:
            settings_data = settings_response.json()
            print(f"Auth settings: {json.dumps(settings_data, indent=2)}")
            
            # Add specific redirect URL check
            print("\nChecking redirect URLs...")
            redirect_urls = settings_data.get('additional_redirect_urls', [])
            site_url = settings_data.get('site_url', '')
            print(f"Site URL: {site_url}")
            print(f"Redirect URLs: {json.dumps(redirect_urls, indent=2)}")
        except json.JSONDecodeError:
            print(f"Raw settings response: {settings_response.text}")

        # Check database configuration
        print("\nChecking database configuration...")
        config_query = """
            SELECT json_build_object(
                'database_info', (
                    SELECT json_build_object(
                        'current_database', current_database(),
                        'current_schema', current_schema(),
                        'current_user', current_user,
                        'session_user', session_user
                    )
                ),
                'auth_schema', (
                    SELECT json_build_object(
                        'exists', EXISTS (
                            SELECT 1 FROM information_schema.schemata 
                            WHERE schema_name = 'auth'
                        ),
                        'tables', (
                            SELECT json_agg(table_name)
                            FROM information_schema.tables
                            WHERE table_schema = 'auth'
                        )
                    )
                ),
                'auth_user', (
                    SELECT row_to_json(u)
                    FROM auth.users u
                    WHERE email = '[email protected]'
                    LIMIT 1
                )
            );
        """
        
        config_url = f"{SUPABASE_URL}/rest/v1/rpc/check_db_config"
        config_data = {
            "sql_query": config_query
        }
        
        config_response = requests.post(
            config_url,
            headers=admin_headers,
            json=config_data,
            timeout=30
        )
        
        print(f"Configuration check status: {config_response.status_code}")
        try:
            config_data = config_response.json()
            print(f"Database configuration:\n{json.dumps(config_data, indent=2)}")
        except json.JSONDecodeError:
            print(f"Raw configuration response: {config_response.text}")

        # Attempt login with password endpoint
        print("\nAttempting login...")
        auth_url = f"{SUPABASE_URL}/auth/v1/token?grant_type=password"  # Add grant_type as URL parameter
        login_headers = {
            'apikey': SUPABASE_ANON_KEY,
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {SUPABASE_ANON_KEY}'  # Add Authorization header
        }
        login_data = {
            'email': '[email protected]',
            'password': '*********'
            # Remove grant_type from body since it's in URL
        }
        
        login_response = requests.post(
            auth_url,
            headers=login_headers,
            json=login_data,
            timeout=30
        )
        
        print(f"\nLogin response status: {login_response.status_code}")
        try:
            login_data = login_response.json()
            print(f"Login response: {json.dumps(login_data, indent=2)}")
        except json.JSONDecodeError:
            print(f"Raw login response: {login_response.text}")

        # If login successful, test the access token
        if login_response.status_code == 200:
            print("\nTesting access token...")
            token = login_data.get('access_token')
            if token:
                test_headers = {
                    'apikey': SUPABASE_ANON_KEY,
                    'Authorization': f'Bearer {token}'
                }
                test_url = f"{SUPABASE_URL}/rest/v1/users?select=id"
                test_response = requests.get(test_url, headers=test_headers)
                print(f"Access token test status: {test_response.status_code}")

    except Exception as e:
        print("\nError occurred:")
        print(f"Type: {type(e).__name__}")
        print(f"Message: {str(e)}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    test_auth()

Here is the terminal output from that:

Configuration:
URL: https://vbcfdhjnzhvxhsysuect.supabase.co
Anon key prefix: eyJhbGci...
Service key prefix: eyJhbGci...

Checking database structure...
Schema check status: 200
Schema access: Successful

Checking auth user...
Auth check status: 200
Auth users: {
"users": [],
"aud": "authenticated"
}

Checking public users...
Public users status: 200
Public users: [
{
"id": "77771dcd-6a90-4413-b7a1-431d77081215",
"email": "[email protected]",
"role": "admin",
"created_at": "2025-01-02T15:50:00.051912+00:00"
}
]

Checking auth settings...
Settings status: 200
Auth settings: {
"external": {
"anonymous_users": false,
"apple": false,
"azure": false,
"bitbucket": false,
"discord": false,
"facebook": false,
"figma": false,
"fly": false,
"github": false,
"gitlab": false,
"google": false,
"keycloak": false,
"kakao": false,
"linkedin": false,
"linkedin_oidc": false,
"notion": false,
"spotify": false,
"slack": false,
"slack_oidc": false,
"workos": false,
"twitch": false,
"twitter": false,
"email": true,
"phone": false,
"zoom": false
},
"disable_signup": false,
"mailer_autoconfirm": false,
"phone_autoconfirm": false,
"sms_provider": "twilio",
"saml_enabled": false
}

Checking redirect URLs...
Site URL:
Redirect URLs: []

Checking database configuration...
Configuration check status: 200
Database configuration:
{
"database_info": {
"current_database": "postgres",
"current_schema": "public",
"current_user": "postgres",
"session_user": "authenticator"
},
"auth_schema": {
"exists": true,
"tables": [
"refresh_tokens",
"instances",
"schema_migrations",
"users",
"saml_providers",
"saml_relay_states",
"flow_state",
"one_time_tokens",
"identities",
"audit_log_entries",
"mfa_factors",
"mfa_challenges",
"sessions",
"mfa_amr_claims",
"sso_providers",
"sso_domains"
]
},
"auth_user": {
"instance_id": "00000000-0000-0000-0000-000000000000",
"id": "77771dcd-6a90-4413-b7a1-431d77081215",
"aud": "authenticated",
"role": "authenticated",
"email": "[email protected]",
"encrypted_password": "$2a$06$/3jahVij37FPOI90UHSe3.xS5mlFm3zecQpGLOXe1QiyLytOP4noC",
"email_confirmed_at": "2025-01-02T15:50:00.051912+00:00",
"invited_at": null,
"confirmation_token": null,
"confirmation_sent_at": null,
"recovery_token": null,
"recovery_sent_at": null,
"email_change_token_new": null,
"email_change": null,
"email_change_sent_at": null,
"last_sign_in_at": null,
"raw_app_meta_data": {
"provider": "email",
"providers": [
"email"
]
},
"raw_user_meta_data": {
"full_name": "Danny B********"
},
"is_super_admin": false,
"created_at": "2025-01-02T15:50:00.051912+00:00",
"updated_at": "2025-01-02T15:50:00.051912+00:00",
"phone": null,
"phone_confirmed_at": null,
"phone_change": "",
"phone_change_token": "",
"phone_change_sent_at": null,
"confirmed_at": "2025-01-02T15:50:00.051912+00:00",
"email_change_token_current": "",
"email_change_confirm_status": 0,
"banned_until": null,
"reauthentication_token": "",
"reauthentication_sent_at": null,
"is_sso_user": false,
"deleted_at": null,
"is_anonymous": false
}
}

Attempting login...

Login response status: 400
Login response: {
"code": 400,
"error_code": "invalid_credentials",
"msg": "Invalid login credentials"
}