prostgles-server 4.2.155 → 4.2.157

package/lib/Auth/AuthTypes.ts

@@ -8,6 +8,7 @@ import type { StrategyOptions as GoogleStrategy, Profile as GoogleProfile } from
 import type { StrategyOptions as GitHubStrategy, Profile as GitHubProfile } from "passport-github2";
 import type { MicrosoftStrategyOptions } from "passport-microsoft";
 import type { StrategyOptions as FacebookStrategy, Profile as FacebookProfile } from "passport-facebook";
+import Mail from "nodemailer/lib/mailer";
 
 type Awaitable<T> = T | Promise<T>;
 
@@ -49,30 +50,62 @@ type ThirdPartyProviders = {
   };
 };
 
-type SMTPConfig = {
-  type: "aws-ses" | "smtp";
+export type SMTPConfig = {
+  type: "smtp";
   host: string;
   port: number;
   secure: boolean;
-  auth: {
-    user: string;
-    pass: string;
-  }
+  user: string;
+  pass: string;
+} | {
+  type: "aws-ses";
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  /**
+   * Sending rate per second
+   * Defaults to 1
+   */
+  sendingRate?: number;
 }
 
-type RegistrationProviders = ThirdPartyProviders & {
-  email?: {
-    signupType: "withMagicLink" | "withPassword";
-    smtp: SMTPConfig
-  } | {
-    signupType: "withPassword";
-    /**
-     * If provided, the user will be required to confirm their email address
-     */
-    smtp?: SMTPConfig;
-  };
+export type Email = {
+  from: string;
+  to: string;
+  subject: string;
+  html: string;
+  text?: string;
+  attachments?: { filename: string; content: string; }[] | Mail.Attachment[];
 }
 
+type EmailWithoutTo = Omit<Email, "to">;
+
+type EmailProvider = 
+| {
+  signupType: "withMagicLink";
+  onRegistered: (data: { username: string; }) => void | Promise<void>;
+  emailMagicLink:  {
+    onSend: (data: { email: string; magicLinkPath: string; }) => EmailWithoutTo | Promise<EmailWithoutTo>;
+    smtp: SMTPConfig;
+  };
+} 
+| {
+  signupType: "withPassword";
+  onRegistered: (data: { username: string; password: string; }) => void | Promise<void>;
+  /**
+   * Defaults to 8
+   */
+  minPasswordLength: number;
+  /**
+   * If provided, the user will be required to confirm their email address
+   */
+  emailConfirmation?: {
+    onSend: (data: { email: string; confirmationUrlPath: string; }) => EmailWithoutTo | Promise<EmailWithoutTo>;
+    smtp: SMTPConfig;
+    onConfirmed: (data: { confirmationUrlPath: string; }) => void | Promise<void>;
+  };
+};
+
 export type AuthProviderUserData = 
 | {
   provider: "google";
@@ -109,7 +142,11 @@ export type RegistrationData =
 } 
 | AuthProviderUserData;
 
-export type AuthRegistrationConfig<S> = RegistrationProviders & {
+export type AuthRegistrationConfig<S> = {
+  email?: EmailProvider;
+
+  OAuthProviders?: ThirdPartyProviders;
+
   /**
    * Required for social login callback
    */

package/lib/Auth/sendEmail.ts

@@ -0,0 +1,83 @@
+import { Email, SMTPConfig } from "./AuthTypes";
+import nodemailer from "nodemailer";
+import 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 Transporter = SESTransporter | SMTPTransporter;
+
+const transporterCache: Map<string, Transporter> = new Map();
+
+/**
+ * Allows sending emails using nodemailer default config or AWS SES
+ * https://www.nodemailer.com/transports/ses/
+ */
+export const sendEmail = (smptConfig: SMTPConfig, email: Email) => {
+  const configStr = JSON.stringify(smptConfig);
+  const transporter = transporterCache.get(configStr) ?? getTransporter(smptConfig);
+  if(!transporterCache.has(configStr)){
+    transporterCache.set(configStr, transporter);
+  }
+
+  return send(transporter, email);
+}
+
+const getTransporter = (smptConfig: SMTPConfig) => {
+  let transporter: Transporter | undefined;
+  if(smptConfig.type === "aws-ses"){
+    const { 
+      region, 
+      accessKeyId, 
+      secretAccessKey,
+      /**
+       * max 1 messages/second
+       */
+      sendingRate = 1 
+    } = smptConfig;
+    const ses = new aws.SES({
+      apiVersion: "2010-12-01",
+      region,
+      credentials: {
+        accessKeyId,
+        secretAccessKey
+      }
+    });
+
+    transporter = nodemailer.createTransport({
+      SES: { ses, aws },
+      maxConnections: 1,
+      sendingRate 
+    });
+
+  } else {
+    const { user, pass, host, port, secure } = smptConfig;
+    transporter = nodemailer.createTransport({
+      host,
+      port,
+      secure,
+      auth: { user, pass }
+    });
+  }
+
+  return transporter;
+}
+
+const send = (transporter: Transporter, email: Email) => {
+  return new Promise((resolve, reject) => {
+    transporter.once('idle', () => {
+      if (transporter.isIdle()) {
+        transporter.sendMail(
+          email,
+          (err, info) => {
+            if(err){
+              reject(err);
+            } else {
+              resolve(info);
+            }
+          }
+        );
+      }
+    });
+  });
+};

package/lib/Auth/setAuthProviders.ts

@@ -1,17 +1,17 @@
-import { Auth } from './AuthTypes';
-/** For some reason normal import is undefined */
-const passport = require("passport") as typeof import("passport");
-import { Strategy as GoogleStrategy } from "passport-google-oauth20";
-import { Strategy as GitHubStrategy } from "passport-github2";
-import { Strategy as MicrosoftStrategy } from "passport-microsoft";
-import { Strategy as FacebookStrategy } from "passport-facebook";
-import { AuthSocketSchema, getKeys, isDefined, isEmpty } from "prostgles-types";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo } from "./AuthHandler";
 import type e from "express";
 import { RequestHandler } from "express";
-import { removeExpressRouteByName } from "../FileManager/FileManager";
+import { Strategy as FacebookStrategy } from "passport-facebook";
+import { Strategy as GitHubStrategy } from "passport-github2";
+import { Strategy as GoogleStrategy } from "passport-google-oauth20";
+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 { setEmailProvider } from "./setEmailProvider";
+/** For some reason normal import is undefined */
+const passport = require("passport") as typeof import("passport");
 
 export const upsertNamedExpressMiddleware = (app: e.Express, handler: RequestHandler, name: string) => {
   const funcName = name;
@@ -22,56 +22,36 @@ export const upsertNamedExpressMiddleware = (app: e.Express, handler: RequestHan
 
 export function setAuthProviders (this: AuthHandler, { registrations, app }: Required<Auth>["expressConfig"]) {
   if(!registrations) return;
-  const { email, onRegister, onProviderLoginFail, onProviderLoginStart, websiteUrl, ...providers } = registrations;
-  if(email){
-    app.post(AUTH_ROUTES_AND_PARAMS.emailSignup, async (req, res) => {
-      const { username, password } = req.body;
-      if(typeof username !== "string" || typeof password !== "string"){
-        res.status(400).json({ msg: "Invalid username or password" });
-        return;
-      }
-      await onRegister({ provider: "email", profile: { username, password }});
-    })
-  }
+  const { onRegister, onProviderLoginFail, onProviderLoginStart, websiteUrl, OAuthProviders } = registrations;
+
+  setEmailProvider.bind(this)(app);
 
-  if(!isEmpty(providers)){
-    upsertNamedExpressMiddleware(app, passport.initialize(), "prostglesPassportMiddleware");
+  if(!OAuthProviders || isEmpty(OAuthProviders)){
+    return;
   }
 
-  ([
-    providers.google && {
-      providerName: "google"  as const,
-      config: providers.google,
-      strategy: GoogleStrategy,
-    }, 
-    providers.github && {
-      providerName: "github"  as const,
-      config: providers.github,
-      strategy: GitHubStrategy,
-    },
-    providers.facebook && {
-      providerName: "facebook"  as const,
-      config: providers.facebook,
-      strategy: FacebookStrategy,
-    },
-    providers.microsoft && {
-      providerName: "microsoft"  as const,
-      config: providers.microsoft,
-      strategy: MicrosoftStrategy,
+  upsertNamedExpressMiddleware(app, passport.initialize(), "prostglesPassportMiddleware");
+
+  getObjectEntries(OAuthProviders).forEach(([providerName, providerConfig]) => {
+
+    if(!providerConfig?.clientID){
+      return;
     }
-  ])
-  .filter(isDefined)
-  .forEach(({
-    config: { authOpts, ...config },
-    strategy,
-    providerName,
-  }) => {
+
+    const { authOpts, ...config } = providerConfig;
+    
+    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)(
         {
-          ...config as any,
+          ...config,
           callbackURL: `${websiteUrl}${callbackPath}`,
         },
         async (accessToken, refreshToken, profile, done) => {
@@ -92,8 +72,9 @@ export function setAuthProviders (this: AuthHandler, { registrations, app }: Req
         try {
           const clientInfo = getLoginClientInfo({ httpReq: req });
           const db = this.db;
-          const dbo = this.dbo as any
-          const startCheck = await onProviderLoginStart({ provider: providerName, req, res, clientInfo, db, dbo });
+          const dbo = this.dbo as any;
+          const args = { provider: providerName, req, res, clientInfo, db, dbo };
+          const startCheck = await onProviderLoginStart(args);
           if("error" in startCheck){
             res.status(500).json({ error: startCheck.error });
             return;
@@ -107,7 +88,7 @@ export function setAuthProviders (this: AuthHandler, { registrations, app }: Req
             },
             async (error: any, _profile: any, authInfo: any) => {
               if(error){
-                await onProviderLoginFail({ provider: providerName, error, req, res, clientInfo, db, dbo });
+                await onProviderLoginFail({ ...args, error });
                 res.status(500).json({
                   error: "Failed to login with provider",
                 });
@@ -120,7 +101,7 @@ export function setAuthProviders (this: AuthHandler, { registrations, app }: Req
             } 
           )(req, res);
 
-        } catch (e) {
+        } catch (_e) {
           res.status(500).json({ error: "Something went wrong" });
         }
       }
@@ -132,16 +113,12 @@ export function setAuthProviders (this: AuthHandler, { registrations, app }: Req
 export function getProviders(this: AuthHandler): AuthSocketSchema["providers"] | undefined {
   const { registrations } = this.opts?.expressConfig ?? {}
   if(!registrations) return undefined;
-  const { 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    email, websiteUrl, onRegister, onProviderLoginFail, onProviderLoginStart,
-    ...providers 
-  } = registrations;
-  if(isEmpty(providers)) return undefined;
+  const {  OAuthProviders } = registrations;
+  if(!OAuthProviders || isEmpty(OAuthProviders)) return undefined;
  
   const result: AuthSocketSchema["providers"] = {}
-  getKeys(providers).forEach(providerName => {
-    if(providers[providerName]?.clientID){
+  getObjectEntries(OAuthProviders).forEach(([providerName, config]) => {
+    if(config?.clientID){
       result[providerName] = {
         url: `${AUTH_ROUTES_AND_PARAMS.loginWithProvider}/${providerName}`,
       }

package/lib/Auth/setEmailProvider.ts

@@ -0,0 +1,63 @@
+import e from "express";
+import { AUTH_ROUTES_AND_PARAMS, AuthHandler } from "./AuthHandler";
+import { Email, SMTPConfig } from "./AuthTypes";
+import { sendEmail } from "./sendEmail";
+
+export function setEmailProvider(this: AuthHandler, app: e.Express) {
+  
+  const { email, websiteUrl } = this.opts?.expressConfig?.registrations ?? {};
+  if(!email) return;
+
+  app.post(AUTH_ROUTES_AND_PARAMS.emailSignup, async (req, res) => {
+    const { username, password } = req.body;
+    let validationError = "";
+    if(typeof username !== "string"){
+      validationError = "Invalid username";
+    }
+    if(email.signupType === "withPassword"){
+      const { minPasswordLength = 8 } = email;
+      if(typeof password !== "string"){
+        validationError = "Invalid password";
+      } else if(password.length < minPasswordLength){
+        validationError = `Password must be at least ${minPasswordLength} characters long`;
+      }
+    }
+    if(validationError){
+      res.status(400).json({ error: validationError });
+      return;
+    }
+    try {
+      let emailMessage: undefined | { message: Email; smtp: SMTPConfig };
+      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}` });
+          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 };
+      }
+
+      if(emailMessage){
+        await sendEmail(emailMessage.smtp, emailMessage.message);
+        res.json({ msg: "Email sent" });
+      }
+    } catch {
+      res.status(500).json({ 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({ confirmationUrlPath: id });
+        res.json({ msg: "Email confirmed" });
+      } catch (_e) {
+        res.status(500).json({ error: "Failed to confirm email" });
+      }
+    });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.155",
+  "version": "4.2.157",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,9 +35,17 @@
   ],
   "homepage": "https://prostgles.com",
   "dependencies": {
+    "@aws-sdk/client-ses": "^3.699.0",
+    "@aws-sdk/credential-provider-node": "^3.699.0",
+    "@types/passport": "^1.0.17",
+    "@types/passport-facebook": "^3.0.3",
+    "@types/passport-github2": "^1.2.9",
+    "@types/passport-google-oauth20": "^2.0.16",
+    "@types/passport-microsoft": "^1.0.3",
     "body-parser": "^1.20.3",
     "check-disk-space": "^3.4.0",
     "file-type": "^18.5.0",
+    "nodemailer": "^6.9.16",
     "passport": "^0.7.0",
     "passport-facebook": "^3.0.0",
     "passport-github2": "^0.1.12",
@@ -46,17 +54,13 @@
     "pg": "^8.11.5",
     "pg-cursor": "^2.11.0",
     "pg-promise": "^11.9.1",
-    "prostgles-types": "^4.0.105"
+    "prostgles-types": "^4.0.107"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/json-schema": "^7.0.15",
     "@types/node": "^22.8.1",
-    "@types/passport": "^1.0.17",
-    "@types/passport-facebook": "^3.0.3",
-    "@types/passport-github2": "^1.2.9",
-    "@types/passport-google-oauth20": "^2.0.16",
-    "@types/passport-microsoft": "^1.0.3",
+    "@types/nodemailer": "^6.4.17",
     "@types/pg": "^8.11.5",
     "@types/pg-cursor": "^2.7.2",
     "@types/sharp": "^0.30.4",