feat: Add google auth for signin

package.json

@@ -26,11 +26,16 @@
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "express": "^4.19.2",
+    "express-session": "^1.18.0",
     "express-winston": "^4.2.0",
     "highlight.js": "^11.9.0",
     "jsend": "^1.1.0",
     "morgan": "^1.10.0",
     "nodemon": "^3.1.0",
+    "passport": "^0.7.0",
+    "passport-facebook": "^3.0.0",
+    "passport-google-oauth": "^2.0.0",
+    "passport-google-oauth20": "^2.0.0",
     "pg": "^8.11.5",
     "reflect-metadata": "^0.2.2",
     "source-map-support": "^0.5.21",
@@ -53,10 +58,14 @@
     "@types/eslint": "^8.56.10",
     "@types/eslint__js": "^8.42.3",
     "@types/express": "^4.17.21",
+    "@types/express-session": "^1.18.0",
     "@types/jest": "^29.5.12",
     "@types/jsend": "^1.0.32",
     "@types/morgan": "^1.9.9",
     "@types/node": "^20.12.7",
+    "@types/passport": "^1.0.16",
+    "@types/passport-facebook": "^3.0.3",
+    "@types/passport-google-oauth20": "^2.0.14",
     "@types/reflect-metadata": "^0.1.0",
     "@types/supertest": "^6.0.2",
     "@types/winston": "^2.4.4",
@@ -75,4 +84,4 @@
     "typescript": "^5.4.5",
     "typescript-eslint": "^7.7.1"
   }
-}
+}

src/controllers/authController.ts

@@ -1,5 +1,5 @@
 import { Request, Response } from 'express';
-import { User } from '../entities/User';;
+import { User } from '../entities/User';
 import bcrypt from 'bcrypt';
 import { getRepository } from 'typeorm';
 

src/controllers/facebook.auth.ts

@@ -0,0 +1,82 @@
+import { getRepository } from 'typeorm';
+import { User } from '../entities/user.auth'; 
+import express from 'express';
+import passport from 'passport';
+// import session from 'express-session';
+// import { PassportStatic } from 'passport';
+const routerfb = express.Router();
+require('dotenv').config();
+
+async function findUserAccountIdProvider(accountId: string, provider: string): Promise<User | undefined> {
+    try {
+      const userRepository = getRepository(User);
+
+      const user = await userRepository.findOne({
+        where: {
+          accountId: accountId,
+          provider: provider,
+        },
+      });
+
+      if (user === null) {
+        return undefined;
+      }
+
+      return user as User; 
+    } catch (error) {
+      console.error('Error finding user:', error);
+      return undefined;
+    }
+  }
+const accountId = 'your_account_id';
+const provider = 'facebook';
+
+findUserAccountIdProvider(accountId, provider)
+  .then((user) => {
+    if (user) {
+      console.log('User found:', user);
+    } else {
+      console.log('User not found');
+    }
+  })
+  .catch((error) => {
+    console.error('Error:', error);
+  });
+
+  routerfb.get('/', passport.authenticate('facebook', { scope: 'email' }));
+
+  routerfb.get(
+    '/callback',
+    passport.authenticate('facebook', {
+      failureRedirect: '/auth/facebook/error',
+    }),
+    function (req, res) {
+      // Successful authentication, redirect to success screen.
+      res.redirect('/auth/facebook/success');
+    }
+  );
+
+  routerfb.get('/success', async (req, res) => {
+    const userInfo = {
+      id: req.session.passport.user.id,
+      displayName: req.session.passport.user.displayName,
+      provider: req.session.passport.user.provider,
+    };
+    res.render('fb-github-success', { user: userInfo });
+  });
+
+  routerfb.get('/error', (req, res) => res.send('Error logging in via Facebook..'));
+
+  routerfb.get('/signout', (req, res) => {
+    try {
+      req.session.destroy(function (err) {
+        console.log('session destroyed.');
+      });
+      res.render('auth');
+    } catch (err) {
+      res.status(400).send({ message: 'Failed to sign out fb user' });
+    }
+  });
+
+  module.exports = routerfb;
+

src/controllers/google.auth.ts

@@ -0,0 +1,49 @@
+import passport from 'passport';
+const GoogleStrategy = require('passport-google-oauth').OAuth2Strategy;
+import express from 'express';
+import googleAuth from '../middlewares/auth';
+const routers = express.Router();
+require('dotenv').config();
+
+let userProfile: any;
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+      callbackURL: process.env.CALLBACK_URL,
+    },
+    function (_accessToken: any, _refreshToken: any, profile: any, done: (arg0: null, arg1: any) => any) {
+      userProfile = profile;
+      return done(null, userProfile);
+    }
+  )
+);
+
+// request at /auth/google, when user click sign-up with google button transferring
+// the request to google server, to show emails screen
+routers.get(
+  '/',
+  passport.authenticate('google', { scope: ['profile', 'email'] })
+);
+
+// URL Must be same as 'Authorized redirect URIs' field of OAuth client, i.e: /auth/google/callback
+routers.get(
+  '/callback',
+  passport.authenticate('google', { failureRedirect: '/auth/google/error' }),
+  (req: any, res: { redirect: (arg0: string) => void; }) => {
+    res.redirect('/auth/google/success'); // Successful authentication, redirect success.
+  }
+);
+
+routers.get('/success', async (req: any, res: { render: (arg0: string, arg1: { user: any; }) => void; }) => {
+  const { failure, success } = await googleAuth.registerWithGoogle(userProfile);
+  if (failure) console.log('Google user already exist in DB..');
+  else console.log('Registering new Google user..');
+  res.render('success', { user: userProfile });
+});
+
+routers.get('/error', (req: any, res: { send: (arg0: string) => any; }) => res.send('Error logging in via Google..'));
+
+
+export default routers;

src/entities/User.ts

@@ -11,6 +11,15 @@ import {
   @Entity()
   @Unique(['email'])
   export class User {
+    save() {
+        throw new Error('Method not implemented.');
+    }
+    static create(arg0: { accountId: string; name: string; provider: string; }): User | PromiseLike<User | null> | null {
+        throw new Error('Method not implemented.');
+    }
+    static findOne(arg0: { accountId: any; provider: string; }) {
+        throw new Error('Method not implemented.');
+    }
     @PrimaryGeneratedColumn('uuid')
     @IsNotEmpty()
     id!: string;
@@ -66,4 +75,20 @@ import {
 
     @UpdateDateColumn()
     updatedAt!: Date;
+
+    @Column({ nullable: true })
+    @IsString()
+    accountId?: string;
+
+    @Column({ nullable: true })
+    @IsString()
+    name?: string;
+
+    @Column({ nullable: true })
+    @IsString()
+    photoURL?: string;
+
+    @Column({ nullable: true })
+    @IsString()
+    provider?: string;
   }

src/entities/user.auth.ts

@@ -0,0 +1,22 @@
+import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from 'typeorm';
+
+@Entity()
+export class User extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string | undefined;
+
+  @Column({ type: 'text', nullable: true, unique: true })
+  email: string | undefined;
+
+  @Column({ type: 'text', nullable: true })
+  accountId: string | undefined; 
+
+  @Column({ type: 'text', nullable: true })
+    name!: string;
+
+  @Column({ type: 'text', nullable: true })
+  photoURL: string | undefined;
+
+  @Column({ type: 'text', nullable: true })
+  provider: string | undefined;
+}

src/index.ts

@@ -1,14 +1,16 @@
 import express, { Request, Response } from 'express';
 import cors from 'cors';
-import dotenv from 'dotenv';
 import router from './routes';
 import { addDocumentation } from './startups/docs';
 import 'reflect-metadata';
-
-
+import dotenv from 'dotenv';
+dotenv.config();
 import { CustomError, errorHandler } from './middlewares/errorHandler';
 import morgan from 'morgan';
 import { dbConnection } from './startups/dbConnection';
+import passport from 'passport';
+import session from 'express-session';
+import routers from '../src/controllers/google.auth';
 dotenv.config();
 
 export const app = express();
@@ -32,6 +34,13 @@ dbConnection();
 const morganFormat = ':method :url :status :response-time ms - :res[content-length]';
 app.use(morgan(morganFormat));
 
+
+//Google OAuth routes
+app.use('/auth/google', routers);
 export const server = app.listen(port, () => {
   console.log(`[server]: Server is running at http://localhost:${port}`);
-});
+});
+
+function passportConfig() {
+  throw new Error('Function not implemented.');
+}

src/middlewares/auth.ts

@@ -0,0 +1,72 @@
+import { User } from '../entities/user.auth';
+import { getRepository, FindOneOptions } from 'typeorm';
+
+interface OAuthUser {
+  id: any;
+  provider: any;
+  displayName: any;
+  emails: { value: any }[];
+  photos: { value: any }[];
+}
+
+const googleAuthDal = {
+  registerWithGoogle: async (oauthUser: OAuthUser) => {
+    const userRepository = getRepository(User);
+
+    try {
+      // Check if user already exists
+      const existingUser = await userRepository.findOne({
+        where: {
+          accountId: oauthUser.id,
+          provider: oauthUser.provider,
+        },
+      });
+
+      if (existingUser) {
+        return { failure: { message: 'User already registered.' } };
+      }
+
+      // Create a new user entity
+      const newUser = userRepository.create({
+        accountId: oauthUser.id,
+        name: oauthUser.displayName,
+        provider: oauthUser.provider,
+        // Adjust property names based on your User entity
+        email: oauthUser.emails[0]?.value, // Assuming emails[0] contains the email value
+        photoURL: oauthUser.photos[0]?.value, // Assuming photos[0] contains the photo URL value
+      });
+
+      // Save the new user to the database
+      await userRepository.save(newUser);
+
+      return { success: { message: 'User registered successfully.' } };
+    } catch (error) {
+      console.error('Error registering user with Google:', error);
+      return { failure: { message: 'Failed to register user.' } };
+    }
+  },
+
+  loginUser: async (oauthUser: OAuthUser) => {
+    const userRepository = getRepository(User);
+
+    try {
+      // Check if a user with the provided email exists
+      const userExists = await userRepository.findOne({
+        where: {
+          email: oauthUser.emails[0]?.value, // Assuming emails[0] contains the email value
+        },
+      });
+
+      if (userExists) {
+        return { success: { message: 'User successfully logged in.' } };
+      } else {
+        return { failure: { message: 'Email not registered. You need to sign up first.' } };
+      }
+    } catch (error) {
+      console.error('Error logging in user:', error);
+      return { failure: { message: 'Failed to log in user.' } };
+    }
+  },
+};
+
+export default googleAuthDal;

src/types/session.d.ts

@@ -0,0 +1,8 @@
+import 'express-session';
+import { PassportStatic } from 'passport';
+
+declare module 'express-session' {
+  interface SessionData {
+    passport?: any; // Define the passport property as any
+  }
+}

tsconfig.json

@@ -25,8 +25,10 @@
     "module": "commonjs" /* Specify what module code is generated. */,
     "rootDir": "./src" /* Specify the root folder within your source files. */,
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+     "paths": {
+      "*": ["types/*"]
+     },                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
     // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
     "types": ["node", "jest"] /* Specify type package names to be included without being referenced in a source file. */,
@@ -98,6 +100,6 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "types"],
   "exclude": ["node_modules"]
 }