Supabase

app.py

@@ -20,14 +20,16 @@ app.register_blueprint(domain_bp, url_prefix='/api/analytics')
 # Health check with database status
 @app.route('/health', methods=['GET'])
 def health_check():
-    from database.db import get_db_or_none, get_db_error
+    from database.db import get_db_or_none, get_db_error, get_storage_mode
     db = get_db_or_none()
     db_status = 'connected' if db is not None else 'disconnected'
     db_error = get_db_error()
+    storage_mode = get_storage_mode()
     
     return {
         'status': 'healthy' if db else 'degraded',
         'service': 'analytics-api',
+        'storage_mode': storage_mode,  # 'supabase' or 'local'
         'database': db_status,
         'db_error': db_error if db_error else None
     }, 200 if db else 503

database/add_semester_columns.sql

@@ -1,9 +0,0 @@
--- Add missing semester columns to analytics_students table
--- Run this in Supabase SQL Editor
-
-ALTER TABLE analytics_students 
-ADD COLUMN IF NOT EXISTS sgpa_sem1 REAL CHECK (sgpa_sem1 >= 0 AND sgpa_sem1 <= 10),
-ADD COLUMN IF NOT EXISTS sgpa_sem2 REAL CHECK (sgpa_sem2 >= 0 AND sgpa_sem2 <= 10),
-ADD COLUMN IF NOT EXISTS sgpa_sem3 REAL CHECK (sgpa_sem3 >= 0 AND sgpa_sem3 <= 10),
-ADD COLUMN IF NOT EXISTS sgpa_sem7 REAL CHECK (sgpa_sem7 >= 0 AND sgpa_sem7 <= 10),
-ADD COLUMN IF NOT EXISTS sgpa_sem8 REAL CHECK (sgpa_sem8 >= 0 AND sgpa_sem8 <= 10);

database/create_storage_bucket.sql

@@ -0,0 +1,28 @@
+-- Create Analytics Storage Bucket
+-- Run this in Supabase SQL Editor
+
+-- 1. Create a public storage bucket for analytics data
+INSERT INTO storage.buckets (id, name, public)
+VALUES ('analytics-data', 'analytics-data', true)
+ON CONFLICT (id) DO NOTHING;
+
+-- 2. Allow public read access (for API to fetch data)
+CREATE POLICY "Allow public read access on analytics-data"
+ON storage.objects FOR SELECT
+USING (bucket_id = 'analytics-data');
+
+-- 3. Allow authenticated upsert (for API to write data)  
+CREATE POLICY "Allow public insert on analytics-data"
+ON storage.objects FOR INSERT
+WITH CHECK (bucket_id = 'analytics-data');
+
+CREATE POLICY "Allow public update on analytics-data"
+ON storage.objects FOR UPDATE
+USING (bucket_id = 'analytics-data');
+
+CREATE POLICY "Allow public delete on analytics-data"
+ON storage.objects FOR DELETE
+USING (bucket_id = 'analytics-data');
+
+-- Verify bucket was created
+SELECT * FROM storage.buckets WHERE id = 'analytics-data';

database/db.py

@@ -1,62 +1,97 @@
-"""Database connection and utilities"""
+"""Database connection with Storage Bucket + Local fallback"""
 import os
-from supabase import create_client, Client
 from config import Config
 
-# Validate Supabase credentials before creating client
-_supabase_client: Client = None
+# Storage mode: 'storage_bucket', 'local', or None
+STORAGE_MODE = None
+_db_client = None
 _db_error: str = None
 
-def _init_supabase():
-    """Initialize Supabase client with proper validation"""
-    global _supabase_client, _db_error
+def _init_storage_bucket():
+    """Try to initialize Supabase Storage Bucket DB"""
+    global STORAGE_MODE, _db_client, _db_error
     
     supabase_url = Config.SUPABASE_URL
     supabase_key = Config.SUPABASE_KEY
     
-    # Log for debugging (partial key for security)
+    # Log for debugging
     print(f"[DB] SUPABASE_URL: {supabase_url[:30]}..." if supabase_url else "[DB] SUPABASE_URL: NOT SET")
-    print(f"[DB] SUPABASE_KEY: {'*' * 10}...{supabase_key[-10:]}" if supabase_key and len(supabase_key) > 10 else "[DB] SUPABASE_KEY: NOT SET OR TOO SHORT")
+    print(f"[DB] SUPABASE_KEY: {'*' * 10}...{supabase_key[-10:]}" if supabase_key and len(supabase_key) > 10 else "[DB] SUPABASE_KEY: NOT SET")
     
-    if not supabase_url or supabase_url == '':
-        _db_error = "SUPABASE_URL environment variable is not set"
-        print(f"[DB ERROR] {_db_error}")
-        return None
+    if not supabase_url or not supabase_key or supabase_key == '':
+        _db_error = "SUPABASE credentials not set"
+        print(f"[DB] {_db_error} - falling back to local storage")
+        return False
     
-    if not supabase_key or supabase_key == '':
-        _db_error = "SUPABASE_KEY environment variable is not set"
+    try:
+        from supabase import create_client
+        from database.storage_bucket_db import StorageBucketDB
+        
+        # Create Supabase client
+        supabase_client = create_client(supabase_url, supabase_key)
+        
+        # Wrap with StorageBucketDB to use Storage instead of DB tables
+        _db_client = StorageBucketDB(supabase_client)
+        STORAGE_MODE = 'storage_bucket'
+        print("[DB] Using Supabase STORAGE BUCKET (analytics-data bucket)")
+        return True
+    except Exception as e:
+        _db_error = f"Failed to initialize storage bucket: {str(e)}"
         print(f"[DB ERROR] {_db_error}")
-        return None
+        return False
+
+
+def _init_local():
+    """Initialize local file storage as fallback"""
+    global STORAGE_MODE, _db_client, _db_error
     
     try:
-        _supabase_client = create_client(supabase_url, supabase_key)
-        print("[DB] Supabase client created successfully")
-        return _supabase_client
+        from database.local_storage import get_local_storage
+        _db_client = get_local_storage()
+        STORAGE_MODE = 'local'
+        print("[DB] Using LOCAL FILE STORAGE (data saved to /tmp/analytics_data)")
+        return True
     except Exception as e:
-        _db_error = f"Failed to create Supabase client: {str(e)}"
+        _db_error = f"Failed to initialize local storage: {str(e)}"
         print(f"[DB ERROR] {_db_error}")
-        return None
+        return False
+
+
+def _init_db():
+    """Initialize database - tries Storage Bucket first, falls back to local"""
+    if not _init_storage_bucket():
+        _init_local()
+
 
 # Initialize on module load
-_init_supabase()
+_init_db()
+
 
 def get_db():
-    """Get Supabase client instance"""
-    global _supabase_client, _db_error
+    """Get database client instance"""
+    global _db_client, _db_error
     
-    if _supabase_client is None:
-        # Try to reinitialize
-        _init_supabase()
+    if _db_client is None:
+        _init_db()
         
-    if _supabase_client is None:
-        raise RuntimeError(f"Database not available: {_db_error}")
+    if _db_client is None:
+        raise RuntimeError(f"No database available: {_db_error}")
     
-    return _supabase_client
+    return _db_client
+
 
 def get_db_or_none():
-    """Get Supabase client or None (for health checks)"""
-    return _supabase_client
+    """Get database client or None (for health checks)"""
+    return _db_client
+
 
 def get_db_error():
     """Get database initialization error if any"""
     return _db_error
+
+
+def get_storage_mode():
+    """Get current storage mode: 'storage_bucket', 'local', or None"""
+    return STORAGE_MODE
+
+

database/local_storage.py

@@ -0,0 +1,226 @@
+"""Local file-based storage fallback for analytics data"""
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+import uuid
+
+# Storage directory - works on HuggingFace Spaces in /tmp
+STORAGE_DIR = os.getenv('ANALYTICS_STORAGE_DIR', '/tmp/analytics_data')
+
+class LocalStorage:
+    """Simple file-based storage that mimics Supabase responses"""
+    
+    def __init__(self):
+        self.storage_dir = STORAGE_DIR
+        os.makedirs(self.storage_dir, exist_ok=True)
+        print(f"[LocalStorage] Initialized at: {self.storage_dir}")
+        
+        # Initialize data files
+        self.students_file = os.path.join(self.storage_dir, 'students.json')
+        self.personality_file = os.path.join(self.storage_dir, 'personality.json')
+        self.text_file = os.path.join(self.storage_dir, 'text.json')
+        self.domain_file = os.path.join(self.storage_dir, 'domain.json')
+        
+        # Load existing data
+        self._students = self._load(self.students_file, {})
+        self._personality = self._load(self.personality_file, {})
+        self._text = self._load(self.text_file, {})
+        self._domain = self._load(self.domain_file, {})
+    
+    def _load(self, filepath: str, default: Any) -> Any:
+        """Load JSON file or return default"""
+        try:
+            if os.path.exists(filepath):
+                with open(filepath, 'r') as f:
+                    return json.load(f)
+        except Exception as e:
+            print(f"[LocalStorage] Error loading {filepath}: {e}")
+        return default
+    
+    def _save(self, filepath: str, data: Any):
+        """Save data to JSON file"""
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(data, f, indent=2, default=str)
+        except Exception as e:
+            print(f"[LocalStorage] Error saving {filepath}: {e}")
+    
+    def table(self, table_name: str) -> 'LocalTable':
+        """Return a table-like interface"""
+        return LocalTable(self, table_name)
+    
+    def get_data(self, table_name: str) -> Dict:
+        """Get raw data for a table"""
+        mapping = {
+            'analytics_students': (self._students, self.students_file),
+            'analytics_personality_responses': (self._personality, self.personality_file),
+            'analytics_text_responses': (self._text, self.text_file),
+            'analytics_domain_evidence': (self._domain, self.domain_file),
+        }
+        return mapping.get(table_name, ({}, None))
+    
+    def set_data(self, table_name: str, key: str, value: Dict):
+        """Set data for a table"""
+        data, filepath = self.get_data(table_name)
+        if data is not None:
+            data[key] = value
+            self._save(filepath, data)
+
+
+class LocalTable:
+    """Mimics Supabase table interface for local storage"""
+    
+    def __init__(self, storage: LocalStorage, table_name: str):
+        self.storage = storage
+        self.table_name = table_name
+        self._query = {}
+        self._select_cols = '*'
+    
+    def select(self, columns: str = '*') -> 'LocalTable':
+        self._select_cols = columns
+        return self
+    
+    def eq(self, column: str, value: Any) -> 'LocalTable':
+        self._query[column] = value
+        return self
+    
+    def maybe_single(self) -> 'LocalTable':
+        self._single = True
+        return self
+    
+    def single(self) -> 'LocalTable':
+        self._single = True
+        return self
+    
+    def execute(self) -> 'LocalResult':
+        """Execute the query or write operation"""
+        # Check if this is a write operation
+        if hasattr(self, '_insert_data'):
+            return self._do_insert()
+        if hasattr(self, '_upsert_data'):
+            return self._do_upsert()
+        if hasattr(self, '_update_data'):
+            return self._do_update()
+        
+        # Otherwise it's a read/select operation
+        data, _ = self.storage.get_data(self.table_name)
+        
+        if self._query:
+            # Filter by query
+            results = []
+            for key, record in data.items():
+                match = all(record.get(k) == v for k, v in self._query.items())
+                if match:
+                    results.append(record)
+            
+            if getattr(self, '_single', False) and results:
+                return LocalResult(results[0])
+            elif getattr(self, '_single', False):
+                return LocalResult(None)
+            return LocalResult(results)
+        else:
+            # Return all
+            return LocalResult(list(data.values()))
+    
+    def insert(self, record: Dict) -> 'LocalTable':
+        """Insert a record"""
+        self._insert_data = record
+        return self
+    
+    def upsert(self, record: Dict) -> 'LocalTable':
+        """Upsert a record"""
+        self._upsert_data = record
+        return self
+    
+    def update(self, record: Dict) -> 'LocalTable':
+        """Update records"""
+        self._update_data = record
+        return self
+    
+    def _do_insert(self) -> 'LocalResult':
+        """Perform insert"""
+        record = getattr(self, '_insert_data', {})
+        data, filepath = self.storage.get_data(self.table_name)
+        
+        # Generate ID if needed
+        if 'id' not in record:
+            record['id'] = str(uuid.uuid4())
+        
+        # Use student_id as key if present
+        key = record.get('student_id', record.get('id'))
+        record['created_at'] = datetime.utcnow().isoformat()
+        
+        data[key] = record
+        self.storage._save(filepath, data)
+        
+        print(f"[LocalStorage] Inserted into {self.table_name}: {key}")
+        return LocalResult([record])
+    
+    def _do_upsert(self) -> 'LocalResult':
+        """Perform upsert"""
+        record = getattr(self, '_upsert_data', {})
+        data, filepath = self.storage.get_data(self.table_name)
+        
+        # Use student_id as key
+        key = record.get('student_id', str(uuid.uuid4()))
+        
+        # Merge with existing if present
+        if key in data:
+            existing = data[key]
+            existing.update(record)
+            existing['updated_at'] = datetime.utcnow().isoformat()
+            record = existing
+        else:
+            record['id'] = str(uuid.uuid4())
+            record['created_at'] = datetime.utcnow().isoformat()
+        
+        data[key] = record
+        self.storage._save(filepath, data)
+        
+        print(f"[LocalStorage] Upserted into {self.table_name}: {key}")
+        return LocalResult([record])
+    
+    def _do_update(self) -> 'LocalResult':
+        """Perform update on matching records"""
+        updates = getattr(self, '_update_data', {})
+        data, filepath = self.storage.get_data(self.table_name)
+        updated = []
+        
+        for key, record in data.items():
+            match = all(record.get(k) == v for k, v in self._query.items())
+            if match:
+                record.update(updates)
+                record['updated_at'] = datetime.utcnow().isoformat()
+                updated.append(record)
+        
+        self.storage._save(filepath, data)
+        print(f"[LocalStorage] Updated {len(updated)} records in {self.table_name}")
+        return LocalResult(updated)
+
+
+class LocalResult:
+    """Mimics Supabase result object"""
+    
+    def __init__(self, data: Any):
+        if data is None:
+            self.data = None
+        elif isinstance(data, list):
+            self.data = data
+        else:
+            self.data = data
+    
+    def execute(self) -> 'LocalResult':
+        """For chained calls that end with execute()"""
+        return self
+
+
+# Singleton instance
+_local_storage: LocalStorage = None
+
+def get_local_storage() -> LocalStorage:
+    """Get or create local storage instance"""
+    global _local_storage
+    if _local_storage is None:
+        _local_storage = LocalStorage()
+    return _local_storage

database/migrate_domain_module.sql

@@ -1,113 +0,0 @@
--- Domain Module Migration Script
--- Run this in Supabase SQL Editor to add domain-specific scoring support
--- Date: December 9, 2025
-
--- ============================================================================
--- STEP 1: Add domain fields to existing analytics_students table
--- ============================================================================
-
-ALTER TABLE analytics_students 
-ADD COLUMN IF NOT EXISTS active_domain TEXT CHECK (active_domain IN ('tech', 'business', 'creative', 'research', NULL)),
-ADD COLUMN IF NOT EXISTS domain_score REAL CHECK (domain_score >= 0 AND domain_score <= 1),
-ADD COLUMN IF NOT EXISTS domain_confidence REAL CHECK (domain_confidence >= 0 AND domain_confidence <= 1);
-
--- ============================================================================
--- STEP 2: Create domain evidence table
--- ============================================================================
-
-CREATE TABLE IF NOT EXISTS analytics_domain_evidence (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    student_id TEXT REFERENCES analytics_students(student_id) ON DELETE CASCADE,
-    domain_type TEXT NOT NULL CHECK (domain_type IN ('tech', 'business', 'creative', 'research')),
-    evidence_data JSONB NOT NULL,
-    domain_score REAL CHECK (domain_score >= 0 AND domain_score <= 1),
-    domain_confidence REAL CHECK (domain_confidence >= 0 AND domain_confidence <= 1),
-    raw_features JSONB,
-    processing_status TEXT DEFAULT 'pending' CHECK (processing_status IN ('pending', 'processing', 'completed', 'failed')),
-    error_message TEXT,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    UNIQUE(student_id, domain_type)
-);
-
--- ============================================================================
--- STEP 3: Create indexes for performance
--- ============================================================================
-
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_student ON analytics_domain_evidence(student_id);
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_type ON analytics_domain_evidence(domain_type);
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_status ON analytics_domain_evidence(processing_status);
-
--- ============================================================================
--- STEP 4: Enable Row Level Security
--- ============================================================================
-
-ALTER TABLE analytics_domain_evidence ENABLE ROW LEVEL SECURITY;
-
--- ============================================================================
--- STEP 5: Create RLS Policies for domain evidence
--- ============================================================================
-
--- Users can view their own domain evidence
-CREATE POLICY "Users can view own domain evidence"
-ON analytics_domain_evidence FOR SELECT
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- Users can insert their own domain evidence
-CREATE POLICY "Users can insert own domain evidence"
-ON analytics_domain_evidence FOR INSERT
-TO authenticated
-WITH CHECK (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- Users can update their own domain evidence
-CREATE POLICY "Users can update own domain evidence"
-ON analytics_domain_evidence FOR UPDATE
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- Users can delete their own domain evidence
-CREATE POLICY "Users can delete own domain evidence"
-ON analytics_domain_evidence FOR DELETE
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- ============================================================================
--- STEP 6: Verification queries (run these to verify successful migration)
--- ============================================================================
-
--- Check if columns were added
-SELECT column_name, data_type 
-FROM information_schema.columns 
-WHERE table_name = 'analytics_students' 
-  AND column_name IN ('active_domain', 'domain_score', 'domain_confidence');
-
--- Check if table was created
-SELECT table_name 
-FROM information_schema.tables 
-WHERE table_name = 'analytics_domain_evidence';
-
--- Check if indexes were created
-SELECT indexname 
-FROM pg_indexes 
-WHERE tablename = 'analytics_domain_evidence';
-
--- Check if RLS policies were created
-SELECT policyname 
-FROM pg_policies 
-WHERE tablename = 'analytics_domain_evidence';
-
--- ============================================================================
--- Migration Complete!
--- ============================================================================
-
--- Expected results:
--- ✓ 3 new columns in analytics_students table
--- ✓ 1 new table: analytics_domain_evidence
--- ✓ 3 new indexes
--- ✓ 4 new RLS policies
-
--- Next steps:
--- 1. Restart your Flask backend: python app.py
--- 2. Test domain submission via API or frontend form
--- 3. Verify score fusion includes domain component

database/migrate_scores_table.sql

@@ -1,71 +0,0 @@
--- Analytics Scores Table - Store computed reports
--- Run this in Supabase SQL Editor
-
--- Create table for storing computed analytics scores/reports
-CREATE TABLE IF NOT EXISTS analytics_scores (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    student_id TEXT REFERENCES analytics_students(student_id) ON DELETE CASCADE,
-    
-    -- Overall scores
-    final_score REAL NOT NULL CHECK (final_score >= 0 AND final_score <= 100),
-    tier TEXT CHECK (tier IN ('Excellent', 'Good', 'Average', 'Needs Work')),
-    
-    -- Component scores
-    universal_score REAL CHECK (universal_score >= 0 AND universal_score <= 100),
-    personality_score REAL CHECK (personality_score >= 0 AND personality_score <= 100),
-    text_score REAL CHECK (text_score >= 0 AND text_score <= 100),
-    
-    -- Fidelity and domain
-    fidelity_score REAL CHECK (fidelity_score >= 0 AND fidelity_score <= 1),
-    detected_domain TEXT,
-    domain_confidence REAL CHECK (domain_confidence >= 0 AND domain_confidence <= 1),
-    
-    -- Full report JSON (includes strengths, improvements, career suggestions, etc.)
-    full_report JSONB NOT NULL,
-    
-    -- Timestamps
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    
-    -- Only one score record per student (can be updated)
-    UNIQUE(student_id)
-);
-
--- Index for faster lookups
-CREATE INDEX IF NOT EXISTS idx_analytics_scores_student ON analytics_scores(student_id);
-CREATE INDEX IF NOT EXISTS idx_analytics_scores_tier ON analytics_scores(tier);
-CREATE INDEX IF NOT EXISTS idx_analytics_scores_domain ON analytics_scores(detected_domain);
-
--- RLS Policies
-ALTER TABLE analytics_scores ENABLE ROW LEVEL SECURITY;
-
--- Users can view their own scores
-CREATE POLICY "Users can view own scores"
-ON analytics_scores FOR SELECT
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- Service role can insert/update (for backend processing)
-CREATE POLICY "Service can insert scores"
-ON analytics_scores FOR INSERT
-TO service_role
-WITH CHECK (true);
-
-CREATE POLICY "Service can update scores"
-ON analytics_scores FOR UPDATE
-TO service_role
-USING (true);
-
--- Function to auto-update updated_at timestamp
-CREATE OR REPLACE FUNCTION update_analytics_scores_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
-    NEW.updated_at = NOW();
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER trigger_analytics_scores_updated
-    BEFORE UPDATE ON analytics_scores
-    FOR EACH ROW
-    EXECUTE FUNCTION update_analytics_scores_timestamp();

database/migrate_to_text_fields.sql

@@ -1,17 +0,0 @@
--- Migration: Replace numeric fields with text fields for extracurricular, certifications, and internships
--- Run this in Supabase SQL Editor
-
--- Add new text columns
-ALTER TABLE analytics_students 
-ADD COLUMN IF NOT EXISTS extracurricular_text TEXT,
-ADD COLUMN IF NOT EXISTS certifications_text TEXT,
-ADD COLUMN IF NOT EXISTS internship_text TEXT;
-
--- Optional: Drop old numeric columns if you want to clean up
--- Uncomment these lines after verifying the new text fields work
--- ALTER TABLE analytics_students DROP COLUMN IF EXISTS extracurricular_count;
--- ALTER TABLE analytics_students DROP COLUMN IF EXISTS certifications_count;
--- ALTER TABLE analytics_students DROP COLUMN IF EXISTS internship_total_months;
-
--- Note: If you want to keep both old and new columns during transition,
--- you can skip dropping the old columns and they will coexist.

database/schema.sql

@@ -1,151 +0,0 @@
--- Analytics Module Schema for Supabase
--- Run this in Supabase SQL Editor
-
--- 1. Students Table
-CREATE TABLE IF NOT EXISTS analytics_students (
-    student_id TEXT PRIMARY KEY,
-    user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
-    cgpa REAL NOT NULL CHECK (cgpa >= 0 AND cgpa <= 10),
-    sgpa_sem1 REAL CHECK (sgpa_sem1 >= 0 AND sgpa_sem1 <= 10),
-    sgpa_sem2 REAL CHECK (sgpa_sem2 >= 0 AND sgpa_sem2 <= 10),
-    sgpa_sem3 REAL CHECK (sgpa_sem3 >= 0 AND sgpa_sem3 <= 10),
-    sgpa_sem4 REAL CHECK (sgpa_sem4 >= 0 AND sgpa_sem4 <= 10),
-    sgpa_sem5 REAL CHECK (sgpa_sem5 >= 0 AND sgpa_sem5 <= 10),
-    sgpa_sem6 REAL CHECK (sgpa_sem6 >= 0 AND sgpa_sem6 <= 10),
-    sgpa_sem7 REAL CHECK (sgpa_sem7 >= 0 AND sgpa_sem7 <= 10),
-    sgpa_sem8 REAL CHECK (sgpa_sem8 >= 0 AND sgpa_sem8 <= 10),
-    tenth_pct REAL CHECK (tenth_pct >= 0 AND tenth_pct <= 100),
-    twelfth_pct REAL CHECK (twelfth_pct >= 0 AND twelfth_pct <= 100),
-    extracurricular_text TEXT,
-    certifications_text TEXT,
-    internship_text TEXT,
-    active_domain TEXT CHECK (active_domain IN ('tech', 'business', 'creative', 'research', NULL)),
-    domain_score REAL CHECK (domain_score >= 0 AND domain_score <= 1),
-    domain_confidence REAL CHECK (domain_confidence >= 0 AND domain_confidence <= 1),
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-);
-
--- 2. Personality Responses Table
-CREATE TABLE IF NOT EXISTS analytics_personality_responses (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    student_id TEXT REFERENCES analytics_students(student_id) ON DELETE CASCADE,
-    p_q1 INTEGER CHECK (p_q1 >= 1 AND p_q1 <= 5),
-    p_q2 INTEGER CHECK (p_q2 >= 1 AND p_q2 <= 5),
-    p_q3 INTEGER CHECK (p_q3 >= 1 AND p_q3 <= 5),
-    p_q4 INTEGER CHECK (p_q4 >= 1 AND p_q4 <= 5),
-    p_q5 INTEGER CHECK (p_q5 >= 1 AND p_q5 <= 5),
-    p_q6 INTEGER CHECK (p_q6 >= 1 AND p_q6 <= 5),
-    p_q7 INTEGER CHECK (p_q7 >= 1 AND p_q7 <= 5),
-    p_q8 INTEGER CHECK (p_q8 >= 1 AND p_q8 <= 5),
-    p_q9 INTEGER CHECK (p_q9 >= 1 AND p_q9 <= 5),
-    p_q10 INTEGER CHECK (p_q10 >= 1 AND p_q10 <= 5),
-    p_q11 INTEGER CHECK (p_q11 >= 1 AND p_q11 <= 5),
-    p_q12 INTEGER CHECK (p_q12 >= 1 AND p_q12 <= 5),
-    p_q13 INTEGER CHECK (p_q13 >= 1 AND p_q13 <= 5),
-    p_q14 INTEGER CHECK (p_q14 >= 1 AND p_q14 <= 5),
-    p_q15 INTEGER CHECK (p_q15 >= 1 AND p_q15 <= 5),
-    p_q16 INTEGER CHECK (p_q16 >= 1 AND p_q16 <= 5),
-    p_q17 INTEGER CHECK (p_q17 >= 1 AND p_q17 <= 5),
-    p_q18 INTEGER CHECK (p_q18 >= 1 AND p_q18 <= 5),
-    p_q19 INTEGER CHECK (p_q19 >= 1 AND p_q19 <= 5),
-    p_q20 INTEGER CHECK (p_q20 >= 1 AND p_q20 <= 5),
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    UNIQUE(student_id)
-);
-
--- 3. Text Responses Table
-CREATE TABLE IF NOT EXISTS analytics_text_responses (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    student_id TEXT REFERENCES analytics_students(student_id) ON DELETE CASCADE,
-    text_q1 TEXT NOT NULL, -- Strengths
-    text_q2 TEXT NOT NULL, -- Career interests
-    text_q3 TEXT NOT NULL, -- Extracurriculars + leadership
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    UNIQUE(student_id)
-);
-
--- 4. Domain Evidence Table
-CREATE TABLE IF NOT EXISTS analytics_domain_evidence (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    student_id TEXT REFERENCES analytics_students(student_id) ON DELETE CASCADE,
-    domain_type TEXT NOT NULL CHECK (domain_type IN ('tech', 'business', 'creative', 'research')),
-    evidence_data JSONB NOT NULL, -- Flexible storage for domain-specific inputs
-    domain_score REAL CHECK (domain_score >= 0 AND domain_score <= 1),
-    domain_confidence REAL CHECK (domain_confidence >= 0 AND domain_confidence <= 1),
-    raw_features JSONB, -- Raw feature values for explainability
-    processing_status TEXT DEFAULT 'pending' CHECK (processing_status IN ('pending', 'processing', 'completed', 'failed')),
-    error_message TEXT,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    UNIQUE(student_id, domain_type)
-);
-
--- Indexes
-CREATE INDEX IF NOT EXISTS idx_analytics_students_user_id ON analytics_students(user_id);
-CREATE INDEX IF NOT EXISTS idx_personality_student ON analytics_personality_responses(student_id);
-CREATE INDEX IF NOT EXISTS idx_text_student ON analytics_text_responses(student_id);
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_student ON analytics_domain_evidence(student_id);
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_type ON analytics_domain_evidence(domain_type);
-CREATE INDEX IF NOT EXISTS idx_domain_evidence_status ON analytics_domain_evidence(processing_status);
-
--- RLS Policies
-ALTER TABLE analytics_students ENABLE ROW LEVEL SECURITY;
-ALTER TABLE analytics_personality_responses ENABLE ROW LEVEL SECURITY;
-ALTER TABLE analytics_text_responses ENABLE ROW LEVEL SECURITY;
-
--- Students can view/update their own data
-CREATE POLICY "Users can view own analytics data"
-ON analytics_students FOR SELECT
-TO authenticated
-USING (user_id = auth.uid());
-
-CREATE POLICY "Users can insert own analytics data"
-ON analytics_students FOR INSERT
-TO authenticated
-WITH CHECK (user_id = auth.uid());
-
-CREATE POLICY "Users can update own analytics data"
-ON analytics_students FOR UPDATE
-TO authenticated
-USING (user_id = auth.uid());
-
--- Personality responses
-CREATE POLICY "Users can view own personality responses"
-ON analytics_personality_responses FOR SELECT
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
-CREATE POLICY "Users can insert own personality responses"
-ON analytics_personality_responses FOR INSERT
--- Text responses
-CREATE POLICY "Users can view own text responses"
-ON analytics_text_responses FOR SELECT
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
-CREATE POLICY "Users can insert own text responses"
-ON analytics_text_responses FOR INSERT
-TO authenticated
-WITH CHECK (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
--- Domain evidence
-ALTER TABLE analytics_domain_evidence ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY "Users can view own domain evidence"
-ON analytics_domain_evidence FOR SELECT
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
-CREATE POLICY "Users can insert own domain evidence"
-ON analytics_domain_evidence FOR INSERT
-TO authenticated
-WITH CHECK (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-
-CREATE POLICY "Users can update own domain evidence"
-ON analytics_domain_evidence FOR UPDATE
-TO authenticated
-USING (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));
-ON analytics_text_responses FOR INSERT
-TO authenticated
-WITH CHECK (student_id IN (SELECT student_id FROM analytics_students WHERE user_id = auth.uid()));

database/storage_bucket_db.py

@@ -0,0 +1,196 @@
+"""Supabase Storage-based storage for analytics data"""
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+import uuid
+
+class StorageBucketDB:
+    """Uses Supabase Storage bucket to store analytics JSON files"""
+    
+    BUCKET_NAME = 'analytics-data'
+    
+    def __init__(self, supabase_client):
+        self.supabase = supabase_client
+        self.storage = supabase_client.storage
+        print(f"[StorageBucketDB] Initialized with bucket: {self.BUCKET_NAME}")
+        
+        # In-memory cache for faster reads
+        self._cache = {}
+    
+    def _get_path(self, table_name: str) -> str:
+        """Get storage path for a table"""
+        return f"{table_name}.json"
+    
+    def _load_table(self, table_name: str) -> Dict:
+        """Load table data from storage"""
+        if table_name in self._cache:
+            return self._cache[table_name]
+        
+        try:
+            path = self._get_path(table_name)
+            response = self.storage.from_(self.BUCKET_NAME).download(path)
+            if response:
+                data = json.loads(response.decode('utf-8'))
+                self._cache[table_name] = data
+                print(f"[StorageBucketDB] Loaded {table_name}: {len(data)} records")
+                return data
+        except Exception as e:
+            print(f"[StorageBucketDB] Table {table_name} not found or empty: {e}")
+        
+        self._cache[table_name] = {}
+        return {}
+    
+    def _save_table(self, table_name: str, data: Dict):
+        """Save table data to storage"""
+        try:
+            path = self._get_path(table_name)
+            content = json.dumps(data, indent=2, default=str).encode('utf-8')
+            
+            # Try to update first, then upload if not exists
+            try:
+                self.storage.from_(self.BUCKET_NAME).update(path, content, {
+                    'content-type': 'application/json'
+                })
+            except:
+                self.storage.from_(self.BUCKET_NAME).upload(path, content, {
+                    'content-type': 'application/json'
+                })
+            
+            self._cache[table_name] = data
+            print(f"[StorageBucketDB] Saved {table_name}: {len(data)} records")
+        except Exception as e:
+            print(f"[StorageBucketDB] Error saving {table_name}: {e}")
+            raise
+    
+    def table(self, table_name: str) -> 'StorageTable':
+        """Return a table-like interface"""
+        return StorageTable(self, table_name)
+
+
+class StorageTable:
+    """Mimics Supabase table interface using storage bucket"""
+    
+    def __init__(self, db: StorageBucketDB, table_name: str):
+        self.db = db
+        self.table_name = table_name
+        self._query = {}
+        self._single = False
+    
+    def select(self, columns: str = '*') -> 'StorageTable':
+        return self
+    
+    def eq(self, column: str, value: Any) -> 'StorageTable':
+        self._query[column] = value
+        return self
+    
+    def maybe_single(self) -> 'StorageTable':
+        self._single = True
+        return self
+    
+    def single(self) -> 'StorageTable':
+        self._single = True
+        return self
+    
+    def insert(self, record: Dict) -> 'StorageTable':
+        self._insert_data = record
+        return self
+    
+    def upsert(self, record: Dict) -> 'StorageTable':
+        self._upsert_data = record
+        return self
+    
+    def update(self, record: Dict) -> 'StorageTable':
+        self._update_data = record
+        return self
+    
+    def execute(self) -> 'StorageResult':
+        """Execute the query or write operation"""
+        # Handle write operations
+        if hasattr(self, '_insert_data'):
+            return self._do_insert()
+        if hasattr(self, '_upsert_data'):
+            return self._do_upsert()
+        if hasattr(self, '_update_data'):
+            return self._do_update()
+        
+        # Handle read operation
+        data = self.db._load_table(self.table_name)
+        
+        if self._query:
+            results = []
+            for key, record in data.items():
+                match = all(record.get(k) == v for k, v in self._query.items())
+                if match:
+                    results.append(record)
+            
+            if self._single and results:
+                return StorageResult(results[0])
+            elif self._single:
+                return StorageResult(None)
+            return StorageResult(results)
+        else:
+            return StorageResult(list(data.values()))
+    
+    def _do_insert(self) -> 'StorageResult':
+        record = self._insert_data
+        data = self.db._load_table(self.table_name)
+        
+        if 'id' not in record:
+            record['id'] = str(uuid.uuid4())
+        
+        key = record.get('student_id', record.get('id'))
+        record['created_at'] = datetime.utcnow().isoformat()
+        
+        data[key] = record
+        self.db._save_table(self.table_name, data)
+        
+        print(f"[StorageBucketDB] Inserted into {self.table_name}: {key}")
+        return StorageResult([record])
+    
+    def _do_upsert(self) -> 'StorageResult':
+        record = self._upsert_data
+        data = self.db._load_table(self.table_name)
+        
+        key = record.get('student_id', str(uuid.uuid4()))
+        
+        if key in data:
+            existing = data[key]
+            existing.update(record)
+            existing['updated_at'] = datetime.utcnow().isoformat()
+            record = existing
+        else:
+            record['id'] = str(uuid.uuid4())
+            record['created_at'] = datetime.utcnow().isoformat()
+        
+        data[key] = record
+        self.db._save_table(self.table_name, data)
+        
+        print(f"[StorageBucketDB] Upserted into {self.table_name}: {key}")
+        return StorageResult([record])
+    
+    def _do_update(self) -> 'StorageResult':
+        updates = self._update_data
+        data = self.db._load_table(self.table_name)
+        updated = []
+        
+        for key, record in data.items():
+            match = all(record.get(k) == v for k, v in self._query.items())
+            if match:
+                record.update(updates)
+                record['updated_at'] = datetime.utcnow().isoformat()
+                updated.append(record)
+        
+        self.db._save_table(self.table_name, data)
+        print(f"[StorageBucketDB] Updated {len(updated)} records in {self.table_name}")
+        return StorageResult(updated)
+
+
+class StorageResult:
+    """Mimics Supabase result object"""
+    
+    def __init__(self, data: Any):
+        self.data = data
+    
+    def execute(self) -> 'StorageResult':
+        return self