prostgles-server 4.2.183 → 4.2.184

package/lib/Auth/setEmailProvider.ts

@@ -5,18 +5,17 @@ import { getOrSetTransporter, sendEmail } from "./sendEmail";
 import { promises } from "node:dns";
 
 export async function setEmailProvider(this: AuthHandler, app: e.Express) {
-  
   const { email, websiteUrl } = this.opts?.expressConfig?.registrations ?? {};
-  if(!email) return;
-  if(websiteUrl){
+  if (!email) return;
+  if (websiteUrl) {
     await checkDmarc(websiteUrl);
   }
 
   /**
    * Setup nodemailer transporters
    */
-  if(email.signupType === "withPassword"){
-    if(email.emailConfirmation){
+  if (email.signupType === "withPassword") {
+    if (email.emailConfirmation) {
       tryGetTransporter(email.emailConfirmation.smtp);
     }
   } else {
@@ -26,79 +25,97 @@ export async function setEmailProvider(this: AuthHandler, app: e.Express) {
   app.post(AUTH_ROUTES_AND_PARAMS.emailSignup, async (req, res) => {
     const { username, password } = req.body;
     let validationError = "";
-    if(typeof username !== "string"){
+    if (typeof username !== "string") {
       validationError = "Invalid username";
     }
-    if(email.signupType === "withPassword"){
+    if (email.signupType === "withPassword") {
       const { minPasswordLength = 8 } = email;
-      if(typeof password !== "string"){
+      if (typeof password !== "string") {
         validationError = "Invalid password";
-      } else if(password.length < minPasswordLength){
+      } else if (password.length < minPasswordLength) {
         validationError = `Password must be at least ${minPasswordLength} characters long`;
       }
     }
-    if(validationError){
-      res.status(HTTPCODES.AUTH_ERROR).json({ success: false, error: validationError });
+    if (validationError) {
+      res
+        .status(HTTPCODES.AUTH_ERROR)
+        .json({ success: false, error: validationError });
       return;
     }
     try {
       let emailMessage: undefined | { message: Email; smtp: SMTPConfig };
-      if(email.signupType === "withPassword"){
-        if(email.emailConfirmation){
+      if (email.signupType === "withPassword") {
+        if (email.emailConfirmation) {
           const { onSend, smtp } = email.emailConfirmation;
-          const message = await onSend({ email: username, confirmationUrlPath: `${websiteUrl}${AUTH_ROUTES_AND_PARAMS.confirmEmail}` });
+          const message = await onSend({
+            email: username,
+            confirmationUrlPath: `${websiteUrl}${AUTH_ROUTES_AND_PARAMS.confirmEmail}`,
+          });
           emailMessage = { message: { ...message, to: username }, smtp };
         }
       } else {
         const { emailMagicLink } = email;
-        const message = await emailMagicLink.onSend({ email: username, magicLinkPath: `${websiteUrl}${AUTH_ROUTES_AND_PARAMS.magicLinksRoute}` });
-        emailMessage = { message: { ...message, to: username }, smtp: emailMagicLink.smtp };
+        const message = await emailMagicLink.onSend({
+          email: username,
+          magicLinkPath: `${websiteUrl}${AUTH_ROUTES_AND_PARAMS.magicLinksRoute}`,
+        });
+        emailMessage = {
+          message: { ...message, to: username },
+          smtp: emailMagicLink.smtp,
+        };
       }
 
-      if(emailMessage){
+      if (emailMessage) {
         await sendEmail(emailMessage.smtp, emailMessage.message);
         res.json({ success: true, message: "Email sent" });
       }
     } catch {
-      res.status(HTTPCODES.AUTH_ERROR).json({ success: false, error: "Failed to send email" });
+      res
+        .status(HTTPCODES.AUTH_ERROR)
+        .json({ success: false, error: "Failed to send email" });
     }
   });
 
-  if(email.signupType === "withPassword" && email.emailConfirmation){
-    app.get(AUTH_ROUTES_AND_PARAMS.confirmEmailExpressRoute, async (req, res) => {
-      const { id } = req.params ?? {};
-      try {
-        await email.emailConfirmation?.onConfirmed({ confirmationCode: id });
-        res.json({ success: true, message: "Email confirmed" });
-      } catch (_e) {
-        res.status(HTTPCODES.AUTH_ERROR).json({ success: false, error: "Failed to confirm email" });
-      }
-    });
+  if (email.signupType === "withPassword" && email.emailConfirmation) {
+    app.get(
+      AUTH_ROUTES_AND_PARAMS.confirmEmailExpressRoute,
+      async (req, res) => {
+        const { id } = req.params ?? {};
+        try {
+          await email.emailConfirmation?.onConfirmed({ confirmationCode: id });
+          res.json({ success: true, message: "Email confirmed" });
+        } catch (_e) {
+          res
+            .status(HTTPCODES.AUTH_ERROR)
+            .json({ success: false, error: "Failed to confirm email" });
+        }
+      },
+    );
   }
 }
 
 const checkDmarc = async (websiteUrl: string) => {
   const { host, hostname } = new URL(websiteUrl);
-  const ignoredHosts = ["localhost", "127.0.0.1"]
-  if(!hostname || ignoredHosts.includes(hostname)){
+  const ignoredHosts = ["localhost", "127.0.0.1"];
+  if (!hostname || ignoredHosts.includes(hostname)) {
     return;
   }
   const dmarc = await promises.resolveTxt(`_dmarc.${host}`);
   const dmarkTxt = dmarc[0]?.[0];
-  if(
+  if (
     !dmarkTxt?.includes("v=DMARC1") ||
     (!dmarkTxt?.includes("p=reject") && !dmarkTxt?.includes("p=quarantine"))
-  ){
+  ) {
     throw new Error("DMARC not set to reject/quarantine");
   } else {
-    console.log("DMARC set to reject")
+    console.log("DMARC set to reject");
   }
-}
+};
 
 const tryGetTransporter = (smtp: SMTPConfig) => {
   try {
     getOrSetTransporter(smtp);
-  } catch(err) {
+  } catch (err) {
     console.error("Failed to set email transporter", err);
   }
-}
+};

package/lib/Auth/setupAuthRoutes.ts

@@ -1,12 +1,25 @@
 import { RequestHandler } from "express";
 import { DBOFullyTyped } from "../DBSchemaBuilder";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo, HTTPCODES } from "./AuthHandler";
-import { AuthClientRequest, ExpressReq, ExpressRes, LoginParams } from "./AuthTypes";
-import { setAuthProviders, upsertNamedExpressMiddleware } from "./setAuthProviders";
+import {
+  AUTH_ROUTES_AND_PARAMS,
+  AuthHandler,
+  getLoginClientInfo,
+  HTTPCODES,
+} from "./AuthHandler";
+import {
+  AuthClientRequest,
+  ExpressReq,
+  ExpressRes,
+  LoginParams,
+} from "./AuthTypes";
+import {
+  setAuthProviders,
+  upsertNamedExpressMiddleware,
+} from "./setAuthProviders";
 
 export async function setupAuthRoutes(this: AuthHandler) {
   if (!this.opts) return;
- 
+
   const { login, getUser, expressConfig } = this.opts;
 
   if (!login) {
@@ -20,27 +33,37 @@ export async function setupAuthRoutes(this: AuthHandler) {
   if (!getUser) throw "getUser missing from auth config";
 
   if (!expressConfig) {
-    return 
+    return;
   }
-  const { app, publicRoutes = [], onGetRequestOK, magicLinks, use } = expressConfig;
-  if (publicRoutes.find(r => typeof r !== "string" || !r)) {
-    throw "Invalid or empty string provided within publicRoutes "
+  const {
+    app,
+    publicRoutes = [],
+    onGetRequestOK,
+    magicLinks,
+    use,
+  } = expressConfig;
+  if (publicRoutes.find((r) => typeof r !== "string" || !r)) {
+    throw "Invalid or empty string provided within publicRoutes ";
   }
 
   await setAuthProviders.bind(this)(expressConfig);
 
-  if(use){
+  if (use) {
     const prostglesUseMiddleware: RequestHandler = (req, res, next) => {
-      use({ 
-        req, 
-        res, 
-        next, 
+      use({
+        req,
+        res,
+        next,
         getUser: () => this.getUser({ httpReq: req }) as any,
-        dbo: this.dbo as DBOFullyTyped, 
+        dbo: this.dbo as DBOFullyTyped,
         db: this.db,
-      })
+      });
     };
-    upsertNamedExpressMiddleware(app, prostglesUseMiddleware, "prostglesUseMiddleware");
+    upsertNamedExpressMiddleware(
+      app,
+      prostglesUseMiddleware,
+      "prostglesUseMiddleware",
+    );
   }
 
   if (magicLinks) {
@@ -49,111 +72,152 @@ export async function setupAuthRoutes(this: AuthHandler) {
       throw "Check must be defined for magicLinks";
     }
 
-    app.get(AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute, async (req: ExpressReq, res: ExpressRes) => {
-      const { id } = req.params ?? {};
-
-      if (typeof id !== "string" || !id) {
-        res.status(HTTPCODES.BAD_REQUEST).json({ msg: "Invalid magic-link id. Expecting a string" });
-      } else {
-        try {
-          const session = await this.throttledFunc(async () => {
-            return check(id, this.dbo as any, this.db, getLoginClientInfo({ httpReq: req }));
-          });
-          if(!session) {
-            res.status(HTTPCODES.AUTH_ERROR).json({ error: "Invalid magic-link" });
-          } else {
-            this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+    app.get(
+      AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute,
+      async (req: ExpressReq, res: ExpressRes) => {
+        const { id } = req.params ?? {};
+
+        if (typeof id !== "string" || !id) {
+          res
+            .status(HTTPCODES.BAD_REQUEST)
+            .json({ msg: "Invalid magic-link id. Expecting a string" });
+        } else {
+          try {
+            const session = await this.throttledFunc(async () => {
+              return check(
+                id,
+                this.dbo as any,
+                this.db,
+                getLoginClientInfo({ httpReq: req }),
+              );
+            });
+            if (!session) {
+              res
+                .status(HTTPCODES.AUTH_ERROR)
+                .json({ error: "Invalid magic-link" });
+            } else {
+              this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+            }
+          } catch (e) {
+            res.status(HTTPCODES.AUTH_ERROR).json({ error: e });
           }
-
-        } catch (e) {
-          res.status(HTTPCODES.AUTH_ERROR).json({ error: e });
         }
-      }
-    });
+      },
+    );
   }
 
-  app.post(AUTH_ROUTES_AND_PARAMS.login, async (req: ExpressReq, res: ExpressRes) => {
-    try {
-      const loginParams: LoginParams = {
-        type: "username",
-        ...req.body,
-      };
-
-      await this.loginThrottledAndSetCookie(req, res, loginParams);
-    } catch (error) {
-      res.status(HTTPCODES.AUTH_ERROR).json({ error });
-    }
-  });
+  app.post(
+    AUTH_ROUTES_AND_PARAMS.login,
+    async (req: ExpressReq, res: ExpressRes) => {
+      try {
+        const loginParams: LoginParams = {
+          type: "username",
+          ...req.body,
+        };
+
+        await this.loginThrottledAndSetCookie(req, res, loginParams);
+      } catch (error) {
+        res.status(HTTPCODES.AUTH_ERROR).json({ error });
+      }
+    },
+  );
 
   const onLogout = async (req: ExpressReq, res: ExpressRes) => {
     const sid = this.validateSid(req?.cookies?.[this.sidKeyName]);
     if (sid) {
       try {
         await this.throttledFunc(() => {
-          return this.opts?.logout?.(req?.cookies?.[this.sidKeyName], this.dbo as any, this.db);
-        })
+          return this.opts?.logout?.(
+            req?.cookies?.[this.sidKeyName],
+            this.dbo as any,
+            this.db,
+          );
+        });
       } catch (err) {
         console.error(err);
       }
     }
-    res.redirect("/")
-  }
-  
+    res.redirect("/");
+  };
+
   /* Redirect if not logged in and requesting non public content */
-  app.get(AUTH_ROUTES_AND_PARAMS.catchAll, async (req: ExpressReq, res: ExpressRes, next) => {
-
-    const clientReq: AuthClientRequest = { httpReq: req };
-    const getUser = this.getUser;
-    if(this.prostgles.restApi){
-      if(Object.values(this.prostgles.restApi.routes).some(restRoute => this.matchesRoute(restRoute.split("/:")[0], req.path))){
-        next();
-        return;
-      }
-    }
-    try {
-      const returnURL = this.getReturnUrl(req);
-      
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)){
-        await onLogout(req, res);
-        return;
+  app.get(
+    AUTH_ROUTES_AND_PARAMS.catchAll,
+    async (req: ExpressReq, res: ExpressRes, next) => {
+      const clientReq: AuthClientRequest = { httpReq: req };
+      const getUser = this.getUser;
+      if (this.prostgles.restApi) {
+        if (
+          Object.values(this.prostgles.restApi.routes).some((restRoute) =>
+            this.matchesRoute(restRoute.split("/:")[0], req.path),
+          )
+        ) {
+          next();
+          return;
+        }
       }
+      try {
+        const returnURL = this.getReturnUrl(req);
 
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.loginWithProvider, req.path)){
-        next();
-        return;
-      }
-      /**
-       * Requesting a User route
-       */
-      if (this.isUserRoute(req.path)) {
-
-        /* Check auth. Redirect to login if unauthorized */
-        const u = await getUser(clientReq);
-        if (!u) {
-          res.redirect(`${AUTH_ROUTES_AND_PARAMS.login}?returnURL=${encodeURIComponent(req.originalUrl)}`);
+        if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)) {
+          await onLogout(req, res);
           return;
         }
 
-        /* If authorized and going to returnUrl then redirect. Otherwise serve file */
-      } else if (returnURL && (await getUser(clientReq))) {
+        if (
+          this.matchesRoute(AUTH_ROUTES_AND_PARAMS.loginWithProvider, req.path)
+        ) {
+          next();
+          return;
+        }
+        /**
+         * Requesting a User route
+         */
+        if (this.isUserRoute(req.path)) {
+          /* Check auth. Redirect to login if unauthorized */
+          const u = await getUser(clientReq);
+          if (!u) {
+            res.redirect(
+              `${AUTH_ROUTES_AND_PARAMS.login}?returnURL=${encodeURIComponent(req.originalUrl)}`,
+            );
+            return;
+          }
 
-        res.redirect(returnURL);
-        return;
+          /* If authorized and going to returnUrl then redirect. Otherwise serve file */
+        } else if (returnURL && (await getUser(clientReq))) {
+          res.redirect(returnURL);
+          return;
 
-        /** If Logged in and requesting login then redirect to main page */
-      } else if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.login, req.path) && (await getUser(clientReq))) {
+          /** If Logged in and requesting login then redirect to main page */
+        } else if (
+          this.matchesRoute(AUTH_ROUTES_AND_PARAMS.login, req.path) &&
+          (await getUser(clientReq))
+        ) {
+          res.redirect("/");
+          return;
+        }
 
-        res.redirect("/");
-        return;
+        onGetRequestOK?.(req, res, {
+          getUser: () => getUser(clientReq),
+          dbo: this.dbo as DBOFullyTyped,
+          db: this.db,
+        });
+      } catch (error) {
+        console.error(error);
+        const errorMessage =
+          typeof error === "string"
+            ? error
+            : error instanceof Error
+              ? error.message
+              : "";
+        res
+          .status(HTTPCODES.AUTH_ERROR)
+          .json({
+            error:
+              "Something went wrong when processing your request" +
+              (errorMessage ? ": " + errorMessage : ""),
+          });
       }
-
-      onGetRequestOK?.(req, res, { getUser: () => getUser(clientReq), dbo: this.dbo as DBOFullyTyped, db: this.db })
-
-    } catch (error) {
-      console.error(error);
-      const errorMessage = typeof error === "string" ? error : error instanceof Error ? error.message : "";
-      res.status(HTTPCODES.AUTH_ERROR).json({ error: "Something went wrong when processing your request" + (errorMessage? (": " + errorMessage) : "") });
-    }
-
-  });
-}
+    },
+  );
+}