resolvers.js

import { quotes,users } from "./fakedb.js";
import {randomBytes} from "crypto";
import mongoose from "mongoose";

import bcrypt  from "bcryptjs";
import jwt from "jsonwebtoken"


const User=mongoose.model("User");
const Quote=mongoose.model("Quote")
const resolvers={
  Query:{
   users:async ()=> await User.find({}),
   user:async (_,{_id})=> await User.findOne({_id}),
   quotes:async ()=>await Quote.find({}).populate("by","_id firstName"),
   ind_quote:async (_,{by})=> await Quote.find({by}),
   myprofile:async (_,args,{userId})=>{
     if(!userId) throw new Error("You must be logged in")
     return await User.findOne({_id:userId})
   }

  },
  User:
  {
    quotes:async(Ur)=>await Quote.find({by:Ur._id}) 
  },
  Mutation:
  {
     signupUser:async(_,{userNew})=>{
       
     const user= await User.findOne({email:userNew.email})
     if(user)
     {
       throw new  Error("User already exists with that email")
     }
     const hashedPassword= await bcrypt.hash(userNew.password,12)
     const newUser= new User({
        ...userNew,
        password:hashedPassword
      })

     return await newUser.save()
     },
     signinUser:async(_,{userSignin})=>{
       const user=await User.findOne({email:userSignin.email})
     if(!user)
     {
       throw new Error("User doesn't exists with that email")
     }
    const doMatch= await bcrypt.compare(userSignin.password,user.password)
    if(!doMatch)
    {
      throw new Error("email or password is invalid")
    }
    const token=jwt.sign({userId:user._id},process.env.JWT_SECRET)
    return {token}
      },
      createQuote:async(_,{name},{userId})=>{
        //user only create qutoe when logged in
       if(!userId)
       {
         throw new Error("You must be logged In")
       }
      const newQuote= new Quote({
         name,
         by:userId
       })
       await newQuote.save()
       return "Quote saved successfully"
      }
  }
}

export default resolvers;