Add collection data inspection and test data seeding endpoints

Added two debug endpoints to diagnose and fix the admin dashboard data issues:

1. /api/debug/collection-data - Shows what data actually exists in production collections
   - Checks users, pages, analytics_events, subscriptions collections
   - Shows sample data and timestamp formats
   - Helps identify if collections are empty or have date format issues

2. /api/debug/seed-test-data - Seeds test data for analytics testing
   - Adds test users, pages, and analytics events with recent timestamps
   - Only accessible to admin users
   - Helps verify that analytics pipelines work with real data

This will help identify why all dashboard widgets show 'No data available' despite working authentication and collection access.

Author: sirjamesgray

app/api/debug/collection-data/route.ts

@@ -0,0 +1,184 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { checkAdminPermissions } from '../../admin-auth-helper';
+import { getFirebaseAdmin } from '../../../firebase/firebaseAdmin';
+import { getCollectionName } from '../../../utils/environmentConfig';
+
+/**
+ * Debug endpoint to check what data actually exists in collections
+ */
+export async function GET(request: NextRequest) {
+  try {
+    console.log('[Collection Data] Starting collection data check...');
+    
+    const testResults = {
+      timestamp: new Date().toISOString(),
+      collections: []
+    };
+    
+    // Check admin permissions
+    const adminCheck = await checkAdminPermissions(request);
+    if (!adminCheck.success) {
+      return NextResponse.json({
+        error: 'Admin access required',
+        details: adminCheck.error
+      }, { status: 403 });
+    }
+    
+    const admin = getFirebaseAdmin();
+    const db = admin.firestore();
+    
+    // Check users collection
+    try {
+      const usersCollection = getCollectionName('users');
+      const usersSnapshot = await db.collection(usersCollection)
+        .orderBy('createdAt', 'desc')
+        .limit(5)
+        .get();
+      
+      const usersData = usersSnapshot.docs.map(doc => ({
+        id: doc.id,
+        data: {
+          email: doc.data().email,
+          createdAt: doc.data().createdAt?.toDate?.()?.toISOString() || doc.data().createdAt,
+          username: doc.data().username
+        }
+      }));
+      
+      testResults.collections.push({
+        name: 'users',
+        collectionName: usersCollection,
+        totalDocs: usersSnapshot.size,
+        sampleData: usersData,
+        hasCreatedAt: usersData.some(u => u.data.createdAt)
+      });
+    } catch (error) {
+      testResults.collections.push({
+        name: 'users',
+        error: error.message
+      });
+    }
+    
+    // Check pages collection
+    try {
+      const pagesCollection = getCollectionName('pages');
+      const pagesSnapshot = await db.collection(pagesCollection)
+        .orderBy('createdAt', 'desc')
+        .limit(5)
+        .get();
+      
+      const pagesData = pagesSnapshot.docs.map(doc => ({
+        id: doc.id,
+        data: {
+          title: doc.data().title,
+          createdAt: doc.data().createdAt?.toDate?.()?.toISOString() || doc.data().createdAt,
+          isPublic: doc.data().isPublic,
+          authorId: doc.data().authorId
+        }
+      }));
+      
+      testResults.collections.push({
+        name: 'pages',
+        collectionName: pagesCollection,
+        totalDocs: pagesSnapshot.size,
+        sampleData: pagesData,
+        hasCreatedAt: pagesData.some(p => p.data.createdAt)
+      });
+    } catch (error) {
+      testResults.collections.push({
+        name: 'pages',
+        error: error.message
+      });
+    }
+    
+    // Check analytics_events collection
+    try {
+      const analyticsCollection = getCollectionName('analytics_events');
+      const analyticsSnapshot = await db.collection(analyticsCollection)
+        .orderBy('timestamp', 'desc')
+        .limit(10)
+        .get();
+      
+      const analyticsData = analyticsSnapshot.docs.map(doc => ({
+        id: doc.id,
+        data: {
+          event: doc.data().event,
+          timestamp: doc.data().timestamp?.toDate?.()?.toISOString() || doc.data().timestamp,
+          userId: doc.data().userId,
+          metadata: doc.data().metadata
+        }
+      }));
+      
+      testResults.collections.push({
+        name: 'analytics_events',
+        collectionName: analyticsCollection,
+        totalDocs: analyticsSnapshot.size,
+        sampleData: analyticsData,
+        hasTimestamp: analyticsData.some(a => a.data.timestamp)
+      });
+    } catch (error) {
+      testResults.collections.push({
+        name: 'analytics_events',
+        error: error.message
+      });
+    }
+    
+    // Check subscriptions collection
+    try {
+      const subscriptionsCollection = getCollectionName('subscriptions');
+      const subscriptionsSnapshot = await db.collection(subscriptionsCollection)
+        .orderBy('createdAt', 'desc')
+        .limit(5)
+        .get();
+      
+      const subscriptionsData = subscriptionsSnapshot.docs.map(doc => ({
+        id: doc.id,
+        data: {
+          userId: doc.data().userId,
+          status: doc.data().status,
+          createdAt: doc.data().createdAt?.toDate?.()?.toISOString() || doc.data().createdAt,
+          plan: doc.data().plan
+        }
+      }));
+      
+      testResults.collections.push({
+        name: 'subscriptions',
+        collectionName: subscriptionsCollection,
+        totalDocs: subscriptionsSnapshot.size,
+        sampleData: subscriptionsData,
+        hasCreatedAt: subscriptionsData.some(s => s.data.createdAt)
+      });
+    } catch (error) {
+      testResults.collections.push({
+        name: 'subscriptions',
+        error: error.message
+      });
+    }
+    
+    // Check date ranges for recent data
+    const now = new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+    
+    testResults.dateRangeInfo = {
+      now: now.toISOString(),
+      sevenDaysAgo: sevenDaysAgo.toISOString(),
+      thirtyDaysAgo: thirtyDaysAgo.toISOString()
+    };
+    
+    return NextResponse.json(testResults, { 
+      status: 200,
+      headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate'
+      }
+    });
+    
+  } catch (error) {
+    console.error('[Collection Data] Error:', error);
+    
+    return NextResponse.json({
+      error: 'Collection data check failed',
+      details: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date().toISOString()
+    }, { status: 500 });
+  }
+}

app/api/debug/seed-test-data/route.ts

@@ -0,0 +1,192 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { checkAdminPermissions } from '../../admin-auth-helper';
+import { getFirebaseAdmin } from '../../../firebase/firebaseAdmin';
+import { getCollectionName } from '../../../utils/environmentConfig';
+
+/**
+ * Debug endpoint to seed some test data for analytics testing
+ * ONLY for admin use to test analytics functionality
+ */
+export async function POST(request: NextRequest) {
+  try {
+    console.log('[Seed Test Data] Starting test data seeding...');
+    
+    // Check admin permissions
+    const adminCheck = await checkAdminPermissions(request);
+    if (!adminCheck.success) {
+      return NextResponse.json({
+        error: 'Admin access required',
+        details: adminCheck.error
+      }, { status: 403 });
+    }
+    
+    const admin = getFirebaseAdmin();
+    const db = admin.firestore();
+    
+    const results = {
+      timestamp: new Date().toISOString(),
+      seeded: []
+    };
+    
+    // Seed some test analytics events
+    const analyticsCollection = getCollectionName('analytics_events');
+    const now = new Date();
+    
+    const testEvents = [
+      {
+        event: 'user_signup',
+        timestamp: new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000), // 1 day ago
+        userId: 'test-user-1',
+        metadata: { source: 'test-seed' }
+      },
+      {
+        event: 'user_signup',
+        timestamp: new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000), // 2 days ago
+        userId: 'test-user-2',
+        metadata: { source: 'test-seed' }
+      },
+      {
+        event: 'page_created',
+        timestamp: new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000), // 1 day ago
+        userId: 'test-user-1',
+        metadata: { 
+          pageId: 'test-page-1',
+          isPublic: true,
+          source: 'test-seed'
+        }
+      },
+      {
+        event: 'page_created',
+        timestamp: new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000), // 3 days ago
+        userId: 'test-user-2',
+        metadata: { 
+          pageId: 'test-page-2',
+          isPublic: false,
+          source: 'test-seed'
+        }
+      },
+      {
+        event: 'page_shared',
+        timestamp: new Date(now.getTime() - 2 * 60 * 60 * 1000), // 2 hours ago
+        userId: 'test-user-1',
+        metadata: { 
+          pageId: 'test-page-1',
+          shareMethod: 'link',
+          source: 'test-seed'
+        }
+      }
+    ];
+    
+    // Add analytics events
+    for (const event of testEvents) {
+      try {
+        const docRef = await db.collection(analyticsCollection).add(event);
+        results.seeded.push({
+          type: 'analytics_event',
+          id: docRef.id,
+          event: event.event,
+          timestamp: event.timestamp.toISOString()
+        });
+      } catch (error) {
+        results.seeded.push({
+          type: 'analytics_event',
+          error: error.message,
+          event: event.event
+        });
+      }
+    }
+    
+    // Seed some test users (with recent createdAt)
+    const usersCollection = getCollectionName('users');
+    const testUsers = [
+      {
+        email: 'test-user-1@example.com',
+        username: 'testuser1',
+        createdAt: new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000), // 1 day ago
+        isTestData: true
+      },
+      {
+        email: 'test-user-2@example.com',
+        username: 'testuser2',
+        createdAt: new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000), // 2 days ago
+        isTestData: true
+      }
+    ];
+    
+    for (const user of testUsers) {
+      try {
+        const docRef = await db.collection(usersCollection).add(user);
+        results.seeded.push({
+          type: 'user',
+          id: docRef.id,
+          email: user.email,
+          createdAt: user.createdAt.toISOString()
+        });
+      } catch (error) {
+        results.seeded.push({
+          type: 'user',
+          error: error.message,
+          email: user.email
+        });
+      }
+    }
+    
+    // Seed some test pages
+    const pagesCollection = getCollectionName('pages');
+    const testPages = [
+      {
+        title: 'Test Page 1',
+        content: 'This is test content for analytics testing',
+        authorId: 'test-user-1',
+        isPublic: true,
+        createdAt: new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000), // 1 day ago
+        isTestData: true
+      },
+      {
+        title: 'Test Page 2',
+        content: 'This is private test content',
+        authorId: 'test-user-2',
+        isPublic: false,
+        createdAt: new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000), // 3 days ago
+        isTestData: true
+      }
+    ];
+    
+    for (const page of testPages) {
+      try {
+        const docRef = await db.collection(pagesCollection).add(page);
+        results.seeded.push({
+          type: 'page',
+          id: docRef.id,
+          title: page.title,
+          isPublic: page.isPublic,
+          createdAt: page.createdAt.toISOString()
+        });
+      } catch (error) {
+        results.seeded.push({
+          type: 'page',
+          error: error.message,
+          title: page.title
+        });
+      }
+    }
+    
+    console.log('[Seed Test Data] Seeded', results.seeded.length, 'test records');
+    
+    return NextResponse.json(results, { 
+      status: 200,
+      headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate'
+      }
+    });
+    
+  } catch (error) {
+    console.error('[Seed Test Data] Error:', error);
+    
+    return NextResponse.json({
+      error: 'Test data seeding failed',
+      details: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date().toISOString()
+    }, { status: 500 });
+  }
+}