canvas-backend/src/api/auth/auth.controller.ts

import { createClerkClient } from "@clerk/backend";
import { ENV } from "../../config/env"
import { users } from "../../db/schema";
import { db } from "../../db";
import { eq } from "drizzle-orm";

// @ts-ignore
import jwt from "jsonwebtoken";

import { checkUserInDB, createUser, storeRefreshToken } from "../../helper/auth/auth.helper";

// Initialize Clerk with your API key
const clerk = createClerkClient({ secretKey: ENV.CLERK_SECRET_KEY });

export const getUserData = async (userId: string) => {
    try {
        const [user, checkInDB] = await Promise.all([
            clerk.users.getUser(userId),
            checkUserInDB(userId)
        ]);

        if (user && !checkInDB.found) {

            // Validate and transform user data
            const userDBData = {
                id: user.id,
                email: user.emailAddresses[0].emailAddress, // Assuming the first email address
                firstName: user.firstName || "N/A", // Provide a default value if needed
                lastName: user.lastName || "N/A",
                image: user.imageUrl,
            };

            const userData = await createUser(userDBData);

            return { status: 200, message: "User retrieved successfully", data: userData };
        }
        if (user && checkInDB.found) {
            return { status: 200, message: "User retrieved successfully", data: checkInDB };
        }
        if (!user) {
            return { status: 404, message: "User not found" };
        }
    } catch (error: any) {
        console.error("Error in getUserData:", error.message || error.toString());
        return { status: 500, message: `An error occurred while getting the user` };
    }
};

export const updateUser = async (id: string, body) => {
    try {
        const updateUserData = await db.update(users).set({ paid_status: body?.paid_status, expires_in: body?.package_expire_date }).where(eq(users.id, id)).returning({ updatedId: users.id });

        return { status: 200, message: "User updated successfully", updateUserData };

    } catch (error: any) {
        console.error("Error in updateUser:", error.message || error.toString());
        return { status: 500, message: `An error occurred while updating the user` };
    }
}

export const generateToken = async (context: any) => {
    try {
        const userId = context?.params?.userId;
        // generating accessToken and refreshToken
        const user = await checkUserInDB(userId);
        if (user?.found === true) {
            const accessSecret = ENV.JWT_ACCESS_TOKEN_SECRET;
            const refreshSecret = ENV.JWT_REFRESH_TOKEN_SECRET;

            // generate access token
            const accessToken = jwt.sign({ userId }, accessSecret, { expiresIn: '3h' });

            // generate refresh token
            const refreshToken = jwt.sign({ userId }, refreshSecret, { expiresIn: '7d' });

            // store refresh token in db
            const storeRToken = await storeRefreshToken(userId, refreshToken);

            if (storeRToken.status === 200) {
                context.cookie.access_token = {
                    value: accessToken,
                    httpOnly: true,
                    secure: true,
                    sameSite: 'none',
                    path: "/",
                    maxAge: 3 * 60 * 60 * 1000, // 3 hours
                }

                return { status: 200, message: "Token generated successfully", token: accessToken };
            }

            return { status: 500, message: "An error occurred while storing the refresh token" };
        }
        else {
            return { status: 404, message: "Unauthorized!!!" };
        }
    } catch (error: any) {
        console.error("Error in generateToken:", error.message || error.toString());
        return { status: 500, message: `An error occurred while generating the token` };
    }
}

export const verifyToken = async (context: any) => {
    try {
        // if token is in cookie, verify it
        const token_cookie = context.cookie.access_token.value;
        if (token_cookie) {
            const verify_cookie = jwt.verify(token_cookie, ENV.JWT_REFRESH_TOKEN_SECRET);
            if (verify_cookie) {
                return { status: 200, message: "Token verified successfully" };
            }
            else {
                return { status: 401, message: "Unauthorized!!!" };
            }
        }
        // if token is not in cookie, then check in header and verify it
        else {
            const token_header = context.headers.authorization.split("Bearer ")[1];

            if (token_header) {
                const verify_header = jwt.decode(token_header);

                if (verify_header?.userId) {
                    context.params.userId = verify_header.userId;
                    await generateToken(context);
                }
                else {
                    return { status: 401, message: "Unauthorized!!!" };
                }
            }
            else {
                return { status: 401, message: "Unauthorized!!!" };
            }
        }

    } catch (error: any) {
        console.log("Error in verifyToken:", error.message || error.toString());
        return { status: 500, message: `An error occurred while verifying the token` };
    }
}