auth.ts

import { env } from "@/env.mjs"
import { db } from "@/lib/db"
import { PrismaAdapter } from "@auth/prisma-adapter"
import { compare } from "bcrypt"
import { NextAuthOptions } from "next-auth"
import { Adapter } from "next-auth/adapters"
import CredentialsProvider from 'next-auth/providers/credentials'
import GitHubProvider from "next-auth/providers/github"

export const authOptions: NextAuthOptions = {
    adapter: PrismaAdapter(db as any) as Adapter,
    session: {
        strategy: 'jwt'
    },
    pages: {
        signIn: "/login",
    },
    providers: [
        GitHubProvider({
            clientId: env.GITHUB_CLIENT_ID as string,
            clientSecret: env.GITHUB_CLIENT_SECRET as string,
        }),

        CredentialsProvider({
            name: 'Login',
            credentials: {
                username: { label: 'Username', type: 'text' },
                email: { label: 'Email', type: 'email', placeholder: 'hello@example.com' },
                password: { label: 'Password', type: 'password' }
            },
            async authorize(credentials) {
                if (!credentials?.username || !credentials.email || !credentials.password) {
                    return null
                }

                let isUnique = false;
                while (!isUnique) {
                    const existingUserName = await db.user.findUnique({
                        where: {
                            username: credentials.username
                        }
                    })

                    if (existingUserName) {
                        credentials.username = `${credentials.username}${Math.floor(Math.random() * 1000)}`
                    } else {
                        isUnique = true;
                    }
                }

                const user = await db.user.findUnique({
                    where: {
                        email: credentials.email
                    }
                })

                if (!user) {
                    return null
                }

                const isPasswordValid = await compare(
                    credentials.password,
                    user.password
                )

                if (!isPasswordValid) {
                    return null
                }

                return {
                    id: user.id,
                    username: user.username,
                    email: user.email,
                    name: user.name,
                }
            }
        })
    ],
    secret: env.NEXTAUTH_SECRET,
    callbacks: {
        async session({ token, session }) {
            if (token) {
                session.user.id = token.id + ''
                session.user.name = token.name
                session.user.email = token.email
                session.user.image = token.picture
            }

            return session
        },
        async jwt({ token, user }) {
            const dbUser = await db.user.findFirst({
                where: {
                    email: token.email,
                },
            })

            if (!dbUser) {
                if (user) {
                    token.id = user?.id
                }
                return token
            }

            return {
                id: dbUser.id,
                name: dbUser.name,
                email: dbUser.email,
                picture: dbUser.image,
            }
        }
    }
}