@adminforth/open-signup 1.0.2 → 1.0.4

package/dist/index.js

@@ -8,7 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import AdminForth, { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes } from "adminforth";
-import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
 export default class OpenSignupPlugin extends AdminForthPlugin {
     constructor(options) {
         super(options, import.meta.url);
@@ -23,9 +22,15 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
             if (!this.options.emailField) {
                 throw new Error(`emailField is required and should be a name of field in auth resource`);
             }
+            // find field with name resourceConfig.emailField in adminforth.auth.usersResourceId and show error if it doesn't exist
+            const authResource = adminforth.config.resources.find(r => r.resourceId === adminforth.config.auth.usersResourceId);
+            if (!authResource) {
+                throw new Error(`Resource with id config.auth.usersResourceId=${adminforth.config.auth.usersResourceId} not found`);
+            }
+            this.authResource = authResource;
             if (this.options.confirmEmails) {
-                if (!this.options.confirmEmails.emailProvider) {
-                    throw new Error(`confirmEmails.emailProvider is required and should be a name of field in auth resource`);
+                if (!this.options.confirmEmails.adapter) {
+                    throw new Error(`confirmEmails.adapter is required and should be a name of field in auth resource`);
                 }
                 if (!this.options.confirmEmails.emailConfirmedField) {
                     throw new Error(`confirmEmails.emailConfirmedField is required and should be a name of field in auth resource`);
@@ -38,16 +43,7 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
         `);
                 }
                 this.emailConfirmedField = emailConfirmedField;
-                if (this.emailConfirmedField.type !== AdminForthDataTypes.BOOLEAN) {
-                    throw new Error(`Field ${this.emailConfirmedField.name} must be of type boolean`);
-                }
             }
-            // find field with name resourceConfig.emailField in adminforth.auth.usersResourceId and show error if it doesn't exist
-            const authResource = adminforth.config.resources.find(r => r.resourceId === adminforth.config.auth.usersResourceId);
-            if (!authResource) {
-                throw new Error(`Resource with id config.auth.usersResourceId=${adminforth.config.auth.usersResourceId} not found`);
-            }
-            this.authResource = authResource;
             const emailField = authResource.columns.find(f => f.name === this.options.emailField);
             if (!emailField) {
                 const similar = suggestIfTypo(authResource.columns.map(f => f.name), this.options.emailField);
@@ -81,7 +77,8 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                             minLength: passwordField.minLength,
                             maxLength: passwordField.maxLength,
                             validation: passwordField.validation
-                        }
+                        },
+                        requestEmailConfirmation: !!this.options.confirmEmails
                     }
                 }
             });
@@ -90,24 +87,23 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                 if (!adminforth.config.auth.beforeLoginConfirmation) {
                     adminforth.config.auth.beforeLoginConfirmation = [];
                 }
-                // unshift because if e.g. 2fa set it's hook, this one should be first
-                adminforth.config.auth.beforeLoginConfirmation.unshift((_a) => __awaiter(this, [_a], void 0, function* ({ adminUser }) {
-                    if (!adminUser.dbUser[this.emailConfirmedField.name]) {
-                        return { body: { allowedLogin: false }, error: 'You need to confirm your email to be able to login' };
-                    }
-                }));
             }
         });
     }
     validateConfigAfterDiscover(adminforth, resourceConfig) {
-        // optional method where you can safely check field types after database discovery was performed
+        if (this.options.confirmEmails) {
+            const emailConfirmedColumn = this.resourceConfig.columns.find(f => f.name === this.options.confirmEmails.emailConfirmedField);
+            if (emailConfirmedColumn.type !== AdminForthDataTypes.BOOLEAN) {
+                throw new Error(`Field ${this.emailConfirmedField.name} must be of type boolean`);
+            }
+        }
     }
     instanceUniqueRepresentation(pluginOptions) {
         // optional method to return unique string representation of plugin instance. 
         // Needed if plugin can have multiple instances on one resource 
         return `single`;
     }
-    doLogin(email, response) {
+    doLogin(email, response, extra) {
         return __awaiter(this, void 0, void 0, function* () {
             const username = email;
             const userRecord = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
@@ -117,7 +113,7 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                 username,
             };
             const toReturn = { allowedLogin: true, error: '' };
-            yield this.adminforth.restApi.processLoginCallbacks(adminUser, toReturn, response);
+            yield this.adminforth.restApi.processLoginCallbacks(adminUser, toReturn, response, extra);
             if (toReturn.allowedLogin) {
                 this.adminforth.auth.setAuthCookie({
                     response,
@@ -131,84 +127,79 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
     setupEndpoints(server) {
         server.endpoint({
             method: 'POST',
-            path: `/plugin/${this.pluginInstanceId}/completeVerifiedSignup`,
+            path: `/plugin/${this.pluginInstanceId}/complete-verified-signup`,
             noAuth: true,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response }) {
-                const { token } = body;
-                const { email } = yield this.adminforth.auth.verify(token, 'tempVerifyEmailToken');
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response, headers, query, cookies }) {
+                const { token, password } = body;
+                const { email } = yield this.adminforth.auth.verify(token, 'tempVerifyEmailToken', false);
                 if (!email) {
                     return { error: 'Invalid token', ok: false };
                 }
+                if (!password) {
+                    return { error: 'Password is required', ok: false };
+                }
                 const userRecord = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
                 if (!userRecord) {
                     return { error: 'User not found', ok: false };
                 }
+                if (userRecord[this.options.confirmEmails.emailConfirmedField]) {
+                    return { error: 'Email already confirmed', ok: false };
+                }
                 yield this.adminforth.resource(this.authResource.resourceId).update(userRecord[this.authResource.columns.find((col) => col.primaryKey).name], {
-                    [this.options.confirmEmails.emailConfirmedField]: true
+                    [this.options.confirmEmails.emailConfirmedField]: true,
+                    [this.options.passwordHashField]: yield AdminForth.Utils.generatePasswordHash(password),
                 });
-                return yield this.doLogin(email, response);
+                return yield this.doLogin(email, response, { body, headers, query, cookies });
             })
         });
         server.endpoint({
             method: 'POST',
             path: `/plugin/${this.pluginInstanceId}/signup`,
             noAuth: true,
-            handler: (_b) => __awaiter(this, [_b], void 0, function* ({ body, response }) {
+            handler: (_b) => __awaiter(this, [_b], void 0, function* ({ body, response, headers, query, cookies }) {
                 const { email, url, password } = body;
                 // validate email
                 if (this.emailField.validation) {
                     for (const { regExp, message } of this.emailField.validation) {
-                        if (!new RegExp(regExp).test(password)) {
+                        if (!new RegExp(regExp).test(email)) {
                             return { error: message, ok: false };
                         }
                     }
                 }
                 // validate password
-                if (password.length < this.passwordField.minLength) {
-                    return { error: `Password must be at least ${this.passwordField.minLength} characters long`, ok: false };
-                }
-                if (password.length > this.passwordField.maxLength) {
-                    return { error: `Password must be at most ${this.passwordField.maxLength} characters long`, ok: false };
-                }
-                if (this.passwordField.validation) {
-                    for (const { regExp, message } of this.passwordField.validation) {
-                        if (!new RegExp(regExp).test(password)) {
-                            return { error: message, ok: false };
+                if (!this.options.confirmEmails) {
+                    if (password.length < this.passwordField.minLength) {
+                        return { error: `Password must be at least ${this.passwordField.minLength} characters long`, ok: false };
+                    }
+                    if (password.length > this.passwordField.maxLength) {
+                        return { error: `Password must be at most ${this.passwordField.maxLength} characters long`, ok: false };
+                    }
+                    if (this.passwordField.validation) {
+                        for (const { regExp, message } of this.passwordField.validation) {
+                            if (!new RegExp(regExp).test(password)) {
+                                return { error: message, ok: false };
+                            }
                         }
                     }
                 }
                 // first check again if email already exists
-                const existing = yield this.adminforth.resource(this.authResource.resourceId).count(Filters.EQ(this.emailField.name, email));
-                if (existing > 0) {
+                const existingUser = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
+                if ((!this.options.confirmEmails && existingUser) || (this.options.confirmEmails && (existingUser === null || existingUser === void 0 ? void 0 : existingUser[this.emailConfirmedField.name]))) {
                     return { error: 'Email already exists', ok: false };
                 }
                 // create user
-                const created = yield this.adminforth.resource(this.authResource.resourceId).create(Object.assign(Object.assign(Object.assign({}, (this.options.defaultFieldValues || {})), (this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {})), { [this.emailField.name]: email, [this.options.passwordHashField]: yield AdminForth.Utils.generatePasswordHash(password) }));
+                if (!existingUser) {
+                    const created = yield this.adminforth.resource(this.authResource.resourceId).create(Object.assign(Object.assign(Object.assign({}, (this.options.defaultFieldValues || {})), (this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {})), { [this.emailField.name]: email, [this.options.passwordHashField]: password ? yield AdminForth.Utils.generatePasswordHash(password) : '' }));
+                }
                 if (!this.options.confirmEmails) {
-                    const resp = yield this.doLogin(email, response);
+                    const resp = yield this.doLogin(email, response, { body, headers, query, cookies });
                     return resp;
                 }
                 // send confirmation email
                 const brandName = this.adminforth.config.customization.brandName;
                 const verifyToken = this.adminforth.auth.issueJWT({ email, issuer: brandName }, 'tempVerifyEmailToken', '2h');
-                // send email with AWS SES this.options.providerOptions.AWS_SES
-                const ses = new SESClient({
-                    region: this.options.confirmEmails.providerOptions.AWS_SES.region,
-                    credentials: {
-                        accessKeyId: this.options.confirmEmails.providerOptions.AWS_SES.accessKeyId,
-                        secretAccessKey: this.options.confirmEmails.providerOptions.AWS_SES.secretAccessKey
-                    }
-                });
                 process.env.HEAVY_DEBUG && console.log('🐛Sending reset tok to', verifyToken);
-                const emailCommand = new SendEmailCommand({
-                    Destination: {
-                        ToAddresses: [email]
-                    },
-                    Message: {
-                        Body: {
-                            Text: {
-                                Charset: "UTF-8",
-                                Data: `
+                const emailText = `
                   Dear user,
                   Welcome to ${brandName}! 
                   
@@ -222,11 +213,8 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                   Thanks,
                   The ${brandName} Team
                                     
-                `
-                            },
-                            Html: {
-                                Charset: "UTF-8",
-                                Data: `
+                `;
+                const emailHtml = `
                 <html>
                   <head></head>
                   <body>
@@ -242,26 +230,10 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                 </html>
 
 
-                `
-                            }
-                        },
-                        Subject: {
-                            Charset: "UTF-8",
-                            Data: `Signup request at ${brandName}`
-                        }
-                    },
-                    Source: `${this.options.confirmEmails.sendFrom}`
-                });
-                try {
-                    const sRes = yield ses.send(emailCommand);
-                }
-                catch (e) {
-                    console.error('Error sending email', e);
-                    if (process.env.NODE_ENV === 'development') {
-                        return { error: 'Some thing went wrong, please check the console', ok: false };
-                    }
-                    return { error: 'Something went wrong, please contact support', ok: false };
-                }
+                `;
+                const emailSubject = `Signup request at ${brandName}`;
+                // send email with AWS SES this.options.providerOptions.AWS_SES
+                this.options.confirmEmails.adapter.sendEmail(this.options.confirmEmails.sendFrom, email, emailText, emailHtml, emailSubject);
                 return { ok: true };
             })
         });

package/index.ts

@@ -1,7 +1,6 @@
 import AdminForth, { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes } from "adminforth";
-import type { IAdminForth, IHttpServer, AdminForthComponentDeclaration, AdminForthResourceColumn, AdminForthResource, BeforeLoginConfirmationFunction } from "adminforth";
+import type { IAdminForth, IHttpServer, AdminForthComponentDeclaration, AdminForthResourceColumn, AdminForthResource, BeforeLoginConfirmationFunction, HttpExtra } from "adminforth";
 import type { PluginOptions } from './types.js';
-import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
 
 
 export default class OpenSignupPlugin extends AdminForthPlugin {
@@ -25,9 +24,16 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
       throw new Error(`emailField is required and should be a name of field in auth resource`);
     }
 
+    // find field with name resourceConfig.emailField in adminforth.auth.usersResourceId and show error if it doesn't exist
+    const authResource = adminforth.config.resources.find(r => r.resourceId === adminforth.config.auth.usersResourceId);
+    if (!authResource) {
+      throw new Error(`Resource with id config.auth.usersResourceId=${adminforth.config.auth.usersResourceId} not found`);
+    }
+    this.authResource = authResource;
+
     if (this.options.confirmEmails) {
-      if (!this.options.confirmEmails.emailProvider) {
-        throw new Error(`confirmEmails.emailProvider is required and should be a name of field in auth resource`);
+      if (!this.options.confirmEmails.adapter) {
+        throw new Error(`confirmEmails.adapter is required and should be a name of field in auth resource`);
       }
       if (!this.options.confirmEmails.emailConfirmedField) {
         throw new Error(`confirmEmails.emailConfirmedField is required and should be a name of field in auth resource`);
@@ -40,18 +46,8 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
         `);
       }
       this.emailConfirmedField = emailConfirmedField;
-      if (this.emailConfirmedField.type !== AdminForthDataTypes.BOOLEAN) {
-        throw new Error(`Field ${this.emailConfirmedField.name} must be of type boolean`);
-      }
     }
 
-    // find field with name resourceConfig.emailField in adminforth.auth.usersResourceId and show error if it doesn't exist
-    const authResource = adminforth.config.resources.find(r => r.resourceId === adminforth.config.auth.usersResourceId);
-    if (!authResource) {
-      throw new Error(`Resource with id config.auth.usersResourceId=${adminforth.config.auth.usersResourceId} not found`);
-    }
-    this.authResource = authResource;
-
     const emailField = authResource.columns.find(f => f.name === this.options.emailField);
     if (!emailField) {
       const similar = suggestIfTypo(authResource.columns.map(f => f.name), this.options.emailField);
@@ -89,7 +85,8 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
             minLength: passwordField.minLength,
             maxLength: passwordField.maxLength,
             validation: passwordField.validation
-          }
+          },
+          requestEmailConfirmation: !!this.options.confirmEmails
         }
       }
     });
@@ -99,19 +96,16 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
       if (!adminforth.config.auth.beforeLoginConfirmation) {
         adminforth.config.auth.beforeLoginConfirmation = [];
       }
-      // unshift because if e.g. 2fa set it's hook, this one should be first
-      (adminforth.config.auth.beforeLoginConfirmation as BeforeLoginConfirmationFunction[]).unshift(
-        async ({ adminUser }) => {
-          if (!adminUser.dbUser[this.emailConfirmedField.name]) {
-            return { body: { allowedLogin: false }, error: 'You need to confirm your email to be able to login' };
-          }
-        }
-      );
     }
   }
   
   validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
-    // optional method where you can safely check field types after database discovery was performed
+    if(this.options.confirmEmails){
+      const emailConfirmedColumn = this.resourceConfig.columns.find(f => f.name === this.options.confirmEmails.emailConfirmedField);
+      if (emailConfirmedColumn.type !== AdminForthDataTypes.BOOLEAN) {
+        throw new Error(`Field ${this.emailConfirmedField.name} must be of type boolean`);
+      }
+    }
   }
 
   instanceUniqueRepresentation(pluginOptions: any) : string {
@@ -120,7 +114,7 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
     return `single`;
   }
 
-  async doLogin(email: string, response: any): Promise<{ error?: string; allowedLogin: boolean; redirectTo?: string; }> {
+  async doLogin(email: string, response: any, extra: HttpExtra): Promise<{ error?: string; allowedLogin: boolean; redirectTo?: string; }> {
 
     const username = email;
     const userRecord = await this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
@@ -131,7 +125,7 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
     };
     const toReturn = { allowedLogin: true, error: '' };
 
-    await this.adminforth.restApi.processLoginCallbacks(adminUser, toReturn, response);
+    await this.adminforth.restApi.processLoginCallbacks(adminUser, toReturn, response, extra);
     if (toReturn.allowedLogin) {
       this.adminforth.auth.setAuthCookie({ 
         response, 
@@ -149,22 +143,32 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
   setupEndpoints(server: IHttpServer) {
     server.endpoint({
       method: 'POST',
-      path: `/plugin/${this.pluginInstanceId}/completeVerifiedSignup`,
+      path: `/plugin/${this.pluginInstanceId}/complete-verified-signup`,
       noAuth: true,
-      handler: async ({ body, response }) => {
-        const { token } = body;
-        const { email } = await this.adminforth.auth.verify(token, 'tempVerifyEmailToken');
+      handler: async ({ body, response, headers, query, cookies }) => {
+        const { token, password } = body;
+        const { email } = await this.adminforth.auth.verify(token, 'tempVerifyEmailToken', false);
         if (!email) {
           return { error: 'Invalid token', ok: false };
         }
+
+        if(!password) {
+          return { error: 'Password is required', ok: false };
+        }
         const userRecord = await this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
         if (!userRecord) {
           return { error: 'User not found', ok: false };
         }
+
+        if (userRecord[this.options.confirmEmails.emailConfirmedField]) {
+          return { error: 'Email already confirmed', ok: false };
+        }
+
         await this.adminforth.resource(this.authResource.resourceId).update(userRecord[this.authResource.columns.find((col) => col.primaryKey).name], {
-          [this.options.confirmEmails.emailConfirmedField]: true
+          [this.options.confirmEmails.emailConfirmedField]: true,
+          [this.options.passwordHashField]: await AdminForth.Utils.generatePasswordHash(password),
         });
-        return await this.doLogin(email, response);
+        return await this.doLogin(email, response, { body, headers, query, cookies });
       }
     });
 
@@ -172,49 +176,53 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/signup`,
       noAuth: true,
-      handler: async ({ body, response }) => {
+      handler: async ({ body, response, headers, query, cookies }) => {
         const { email, url, password } = body;
 
         // validate email
         if (this.emailField.validation) {
           for (const { regExp, message } of this.emailField.validation) {
-            if (!new RegExp(regExp).test(password)) {
+            if (!new RegExp(regExp).test(email)) {
               return { error: message, ok: false };
             }
           }
         }
 
         // validate password
-        if (password.length < this.passwordField.minLength) {
-          return { error: `Password must be at least ${this.passwordField.minLength} characters long`, ok: false };
-        }
-        if (password.length > this.passwordField.maxLength) {
-          return { error: `Password must be at most ${this.passwordField.maxLength} characters long`, ok: false };
-        }
-        if (this.passwordField.validation) {
-          for (const { regExp, message } of this.passwordField.validation) {
-            if (!new RegExp(regExp).test(password)) {
-              return { error: message, ok: false };
+        if (!this.options.confirmEmails) {
+          if (password.length < this.passwordField.minLength) {
+            return { error: `Password must be at least ${this.passwordField.minLength} characters long`, ok: false };
+          }
+          if (password.length > this.passwordField.maxLength) {
+            return { error: `Password must be at most ${this.passwordField.maxLength} characters long`, ok: false };
+          }
+          if (this.passwordField.validation) {
+            for (const { regExp, message } of this.passwordField.validation) {
+              if (!new RegExp(regExp).test(password)) {
+                return { error: message, ok: false };
+              }
             }
           }
         }
 
         // first check again if email already exists
-        const existing = await this.adminforth.resource(this.authResource.resourceId).count(Filters.EQ(this.emailField.name, email));
-        if (existing > 0) {
+        const existingUser = await this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
+        if ((!this.options.confirmEmails && existingUser) || (this.options.confirmEmails && existingUser?.[this.emailConfirmedField.name])) {
           return { error: 'Email already exists', ok: false };
         }
 
         // create user
-        const created = await this.adminforth.resource(this.authResource.resourceId).create({
-          ...(this.options.defaultFieldValues || {}),
-          ...(this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {}),  
-          [this.emailField.name]: email,
-          [this.options.passwordHashField]: await AdminForth.Utils.generatePasswordHash(password),
-        });
+        if (!existingUser) {
+          const created = await this.adminforth.resource(this.authResource.resourceId).create({
+            ...(this.options.defaultFieldValues || {}),
+            ...(this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {}),  
+            [this.emailField.name]: email,
+            [this.options.passwordHashField]: password ? await AdminForth.Utils.generatePasswordHash(password) : '',
+          });
+        }
         
         if (!this.options.confirmEmails) {
-          const resp = await this.doLogin(email, response);
+          const resp = await this.doLogin(email, response, { body, headers, query, cookies });
           return resp;
         }
 
@@ -223,27 +231,8 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
         const brandName = this.adminforth.config.customization.brandName;
 
         const verifyToken = this.adminforth.auth.issueJWT({email, issuer: brandName }, 'tempVerifyEmailToken', '2h');
-
-        // send email with AWS SES this.options.providerOptions.AWS_SES
-        const ses = new SESClient({
-          region: this.options.confirmEmails.providerOptions.AWS_SES.region,
-          credentials: {
-            accessKeyId: this.options.confirmEmails.providerOptions.AWS_SES.accessKeyId,
-            secretAccessKey: this.options.confirmEmails.providerOptions.AWS_SES.secretAccessKey
-          }
-        });
-
         process.env.HEAVY_DEBUG && console.log('🐛Sending reset tok to', verifyToken);
-
-        const emailCommand = new SendEmailCommand({
-          Destination: {
-            ToAddresses: [email]
-          },
-          Message: {
-            Body: {
-              Text: {
-                Charset: "UTF-8",
-                Data: `
+        const emailText = `
                   Dear user,
                   Welcome to ${brandName}! 
                   
@@ -257,11 +246,9 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                   Thanks,
                   The ${brandName} Team
                                     
-                `
-              },
-              Html: {
-                Charset: "UTF-8",
-                Data: `
+                `;
+          
+          const emailHtml = `
                 <html>
                   <head></head>
                   <body>
@@ -277,26 +264,11 @@ export default class OpenSignupPlugin extends AdminForthPlugin {
                 </html>
 
 
-                `
-              }
-            },
-            Subject: {
-              Charset: "UTF-8",
-              Data: `Signup request at ${brandName}`
-            }
-          },
-          Source: `${this.options.confirmEmails.sendFrom}`
-        });
+                `;
+          const emailSubject = `Signup request at ${brandName}`;
 
-        try {
-          const sRes = await ses.send(emailCommand);
-        } catch (e) {
-          console.error('Error sending email', e);
-          if (process.env.NODE_ENV === 'development') {
-            return { error: 'Some thing went wrong, please check the console', ok: false };
-          }
-          return { error: 'Something went wrong, please contact support', ok: false };
-        }
+        // send email with AWS SES this.options.providerOptions.AWS_SES
+        this.options.confirmEmails.adapter.sendEmail(this.options.confirmEmails.sendFrom, email, emailText, emailHtml, emailSubject);
 
         return { ok: true };
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/open-signup",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/types.ts

@@ -1,3 +1,5 @@
+import { EmailAdapter } from 'adminforth';
+
 export interface PluginOptions {
 
   /**
@@ -40,11 +42,6 @@ export interface PluginOptions {
      */
     emailConfirmedField: string;
 
-    /**
-     * Required to confirm email
-     */
-    emailProvider: 'AWS_SES' ;
-
     /**
      * From which email to send password reset emails
      * e.g. no-reply@example.com
@@ -53,15 +50,9 @@ export interface PluginOptions {
     sendFrom: string;
 
     /**
-     * Options for email provider
+     * Adapter to send emails
      */
-    providerOptions: {
-      AWS_SES: {
-        region: string;
-        accessKeyId: string;
-        secretAccessKey: string;
-      }
-    }
+    adapter: EmailAdapter;
   }