emails infra + welcome email + function: delete user

Author: moshfeu

netlify.toml

@@ -4,6 +4,7 @@
 
 [functions]
   directory = "netlify/functions-src/functions"
+  included_files = ["netlify/functions-src/functions/email/templates/**.html"]
 
 [dev]
   command = "yarn start"

netlify/functions-src/email/interfaces/email.interface.ts

@@ -0,0 +1,48 @@
+import Config from '../config';
+
+const auth0Domain = Config.auth0.backend.DOMAIN;
+
+const getAdminAccessToken = async (): Promise<string> => {
+  try {
+
+    const response = await fetch(`https://${auth0Domain}/oauth/token`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        client_id: Config.auth0.backend.CLIENT_ID,
+        client_secret: Config.auth0.backend.CLIENT_SECRET,
+        audience: Config.auth0.backend.AUDIENCE,
+        grant_type: 'client_credentials',
+      }),
+    });
+    const data = await response.json();
+    return data.access_token;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Error fetching admin access token:', error);
+    throw new Error('Failed to fetch access token');
+  }
+};
+
+
+export const deleteUser = async (userId: string): Promise<void> => {
+  const accessToken = await getAdminAccessToken();
+  if (!accessToken) {
+    throw new Error('Failed to get access token');
+  }
+
+  const response = await fetch(`https://${auth0Domain}/api/v2/users/${userId}`, {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to delete user: ${response.statusText}`);
+  }
+
+  return response.json();
+}

netlify/functions-src/functions/admin/delete.ts

@@ -14,6 +14,8 @@ export interface User {
   };
   channels?: any[];
   createdAt: Date;
+  spokenLanguages?: string[];
+  tags?: string[];
 }
 
 export enum Role {

netlify/functions-src/functions/common/interfaces/user.interface.ts

@@ -3,6 +3,7 @@ import type { User } from '../common/interfaces/user.interface';
 import { getCollection } from '../utils/db';
 import { upsertEntity } from './utils';
 import { DataError } from './errors';
+import type { EntityPayload } from './types';
 
 const getUserWithoutChannels = async (id: string): Promise<User> => {
   const user = await getCollection<User>('users').findOne({ _id: new ObjectId(id) });
@@ -98,7 +99,15 @@ export const getUserByAuthId = async (auth0Id: string) => {
   return user;
 }
 
-export const upsertUser = async (user: User) => {
+export const upsertUser = async (user: EntityPayload<User>) => {
   const upsertedUser = await upsertEntity<User>('users', user);
   return upsertedUser;
 }
+
+export const deleteUser = async (id: ObjectId) => {
+  const result = await getCollection<User>('users').deleteOne({ _id: id });
+  if (result.deletedCount === 0) {
+    throw new DataError(404, 'User not found');
+  }
+  return result.acknowledged;
+}

netlify/functions-src/functions/data/users.ts

@@ -0,0 +1,29 @@
+import type { Handler } from '@netlify/functions';
+import { send } from './email/client';
+
+export const handler: Handler = async (event) => {
+  const { to, subject } = event.queryStringParameters || {};
+
+  if (!to || !subject) {
+    return {
+      statusCode: 400,
+      body: JSON.stringify({ error: 'Missing required fields' }),
+    };
+  }
+
+  try {
+    await send({ to, subject, name: 'welcome', data: { name: 'John Doe' } });
+
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'Email sent successfully' }),
+    };
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Error sending email:', error);
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ error: 'Failed to send email' }),
+    };
+  }
+}

netlify/functions-src/functions/email.ts

@@ -0,0 +1,45 @@
+import { promises } from 'fs';
+import path from 'path';
+import { compile } from 'ejs';
+import type { EmailParams } from './interfaces/email.interface';
+import { sendEmail } from './sendgrid';
+
+export const send = async (params: EmailParams) => {
+  const { to, subject, data = {}, name } = params;
+
+  const content = await injectData(name, data);
+  try {
+    return sendEmail({
+      to: to as string,
+      subject,
+      html: content,
+    });
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Send email error', params, JSON.stringify(error, null, 2));
+    throw new Error('Failed to send email');
+  }
+}
+
+const injectData = async (name: string, data: Record<string, string>) => {
+  const template = await getTemplateContent(name);
+  const layout = await getLayout();
+  const content = compile(template)(data);
+  return compile(layout)({ content });
+}
+
+const getLayout = async () => {
+  return getTemplateContent('layout');
+}
+
+const getTemplateContent = (name: string) => {
+  const templatesDir = path.resolve(__dirname, 'email/templates');
+  const templatePath = `${templatesDir}/${name}.html`;
+  return promises.readFile(templatePath, {
+    encoding: 'utf8',
+  }).catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error('Error reading template file:', error);
+    throw new Error(`Template file not found: ${templatePath}`);
+  });
+}

netlify/functions-src/functions/email/client.ts

@@ -0,0 +1,145 @@
+import type { MailData } from '@sendgrid/helpers/classes/mail';
+import type { User } from '../../common/interfaces/user.interface';
+
+interface WelcomePayload {
+  name: 'welcome';
+  data: {
+    name: string;
+  };
+}
+
+interface MentorshipAccepted {
+  name: 'mentorship-accepted';
+  data: {
+    menteeName: string;
+    mentorName: string;
+    contactURL: string;
+    openRequests: number;
+  };
+}
+
+interface MentorshipCancelled {
+  name: 'mentorship-cancelled';
+  data: {
+    mentorName: string;
+    menteeName: string;
+    reason: string;
+  };
+}
+
+interface MentorshipDeclined {
+  name: 'mentorship-declined';
+  data: {
+    menteeName: string;
+    mentorName: string;
+    reason: string;
+    bySystem: boolean;
+  };
+}
+
+interface MentorshipRequested {
+  name: 'mentorship-requested';
+  data: {
+    menteeName: string;
+    menteeEmail: string;
+    mentorName: string;
+    message: string;
+    background: string;
+    expectation: string;
+  };
+}
+
+interface MentorshipReminder {
+  name: 'mentorship-reminder';
+  data: {
+    menteeName: string;
+    mentorName: string;
+    message: string;
+  };
+}
+
+interface MentorApplicationReceived {
+  name: 'mentor-application-received';
+  data: {
+    name: string;
+  };
+}
+
+interface MentorApplicationDeclined {
+  name: 'mentor-application-declined';
+  data: {
+    name: string;
+    reason: string;
+  };
+}
+
+interface MentorApplicationApproved {
+  name: 'mentor-application-approved';
+  data: {
+    name: string;
+  };
+}
+
+interface MentorNotActive {
+  name: 'mentor-not-active';
+  data: {
+    mentorName: string;
+    numOfMentorshipRequests: number;
+  };
+}
+
+interface MentorFreeze {
+  name: 'mentor-freeze';
+  data: {
+    mentorName: string;
+  };
+}
+
+export type EmailParams = Required<Pick<MailData, 'to' | 'subject'>> &
+  (
+    | WelcomePayload
+    | MentorshipAccepted
+    | MentorshipCancelled
+    | MentorshipDeclined
+    | MentorshipRequested
+    | MentorshipReminder
+    | MentorApplicationReceived
+    | MentorApplicationDeclined
+    | MentorApplicationApproved
+    | MentorNotActive
+    | MentorFreeze
+  );
+
+/**
+ * Data for SendGrid templates, when an admin rejects a mentor from the platform.
+ */
+export interface SendDataRejectParams {
+  reason: string;
+}
+
+/**
+ * Data for SendGrid templates, when a user request a mentorship.
+ */
+export interface SendDataMentorshipParams {
+  name: string;
+  message: string;
+}
+
+export interface SendDataMentorshipApprovalParams {
+  menteeName: string;
+  mentorName: string;
+  contactURL: string;
+  channels: User['channels'];
+}
+
+export interface SendDataMentorshipRejectionParams {
+  menteeName: string;
+  mentorName: string;
+  reason: string;
+}
+
+export interface SendData {
+  to: string;
+  subject: string;
+  html: string;
+}

netlify/functions-src/functions/email/interfaces/email.interface.ts

@@ -0,0 +1,21 @@
+import sgMail from '@sendgrid/mail';
+import type { SendData } from './interfaces/email.interface';
+import Config from '../config';
+
+sgMail.setApiKey(Config.sendGrid.API_KEY);
+
+export const sendEmail = async (payload: SendData) => {
+  try {
+    const msg = {
+      to: payload.to,
+      from: Config.email.FROM,
+      subject: payload.subject,
+      html: payload.html,
+    };
+
+    return sgMail.send(msg);
+  } catch (error) {
+    console.error('Error sending email:', error);
+    throw new Error('Failed to send email');
+  }
+}

netlify/functions-src/functions/email/sendgrid.ts

@@ -0,0 +1,20 @@
+### Run
+
+```bash
+nodemon --config nodemon-emails.json
+```
+
+### Links
+
+|||
+|--- |--- |
+|Welcome|http://localhost:3003/welcome?data={%22name%22:%22Moshe%22}|
+|Mentorship accepted|http://localhost:3003/mentorship-accepted?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%20%22Brent%22,%22contactURL%22:%20%22https%22,%20%22openRequests%22:%208}|
+|Mentorship declined|http://localhost:3003/mentorship-declined?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%22Brent%22,%22reason%22:%22because%22}|
+|Mentorship declined (by system)|http://localhost:3003/mentorship-declined?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%22Brent%22,%22reason%22:%22because%22,%22bySystem%22:true}|
+|Mentorship cancelled|http://localhost:3003/mentorship-cancelled?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%20%22Brent%22,%22reason%22:%20%22I%27ve%20already%20found%20a%20mentor%22}|
+|Mentorship requested|http://localhost:3003/mentorship-requested?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%22Brent%22,%22message%22:%22because%22,%22background%22:%22here%20is%20my%20background%22,%22expectation%22:%22I'm%20expecting%20for%20the%20best!%22}|
+|Mentorship reminder|http://localhost:3003/mentorship-reminder?data={%22menteeName%22:%22Moshe%22,%22mentorName%22:%22Brent%22,%22message%22:%22because%22}|
+|Mentor application received|http://localhost:3003/mentor-application-received?data={%22name%22:%22Brent%22}|
+|Mentorship application denied|http://localhost:3003/mentor-application-declined?data={%22name%22:%22Moshe%22,%22reason%22:%22your%20avatar%20is%20not%20you%22}|
+|Mentorship application approved|http://localhost:3003/mentor-application-approved?data={%22name%22:%22Moshe%22}|