Merge pull request #22 from MisbahAN/misbah/ft/p1-02-04-auth-db-users

authentication, user persistence, and onboarding (issues #2, #3, #4)

Author: MisbahAN

.env.example

@@ -5,7 +5,16 @@ FIREBASE_AUTH_DOMAIN=
 FIREBASE_APP_ID=
 FIREBASE_STORAGE_BUCKET=
 FIREBASE_MESSAGING_SENDER_ID=
-FIREBASE_MEASUREMENT_ID=
+FIREBASE_MEASUREMENT_ID=G-
+
+# Vite (Firebase variables prefixed with VITE_)
+VITE_FIREBASE_PROJECT_ID=
+VITE_FIREBASE_API_KEY=
+VITE_FIREBASE_AUTH_DOMAIN=
+VITE_FIREBASE_APP_ID=
+VITE_FIREBASE_STORAGE_BUCKET=
+VITE_FIREBASE_MESSAGING_SENDER_ID=
+VITE_FIREBASE_MEASUREMENT_ID=
 
 # MongoDB
 MONGODB_URI=

.gitignore

@@ -23,4 +23,5 @@ dist-ssr
 *.sln
 *.sw?
 .env
-.claude
+.claude
+.vercel

api/onboarding.ts

@@ -17,8 +17,8 @@ type VercelResponse = {
   json: (data: unknown) => void;
   send: (data: unknown) => void;
 };
-import { generateAdaptiveQuestions } from "../src/lib/services/gemini";
-import { getCollection } from "../src/lib/mongodb";
+import { generateAdaptiveQuestions } from "../src/lib/services/gemini.js";
+import { getCollection } from "../src/lib/mongodb.js";
 
 export default async function handler(
   req: VercelRequest,
@@ -29,23 +29,62 @@ export default async function handler(
   }
 
   try {
-    interface OnboardingRequestBody {
+    type OnboardingAction = "generate" | "complete";
+    interface BaseOnboardingBody {
+      action?: OnboardingAction;
       firebaseUid?: string;
+    }
+    interface GenerateBody extends BaseOnboardingBody {
       ageRange?: string;
       experience?: string;
       monthlyIncome?: string;
       riskTolerance?: number;
       learningGoals?: string[];
     }
-    const body = req.body as OnboardingRequestBody;
+    interface CompleteBody extends BaseOnboardingBody {
+      action: "complete";
+      answers?: Record<string, unknown>;
+      startingLesson?: number;
+    }
+
+    const body = req.body as GenerateBody | CompleteBody;
+    const action: OnboardingAction = body.action || "generate";
+
+    if (action === "complete") {
+      const { firebaseUid, answers, startingLesson } = body as CompleteBody;
+      
+      if (!firebaseUid || !answers) {
+        return res.status(400).json({ error: "Missing required completion data" });
+      }
+
+      const usersCollection = await getCollection("users");
+      const result = await usersCollection.updateOne(
+        { firebaseUid },
+        {
+          $set: {
+            onboardingCompleted: true,
+            onboardingAnswers: answers,
+            currentLesson: typeof startingLesson === "number" ? startingLesson : 1,
+            updatedAt: new Date(),
+          },
+        }
+      );
+
+      if (result.matchedCount === 0) {
+        return res.status(404).json({ error: "User not found" });
+      }
+
+      return res.status(200).json({ success: true });
+    }
+
     const {
       firebaseUid,
       ageRange,
       experience,
       monthlyIncome,
       riskTolerance,
       learningGoals,
-    } = body;
+    } = body as GenerateBody;
 
     // Validate required fields
     if (!firebaseUid || !ageRange || !experience || !monthlyIncome || riskTolerance === undefined || !learningGoals) {
@@ -61,28 +100,6 @@ export default async function handler(
       learningGoals
     );
 
-    // Save to MongoDB
-    const usersCollection = await getCollection("users");
-    
-    await usersCollection.updateOne(
-      { firebaseUid },
-      {
-        $set: {
-          onboardingCompleted: true,
-          onboardingAnswers: {
-            ageRange,
-            investmentExperience: experience,
-            monthlyIncome,
-            riskTolerance,
-            goals: learningGoals,
-          },
-          currentLesson: geminiResponse.startingLesson,
-          updatedAt: new Date(),
-        },
-      },
-      { upsert: true }
-    );
-
     return res.status(200).json({
       adaptiveQuestions: geminiResponse.adaptiveQuestions,
       startingLesson: geminiResponse.startingLesson,
@@ -94,4 +111,4 @@ export default async function handler(
       message: error instanceof Error ? error.message : "Unknown error"
     });
   }
-}
+}

api/users/[uid].ts

@@ -0,0 +1,99 @@
+/**
+ * GET /api/users/[uid] - Get user by Firebase UID
+ * PUT /api/users/[uid] - Update user profile
+ */
+
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { MongoClient } from "mongodb";
+
+const MONGODB_URI = process.env.MONGODB_URI!;
+const DB_NAME = "finwise";
+
+let cachedClient: MongoClient | null = null;
+
+async function connectToDatabase() {
+  if (cachedClient) {
+    return cachedClient.db(DB_NAME);
+  }
+
+  const client = await MongoClient.connect(MONGODB_URI, {
+    maxPoolSize: 10,
+    minPoolSize: 2,
+    maxIdleTimeMS: 60000,
+  });
+
+  cachedClient = client;
+  return client.db(DB_NAME);
+}
+
+export default async function handler(
+  req: VercelRequest,
+  res: VercelResponse,
+) {
+  const { uid } = req.query;
+
+  if (!uid || typeof uid !== "string") {
+    return res.status(400).json({ error: "Missing or invalid uid parameter" });
+  }
+
+  try {
+    const db = await connectToDatabase();
+    const usersCollection = db.collection("users");
+
+    // GET - Fetch user data
+    if (req.method === "GET") {
+      const user = await usersCollection.findOne({ firebaseUid: uid });
+
+      if (!user) {
+        return res.status(404).json({ error: "User not found" });
+      }
+
+      // Update lastLoginAt
+      await usersCollection.updateOne(
+        { firebaseUid: uid },
+        { $set: { lastLoginAt: new Date() } },
+      );
+
+      return res.status(200).json({
+        success: true,
+        user,
+      });
+    }
+
+    // PUT - Update user profile
+    if (req.method === "PUT") {
+      const updateData = req.body;
+
+      // Remove fields that shouldn't be updated directly
+      delete updateData._id;
+      delete updateData.firebaseUid;
+      delete updateData.createdAt;
+
+      const result = await usersCollection.updateOne(
+        { firebaseUid: uid },
+        { $set: updateData },
+      );
+
+      if (result.matchedCount === 0) {
+        return res.status(404).json({ error: "User not found" });
+      }
+
+      // Fetch updated user
+      const updatedUser = await usersCollection.findOne({ firebaseUid: uid });
+
+      return res.status(200).json({
+        success: true,
+        user: updatedUser,
+      });
+    }
+
+    // Method not allowed
+    return res.status(405).json({ error: "Method not allowed" });
+  } catch (error) {
+    console.error("Error handling user request:", error);
+    return res.status(500).json({
+      error: "Internal server error",
+      message: error instanceof Error ? error.message : "Unknown error",
+    });
+  }
+}

api/users/index.ts

@@ -0,0 +1,126 @@
+/**
+ * POST /api/users
+ * Create a new user in MongoDB after Firebase auth
+ */
+
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { MongoClient } from "mongodb";
+
+const MONGODB_URI = process.env.MONGODB_URI!;
+const DB_NAME = "finwise";
+
+let cachedClient: MongoClient | null = null;
+
+async function connectToDatabase() {
+  if (cachedClient) {
+    return cachedClient.db(DB_NAME);
+  }
+
+  const client = await MongoClient.connect(MONGODB_URI, {
+    maxPoolSize: 10,
+    minPoolSize: 2,
+    maxIdleTimeMS: 60000,
+  });
+
+  cachedClient = client;
+  return client.db(DB_NAME);
+}
+
+interface CreateUserRequest {
+  firebaseUid: string;
+  email: string;
+  displayName: string;
+  photoURL?: string;
+}
+
+export default async function handler(
+  req: VercelRequest,
+  res: VercelResponse,
+) {
+  // Only allow POST requests
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "Method not allowed" });
+  }
+
+  try {
+    const { firebaseUid, email, displayName, photoURL } =
+      req.body as CreateUserRequest;
+
+    // Validate required fields
+    if (!firebaseUid || !email || !displayName) {
+      return res.status(400).json({
+        error: "Missing required fields: firebaseUid, email, displayName",
+      });
+    }
+
+    const db = await connectToDatabase();
+    const usersCollection = db.collection("users");
+
+    const now = new Date();
+
+    const defaults = {
+      firebaseUid,
+      email,
+      displayName,
+      photoURL: photoURL || "",
+      createdAt: now,
+      lastLoginAt: now,
+
+      // Onboarding
+      onboardingCompleted: false,
+      onboardingAnswers: {},
+
+      // Current Progress
+      currentLesson: 1,
+      totalXP: 0,
+      currentStreak: 0,
+      longestStreak: 0,
+      lastLessonDate: null,
+
+      // Social
+      friends: [],
+      friendRequestsSent: [],
+      friendRequestsReceived: [],
+
+      // Settings
+      settings: {
+        notificationsEnabled: true,
+        emailNotifications: true,
+        lessonReminders: true,
+        voiceMode: false,
+      },
+    };
+
+    const result = await usersCollection.updateOne(
+      { firebaseUid },
+      {
+        $setOnInsert: defaults,
+        $set: {
+          email,
+          displayName,
+          photoURL: photoURL || "",
+          lastLoginAt: now,
+        },
+      },
+      { upsert: true },
+    );
+
+    const user = await usersCollection.findOne({ firebaseUid });
+    if (!user) {
+      throw new Error("Failed to create or fetch user");
+    }
+
+    const wasExisting = result.upsertedCount === 0;
+
+    return res.status(wasExisting ? 200 : 201).json({
+      success: true,
+      user,
+    });
+  } catch (error) {
+    console.error("Error creating user:", error);
+    return res.status(500).json({
+      error: "Internal server error",
+      message: error instanceof Error ? error.message : "Unknown error",
+    });
+  }
+}