Development

backend/configs/passport.js

@@ -1,14 +1,64 @@
-const passport = require('passport');
-const JwtStrategy = require('passport-jwt').Strategy;
-const ExtractJwt = require('passport-jwt').ExtractJwt;
-const User = require('./models/User');
-require('dotenv').config();
+const GoogleStrategy = require("passport-google-oauth20").Strategy;
+const passport = require("passport");
+const JwtStrategy = require("passport-jwt").Strategy;
+const ExtractJwt = require("passport-jwt").ExtractJwt;
+const User = require("../models/User");
+require("dotenv").config({ path: ".env.local" });
 
+
+// JWT strategy
 const opts = {
-  jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+  jwtFromRequest: ExtractJwt.fromExtractors([(req) => req.cookies.accessToken]),
   secretOrKey: process.env.JWT_SECRET,
+  issuer: process.env.ISSUER,
 };
 
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.CLIENT_ID,
+      clientSecret: process.env.CLIENT_SECRET,
+      callbackURL: "http://localhost:4000/auth/google/callback",
+      passReqToCallback: true,
+    },
+    async function (req, accessToken, refreshToken, profile, done) {
+      try {
+        // Check if user already exists
+        let user = await User.findOne({ email: profile.emails[0].value });
+
+        if (!user) {
+          // Create a new user if not found
+          user = new User({
+            name: profile.displayName,
+            email: profile.emails[0].value,
+            googleId: profile.id,
+          });
+          await user.save();
+        } else {
+          //Verify user
+          user = await User.findOne({ email: profile.emails[0].value });
+          user.googleId = profile.id;
+        }
+
+        done(null, user);
+      } catch (error) {
+        console.log(error);
+        done(error, false);
+      }
+    }
+  )
+);
+
+passport.serializeUser((user, done) => {
+  done(null, user);
+});
+
+passport.deserializeUser((user, done) => {
+  done(null, user);
+});
+
+//JWT strategy
+
 passport.use(
   new JwtStrategy(opts, async (jwt_payload, done) => {
     try {

backend/connection.js

@@ -3,6 +3,7 @@ require('dotenv').config({ path: '.env.local' });
 const mongoose = require('mongoose');
 
 const connectionStr = process.env.MONGO_URI;
+mongoose.set("strictQuery", false);
 mongoose.connect(connectionStr, {useNewUrlparser: true})
 .then(() => console.log('connected to mongodb'))
 .catch(err => console.log(err))

backend/models/User.js

@@ -1,95 +1,100 @@
-const mongoose = require('mongoose');
-const bcrypt = require('bcrypt');
-
-const UserSchema = mongoose.Schema({
-
-  name: {
-    type: String,
-    required: [true, 'is required']
-  },
-
-  bdate: {
-    type: String,
-    required: [true, 'is required']
-  },
-
-  address: {
-    type: String,
-    required: [true, 'is required']
-  },
-
-  email: {
-    type: String,
-    required: [true, 'is required'],
-    unique: true,
-    index: true,
-    validate: {
-      validator: function (str) {
-        return /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/g.test(str);
+const mongoose = require("mongoose");
+const bcrypt = require("bcrypt");
+
+const UserSchema = mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, "is required"],
+    },
+
+    bdate: {
+      type: String,
+      required: [false, "is required"],
+    },
+
+    address: {
+      type: String,
+      required: [false, "is required"],
+    },
+
+    email: {
+      type: String,
+      required: [true, "is required"],
+      unique: true,
+      index: true,
+      validate: {
+        validator: function (str) {
+          return /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/g.test(str);
+        },
+        message: (props) => `${props.value} is not a valid email`,
       },
-      message: props => `${props.value} is not a valid email`
-    }
-  },
-
-  password: {
-    type: String,
-    required: [true, 'is required']
-  },
+    },
+
+    password: {
+      type: String,
+      required: [false, "is required"],
+    },
+
+    isAdmin: {
+      type: Boolean,
+      default: false,
+    },
+
+    cart: {
+      type: Object,
+      default: {
+        total: 0,
+        count: 0,
+      },
+    },
 
-  isAdmin: {
-    type: Boolean,
-    default: false
-  },
+    feedbacks: {
+      type: Array,
+      default: [],
+    },
 
-  cart: {
-    type: Object,
-    default: {
-      total: 0,
-      count: 0
-    }
-  },
+    notifications: {
+      type: Array,
+      default: [],
+    },
 
-  feedbacks: {
-    type: Array,
-    default: []
-  },
+    tokens: {
+      type: Array,
+      default: [],
+    },
 
-  notifications: {
-    type: Array,
-    default: []
-  },
+    googleId: {
+      type: String,
+      required: [false, "is required"],
+    },
 
-  tokens: {
-    type: Array,
-    default: []
+    orders: [{ type: mongoose.Schema.Types.ObjectId, ref: "Order" }],
   },
-
-  orders: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Order' }]
-
-}, { minimize: false });
+  { minimize: false }
+);
 
 UserSchema.statics.findByCredentials = async function (email, password) {
   const user = await User.findOne({ email });
-  if (!user) throw new Error('invalid credentials');
+  if (!user) throw new Error("invalid credentials");
   const isSamePassword = bcrypt.compareSync(password, user.password);
   if (isSamePassword) return user;
-  throw new Error('invalid credentials');
-}
+  throw new Error("invalid credentials");
+};
 
 UserSchema.methods.toJSON = function () {
   const user = this;
   const userObject = user.toObject();
   delete userObject.password;
   delete userObject.tokens;
   return userObject;
-}
+};
 
 //before saving => hash the password
-UserSchema.pre('save', function (next) {
-
+UserSchema.pre("save", function (next) {
   const user = this;
 
-  if (!user.isModified('password')) return next();
+  if (!user.isModified("password")) return next();
 
   bcrypt.genSalt(10, function (err, salt) {
     if (err) return next(err);
@@ -99,18 +104,16 @@ UserSchema.pre('save', function (next) {
 
       user.password = hash;
       next();
-    })
-
-  })
-
-})
+    });
+  });
+});
 
 //Remove user check
 
-UserSchema.pre('remove', function (next) {
-  this.model('Order').remove({ owner: this._id }, next);
-})
+UserSchema.pre("remove", function (next) {
+  this.model("Order").remove({ owner: this._id }, next);
+});
 
-const User = mongoose.model('User', UserSchema);
+const User = mongoose.model("User", UserSchema);
 
-module.exports = User;
+module.exports = User;