feat: send email from gmail account (#173)

* feat: send email from gmail account

* refactor: new middleware `getCurrentConnectedService`

this middleware will get the current service from the email present in `req.params`

* feat: sanitize html before sending email in gmail

Author: aayushchugh

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-	"cSpell.words": ["markverified"],
+	"cSpell.words": ["dompurify", "markverified"],
 	"docwriter.style": "Auto-detect",
 	"editor.tabSize": 4,
 	"editor.comments.insertSpace": true,

package.json

@@ -29,6 +29,7 @@
 		"express-rate-limit": "^6.6.0",
 		"helmet": "^6.0.0",
 		"http-status-codes": "^2.2.0",
+		"isomorphic-dompurify": "^0.23.0",
 		"jsonwebtoken": "^8.5.1",
 		"lodash": "^4.17.21",
 		"mongoose": "^6.6.1",

src/app.ts

@@ -13,6 +13,8 @@ import adminRouter from "./routes/admin.routes";
 import mailRouter from "./routes/mail.routes";
 import deserializeUser from "./middleware/deserializeUser.middleware";
 import requireAdminRole from "./middleware/requireAdminRole.middleware";
+import requireSameUser from "./middleware/requireSameUser.middleware";
+import getCurrentConnectedService from "./middleware/getCurrentConnectedService.middleware";
 
 config();
 
@@ -27,7 +29,7 @@ app.use(express.json());
 app.use("/api", authRouter);
 app.use("/api", userRouter);
 app.use("/api", ticketRouter);
-app.use("/api", mailRouter);
+app.use("/api", deserializeUser, mailRouter);
 app.use("/api", deserializeUser, requireAdminRole, adminRouter);
 
 logger.info("Current Environment: " + process.env.NODE_ENV);

src/controllers/auth.controller.ts

@@ -59,7 +59,7 @@ export const signupHandler = async (req: Request<{}, {}, SignupSchema["body"]>,
 
 		sendEmail(
 			email,
-			"OTP for Multi Email",
+			"Verify your Multi Email account",
 			`<h2>Welcome to Multi Email</h2>
 			<h4>please visit this URL and enter your OTP</h4>
 			<p>

src/controllers/mail.controller.ts

@@ -1,10 +1,12 @@
 import { Request, Response } from "express";
 import axios from "axios";
 import { StatusCodes } from "http-status-codes";
-import { GetEmailsFromGmailSchema } from "../schemas/mail.schema";
-import { ConnectedServices, User } from "../models/user.model";
+import { GetEmailsFromGmailSchema, PostSendGmailSchema } from "../schemas/mail.schema";
+import { ConnectedServices } from "../models/user.model";
 import logger from "../utils/logger.util";
 import { URLSearchParams } from "url";
+import { createTransport, SendMailOptions, Transporter } from "nodemailer";
+import DOMPurify from "isomorphic-dompurify";
 
 /**
  * This function will fetch all the emails from gmail
@@ -18,20 +20,8 @@ export const getEmailsFromGmailHandler = async (
 	res: Response,
 ) => {
 	try {
-		const { email } = req.params;
 		const { maxResults, pageToken, q, includeSpamTrash } = req.query;
-		const user = res.locals.user as User;
-
-		// get email accessToken
-		const foundService = user.connected_services.find(
-			(service: ConnectedServices) => service.email === email,
-		);
-
-		if (!foundService) {
-			return res.status(StatusCodes.NOT_FOUND).json({
-				error: "Account not connected",
-			});
-		}
+		const currentConnectedService = res.locals.currentConnectedService as ConnectedServices;
 
 		const fetchEmailsQueryURL = new URLSearchParams({
 			maxResults: maxResults || "100",
@@ -41,10 +31,12 @@ export const getEmailsFromGmailHandler = async (
 		});
 
 		const response = await axios.get(
-			`https://gmail.googleapis.com/gmail/v1/users/${email}/messages?${fetchEmailsQueryURL.toString()}`,
+			`https://gmail.googleapis.com/gmail/v1/users/${
+				currentConnectedService.email
+			}/messages?${fetchEmailsQueryURL.toString()}`,
 			{
 				headers: {
-					Authorization: `Bearer ${foundService.access_token}`,
+					Authorization: `Bearer ${currentConnectedService.access_token}`,
 					"Content-type": "application/json",
 				},
 			},
@@ -56,11 +48,59 @@ export const getEmailsFromGmailHandler = async (
 			size: response.data.messages.length,
 			nextPageToken: response.data.nextPageToken,
 		});
-	} catch (err) {
-		logger.error(err);
+	} catch (err: any) {
+		logger.error(err.response);
 
 		return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
 			error: "Internal Server Error",
 		});
 	}
 };
+
+/**
+ * This controller will send a email from users gmail account
+ * @param req express request
+ * @param res express response
+ *
+ * @author aayushchugh
+ */
+export const postSendGmailHandler = async (
+	req: Request<PostSendGmailSchema["params"], {}, PostSendGmailSchema["body"]>,
+	res: Response,
+) => {
+	const { to, subject, html } = req.body;
+	const currentConnectedService = res.locals.currentConnectedService as ConnectedServices;
+
+	try {
+		const cleanedHTML = DOMPurify.sanitize(html);
+
+		const transporter: Transporter = createTransport({
+			service: "gmail",
+			auth: {
+				type: "OAuth2",
+				user: currentConnectedService.email,
+				clientId: process.env.GOOGLE_CLIENT_ID,
+				clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+				refreshToken: currentConnectedService.refresh_token,
+				accessToken: currentConnectedService.access_token,
+			},
+		});
+
+		const mailOptions: SendMailOptions = {
+			from: currentConnectedService.email,
+			to,
+			subject,
+			html: cleanedHTML,
+		};
+
+		await transporter.sendMail(mailOptions);
+
+		return res.status(StatusCodes.OK).json({
+			message: "Email sent successfully",
+		});
+	} catch (err) {
+		return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+			error: "Internal Server Error",
+		});
+	}
+};

src/middleware/getCurrentConnectedService.middleware.ts

@@ -0,0 +1,39 @@
+import { NextFunction, Request, Response } from "express";
+import { StatusCodes } from "http-status-codes";
+import { User } from "../models/user.model";
+
+/**
+ * This middleware will find current connected service from current user
+ * and save that to `res.locals.currentConnectedService`
+ *
+ * @param req express request
+ * @param res express response
+ * @param next express next function
+ *
+ * @author aayushchugh
+ */
+const getCurrentConnectedService = (req: Request, res: Response, next: NextFunction) => {
+	try {
+		const user = res.locals.user as User;
+		const { email } = req.params;
+
+		const currentConnectedService = user.connected_services.find(
+			(service) => service.email === email,
+		);
+
+		if (!currentConnectedService) {
+			return res.status(StatusCodes.NOT_FOUND).json({
+				error: "Account not connected",
+			});
+		}
+
+		res.locals.currentConnectedService = currentConnectedService;
+		next();
+	} catch (err) {
+		return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+			error: "Internal Server Error",
+		});
+	}
+};
+
+export default getCurrentConnectedService;

src/routes/mail.routes.ts

@@ -1,15 +1,25 @@
 import { Router } from "express";
-import { getEmailsFromGmailHandler } from "../controllers/mail.controller";
-import deserializeUser from "../middleware/deserializeUser.middleware";
+import { getEmailsFromGmailHandler, postSendGmailHandler } from "../controllers/mail.controller";
+import getCurrentConnectedService from "../middleware/getCurrentConnectedService.middleware";
 import requireSameUser from "../middleware/requireSameUser.middleware";
+import validateRequest from "../middleware/validateRequest.middleware";
+import { getEmailsFromGmailSchema, postSendGmailSchema } from "../schemas/mail.schema";
 
 const mailRouter = Router();
 
-mailRouter.get(
-	"/mail/:id/gmail/:email",
-	deserializeUser,
-	requireSameUser,
-	getEmailsFromGmailHandler,
-);
+mailRouter
+	.route("/mail/:id/gmail/:email")
+	.get(
+		requireSameUser,
+		validateRequest(getEmailsFromGmailSchema),
+		getCurrentConnectedService,
+		getEmailsFromGmailHandler,
+	)
+	.post(
+		requireSameUser,
+		validateRequest(postSendGmailSchema),
+		getCurrentConnectedService,
+		postSendGmailHandler,
+	);
 
 export default mailRouter;

src/schemas/mail.schema.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 /**
- * This schema will validate `/mail/gmail/:email` route
+ * This schema will validate `GET /mail/gmail/:email` route
  *
  * @author aayushchugh
  */
@@ -23,3 +23,28 @@ export const getEmailsFromGmailSchema = z.object({
  * @author aayushchugh
  */
 export type GetEmailsFromGmailSchema = z.TypeOf<typeof getEmailsFromGmailSchema>;
+
+/**
+ * This schema will validate `POST /mail/gmail/:email` route
+ *
+ * @author aayushchugh
+ */
+export const postSendGmailSchema = z.object({
+	body: z.object({
+		to: z.string({ required_error: "to is required" }).email("to must be a valid email"),
+		subject: z.string({ required_error: "subject is required" }),
+		html: z.string({ required_error: "html is required" }),
+	}),
+	params: z.object({
+		email: z
+			.string({ required_error: "email param is required" })
+			.email("please enter a valid email param"),
+	}),
+});
+
+/**
+ * This type is generated from `sendGmailSchema`
+ *
+ * @author aayushchugh
+ */
+export type PostSendGmailSchema = z.TypeOf<typeof postSendGmailSchema>;