refactor: update user context and authentication flow [auth revamp]

apps/api/src/context.ts

@@ -1,6 +1,6 @@
 import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
 import prisma from "./prisma.js";
-import type { User } from "@prisma/client";
+import type { UserWithSubscription } from "./utils/auth.js";
 
 export async function createContext({
   req,
@@ -10,7 +10,7 @@ export async function createContext({
   res: CreateExpressContextOptions["res"];
   db: typeof prisma;
   ip?: string;
-  user?: User | null;
+  user?: UserWithSubscription | null;
 }> {
   const ip = req.ip || req.socket.remoteAddress || "unknown";
 

apps/api/src/index.ts

@@ -111,26 +111,14 @@ app.get("/join-community", apiLimiter, async (req: Request, res: Response) => {
 
     const token = authHeader.substring(7);
 
-    // Verify token and get user
     let user;
     try {
       user = await verifyToken(token);
     } catch (error) {
       return res.status(401).json({ error: "Unauthorized - Invalid token" });
     }
 
-    // Check if user has an active subscription
-    const subscription = await prismaModule.prisma.subscription.findFirst({
-      where: {
-        userId: user.id,
-        status: SUBSCRIPTION_STATUS.ACTIVE,
-        endDate: {
-          gte: new Date(),
-        },
-      },
-    });
-
-    if (!subscription) {
+    if (!user.isPaidUser || !user.subscription) {
       return res.status(403).json({
         error: "Forbidden - Active subscription required to join community",
       });

apps/api/src/routers/auth.ts

@@ -68,7 +68,51 @@ export const authRouter = router({
     }),
   getSession: protectedProcedure.query(
     async ({ ctx }: { ctx: { user: any } }) => {
-      return authService.getSession(ctx.user);
+      const userId = ctx.user.id;
+      const user = await ctx.db.prisma.user.findUnique({
+        where: { id: userId },
+        include: {
+          subscriptions: {
+            where: {
+              status: "active",
+              endDate: {
+                gte: new Date(),
+              },
+            },
+            orderBy: {
+              startDate: "desc",
+            },
+            take: 1,
+            include: {
+              plan: true,
+            },
+          },
+        },
+      });
+
+      if (!user) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "User not found",
+        });
+      }
+
+      const activeSubscription = user.subscriptions[0] || null;
+
+      return authService.getSession({
+        ...user,
+        isPaidUser: !!activeSubscription,
+        subscription: activeSubscription
+          ? {
+              id: activeSubscription.id,
+              status: activeSubscription.status,
+              startDate: activeSubscription.startDate,
+              endDate: activeSubscription.endDate,
+              planId: activeSubscription.planId,
+              planName: activeSubscription.plan?.name,
+            }
+          : null,
+      });
     }
   ),
   generateJWT: publicProcedure

apps/api/src/services/auth.service.ts

@@ -1,5 +1,6 @@
 import { generateToken } from "../utils/auth.js";
 import type { PrismaClient } from "@prisma/client";
+import { SUBSCRIPTION_STATUS } from "../constants/subscription.js";
 
 interface GoogleAuthInput {
   email: string;
@@ -39,20 +40,49 @@ export const authService = {
         authMethod: authMethod || "google",
         lastLogin: new Date(),
       },
-      select: {
-        id: true,
-        email: true,
-        firstName: true,
-        authMethod: true,
-        createdAt: true,
-        lastLogin: true,
+      include: {
+        subscriptions: {
+          where: {
+            status: SUBSCRIPTION_STATUS.ACTIVE,
+            endDate: {
+              gte: new Date(),
+            },
+          },
+          orderBy: {
+            startDate: "desc",
+          },
+          take: 1,
+          include: {
+            plan: true,
+          },
+        },
       },
     });
 
+    const activeSubscription = user.subscriptions[0] || null;
     const token = generateToken(email);
 
     return {
-      user,
+      user: {
+        id: user.id,
+        email: user.email,
+        firstName: user.firstName,
+        authMethod: user.authMethod,
+        createdAt: user.createdAt,
+        lastLogin: user.lastLogin,
+        completedSteps: user.completedSteps,
+        isPaidUser: !!activeSubscription,
+        subscription: activeSubscription
+          ? {
+              id: activeSubscription.id,
+              status: activeSubscription.status,
+              startDate: activeSubscription.startDate,
+              endDate: activeSubscription.endDate,
+              planId: activeSubscription.planId,
+              planName: activeSubscription.plan?.name,
+            }
+          : null,
+      },
       token,
     };
   },
@@ -197,12 +227,19 @@ export const authService = {
     });
   },
 
-  /**
-   * Get user session information
-   */
   getSession(user: any) {
     return {
-      user,
+      user: {
+        id: user.id,
+        email: user.email,
+        firstName: user.firstName,
+        authMethod: user.authMethod,
+        createdAt: user.createdAt,
+        lastLogin: user.lastLogin,
+        completedSteps: user.completedSteps,
+        isPaidUser: user.isPaidUser || false,
+        subscription: user.subscription || null,
+      },
     };
   },
 };

apps/api/src/trpc.ts

@@ -1,7 +1,7 @@
 import { initTRPC, TRPCError } from "@trpc/server";
 import superjson from "superjson";
 import type { Context } from "./context.js";
-import { verifyToken } from "./utils/auth.js";
+import { verifyToken, type UserWithSubscription } from "./utils/auth.js";
 
 const t = initTRPC.context<Context>().create({
   transformer: superjson,
@@ -24,7 +24,7 @@ const isAuthed = t.middleware(async ({ ctx, next }) => {
     return next({
       ctx: {
         ...ctx,
-        user,
+        user: user as UserWithSubscription,
       },
     });
   } catch (error) {
@@ -35,6 +35,32 @@ const isAuthed = t.middleware(async ({ ctx, next }) => {
   }
 });
 
+const requiresSubscription = t.middleware(async ({ ctx, next }) => {
+  if (!ctx.user) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Authentication required",
+    });
+  }
+
+  const user = ctx.user as UserWithSubscription;
+
+  if (!user.isPaidUser || !user.subscription) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Active subscription required",
+    });
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      user,
+    },
+  });
+});
+
 export const router = t.router;
 export const publicProcedure = t.procedure;
-export const protectedProcedure:any = t.procedure.use(isAuthed);
+export const protectedProcedure = t.procedure.use(isAuthed) as any;
+export const proProcedure = protectedProcedure.use(requiresSubscription) as any;

apps/api/src/utils/auth.ts

@@ -1,33 +1,95 @@
 import jwt from "jsonwebtoken";
-import prisma from "../prisma.js";
+import prismaModule from "../prisma.js";
+import { SUBSCRIPTION_STATUS } from "../constants/subscription.js";
 
+const { prisma } = prismaModule;
 const JWT_SECRET = process.env.JWT_SECRET! as string;
 
 if (!process.env.JWT_SECRET) {
   throw new Error("JWT_SECRET is not defined in the environment variables");
 }
 
+export interface UserWithSubscription {
+  id: string;
+  email: string;
+  firstName: string;
+  authMethod: string;
+  createdAt: Date;
+  lastLogin: Date;
+  completedSteps: any;
+  isPaidUser: boolean;
+  subscription: {
+    id: string;
+    status: string;
+    startDate: Date;
+    endDate: Date | null;
+    planId: string;
+  } | null;
+}
+
 export const generateToken = (email: string): string => {
   return jwt.sign({ email }, JWT_SECRET, { expiresIn: "7d" });
 };
 
-export const verifyToken = async (token: string) => {
+export const verifyToken = async (token: string): Promise<UserWithSubscription> => {
   try {
     const decoded = jwt.verify(token, JWT_SECRET);
 
-    if (typeof decoded === "string") {
+    if (typeof decoded === "string" || !decoded || typeof decoded !== "object") {
       throw new Error("Invalid token payload");
     }
 
-    const user = await prisma.prisma.user.findUnique({
-      where: { email: decoded.email },
+    const email = (decoded as { email?: string }).email;
+    if (!email) {
+      throw new Error("Email not found in token");
+    }
+
+    const user = await prisma.user.findUnique({
+      where: { email },
+      include: {
+        subscriptions: {
+          where: {
+            status: SUBSCRIPTION_STATUS.ACTIVE,
+            endDate: {
+              gte: new Date(),
+            },
+          },
+          orderBy: {
+            startDate: "desc",
+          },
+          take: 1,
+          include: {
+            plan: true,
+          },
+        },
+      },
     });
 
     if (!user) {
       throw new Error("User not found");
     }
 
-    return user;
+    const activeSubscription = user.subscriptions[0] || null;
+
+    return {
+      id: user.id,
+      email: user.email,
+      firstName: user.firstName,
+      authMethod: user.authMethod,
+      createdAt: user.createdAt,
+      lastLogin: user.lastLogin,
+      completedSteps: user.completedSteps,
+      isPaidUser: !!activeSubscription,
+      subscription: activeSubscription
+        ? {
+            id: activeSubscription.id,
+            status: activeSubscription.status,
+            startDate: activeSubscription.startDate,
+            endDate: activeSubscription.endDate,
+            planId: activeSubscription.planId,
+          }
+        : null,
+    };
   } catch (error) {
     throw new Error("Token verification failed");
   }

apps/web/src/components/checkout/CheckoutWrapper.tsx

@@ -1,13 +1,27 @@
 "use client";
 
-import React from "react";
+import React, { useEffect, useState } from "react";
 import { useSubscription } from "@/hooks/useSubscription";
-import { useRouter } from "next/navigation";
+import { useRouter, useSearchParams } from "next/navigation";
+import { useSession } from "next-auth/react";
 import CheckoutConfirmation from "./checkout-confirmation";
 
 export default function CheckoutWrapper() {
   const { isPaidUser, isLoading } = useSubscription();
   const router = useRouter();
+  const searchParams = useSearchParams();
+  const { data: session, update } = useSession();
+  const paymentSuccess = searchParams.get("payment") === "success";
+  const [hasRefreshed, setHasRefreshed] = useState(false);
+
+  useEffect(() => {
+    if (paymentSuccess && session && !hasRefreshed) {
+      update().then(() => {
+        setHasRefreshed(true);
+        router.refresh();
+      });
+    }
+  }, [paymentSuccess, session, update, hasRefreshed, router]);
 
   // Show loading state while checking subscription
   if (isLoading) {