Added Data Loader Packages

Author: DARK-art108

.env

@@ -0,0 +1,3 @@
+PORT=3001
+MONGO_DB_URL = mongodb://localhost/mydb
+JWT_SECRET_KEY = test@1234

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "deno.enable": false
+}

Resolvers/index.js

@@ -0,0 +1,15 @@
+
+const {GraphQLDateTime} = require('graphql-iso-date')
+const userResolver = require('./user')
+const taskResolver = require('./task')
+
+
+const customDateScalarResolver = {
+ Date: GraphQLDateTime
+
+}
+module.exports = [
+  userResolver,
+  taskResolver,
+  customDateScalarResolver
+];

Resolvers/middleware/index.js

@@ -0,0 +1,29 @@
+
+const {skip} = require('graphql-resolvers')
+const Task = require('../../database/Models/task')
+const {isValidObjectId} = require('../../database/util')
+module.exports.isAuthenticated = (_, __, {email}) => {
+    if(!email) {
+        throw new Error('Access Denied!Please login to continue')
+    }
+    return skip
+}
+
+module.exports.isTaskOwner = async (_,{ id }, {loggedInUserId}) => {
+    try {
+        if(!isValidObjectId(id)){
+            throw new Error('Invalid Task id')
+        }
+        const task = await Task.findById(id)
+if (!task){
+    throw new Error('Task not found')
+}else if (task.user.toString() !== loggedInUserId){
+    throw new Error('Not authorized as task owner')
+}
+return skip
+    } catch (error) {
+        console.log(error)
+        throw error
+    }
+
+}

Resolvers/task.js

@@ -0,0 +1,107 @@
+
+const {combineResolvers} = require('graphql-resolvers')
+
+const {stringToBase64, base64ToString } = require('../helper')
+const Task = require('../database/Models/task')
+const User = require('../database/Models/user')
+const { isAuthenticated, isTaskOwner} = require('./middleware')
+const task = require('../typeDefs/task')
+
+module.exports = {
+  Query: {
+    tasks:combineResolvers(isAuthenticated,async (_,{ cursor,limit=10 },{loggedInUserId}) => {
+      try {
+        const query = { user: loggedInUserId}
+        if(cursor){
+          query['_id'] = {
+            '$lt': base64ToString(cursor)
+          }
+        }
+        let tasks = await Task.find(query).sort({_id: -1}).limit(limit + 1)
+        const hasNextPage = tasks.length > limit
+        tasks = hasNextPage ? tasks.slice(0, -1) : tasks
+        return {
+
+          taskFeed: tasks,
+          pageInfo: {
+            nextPageCursor: hasNextPage ? stringToBase64(tasks[tasks.length - 1].id) : null,
+            hasNextPage
+          }
+
+        }
+      } catch (error) {
+        console.log(error)
+        throw error 
+      }
+     
+    }),
+    task:combineResolvers(isAuthenticated,isTaskOwner, async(_, { id }) => {
+      try {
+        const task = await Task.findById(id)
+      return task
+      } catch (error) {
+        console.log(error)
+        throw error
+        
+      }
+      
+    }) ,
+  },
+  Mutation: {
+    createTask: combineResolvers(isAuthenticated,async(_, { input }, {email}) => {
+      try {
+             const user = await User.findOne({email})
+     const task = new Task({...input, user:user.id})
+     const result = await task.save();
+     user.tasks.push(result.id)
+     await user.save();
+     return result
+      } catch (error) {
+        
+      }
+
+    }),
+    updateTask: combineResolvers(isAuthenticated, isTaskOwner, async (_, {id, input})=>{
+
+      try {
+        const task = await Task.findByIdAndUpdate(id, {...input},{new: true})
+        return task
+      } catch (error) {
+        console.log(error)
+        throw error
+      }
+
+      
+
+    }),
+    deleteTask: combineResolvers(isAuthenticated,isTaskOwner,async (_,{id},{loggedInUserId}) =>{
+
+      try {
+      const task = await Task.findByIdAndDelete(id)
+      await User.updateOne({_id: loggedInUserId },{$pull: {tasks: task.id}})
+      return task;
+      } catch (error) {
+        console.log(error)
+        throw error
+      }
+
+      
+
+    })
+
+
+  },
+  Task: {
+    user: async(parent) => {
+      try {
+        const user = await User.findById(parent.user)
+      return user
+      } catch (error) {
+        console.log(error)
+        throw error
+        
+      }
+      
+    }
+  }
+}

Resolvers/user.js

@@ -0,0 +1,106 @@
+const bcrypt = require('bcryptjs')
+const jwt = require('jsonwebtoken')
+const {combineResolvers} = require('graphql-resolvers')
+
+const User = require('../database/Models/user')
+const Task = require('../database/Models/task')
+const {isAuthenticated} = require('./middleware')
+const PubSub = require('../subscription')
+const {userEvents} = require('../subscription/events')
+
+module.exports = {
+  Query: {
+    
+    user: combineResolvers(isAuthenticated, async (_,__, {email}) =>{
+      try {
+        const user =  await User.findOne({ email })
+        if(!user){
+         throw new Error('User not found!')
+      }
+        return user
+      } catch (error) {
+
+        console.log(error)
+        throw error
+        
+      }
+      
+    })
+  },
+  Mutation: {
+     signup: async (_, {input }) => {
+       try{
+
+        const user = await User.findOne({ email: input.email })
+        if (user) {
+          throw new Error('Email already in use')
+        }
+
+        const hashedPassword = await bcrypt.hash(input.password, 12)
+        const newUser = new User({...input, password: hashedPassword })
+        const result = await newUser.save()
+        PubSub.publish(userEvents.USER_CREATED,{
+          userCreated: result
+        })
+        console.log(result.id, typeof result.id)//result.id virtual getter type string
+        console.log(result._id, typeof result._id)//underscore id type object
+        return result
+
+       }catch(error){
+
+        console.log(error)
+        throw error
+     
+
+     }
+
+     
+    } ,
+
+    login:async (_,{input}) => {
+      try {
+
+        const user = await User.findOne({email: input.email})
+        if(!user){
+          throw new Error('User not found')
+        }
+        const isPasswordValid = await bcrypt.compare(input.password,user.password)
+        if(!isPasswordValid){
+          throw new Error('Incorrect Password')
+        }
+        const secret = process.env.JWT_SECRET_KEY || 'mysecretkey'
+        const token = jwt.sign({email: user.email},secret,{expiresIn: '1d'} )
+        return {token}
+
+      } catch (error) {
+
+        console.log(error)
+        throw error
+        
+      }
+      
+    }
+
+
+  },
+  Subscription: {
+   userCreated: {
+     subscribe: () => PubSub.asyncIterator(userEvents.USER_CREATED)
+   }
+  },
+  User: {
+    tasks: async ({ id }) => {
+      try {
+         const tasks = await Task.find({ user: id})
+         return tasks
+      } catch (error) {
+        console.log(error)
+        throw error
+      }
+
+     
+
+    }
+    
+  }
+}

database/Models/task.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const taskSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true
+  },
+  completed: {
+    type: Boolean,
+    required: true
+  },
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }
+}, {
+    timestamps: true
+  });
+
+module.exports = mongoose.model('Task', taskSchema);

database/Models/user.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose')
+
+const userSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true
+    },
+    password: {
+        type: String,
+        required: true
+    },
+    tasks: [
+        {type: mongoose.Schema.Types.ObjectId,
+        ref: 'Task'}
+    ]
+}, {
+    timestamps: true
+})
+
+module.exports = mongoose.model('User', userSchema)

database/util/index.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose')
+
+module.exports.connection = async () => {
+
+    try {
+
+        
+
+     await mongoose.connect(process.env.MONGO_DB_URL, { useNewUrlParser: true, useUnifiedTopology: true})
+    console.log('Database Connected Successfully')
+    
+    }catch(error){
+
+        console.log(error)
+        throw error
+
+
+    }
+    
+}
+
+module.exports.isValidObjectId = (id) =>
+{
+    return mongoose.Types.ObjectId.isValid(id)
+}
+ 

helper/context/index.js

@@ -0,0 +1,24 @@
+const jwt = require('jsonwebtoken')
+const User = require('../../database/Models/user')
+module.exports.verifyUser =async (req) => {
+try {
+    req.email = null
+    req.loggedInUserId = null
+    
+    const bearerHeader = req.headers.authorization
+    if (bearerHeader){
+        const token = bearerHeader.split(' ')[1]
+        const payload = jwt.verify(token, process.env.JWT_SECRET_KEY || 'mysecretkey')
+        req.email = payload.email
+        const user = await User.findOne({email: payload.email})
+        req.loggedInUserId = user.id
+    }
+    
+} catch (error) {
+    console.log(error)
+    throw error
+    
+}
+
+    
+}