next-auth

authed

authed

isAdmin

isAdmin

const API_KEY: string = process.env.DATA_API_KEY as string;

export async function POST(request: Request, response: Response) {
  const { username, email, chessElo } = await request.json();

  if (!username || !email)
    return NextResponse.json({ message: "Missing required data" });

  const res = await createUser(username, email, chessElo);

  console.log(request.headers.get("authorization"));

  return NextResponse.json(response);
}

const API_KEY: string = process.env.DATA_API_KEY as string;

export async function POST(request: Request, response: Response) {
  const { username, email, chessElo } = await request.json();

  if (!username || !email)
    return NextResponse.json({ message: "Missing required data" });

  const res = await createUser(username, email, chessElo);

  console.log(request.headers.get("authorization"));

  return NextResponse.json(response);
}

import prisma from "@/server/db/seed";
export const createUser = async (
  username: string,

  email: string,
  chessElo?: number,
  role?: "roles" | undefined,

  badge?: "budges" | undefined
) => {
  const user = await prisma.user.create({
    data: <userType>{
      username,
      email,
      chessElo,
      role,

      badge,
    },
  });
  return user;
};

import prisma from "@/server/db/seed";
export const createUser = async (
  username: string,

  email: string,
  chessElo?: number,
  role?: "roles" | undefined,

  badge?: "budges" | undefined
) => {
  const user = await prisma.user.create({
    data: <userType>{
      username,
      email,
      chessElo,
      role,

      badge,
    },
  });
  return user;
};

callbacks: {
        async jwt({ token, user }) {
            if (user) {
                token.accessToken = user.jwt
            }

            return token
        },
        async session({ session, token, user }) {
            session.accessToken = token.accessToken
            return session
        }
    }

callbacks: {
        async jwt({ token, user }) {
            if (user) {
                token.accessToken = user.jwt
            }

            return token
        },
        async session({ session, token, user }) {
            session.accessToken = token.accessToken
            return session
        }
    }

"next/server";
import { form } from "@/schemas/forms";
const bcrypt = require("bcrypt");

export async function POST(request: Request, response: Response) {
  const { username, password, email, confirmPassword } = await request.json();

  if (!username || !email || !password) {
    return NextResponse.json(
      { message: "Missing required data" },
      { status: 400 }
    );
  }

  try {
    const parsedData = await form.parse({
      username,
      password,
      email,
      confirmPassword,
    });
    await bcrypt.hash(parsedData.password, 10, (err: string, hash: string) => {
      try {
        createUser(
          parsedData.username as string,
          hash as string,
          parsedData.email as string
        );
      } catch (error) {
        throw error;
      }
    });

    return NextResponse.json(parsedData);
  } catch (error: unknown) {
    console.log(error);
    const castedError = error as {
      issues?: Array<{ message: string; code: string }>;
    };
    const errorMessage = castedError.issues?.[0]?.message || error;

    return NextResponse.json({ message: errorMessage }, { status: 400 });
  }
}

"next/server";
import { form } from "@/schemas/forms";
const bcrypt = require("bcrypt");

export async function POST(request: Request, response: Response) {
  const { username, password, email, confirmPassword } = await request.json();

  if (!username || !email || !password) {
    return NextResponse.json(
      { message: "Missing required data" },
      { status: 400 }
    );
  }

  try {
    const parsedData = await form.parse({
      username,
      password,
      email,
      confirmPassword,
    });
    await bcrypt.hash(parsedData.password, 10, (err: string, hash: string) => {
      try {
        createUser(
          parsedData.username as string,
          hash as string,
          parsedData.email as string
        );
      } catch (error) {
        throw error;
      }
    });

    return NextResponse.json(parsedData);
  } catch (error: unknown) {
    console.log(error);
    const castedError = error as {
      issues?: Array<{ message: string; code: string }>;
    };
    const errorMessage = castedError.issues?.[0]?.message || error;

    return NextResponse.json({ message: errorMessage }, { status: 400 });
  }
}

 catch (error) {
        throw error;
      }

 catch (error) {
        throw error;
      }

export const options: NextAuthOptions = {
  secret: process.env.JWT_SECRET,
  session: {
    strategy: "jwt",
    maxAge: 3600 * 6,
  },
  callbacks: {
    
     
    
    jwt: async ({ token, account, user }) => {
      user && (token.user = user);
      console.log(token);
      return token;
    },
    session: async ({ session, token }) => {
      if (token && token.user) {
        session.user = token.user as any;
      }
      return session;
    },
  },
  adapter: PrismaAdapter(prisma) as Adapter,
  pages: {
    signIn: "/auth/signin",
  },
  providers: [
    GoogleProvider({
      // profile(profile: GoogleProfile) {
      //   return {
      //     ...profile,
      //     role: profile.role ?? "BASIC",
      //     id: profile.id,
      //   };
      // },
      clientId: process.env.GOOGLE_CLIENT_ID as string,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
    }),
    CredentialsProvider({
      name: "Credentials",
      credentials: {
        username: {
          type: "text",
        },
        password: {
          type: "password",
        },
      },
      async authorize(credentials) {
        const user = await getUser(credentials?.username as string);
        if (user === null) {
          //no user
          throw Error("user or password not valid");
        }
        const ismatch = await bcrypt.compare(
          credentials?.password,
          user?.password
        );
        console.log(ismatch);
        if (ismatch) {
          return {
            id: user.id,
            role: user.role,
            name: user.name,
            email: user.email,
            chessElo: user.chessElo,
            badge: user.badge,
            image: user.image,
          };
        } else {
          // invalid pass
          throw Error("user or password not valid");
        }
      },
    }),
  ],
};

export const options: NextAuthOptions = {
  secret: process.env.JWT_SECRET,
  session: {
    strategy: "jwt",
    maxAge: 3600 * 6,
  },
  callbacks: {
    
     
    
    jwt: async ({ token, account, user }) => {
      user && (token.user = user);
      console.log(token);
      return token;
    },
    session: async ({ session, token }) => {
      if (token && token.user) {
        session.user = token.user as any;
      }
      return session;
    },
  },
  adapter: PrismaAdapter(prisma) as Adapter,
  pages: {
    signIn: "/auth/signin",
  },
  providers: [
    GoogleProvider({
      // profile(profile: GoogleProfile) {
      //   return {
      //     ...profile,
      //     role: profile.role ?? "BASIC",
      //     id: profile.id,
      //   };
      // },
      clientId: process.env.GOOGLE_CLIENT_ID as string,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
    }),
    CredentialsProvider({
      name: "Credentials",
      credentials: {
        username: {
          type: "text",
        },
        password: {
          type: "password",
        },
      },
      async authorize(credentials) {
        const user = await getUser(credentials?.username as string);
        if (user === null) {
          //no user
          throw Error("user or password not valid");
        }
        const ismatch = await bcrypt.compare(
          credentials?.password,
          user?.password
        );
        console.log(ismatch);
        if (ismatch) {
          return {
            id: user.id,
            role: user.role,
            name: user.name,
            email: user.email,
            chessElo: user.chessElo,
            badge: user.badge,
            image: user.image,
          };
        } else {
          // invalid pass
          throw Error("user or password not valid");
        }
      },
    }),
  ],
};

export { default } from "next-auth/middleware"

export const config = { matcher: ["/dashboard"] }

export { default } from "next-auth/middleware"

export const config = { matcher: ["/dashboard"] }

session.user = user
return session

session.user = user
return session

model User {
  id            String    @id @default(cuid())
  role          roles     @default(BASIC)
  name          String    @unique
  chessElo      Int?
  badge         budges    @default(ROCKIE)
  email         String?   @unique
  emailVerified DateTime?
  image         String?
  followedBy    Follows[] @relation("following")
  following     Follows[] @relation("follower")
  accounts      Account[]
  sessions      Session[]
}

model Follows {
  follower    User   @relation("follower", fields: [followerId], references: [id])
  followerId  String
  following   User   @relation("following", fields: [followingId], references: [id])
  followingId String

  @@id([followerId, followingId])
}

model User {
  id            String    @id @default(cuid())
  role          roles     @default(BASIC)
  name          String    @unique
  chessElo      Int?
  badge         budges    @default(ROCKIE)
  email         String?   @unique
  emailVerified DateTime?
  image         String?
  followedBy    Follows[] @relation("following")
  following     Follows[] @relation("follower")
  accounts      Account[]
  sessions      Session[]
}

model Follows {
  follower    User   @relation("follower", fields: [followerId], references: [id])
  followerId  String
  following   User   @relation("following", fields: [followingId], references: [id])
  followingId String

  @@id([followerId, followingId])
}