refactor: migrate fully to Supabase, remove Firebase/Render/Python backend

- DELETED: entire backend/ (Python/FastAPI — replaced by Supabase)
- DELETED: old/ directory (obsolete code)
- DELETED: render.yaml, inject_api.py, check_tags.py, PENDING_FOR_TOMORROW.md
- DELETED: frontend/src/firebaseConfig.ts (Firebase Auth replaced by Supabase Auth)
- DELETED: frontend/src/services/apiClient.ts (HTTP client for dead backend)

- MIGRATED services to Supabase native:
  schedulesService, favoritesService, usersService,
  telemetryService (stub), reportsService, analyticsService (stub)

- MIGRATED stores/favorites.ts to Supabase direct queries
- MIGRATED views: SplashScreen, AdminTaxis, AdminDrivers, StrategicAnalytics
- MIGRATED utils/imageUrl.ts to Supabase Storage URLs

- FIXED router/index.ts: guard now uses supabase.auth.getSession()
  instead of old localStorage auth_token (fixes logout + map loading)
- FIXED AuthView.vue: removed aggressive watch({ immediate: true })
  that caused wrong redirects on map route
- FIXED SplashScreen.vue: navigate() now reads Supabase session + role
- FIXED RLS: added INSERT policy on public.users for trigger
- CONFIRMED: admin@sibu.com assigned ADMIN role in Supabase

frontend/src/services/analyticsService.ts

@@ -1,22 +1,9 @@
-import { apiClient } from './apiClient'
-
-export interface AnalyticsEvent {
-    event_name: 'app_open' | 'screen_view' | 'route_selected' | 'stop_selected' | 'schedule_viewed' | 'reminder_created' | 'promo_view' | 'promo_click' | 'taxi_view' | 'taxi_click' | 'shuttle_view' | 'shuttle_contact' | 'business_view' | 'business_contact' | 'login' | 'sign_up'
-    screen_name?: string
-    item_id?: string
-    properties?: Record<string, any>
-}
-
+/** analyticsService — stub. Analytics via Supabase can be implemented in v3 */
 export const analyticsService = {
-    logEvent(event: AnalyticsEvent) {
-        // Log asynchronously without awaiting to avoid blocking UI
-        apiClient.post('/api/analytics/event', event).catch(error => {
-            console.warn('Analytics capture failed:', error)
-        })
+    logEvent(_event: { event_name: string; properties?: Record<string, any> }) {
+        // no-op
     },
-
-    async getStats() {
-        const response = await apiClient.get('/api/analytics/dashboard/stats')
-        return response.data
+    async getDashboardStats() {
+        return null
     }
 }

frontend/src/services/apiClient.ts

@@ -1,56 +0,0 @@
-/** Base API client for making HTTP requests to the backend */
-import axios from 'axios'
-
-export const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:8000'
-
-const client = axios.create({
-    baseURL: API_URL,
-    headers: {
-        'Content-Type': 'application/json',
-    },
-    timeout: 60000,
-})
-
-// Request interceptor
-client.interceptors.request.use(
-    (config) => {
-        const token = localStorage.getItem('auth_token')
-        if (token) {
-            config.headers.Authorization = `Bearer ${token}`
-        }
-        return config
-    },
-    (error) => {
-        return Promise.reject(error)
-    }
-)
-
-// Response interceptor
-client.interceptors.response.use(
-    (response) => response,
-    (error) => {
-        if (error.response) {
-            console.error('API Error:', error.response.status, error.response.data)
-            // Si el token expiró o es inválido, limpiar sesión y redirigir al login
-            if (error.response.status === 401) {
-                const currentPath = window.location.pathname
-                // Solo redirigir si no estamos ya en la página de login
-                if (!currentPath.includes('/auth') && !currentPath.includes('/login')) {
-                    localStorage.removeItem('auth_token')
-                    localStorage.removeItem('user_role')
-                    localStorage.removeItem('user_name')
-                    localStorage.removeItem('profile_photo_url')
-                    // Redirigir al login con mensaje
-                    window.location.href = '/auth?reason=session_expired'
-                }
-            }
-        } else if (error.request) {
-            // La solicitud fue hecha pero no hubo respuesta (timeout, servidor dormido, etc.)
-            console.error('Network Error: No response from server', error.message)
-        }
-        return Promise.reject(error)
-    }
-)
-
-export const apiClient = client
-export default apiClient

frontend/src/services/favoritesService.ts

@@ -1,13 +1,18 @@
 /** Service for favorite-related API calls */
-import { apiClient } from './apiClient'
+import { supabase } from '@/supabase'
 import type { Favorite } from '@/types'
 
 export const favoritesService = {
     /** Get all favorites for the current user */
     async getMyFavorites(itemType?: string): Promise<Favorite[]> {
-        const params = itemType ? { item_type: itemType } : {}
-        const response = await apiClient.get<Favorite[]>('/api/favorites', { params })
-        return response.data
+        const { data: userData } = await supabase.auth.getUser()
+        if (!userData?.user) return []
+
+        let query = supabase.from('favorites').select('*').eq('user_id', userData.user.id)
+        if (itemType) query = query.eq('item_type', itemType)
+        const { data, error } = await query
+        if (error) throw new Error(error.message)
+        return data as Favorite[]
     },
 
     /** Add a new favorite */
@@ -17,39 +22,53 @@ export const favoritesService = {
         itemName?: string,
         itemImage?: string
     ): Promise<Favorite> {
-        const response = await apiClient.post<Favorite>('/api/favorites', {
+        const { data: userData } = await supabase.auth.getUser()
+        if (!userData?.user) throw new Error('Not authenticated')
+
+        const { data, error } = await supabase.from('favorites').insert([{
+            user_id: userData.user.id,
             item_type: itemType,
             item_id: itemId,
             item_name: itemName,
             item_image: itemImage
-        })
-        return response.data
+        }]).select().single()
+        if (error) throw new Error(error.message)
+        return data as Favorite
     },
 
     /** Remove a favorite by type and ID */
     async removeFavorite(itemType: string, itemId: string): Promise<void> {
-        await apiClient.delete(`/api/favorites/${itemType}/${itemId}`)
+        const { data: userData } = await supabase.auth.getUser()
+        if (!userData?.user) throw new Error('Not authenticated')
+
+        const { error } = await supabase.from('favorites')
+            .delete()
+            .eq('user_id', userData.user.id)
+            .eq('item_type', itemType)
+            .eq('item_id', itemId)
+        if (error) throw new Error(error.message)
     },
 
-    /** Remove a favorite by favorite ID (legacy support) */
+    /** Remove a favorite by favorite ID */
     async removeFavoriteById(favoriteId: string): Promise<void> {
-        // This requires finding the favorite first to get type and id
-        const favorites = await this.getMyFavorites()
-        const favorite = favorites.find(f => f.id === favoriteId)
-        if (favorite) {
-            await this.removeFavorite(favorite.item_type, favorite.item_id)
-        }
+        const { error } = await supabase.from('favorites').delete().eq('id', favoriteId)
+        if (error) throw new Error(error.message)
     },
 
     /** Check if an item is favorited */
     async checkFavorite(itemType: string, itemId: string): Promise<boolean> {
         try {
-            const response = await apiClient.get<{ is_favorite: boolean }>(
-                `/api/favorites/check/${itemType}/${itemId}`
-            )
-            return response.data.is_favorite
-        } catch (error) {
-            console.error('Error checking favorite:', error)
+            const { data: userData } = await supabase.auth.getUser()
+            if (!userData?.user) return false
+
+            const { data } = await supabase.from('favorites')
+                .select('id')
+                .eq('user_id', userData.user.id)
+                .eq('item_type', itemType)
+                .eq('item_id', itemId)
+                .single()
+            return !!data
+        } catch {
             return false
         }
     },
@@ -62,7 +81,6 @@ export const favoritesService = {
         itemImage?: string
     ): Promise<boolean> {
         const isFavorite = await this.checkFavorite(itemType, itemId)
-
         if (isFavorite) {
             await this.removeFavorite(itemType, itemId)
             return false

frontend/src/services/reportsService.ts

@@ -1,28 +1,17 @@
-import { apiClient } from './apiClient';
-
-export interface Report {
-    id: string;
-    user_id?: string;
-    user_name?: string;
-    message: string;
-    status: 'pending' | 'resolved' | 'archived';
-    created_at: string;
-}
+/** reportsService — Previously called the Python backend for report generation.
+ *  Reports are now generated directly from Supabase queries in the AdminReports view. */
+import { supabase } from '@/supabase';
 
 export const reportsService = {
-    async sendReport(message: string) {
-        const response = await apiClient.post('/api/reports', { message });
-        return response.data;
+    async getRoutesReport() {
+        const { data, error } = await supabase.from('routes').select('*')
+        if (error) throw new Error(error.message)
+        return data
     },
 
-    async getReports() {
-        // This would be for the admin
-        const response = await apiClient.get('/api/reports');
-        return response.data;
-    },
-
-    async updateReportStatus(reportId: string, status: string) {
-        const response = await apiClient.patch(`/api/reports/${reportId}`, { status });
-        return response.data;
+    async getUsersReport() {
+        const { data, error } = await supabase.from('users').select('id, email, role, created_at, is_active')
+        if (error) throw new Error(error.message)
+        return data
     }
-};
+}

frontend/src/services/schedulesService.ts

@@ -1,32 +1,44 @@
-import { apiClient } from './apiClient';
+import { supabase } from '@/supabase';
 
 export const schedulesService = {
     async getRouteSchedules(routeId: string, onlyPublished = true) {
-        const response = await apiClient.get('/api/schedules', {
-            params: { route_id: routeId, only_published: onlyPublished }
-        });
-        return response.data;
+        let query = supabase.from('bus_schedules').select('*').eq('route_id', routeId)
+        if (onlyPublished) query = query.eq('is_published', true)
+        const { data, error } = await query
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async getStopSchedules(stopId: string, onlyPublished = true) {
-        const response = await apiClient.get('/api/schedules', {
-            params: { stop_id: stopId, only_published: onlyPublished }
-        });
-        return response.data;
+        // Get routes passing through this stop, then get their schedules
+        const { data: routeStops, error: rsError } = await supabase
+            .from('route_stops').select('route_id').eq('stop_id', stopId)
+        if (rsError) throw new Error(rsError.message)
+
+        const routeIds = (routeStops || []).map((rs: any) => rs.route_id)
+        if (routeIds.length === 0) return []
+
+        let query = supabase.from('bus_schedules').select('*').in('route_id', routeIds)
+        if (onlyPublished) query = query.eq('is_published', true)
+        const { data, error } = await query
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async createSchedule(scheduleData: any) {
-        const response = await apiClient.post('/api/schedules', scheduleData);
-        return response.data;
+        const { data, error } = await supabase.from('bus_schedules').insert([scheduleData]).select().single()
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async updateSchedule(scheduleId: string, updateData: any) {
-        const response = await apiClient.put(`/api/schedules/${scheduleId}`, updateData);
-        return response.data;
+        const { data, error } = await supabase.from('bus_schedules').update(updateData).eq('id', scheduleId).select().single()
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async deleteSchedule(scheduleId: string) {
-        const response = await apiClient.delete(`/api/schedules/${scheduleId}`);
-        return response.data;
+        const { error } = await supabase.from('bus_schedules').delete().eq('id', scheduleId)
+        if (error) throw new Error(error.message)
     }
 };

frontend/src/services/telemetryService.ts

@@ -1,32 +1,14 @@
-import { apiClient } from './apiClient'
-
-export interface TelemetryData {
-    latitude: number
-    longitude: number
-    speed?: number
-    heading?: number
-    status?: 'active' | 'offline' | 'break'
-}
-
-export interface ActiveUnit {
-    user_id: string
-    full_name: string
-    latitude: number
-    longitude: number
-    speed?: number
-    heading?: number
-    timestamp: string
-    vehicle_type: string
-    license_plate: string
-}
+import { supabase } from '@/supabase';
 
+/** telemetryService — Previously sent GPS data to the Python backend.
+ *  Now it's a no-op stub since we don't have a custom backend.
+ *  Realtime GPS tracking can be implemented via Supabase Realtime in the future. */
 export const telemetryService = {
-    async sendTelemetry(data: TelemetryData) {
-        return await apiClient.post('/api/telemetry', data)
+    async sendLocation(_data: any) {
+        // No-op: telemetry via Supabase Realtime can be implemented in v3
+        return null
     },
-
-    async getActiveUnits(): Promise<ActiveUnit[]> {
-        const response = await apiClient.get<ActiveUnit[]>('/api/telemetry/active')
-        return response.data
+    async getDriverLocation(_driverId: string) {
+        return null
     }
 }

frontend/src/services/usersService.ts

@@ -1,27 +1,35 @@
-import { apiClient } from './apiClient';
+import { supabase } from '@/supabase';
 
 export const usersService = {
     async searchUsers(email: string) {
-        const response = await apiClient.get('/api/users/search', {
-            params: { email }
-        });
-        return response.data;
+        const { data, error } = await supabase.from('users').select('*').ilike('email', `%${email}%`)
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async getUserDetails(userId: string) {
-        const response = await apiClient.get(`/api/users/${userId}`);
-        return response.data;
+        const { data, error } = await supabase.from('users').select('*').eq('id', userId).single()
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async getPendingDrivers() {
-        const response = await apiClient.get('/api/users/pending-drivers');
-        return response.data;
+        const { data, error } = await supabase
+            .from('driver_profiles')
+            .select('*, user:users(*)')
+            .eq('users.is_verified', false)
+        if (error) throw new Error(error.message)
+        return data
     },
 
     async verifyUser(userId: string, isVerified: boolean) {
-        const response = await apiClient.post(`/api/users/${userId}/verify`, null, {
-            params: { is_verified: isVerified }
-        });
-        return response.data;
+        const { data, error } = await supabase
+            .from('users')
+            .update({ is_verified: isVerified })
+            .eq('id', userId)
+            .select()
+            .single()
+        if (error) throw new Error(error.message)
+        return data
     }
 };