Add authentication and dashboard features

- Introduced a new authentication module in `auth.ts` using NextAuth with Google and credentials providers.
- Created API routes for user authentication, including login, registration, password reset, and OTP verification.
- Added a dashboard overview API to fetch user-specific data.
- Implemented new components for the dashboard, including activity overview, stats cards, and suggested next steps.
- Refactored existing components to improve structure and maintainability, including the removal of unused imports and components.
- Enhanced middleware for session management and improved error handling in API responses.

Author: 0xdevcollins

app/(dashboard)/dashboard/page.tsx

@@ -1,29 +1,13 @@
-"use client";
-import MyContributionsPage from "@/components/contributions";
-import Dashboard from "@/components/dashboard";
-import { useUserStore } from "@/store/userStore";
-import React from "react";
+'use client';
+import Dashboard from '@/components/dashboard';
+import React from 'react';
 
 const Page = () => {
-	const {
-		user,
-		isLoading,
-		// fetchUserProfile,
-		hasCreatedProject,
-	} = useUserStore();
-
-	if (isLoading) {
-		return <p>Loading...</p>;
-	}
-	return (
-		<>
-			{hasCreatedProject() ? (
-				<Dashboard />
-			) : (
-				<MyContributionsPage username={user?.name} />
-			)}
-		</>
-	);
+  return (
+    <>
+      <Dashboard />
+    </>
+  );
 };
 
 export default Page;

app/api/auth/[...nextauth]/route.ts

@@ -1,6 +1,2 @@
-import { authOptions } from "@/lib/auth.config";
-import NextAuth from "next-auth";
-
-const handler = NextAuth(authOptions);
-
-export { handler as GET, handler as POST };
+import { handlers } from "@/auth" // Referring to the auth.ts we just created
+export const { GET, POST } = handlers

app/api/auth/callback/google/route.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { googleAuth } from "@/lib/api/auth";
+import { z } from "zod";
+
+const googleSchema = z.object({
+  token: z.string().min(1, "Google token is required"),
+});
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { token } = googleSchema.parse(body);
+    const apiRes = await googleAuth({ token });
+    return NextResponse.json(apiRes, { status: 200 });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ message: error.errors[0].message }, { status: 400 });
+    }
+    if (typeof error === "object" && error !== null && "message" in error) {
+      return NextResponse.json({ message: String((error as { message: unknown }).message) }, { status: 500 });
+    }
+    return NextResponse.json({ message: "Internal Server Error" }, { status: 500 });
+  }
+}
+

app/api/auth/forgot-password/route.ts

@@ -1,9 +1,7 @@
-import { sendPasswordResetEmail } from "@/lib/email";
-import { PrismaClient } from "@prisma/client";
 import { NextResponse } from "next/server";
+import { forgotPassword } from "@/lib/api/auth";
 import { z } from "zod";
 
-const prisma = new PrismaClient();
 const emailSchema = z.object({
 	email: z.string().email("Invalid email address"),
 });
@@ -12,52 +10,16 @@ export async function POST(req: Request) {
 	try {
 		const body = await req.json();
 		const { email } = emailSchema.parse(body);
-
-		const user = await prisma.user.findUnique({
-			where: { email },
-		});
-
-		if (!user) {
-			return NextResponse.json(
-				{ message: "User email not found" },
-				{ status: 404 },
-			);
+		const apiRes = await forgotPassword({ email });
+		return NextResponse.json(apiRes, { status: 200 });
+	} catch (error) {
+		if (error instanceof z.ZodError) {
+			return NextResponse.json({ message: error.errors[0].message }, { status: 400 });
 		}
-
-		const otp = Math.floor(100000 + Math.random() * 900000).toString();
-		const otpExpiry = new Date(Date.now() + 10 * 60 * 1000);
-
-		await prisma.verificationToken.create({
-			data: {
-				identifier: email,
-				token: otp,
-				expires: otpExpiry,
-			},
-		});
-
-		try {
-			await sendPasswordResetEmail(user.email || "", user.name || "", otp);
-			return NextResponse.json({
-				success: true,
-				message: "Password reset email sent",
-				status: 200,
-			});
-		} catch (emailError) {
-			console.error("Error sending password reset email:", emailError);
-			return NextResponse.json(
-				{ error: "Failed to send password reset email" },
-				{ status: 500 },
-			);
+		// If backend returns an error, try to forward it
+		if (typeof error === 'object' && error !== null && 'message' in error) {
+			return NextResponse.json({ message: String((error as { message: unknown }).message) }, { status: 500 });
 		}
-	} catch (error) {
-		console.error("Forgot Password API Error:", error);
-
-		return NextResponse.json(
-			{
-				message: "Internal Server Error",
-				error: error instanceof Error ? error.message : "Unknown error",
-			},
-			{ status: 500 },
-		);
+		return NextResponse.json({ message: "Internal Server Error" }, { status: 500 });
 	}
 }

app/api/auth/register/route.ts

@@ -1,10 +1,7 @@
-import { sendVerificationEmail } from "@/lib/email";
-import { PrismaClient } from "@prisma/client";
-import { hash } from "bcrypt";
+import { register } from "@/lib/api/auth";
 import { NextResponse } from "next/server";
 import { z } from "zod";
 
-const prisma = new PrismaClient();
 const userSchema = z.object({
 	name: z.string().min(2, "Name must be at least 2 characters"),
 	email: z.string().email("Invalid email address"),
@@ -15,64 +12,26 @@ export async function POST(req: Request) {
 	try {
 		const body = await req.json();
 		const { name, email, password } = userSchema.parse(body);
-
-		const existingUser = await prisma.user.findUnique({
-			where: { email },
-		});
-
-		if (existingUser) {
-			return NextResponse.json(
-				{ message: "User already exists" },
-				{ status: 400 },
-			);
-		}
-
-		const hashedPassword = await hash(password, 12);
-
-		const user = await prisma.user.create({
-			data: {
-				name,
-				email,
-				password: hashedPassword,
-			},
-		});
-
-		// Generate OTP
-		const otp = Math.floor(100000 + Math.random() * 900000).toString();
-		const otpExpires = new Date(Date.now() + 10 * 60 * 1000);
-
-		// Save OTP to database
-		await prisma.oTP.create({
-			data: {
-				userId: user.id,
-				token: otp,
-				expires: otpExpires,
-			},
-		});
-
-		try {
-			await sendVerificationEmail(email, name, otp);
-			console.log("Verification email sent successfully");
-		} catch (error) {
-			console.error("Error sending verification email:", error);
-		}
-		return NextResponse.json(
-			{
-				message: "User created successfully. Please check your email for OTP.",
-				userId: user.id,
-			},
-			{ status: 201 },
-		);
+		// Compose RegisterRequest
+		const registerData = {
+			email,
+			password,
+			firstName: name, // or split name if needed
+			lastName: name, // You may want to parse this from name or add to schema
+			username: email.split("@")[0],
+		};
+		const response = await register(registerData);
+		return NextResponse.json(response, { status: 201 });
 	} catch (error) {
 		if (error instanceof z.ZodError) {
 			return NextResponse.json(
 				{ message: error.errors[0].message },
 				{ status: 400 },
 			);
 		}
-		console.error("Error during registration:", error);
+		console.error(error)
 		return NextResponse.json(
-			{ message: "An error occurred during registration" },
+			{ message: error},
 			{ status: 500 },
 		);
 	}

app/api/auth/resend-otp/route.ts

@@ -1,48 +1,13 @@
-import { resendOTP } from "@/lib/email";
-import { PrismaClient } from "@prisma/client";
+import { resendOtp } from "@/lib/api/auth";
 import { NextResponse } from "next/server";
 
-const prisma = new PrismaClient();
-
 export async function POST(req: Request) {
 	try {
 		const { email } = await req.json();
 
-		const user = await prisma.user.findUnique({
-			where: { email },
-		});
-
-		if (!user) {
-			return NextResponse.json({ message: "User not found" }, { status: 400 });
-		}
+		const response = await resendOtp({ email });
 
-		// Generate new OTP
-		const otp = Math.floor(100000 + Math.random() * 900000).toString();
-		const otpExpires = new Date(Date.now() + 10 * 60 * 1000);
-		await prisma.oTP.deleteMany({
-			where: { userId: user.id },
-		});
-		await prisma.oTP.create({
-			data: {
-				userId: user.id,
-				token: otp,
-				expires: otpExpires,
-			},
-		});
-		try {
-			await resendOTP(user.email || "", user.name || "", otp);
-			return NextResponse.json({
-				success: true,
-				message: "OTP code succesfully resent",
-				status: 2000,
-			});
-		} catch (error) {
-			console.error("Error sending password reset email:", error);
-			return NextResponse.json(
-				{ error: "Failed to resend OTP" },
-				{ status: 500 },
-			);
-		}
+		return NextResponse.json(response, { status: 200 });
 	} catch (error) {
 		console.error("Error in resending OTP:", error);
 		return NextResponse.json(

app/api/auth/reset-password/route.ts

@@ -1,58 +1,66 @@
-import { PrismaClient } from "@prisma/client";
-import { hash } from "bcrypt";
 import { NextResponse } from "next/server";
+import { resetPassword } from "@/lib/api/auth";
 import { z } from "zod";
 
-const prisma = new PrismaClient();
-
 const resetSchema = z.object({
-	email: z.string().email("Invalid email address"),
-	password: z.string().min(8, "Password must be at least 8 characters"),
-	otp: z.string().length(6, "Invalid OTP"), // Ensure OTP is exactly 6 digits
+	token: z.string().min(1, "Token is required"),
+	newPassword: z.string().min(8, "Password must be at least 8 characters"),
 });
 
-export async function POST(req: Request) {
-	try {
-		const body = await req.json();
-		const { email, password, otp } = resetSchema.parse(body);
-
-		// Verify OTP
-		const verificationToken = await prisma.verificationToken.findFirst({
-			where: { identifier: email, token: otp },
-		});
+const tokenSchema = z.object({
+	token: z.string().min(1, "Token is required"),
+});
 
-		if (!verificationToken) {
-			return NextResponse.json(
-				{ message: "Invalid email or expired OTP" },
-				{ status: 400 },
-			);
+// GET method to verify token
+export async function GET(req: Request) {
+	try {
+		const { searchParams } = new URL(req.url);
+		const token = searchParams.get('token');
+		
+		if (!token) {
+			return NextResponse.json({ message: "Token is required" }, { status: 400 });
 		}
 
-		// Hash new password
-		const hashedPassword = await hash(password, 12);
+		const parsedToken = tokenSchema.parse({ token });
+		
+		// You might want to add a verifyToken function to your auth.ts
+		// For now, we'll just return success if token exists
+		return NextResponse.json({ 
+			message: "Token is valid",
+			token: parsedToken.token 
+		}, { status: 200 });
 
-		// Update user's password
-		await prisma.user.update({
-			where: { email },
-			data: { password: hashedPassword },
-		});
-
-		// Delete OTP after successful password reset
-		await prisma.verificationToken.delete({
-			where: { id: verificationToken.id },
-		});
+	} catch (error) {
+		if (error instanceof z.ZodError) {
+			console.log(error);
+			return NextResponse.json({ message: error.errors[0].message }, { status: 400 });
+		}
+		return NextResponse.json({ message: "Invalid token" }, { status: 400 });
+	}
+}
 
-		return NextResponse.json(
-			{ message: "Password reset successfully" },
-			{ status: 200 },
-		);
+// POST method to reset password
+export async function POST(req: Request) {
+	try {
+		const body = await req.json();
+		
+		// Log the body to debug
+		console.log('Request body:', body);
+		
+		const { token, newPassword } = resetSchema.parse(body);
+		const apiRes = await resetPassword({ token, newPassword });
+		return NextResponse.json(apiRes, { status: 200 });
 	} catch (error) {
 		if (error instanceof z.ZodError) {
-			return NextResponse.json(
-				{ message: error.errors[0].message },
-				{ status: 400 },
-			);
+			console.log(error.errors)
+			return NextResponse.json({ message: error.errors[0].message }, { status: 400 });
+		}
+		// If backend returns an error, try to forward it
+		console.log(error)
+		if (typeof error === 'object' && error !== null && 'message' in error) {
+			
+			return NextResponse.json({ message: String((error as { message: unknown }).message) }, { status: 500 });
 		}
-		return NextResponse.json({ message: "An error occurred" }, { status: 500 });
+		return NextResponse.json({ message: error }, { status: 500 });
 	}
 }