Dev

.eslintrc

@@ -144,6 +144,14 @@
         "modifiers": [
           "requiresQuotes"
         ]
+      },
+      {
+        "selector": "objectLiteralProperty",
+        "filter": {
+          "regex": "^_id$",
+          "match": true
+        },
+        "format": null
       }
     ]
   }

serverless.ts

@@ -17,6 +17,9 @@ import updateBuyIns from '@functions/update-buy-ins';
 import getBuyIns from '@functions/get-buy-ins';
 import notifyByEmail from '@functions/notify-by-email';
 import verifyEmail from '@functions/verify-email';
+import deleteUser from '@functions/delete';
+import userExists from '@functions/user-exists';
+import interestForm from '@functions/interest-form';
 
 import * as path from 'path';
 import * as dotenv from 'dotenv';
@@ -60,6 +63,9 @@ const serverlessConfiguration: AWS = {
     getBuyIns,
     notifyByEmail,
     verifyEmail,
+    deleteUser,
+    userExists,
+    interestForm,
   },
   package: { individually: true, patterns: ['!.env*', '.env.vault'] },
   custom: {

src/config.ts

@@ -1,2 +1,2 @@
-export const registrationStart = '01/01/25';
-export const registrationEnd = '02/03/25';
+export const registrationStart = '1/01/25';
+export const registrationEnd = '10/06/25';

src/functions/create/handler.ts

@@ -7,6 +7,8 @@ import schema from './schema';
 import { MongoDB } from '../../util';
 import * as config from '../../config';
 
+import { validateEmail } from '../../helper';
+
 import * as path from 'path';
 import * as dotenv from 'dotenv';
 dotenv.config({ path: path.resolve(process.cwd(), '.env') });
@@ -25,6 +27,15 @@ const create: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event)
   }
 
   const uEmail = event.body.email.toLowerCase();
+  if (!validateEmail(uEmail)) {
+    return {
+      statusCode: 403,
+      body: JSON.stringify({
+        statusCode: 403,
+        message: 'Improper Email format',
+      }),
+    };
+  }
   let password = event.body.password;
 
   try {

src/functions/delete/handler.ts

@@ -0,0 +1,79 @@
+import type { ValidatedEventAPIGatewayProxyEvent } from '@libs/api-gateway';
+import { middyfy } from '@libs/lambda';
+import schema from './schema';
+import { MongoDB, validateToken, ensureRoles, UserDoc } from '../../util';
+import * as path from 'path';
+import * as dotenv from 'dotenv';
+
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+
+const deleteUser: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event) => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { auth_email, auth_token, user_email } = event.body;
+
+    // 1. Validate auth token
+    const tokenValid = validateToken(auth_token, process.env.JWT_SECRET, auth_email);
+    if (!tokenValid) {
+      return {
+        statusCode: 401,
+        body: JSON.stringify({ statusCode: 401, message: 'Unauthorized' }),
+      };
+    }
+
+    // 2. Connect to MongoDB
+    const db = MongoDB.getInstance(process.env.MONGO_URI);
+    await db.connect();
+    const users = db.getCollection<UserDoc>('users');
+
+    // 3. Check target user exists
+    const target = await users.findOne({ email: user_email });
+    if (!target) {
+      return {
+        statusCode: 404,
+        body: JSON.stringify({ statusCode: 404, message: 'User not found' }),
+      };
+    }
+
+    // 4. Verify auth user exists
+    const authUser = await users.findOne({ email: auth_email });
+    if (!authUser) {
+      return {
+        statusCode: 404,
+        body: JSON.stringify({ statusCode: 404, message: 'Auth user not found' }),
+      };
+    }
+
+    // 5. Ensure auth user role
+    if (!ensureRoles(authUser.role, ['director', 'organizer'])) {
+      return {
+        statusCode: 401,
+        body: JSON.stringify({ statusCode: 401, message: 'Only directors/organizers can call this endpoint.' }),
+      };
+    }
+
+    // 6. Delete the user
+    const result = await users.deleteOne({ email: user_email });
+    if (result.deletedCount !== 1) {
+      // Shouldn't happen since we checked existence
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ statusCode: 500, message: 'Internal server error' }),
+      };
+    }
+
+    // 7. Success
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ statusCode: 200, message: `Deleted ${user_email} successfully` }),
+    };
+  } catch (error) {
+    console.error('Error deleting user:', error);
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ statusCode: 500, message: 'Internal server error' }),
+    };
+  }
+};
+
+export const main = middyfy(deleteUser);

src/functions/delete/index.ts

@@ -0,0 +1,20 @@
+import { handlerPath } from '@libs/handler-resolver';
+import schema from './schema';
+
+export default {
+  handler: `${handlerPath(__dirname)}/handler.main`,
+  events: [
+    {
+      http: {
+        method: 'post',
+        path: 'delete',
+        cors: true,
+        request: {
+          schemas: {
+            'application/json': schema,
+          },
+        },
+      },
+    },
+  ],
+};

src/functions/delete/schema.ts

@@ -0,0 +1,9 @@
+export default {
+  type: 'object',
+  properties: {
+    user_email: { type: 'string', format: 'email' },
+    auth_email: { type: 'string', format: 'email' },
+    auth_token: { type: 'string' },
+  },
+  required: ['user_email', 'auth_token', 'auth_email'],
+} as const;

src/functions/index.ts

@@ -15,3 +15,6 @@ export { default as updateBuyIns } from './update-buy-ins';
 export { default as getBuyIns } from './get-buy-ins';
 export { default as notifyByEmail } from './notify-by-email';
 export { default as verifyEmail } from './verify-email';
+export { default as delete } from './delete';
+export { default as userExists } from './user-exists';
+export { default as interestForm } from './interest-form';

src/functions/interest-form/handler.ts

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { ValidatedEventAPIGatewayProxyEvent } from '@libs/api-gateway';
+import { middyfy } from '@libs/lambda';
+import { MongoDB } from '../../util';
+import * as path from 'path';
+import * as dotenv from 'dotenv';
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+
+import schema from './schema';
+
+const submitInterestForm: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event) => {
+  try {
+    // Destructure all the new fields from event.body
+    const {
+      firstName,
+      lastName,
+      age,
+      phoneNumber,
+      email,
+      school,
+      levelOfStudy,
+      countryOfResidence,
+      linkedInUrl,
+      mlh_code_of_conduct,
+      mlh_privacy_policy,
+      mlh_terms_and_conditions,
+    } = event.body;
+
+    // Validate LinkedIn URL format if provided
+    if (linkedInUrl && linkedInUrl.trim() !== '') {
+      const linkedInRegex = /^https?:\/\/(www\.)?linkedin\.com\/in\/[a-zA-Z0-9-]+\/?$/;
+      if (!linkedInRegex.test(linkedInUrl.trim())) {
+        return {
+          statusCode: 422,
+          body: JSON.stringify({
+            statusCode: 422,
+            message: 'Please provide a valid LinkedIn profile URL (e.g., https://linkedin.com/in/yourname)',
+          }),
+        };
+      }
+    }
+
+    // Connect to database
+    const db = MongoDB.getInstance(process.env.MONGO_URI);
+    await db.connect();
+    const interestFormsCollection = db.getCollection('interest-forms'); // Target collection
+
+    // Create the document to insert
+    const docToInsert = {
+      firstName,
+      lastName,
+      age: age,
+      phoneNumber,
+      email,
+      school,
+      levelOfStudy,
+      countryOfResidence,
+      linkedInUrl,
+      mlh_code_of_conduct,
+      mlh_privacy_policy,
+      mlh_terms_and_conditions,
+    };
+
+    const result = await interestFormsCollection.insertOne(docToInsert);
+
+    // Return success
+    return {
+      statusCode: 200,
+      body: JSON.stringify({
+        message: 'Successful Form Submission',
+        submissionId: result.insertedId,
+      }),
+    };
+  } catch (error) {
+    console.error('Error submitting interest form:', error);
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: error.message,
+      }),
+    };
+  }
+};
+
+export const main = middyfy(submitInterestForm);

src/functions/interest-form/index.ts

@@ -0,0 +1,20 @@
+import { handlerPath } from '@libs/handler-resolver';
+import schema from './schema';
+
+export default {
+  handler: `${handlerPath(__dirname)}/handler.main`,
+  events: [
+    {
+      http: {
+        method: 'post',
+        path: 'interest-form',
+        cors: true,
+        request: {
+          schemas: {
+            'application/json': schema,
+          },
+        },
+      },
+    },
+  ],
+};

src/functions/interest-form/schema.ts

@@ -0,0 +1,30 @@
+export default {
+  type: 'object',
+  properties: {
+    firstName: { type: 'string' },
+    lastName: { type: 'string' },
+    age: { type: 'number' },
+    phoneNumber: { type: 'string' },
+    email: { type: 'string', format: 'email' },
+    school: { type: 'string' },
+    levelOfStudy: { type: 'string' },
+    countryOfResidence: { type: 'string' },
+    linkedInUrl: { type: 'string' },
+    mlh_code_of_conduct: { type: 'boolean' },
+    mlh_privacy_policy: { type: 'boolean' },
+    mlh_terms_and_conditions: { type: 'boolean' },
+  },
+  required: [
+    'firstName',
+    'lastName',
+    'age',
+    'phoneNumber',
+    'email',
+    'school',
+    'levelOfStudy',
+    'countryOfResidence',
+    'mlh_code_of_conduct',
+    'mlh_privacy_policy',
+    'mlh_terms_and_conditions',
+  ],
+} as const;

src/functions/read/handler.ts

@@ -50,7 +50,13 @@ const read: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event) =>
     }
 
     const lookupEmail = event.body.email.toLowerCase();
-    if (!authUser.role['director'] && !authUser.role['organizer'] && authUser.email !== lookupEmail) {
+
+    // Ensures user can only look up their own information
+    if (
+      !authUser.role['director'] &&
+      !authUser.role['organizer'] &&
+      (authUser.email !== lookupEmail || event.body.all)
+    ) {
       return {
         statusCode: 403,
         body: JSON.stringify({
@@ -62,22 +68,41 @@ const read: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event) =>
 
     // Find the user
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    const lookUpUser = await users.findOne({ email: lookupEmail }, { projection: { password: 0, _id: 0 } }); // exclude password and id
-    if (!lookUpUser) {
+    if (!event.body.all) {
+      const lookUpUser = await users.findOne({ email: lookupEmail }, { projection: { password: 0, _id: 0 } }); // exclude password and id
+      if (!lookUpUser) {
+        return {
+          statusCode: 404,
+          body: JSON.stringify({
+            statusCode: 404,
+            message: 'Look-up user not found.',
+          }),
+        };
+      }
+
+      // Return user data
       return {
-        statusCode: 404,
-        body: JSON.stringify({
+        statusCode: 200,
+        body: JSON.stringify(lookUpUser),
+      };
+    } else {
+      const lookUpAllUsers = await users.find({}, { projection: { password: 0, _id: 0 } }).toArray(); // exclude password and id
+      if (!lookUpAllUsers) {
+        return {
           statusCode: 404,
-          message: 'Look-up user not found.',
-        }),
+          body: JSON.stringify({
+            statusCode: 404,
+            message: 'Look-up all users not found.',
+          }),
+        };
+      }
+
+      // Return user data
+      return {
+        statusCode: 200,
+        body: JSON.stringify(lookUpAllUsers),
       };
     }
-
-    // Return user data
-    return {
-      statusCode: 200,
-      body: JSON.stringify(lookUpUser),
-    };
   } catch (error) {
     console.error('Error reading user:', error);
     return {

src/functions/read/schema.ts

@@ -4,6 +4,7 @@ export default {
     auth_email: { type: 'string', format: 'email' },
     auth_token: { type: 'string' },
     email: { type: 'string', format: 'email' },
+    all: { type: 'boolean', default: false },
   },
   required: ['auth_email', 'auth_token', 'email'],
 } as const;