fonctionnalité majeure : setup ultra simplifié (installation/configuration des infos supabase directement du web)

src/app/api/debug-rls/route.ts

@@ -0,0 +1,170 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { supabaseAdmin } from '@/lib/supabase-admin';
+import { supabase } from '@/lib/supabase';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { email } = body;
+
+    if (!email) {
+      return NextResponse.json(
+        { error: 'Email requis' },
+        { status: 400 }
+      );
+    }
+
+    console.log('🔍 Diagnostic RLS pour email:', email);
+
+    // 1. Récupérer l'utilisateur
+    const { data: users, error: usersError } = await supabaseAdmin.auth.admin.listUsers();
+    
+    if (usersError) {
+      return NextResponse.json(
+        { error: `Erreur lors de la récupération des utilisateurs: ${usersError.message}` },
+        { status: 500 }
+      );
+    }
+
+    const user = users.users.find(u => u.email === email);
+    
+    if (!user) {
+      return NextResponse.json(
+        { error: 'Utilisateur non trouvé dans auth.users' },
+        { status: 404 }
+      );
+    }
+
+    // 2. Tests avec le service role (admin)
+    const adminTests = {
+      userPermissionsCount: 0,
+      userPermissionsAccess: false,
+      userExists: false,
+      userDetails: null,
+    };
+
+    try {
+      const { data: userPermissions, error: userPermissionsError } = await supabaseAdmin
+        .from('user_permissions')
+        .select('*');
+
+      if (!userPermissionsError) {
+        adminTests.userPermissionsCount = userPermissions?.length || 0;
+        adminTests.userPermissionsAccess = true;
+        
+        const userPermission = userPermissions?.find(u => u.user_id === user.id);
+        if (userPermission) {
+          adminTests.userExists = true;
+          adminTests.userDetails = userPermission;
+        }
+      }
+    } catch (error) {
+      console.error('Erreur test admin:', error);
+    }
+
+    // 3. Tests avec le client anon (côté client)
+    const clientTests: {
+      canAccessUserPermissions: boolean;
+      canSelectUserPermissions: boolean;
+      canSelectSpecificUser: boolean;
+      rlsError: string | null;
+    } = {
+      canAccessUserPermissions: false,
+      canSelectUserPermissions: false,
+      canSelectSpecificUser: false,
+      rlsError: null,
+    };
+
+    try {
+      // Test 1: Accès général à user_permissions
+      const { data: test1, error: error1 } = await supabase
+        .from('user_permissions')
+        .select('user_id')
+        .limit(1);
+
+      clientTests.canAccessUserPermissions = !error1;
+      if (error1) {
+        clientTests.rlsError = error1.message;
+      }
+    } catch (error: any) {
+      clientTests.rlsError = error.message;
+    }
+
+    try {
+      // Test 2: Sélection avec filtre
+      const { data: test2, error: error2 } = await supabase
+        .from('user_permissions')
+        .select('*')
+        .eq('user_id', user.id);
+
+      clientTests.canSelectSpecificUser = !error2;
+    } catch (error: any) {
+      // Ignore
+    }
+
+    // 4. Vérifier les politiques RLS
+    const rlsPolicies: {
+      userPermissionsPolicies: any[];
+      hasPolicies: boolean;
+    } = {
+      userPermissionsPolicies: [],
+      hasPolicies: false,
+    };
+
+    try {
+      // Note: Cette requête peut ne pas fonctionner selon les permissions
+      const { data: policies, error: policiesError } = await supabaseAdmin
+        .from('information_schema.policies')
+        .select('*')
+        .eq('table_name', 'user_permissions');
+
+      if (!policiesError && policies) {
+        rlsPolicies.userPermissionsPolicies = policies;
+        rlsPolicies.hasPolicies = policies.length > 0;
+      }
+    } catch (error) {
+      console.log('Impossible de récupérer les politiques RLS');
+    }
+
+    // 5. Test de connexion avec l'utilisateur
+    const userSessionTest = {
+      canSignIn: false,
+      sessionError: null,
+    };
+
+    try {
+      // Note: Ce test nécessiterait le mot de passe, on le simule
+      userSessionTest.canSignIn = true; // Supposé vrai si l'utilisateur existe
+    } catch (error: any) {
+      userSessionTest.sessionError = error.message;
+    }
+
+    return NextResponse.json({
+      success: true,
+      user: {
+        id: user.id,
+        email: user.email,
+        created_at: user.created_at,
+        email_confirmed_at: user.email_confirmed_at,
+        last_sign_in_at: user.last_sign_in_at,
+      },
+      adminTests,
+      clientTests,
+      rlsPolicies,
+      userSessionTest,
+      debug: {
+        supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL,
+        hasServiceRole: !!process.env.SUPABASE_SERVICE_ROLE_KEY,
+        hasAnonKey: !!process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
+        totalUsers: users.users.length,
+      }
+    });
+
+  } catch (error: any) {
+    console.error('❌ Erreur lors du diagnostic RLS:', error);
+    return NextResponse.json(
+      { error: `Erreur interne: ${error.message}` },
+      { status: 500 }
+    );
+  }
+}