prostgles-server 4.2.183 → 4.2.185

package/lib/Auth/AuthTypes.ts

@@ -38,7 +38,9 @@ export type BasicSession = {
   /** On expired */
   onExpiration: "redirect" | "show_error";
 };
-export type AuthClientRequest = { socket: PRGLIOSocket } | { httpReq: ExpressReq };
+export type AuthClientRequest =
+  | { socket: PRGLIOSocket; httpReq?: undefined }
+  | { httpReq: ExpressReq; socket?: undefined };
 
 type ThirdPartyProviders = {
   facebook?: Pick<FacebookStrategy, "clientID" | "clientSecret"> & {
@@ -95,13 +97,18 @@ type EmailProvider =
         onSend: (data: {
           email: string;
           magicLinkPath: string;
+          clientInfo: LoginClientInfo;
+          req: ExpressReq;
         }) => EmailWithoutTo | Promise<EmailWithoutTo>;
         smtp: SMTPConfig;
       };
     }
   | {
       signupType: "withPassword";
-      onRegistered: (data: { username: string; password: string }) => void | Promise<void>;
+      onRegistered: (
+        data: { username: string; password: string },
+        clientInfo: LoginClientInfo
+      ) => void | Promise<void>;
       /**
        * Defaults to 8
        */
@@ -110,12 +117,24 @@ type EmailProvider =
        * If provided, the user will be required to confirm their email address
        */
       emailConfirmation?: {
+        /**
+         * Called when the user has registered
+         */
         onSend: (data: {
           email: string;
           confirmationUrlPath: string;
+          clientInfo: LoginClientInfo;
+          req: ExpressReq;
         }) => EmailWithoutTo | Promise<EmailWithoutTo>;
         smtp: SMTPConfig;
-        onConfirmed: (data: { confirmationCode: string }) => void | Promise<void>;
+        /**
+         * Called after the user has clicked the URL to confirm their email address
+         */
+        onConfirmed: (data: {
+          confirmationCode: string;
+          clientInfo: LoginClientInfo;
+          req: ExpressReq;
+        }) => void | Promise<void>;
       };
     };
 
@@ -328,5 +347,9 @@ type ExpressConfig<S, SUser extends SessionUser> = {
 };
 
 type ExpressMiddleware<S, SUser extends SessionUser> = (
-  args: { req: ExpressReq; res: ExpressRes; next: NextFunction } & AuthRequestParams<S, SUser>
+  args: {
+    req: ExpressReq;
+    res: ExpressRes;
+    next: NextFunction;
+  } & AuthRequestParams<S, SUser>
 ) => void | Promise<void>;

package/lib/Auth/getSafeReturnURL.ts

@@ -1,14 +1,21 @@
-export const getSafeReturnURL = (returnURL: string, returnUrlParamName: string, quiet = false) => {
+export const getSafeReturnURL = (
+  returnURL: string,
+  returnUrlParamName: string,
+  quiet = false,
+) => {
   /** Dissalow redirect to other domains */
-  if(returnURL) {
+  if (returnURL) {
     const allowedOrigin = "https://localhost";
-    const { origin, pathname, search, searchParams } = new URL(returnURL, allowedOrigin);
-    if(
+    const { origin, pathname, search, searchParams } = new URL(
+      returnURL,
+      allowedOrigin,
+    );
+    if (
       origin !== allowedOrigin ||
       returnURL !== `${pathname}${search}` ||
       searchParams.get(returnUrlParamName)
-    ){
-      if(!quiet){
+    ) {
+      if (!quiet) {
         console.error(`Unsafe returnUrl: ${returnURL}. Redirecting to /`);
       }
       return "/";
@@ -16,20 +23,27 @@ export const getSafeReturnURL = (returnURL: string, returnUrlParamName: string,
 
     return returnURL;
   }
-}
+};
 
-const issue = ([
-  ["https://localhost", "/"],
-  ["//localhost.bad.com", "/"],
-  ["//localhost.com", "/"],
-  ["/localhost/com", "/localhost/com"],
-  ["/localhost/com?here=there", "/localhost/com?here=there"],
-  ["/localhost/com?returnUrl=there", "/"],
-  ["//http://localhost.com", "/"],
-  ["//abc.com", "/"],
-  ["///abc.com", "/"],
-] as const).find(([returnURL, expected]) => getSafeReturnURL(returnURL, "returnUrl", true) !== expected);
+const issue = (
+  [
+    ["https://localhost", "/"],
+    ["//localhost.bad.com", "/"],
+    ["//localhost.com", "/"],
+    ["/localhost/com", "/localhost/com"],
+    ["/localhost/com?here=there", "/localhost/com?here=there"],
+    ["/localhost/com?returnUrl=there", "/"],
+    ["//http://localhost.com", "/"],
+    ["//abc.com", "/"],
+    ["///abc.com", "/"],
+  ] as const
+).find(
+  ([returnURL, expected]) =>
+    getSafeReturnURL(returnURL, "returnUrl", true) !== expected,
+);
 
-if(issue){
-  throw new Error(`getSafeReturnURL failed for ${issue[0]}. Expected: ${issue[1]}`);
-}
+if (issue) {
+  throw new Error(
+    `getSafeReturnURL failed for ${issue[0]}. Expected: ${issue[1]}`,
+  );
+}

package/lib/Auth/sendEmail.ts

@@ -3,8 +3,14 @@ import * as nodemailer from "nodemailer";
 import * as aws from "@aws-sdk/client-ses";
 import SESTransport from "nodemailer/lib/ses-transport";
 
-type SESTransporter =  nodemailer.Transporter<SESTransport.SentMessageInfo, SESTransport.Options>;
-type SMTPTransporter = nodemailer.Transporter<nodemailer.SentMessageInfo, nodemailer.TransportOptions>;
+type SESTransporter = nodemailer.Transporter<
+  SESTransport.SentMessageInfo,
+  SESTransport.Options
+>;
+type SMTPTransporter = nodemailer.Transporter<
+  nodemailer.SentMessageInfo,
+  nodemailer.TransportOptions
+>;
 type Transporter = SESTransporter | SMTPTransporter;
 
 const transporterCache: Map<string, Transporter> = new Map();
@@ -16,80 +22,77 @@ const transporterCache: Map<string, Transporter> = new Map();
 export const sendEmail = (smptConfig: SMTPConfig, email: Email) => {
   const transporter = getOrSetTransporter(smptConfig);
   return send(transporter, email);
-}
+};
 
 /**
  * Returns a transporter from cache or creates a new one
  */
 export const getOrSetTransporter = (smptConfig: SMTPConfig) => {
   const configStr = JSON.stringify(smptConfig);
-  const transporter = transporterCache.get(configStr) ?? getTransporter(smptConfig);
-  if(!transporterCache.has(configStr)){
+  const transporter =
+    transporterCache.get(configStr) ?? getTransporter(smptConfig);
+  if (!transporterCache.has(configStr)) {
     transporterCache.set(configStr, transporter);
   }
   return transporter;
-}
+};
 
 const getTransporter = (smptConfig: SMTPConfig) => {
   let transporter: Transporter | undefined;
-  if(smptConfig.type === "aws-ses"){
-    const { 
-      region, 
-      accessKeyId, 
+  if (smptConfig.type === "aws-ses") {
+    const {
+      region,
+      accessKeyId,
       secretAccessKey,
       /**
        * max 1 messages/second
        */
-      sendingRate = 1 
+      sendingRate = 1,
     } = smptConfig;
     const ses = new aws.SES({
       apiVersion: "2010-12-01",
       region,
       credentials: {
         accessKeyId,
-        secretAccessKey
-      }
+        secretAccessKey,
+      },
     });
 
     transporter = nodemailer.createTransport({
       SES: { ses, aws },
       maxConnections: 1,
-      sendingRate 
+      sendingRate,
     });
-
   } else {
     const { user, pass, host, port, secure } = smptConfig;
     transporter = nodemailer.createTransport({
       host,
       port,
       secure,
-      auth: { user, pass }
+      auth: { user, pass },
     });
   }
 
   return transporter;
-}
+};
 
 const send = (transporter: Transporter, email: Email) => {
   return new Promise((resolve, reject) => {
     const doSend = () => {
       if (transporter.isIdle()) {
-        transporter.sendMail(
-          email,
-          (err, info) => {
-            if(err){
-              reject(err);
-            } else {
-              resolve(info);
-            }
+        transporter.sendMail(email, (err, info) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(info);
           }
-        );
+        });
       }
-    }
-    if(transporter.isIdle()){
+    };
+    if (transporter.isIdle()) {
       doSend();
     } else {
-      transporter.once('idle', doSend);
+      transporter.once("idle", doSend);
     }
   });
 };
@@ -98,11 +101,11 @@ export const verifySMTPConfig = async (smptConfig: SMTPConfig) => {
   const transporter = getOrSetTransporter(smptConfig);
   return new Promise((resolve, reject) => {
     transporter.verify((err, success) => {
-      if(err){
+      if (err) {
         reject(err);
       } else {
         resolve(success);
       }
     });
   });
-}
+};

package/lib/Auth/setAuthProviders.ts

@@ -7,45 +7,67 @@ import { Strategy as MicrosoftStrategy } from "passport-microsoft";
 import { AuthSocketSchema, getObjectEntries, isEmpty } from "prostgles-types";
 import { getErrorAsObject } from "../DboBuilder/dboBuilderUtils";
 import { removeExpressRouteByName } from "../FileManager/FileManager";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo } from "./AuthHandler";
-import { Auth } from './AuthTypes';
+import {
+  AUTH_ROUTES_AND_PARAMS,
+  AuthHandler,
+  getLoginClientInfo,
+} from "./AuthHandler";
+import { Auth } from "./AuthTypes";
 import { setEmailProvider } from "./setEmailProvider";
 import * as passport from "passport";
 
-export const upsertNamedExpressMiddleware = (app: e.Express, handler: RequestHandler, name: string) => {
+export const upsertNamedExpressMiddleware = (
+  app: e.Express,
+  handler: RequestHandler,
+  name: string,
+) => {
   const funcName = name;
   Object.defineProperty(handler, "name", { value: funcName });
   removeExpressRouteByName(app, name);
   app.use(handler);
-}
+};
 
-export async function setAuthProviders (this: AuthHandler, { registrations, app }: Required<Auth>["expressConfig"]) {
-  if(!registrations) return;
-  const { onProviderLoginFail, onProviderLoginStart, websiteUrl, OAuthProviders } = registrations;
+export async function setAuthProviders(
+  this: AuthHandler,
+  { registrations, app }: Required<Auth>["expressConfig"],
+) {
+  if (!registrations) return;
+  const {
+    onProviderLoginFail,
+    onProviderLoginStart,
+    websiteUrl,
+    OAuthProviders,
+  } = registrations;
 
   await setEmailProvider.bind(this)(app);
 
-  if(!OAuthProviders || isEmpty(OAuthProviders)){
+  if (!OAuthProviders || isEmpty(OAuthProviders)) {
     return;
   }
 
-  upsertNamedExpressMiddleware(app, passport.initialize(), "prostglesPassportMiddleware");
+  upsertNamedExpressMiddleware(
+    app,
+    passport.initialize(),
+    "prostglesPassportMiddleware",
+  );
 
   getObjectEntries(OAuthProviders).forEach(([providerName, providerConfig]) => {
-
-    if(!providerConfig?.clientID){
+    if (!providerConfig?.clientID) {
       return;
     }
 
     const { authOpts, ...config } = providerConfig;
-    
-    const strategy = providerName === "google" ? GoogleStrategy :
-      providerName === "github" ? GitHubStrategy :
-      providerName === "facebook" ? FacebookStrategy :
-      providerName === "microsoft" ? MicrosoftStrategy : 
-      undefined
-    ;
 
+    const strategy =
+      providerName === "google"
+        ? GoogleStrategy
+        : providerName === "github"
+          ? GitHubStrategy
+          : providerName === "facebook"
+            ? FacebookStrategy
+            : providerName === "microsoft"
+              ? MicrosoftStrategy
+              : undefined;
     const callbackPath = `${AUTH_ROUTES_AND_PARAMS.loginWithProvider}/${providerName}/callback`;
     passport.use(
       new (strategy as typeof GoogleStrategy)(
@@ -56,72 +78,73 @@ export async function setAuthProviders (this: AuthHandler, { registrations, app
         async (accessToken, refreshToken, profile, done) => {
           // This callback is where you would normally store or retrieve user info from the database
           return done(null, profile, { accessToken, refreshToken, profile });
-        }
-      )
-    );
-
-    app.get(`${AUTH_ROUTES_AND_PARAMS.loginWithProvider}/${providerName}`,
-      passport.authenticate(providerName, authOpts ?? {})
+        },
+      ),
     );
 
     app.get(
-      callbackPath,
-      async (req, res) => {
-        try {
-          const clientInfo = getLoginClientInfo({ httpReq: req });
-          const db = this.db;
-          const dbo = this.dbo as any;
-          const args = { provider: providerName, req, res, clientInfo, db, dbo };
-          const startCheck = await onProviderLoginStart?.(args);
-          if(startCheck && "error" in startCheck){
-            res.status(500).json({ error: startCheck.error });
-            return;
-          }
-          passport.authenticate(
-            providerName, 
-            {
-              session: false, 
-              failureRedirect: "/login",
-              failWithError: true,
-            },
-            async (error: any, _profile: any, authInfo: any) => {
-              if(error){
-                await onProviderLoginFail?.({ ...args, error });
-                res.status(500).json({
-                  error: "Failed to login with provider",
-                });
-              } else {
-                this.loginThrottledAndSetCookie(req, res, { type: "provider", provider: providerName, ...authInfo })
-                .catch((e: any) => {
-                  res.status(500).json(getErrorAsObject(e));
-                });
-              }
-            } 
-          )(req, res);
+      `${AUTH_ROUTES_AND_PARAMS.loginWithProvider}/${providerName}`,
+      passport.authenticate(providerName, authOpts ?? {}),
+    );
 
-        } catch (_e) {
-          res.status(500).json({ error: "Something went wrong" });
+    app.get(callbackPath, async (req, res) => {
+      try {
+        const clientInfo = getLoginClientInfo({ httpReq: req });
+        const db = this.db;
+        const dbo = this.dbo as any;
+        const args = { provider: providerName, req, res, clientInfo, db, dbo };
+        const startCheck = await onProviderLoginStart?.(args);
+        if (startCheck && "error" in startCheck) {
+          res.status(500).json({ error: startCheck.error });
+          return;
         }
+        passport.authenticate(
+          providerName,
+          {
+            session: false,
+            failureRedirect: "/login",
+            failWithError: true,
+          },
+          async (error: any, _profile: any, authInfo: any) => {
+            if (error) {
+              await onProviderLoginFail?.({ ...args, error });
+              res.status(500).json({
+                error: "Failed to login with provider",
+              });
+            } else {
+              this.loginThrottledAndSetCookie(req, res, {
+                type: "provider",
+                provider: providerName,
+                ...authInfo,
+              }).catch((e: any) => {
+                res.status(500).json(getErrorAsObject(e));
+              });
+            }
+          },
+        )(req, res);
+      } catch (_e) {
+        res.status(500).json({ error: "Something went wrong" });
       }
-    );
-
+    });
   });
 }
 
-export function getProviders(this: AuthHandler): AuthSocketSchema["providers"] | undefined {
-  const { registrations } = this.opts?.expressConfig ?? {}
-  if(!registrations) return undefined;
-  const {  OAuthProviders } = registrations;
-  if(!OAuthProviders || isEmpty(OAuthProviders)) return undefined;
- 
-  const result: AuthSocketSchema["providers"] = {}
+export function getProviders(
+  this: AuthHandler,
+): AuthSocketSchema["providers"] | undefined {
+  const { registrations } = this.opts?.expressConfig ?? {};
+  if (!registrations) return undefined;
+  const { OAuthProviders } = registrations;
+  if (!OAuthProviders || isEmpty(OAuthProviders)) return undefined;
+
+  const result: AuthSocketSchema["providers"] = {};
   getObjectEntries(OAuthProviders).forEach(([providerName, config]) => {
-    if(config?.clientID){
+    if (config?.clientID) {
       result[providerName] = {
         url: `${AUTH_ROUTES_AND_PARAMS.loginWithProvider}/${providerName}`,
-      }
+      };
     }
   });
 
   return result;
-}
+}

package/lib/Auth/setEmailProvider.ts

@@ -1,22 +1,21 @@
 import e from "express";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, HTTPCODES } from "./AuthHandler";
+import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo, HTTPCODES } from "./AuthHandler";
 import { Email, SMTPConfig } from "./AuthTypes";
 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,36 +25,50 @@ 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){
+    if (validationError) {
       res.status(HTTPCODES.AUTH_ERROR).json({ success: false, error: validationError });
       return;
     }
     try {
+      const { httpReq, ...clientInfo } = getLoginClientInfo({ httpReq: req });
       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}`,
+            clientInfo,
+            req: httpReq,
+          });
           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}`,
+          clientInfo,
+          req: httpReq,
+        });
+        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" });
       }
@@ -64,11 +77,16 @@ export async function setEmailProvider(this: AuthHandler, app: e.Express) {
     }
   });
 
-  if(email.signupType === "withPassword" && email.emailConfirmation){
+  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 });
+        const { httpReq, ...clientInfo } = getLoginClientInfo({ httpReq: req });
+        await email.emailConfirmation?.onConfirmed({
+          confirmationCode: id,
+          clientInfo,
+          req: httpReq,
+        });
         res.json({ success: true, message: "Email confirmed" });
       } catch (_e) {
         res.status(HTTPCODES.AUTH_ERROR).json({ success: false, error: "Failed to confirm email" });
@@ -79,26 +97,26 @@ export async function setEmailProvider(this: AuthHandler, app: e.Express) {
 
 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);
   }
-}
+};