Merge pull request #129 from HackRU/teams-read

feat: teams read endpoint

Author: avsomers25

serverless.ts

@@ -21,6 +21,7 @@ import deleteUser from '@functions/delete';
 import userExists from '@functions/user-exists';
 import interestForm from '@functions/interest-form';
 import teamsJoin from '@functions/teams/join';
+import teamsRead from '@functions/teams/read';
 
 import * as path from 'path';
 import * as dotenv from 'dotenv';
@@ -68,6 +69,7 @@ const serverlessConfiguration: AWS = {
     userExists,
     interestForm,
     teamsJoin,
+    teamsRead,
   },
   package: { individually: true, patterns: ['!.env*', '.env.vault'] },
   custom: {

src/functions/attend-event/handler.ts

@@ -4,7 +4,8 @@ import { middyfy } from '@libs/lambda';
 
 import schema from './schema';
 
-import { MongoDB, validateToken, ensureRoles, UserDoc } from '../../util';
+import { MongoDB, validateToken, ensureRoles } from '../../util';
+import type { UserDocument } from 'src/types';
 import * as path from 'path';
 import * as dotenv from 'dotenv';
 dotenv.config({ path: path.resolve(process.cwd(), '.env') });
@@ -26,7 +27,7 @@ const attendEvent: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (ev
     // Connect to MongoDB
     const db = MongoDB.getInstance(process.env.MONGO_URI);
     await db.connect();
-    const users = db.getCollection<UserDoc>('users');
+    const users = db.getCollection<UserDocument>('users');
 
     const attendEvent = await users.findOne({ email: event.body.qr });
 

src/functions/delete/handler.ts

@@ -1,7 +1,10 @@
 import type { ValidatedEventAPIGatewayProxyEvent } from '@libs/api-gateway';
 import { middyfy } from '@libs/lambda';
 import schema from './schema';
-import { MongoDB, validateToken, ensureRoles, UserDoc } from '../../util';
+
+import { MongoDB, validateToken, ensureRoles } from '../../util';
+import type { UserDocument } from 'src/types';
+
 import * as path from 'path';
 import * as dotenv from 'dotenv';
 
@@ -24,7 +27,7 @@ const deleteUser: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (eve
     // 2. Connect to MongoDB
     const db = MongoDB.getInstance(process.env.MONGO_URI);
     await db.connect();
-    const users = db.getCollection<UserDoc>('users');
+    const users = db.getCollection<UserDocument>('users');
 
     // 3. Check target user exists
     const target = await users.findOne({ email: user_email });

src/functions/index.ts

@@ -19,3 +19,4 @@ export { default as delete } from './delete';
 export { default as userExists } from './user-exists';
 export { default as interestForm } from './interest-form';
 export { default as teamsJoin } from './teams/join';
+export { default as teamsRead } from './teams/read';

src/functions/teams/read/handler.ts

@@ -0,0 +1,134 @@
+import type { ValidatedEventAPIGatewayProxyEvent } from '@libs/api-gateway';
+import { middyfy } from '@libs/lambda';
+
+import schema from './schema';
+
+import { ensureRoles, MongoDB, validateToken } from '../../../util';
+import type { UserDocument, TeamDocument } from '../../../types';
+
+import * as path from 'path';
+import * as dotenv from 'dotenv';
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+
+const teamsRead: ValidatedEventAPIGatewayProxyEvent<typeof schema> = async (event) => {
+  try {
+    // Validate auth token
+    const isValidToken = validateToken(event.body.auth_token, process.env.JWT_SECRET, event.body.auth_email);
+    if (!isValidToken) {
+      return {
+        statusCode: 401,
+        body: JSON.stringify({
+          statusCode: 401,
+          message: 'Unauthorized',
+        }),
+      };
+    }
+
+    // Connect to database
+    const db = MongoDB.getInstance(process.env.MONGO_URI);
+    await db.connect();
+    const users = db.getCollection<UserDocument>('users');
+    const teams = db.getCollection<TeamDocument>('teams');
+
+    // Check if auth user exists
+    const authUser = await users.findOne({ email: event.body.auth_email.toLowerCase() });
+    if (!authUser) {
+      return {
+        statusCode: 404,
+        body: JSON.stringify({
+          statusCode: 404,
+          message: 'Auth user not found',
+        }),
+      };
+    }
+
+    let teamId = event.body.team_id;
+
+    // Determine auth user permissions
+    const isOrganizer = ensureRoles(authUser.role, ['director', 'organizer']);
+    if (
+      ((teamId && authUser.team_info?.team_id !== teamId) ||
+        (!teamId && event.body.auth_email !== event.body.member_email)) &&
+      !isOrganizer
+    ) {
+      return {
+        statusCode: 401,
+        body: JSON.stringify({
+          statusCode: 401,
+          message: 'Unauthorized',
+        }),
+      };
+    }
+
+    // Fetch team id if member_email specified
+    if (!teamId) {
+      const teamUser = await users.findOne({ email: event.body.member_email.toLowerCase() });
+      if (!teamUser) {
+        return {
+          statusCode: 404,
+          body: JSON.stringify({
+            statusCode: 404,
+            message: 'Team user not found',
+          }),
+        };
+      }
+
+      if (!teamUser.team_info?.team_id) {
+        return {
+          statusCode: 404,
+          body: JSON.stringify({
+            statusCode: 404,
+            message: `User (${event.body.member_email}) is not in an active team`,
+          }),
+        };
+      }
+
+      teamId = teamUser.team_info.team_id;
+    }
+
+    // Fetch team and validate status
+    const team = await teams.findOne({ team_id: teamId });
+    if (!team) {
+      return {
+        statusCode: 404,
+        body: JSON.stringify({
+          statusCode: 404,
+          message: 'Team not found',
+        }),
+      };
+    }
+
+    if (team.status !== 'Active') {
+      return {
+        statusCode: 400,
+        body: JSON.stringify({
+          statusCode: 400,
+          message: 'Team is not active',
+        }),
+      };
+    }
+
+    // Return team data
+    return {
+      statusCode: 200,
+      body: JSON.stringify({
+        statusCode: 200,
+        message: 'Successfully read team',
+        team,
+      }),
+    };
+  } catch (error) {
+    console.error('Error reading team:', error);
+
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: error.message,
+      }),
+    };
+  }
+};
+
+export const main = middyfy(teamsRead);

src/functions/teams/read/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: 'teams/read',
+        cors: true,
+        request: {
+          schemas: {
+            'application/json': schema,
+          },
+        },
+      },
+    },
+  ],
+};

src/functions/teams/read/schema.ts

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

src/types.ts

@@ -11,13 +11,6 @@ export interface UserTeamInfo {
   pending_invites: TeamInvite[];
 }
 
-export interface UserDocument {
-  email: string;
-  confirmed_team?: boolean;
-  team_info?: UserTeamInfo;
-  [key: string]: unknown;
-}
-
 export interface TeamDocument {
   team_id: string;
   leader_email: string;
@@ -27,3 +20,66 @@ export interface TeamDocument {
   created: Date;
   updated: Date;
 }
+
+export interface UserDocument {
+  first_name: string;
+  last_name: string;
+  email: string;
+  email_verified: boolean;
+  password: string;
+  role: {
+    hacker: boolean;
+    volunteer: boolean;
+    judge: boolean;
+    sponsor: boolean;
+    mentor: boolean;
+    organizer: boolean;
+    director: boolean;
+  };
+  votes: 0;
+  github: string;
+  major: string;
+  short_answer: string;
+  shirt_size: string;
+  dietary_restrictions: string;
+  special_needs: string;
+  date_of_birth: string;
+  school: string;
+  grad_year: string;
+  gender: string;
+  level_of_study: string;
+  ethnicity: string;
+  phone_number: string;
+  registration_status: RegistrationStatus;
+  day_of: {
+    event: Record<
+      string,
+      {
+        attend: number;
+        time: string[];
+      }
+    >;
+  };
+  discord: {
+    user_id: string;
+    username: string;
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+  };
+  confirmed_team?: boolean;
+  team_info?: UserTeamInfo;
+  created_at: string;
+  registered_at: string;
+}
+
+type RegistrationStatus =
+  | 'unregistered'
+  | 'registered'
+  | 'rejected'
+  | 'confirmation'
+  | 'waitlist'
+  | 'coming'
+  | 'not_coming'
+  | 'confirmed'
+  | 'checked_in';

src/util.ts

@@ -163,64 +163,3 @@ export async function userExistsLogic(
     };
   }
 }
-
-export interface UserDoc {
-  first_name: string;
-  last_name: string;
-  email: string;
-  email_verified: boolean;
-  password: string;
-  role: {
-    hacker: boolean;
-    volunteer: boolean;
-    judge: boolean;
-    sponsor: boolean;
-    mentor: boolean;
-    organizer: boolean;
-    director: boolean;
-  };
-  votes: 0;
-  github: string;
-  major: string;
-  short_answer: string;
-  shirt_size: string;
-  dietary_restrictions: string;
-  special_needs: string;
-  date_of_birth: string;
-  school: string;
-  grad_year: string;
-  gender: string;
-  level_of_study: string;
-  ethnicity: string;
-  phone_number: string;
-  registration_status: RegistrationStatus;
-  day_of: {
-    event: Record<
-      string,
-      {
-        attend: number;
-        time: string[];
-      }
-    >;
-  };
-  discord: {
-    user_id: string;
-    username: string;
-    access_token: string;
-    refresh_token: string;
-    expires_at: number;
-  };
-  created_at: string;
-  registered_at: string;
-}
-
-type RegistrationStatus =
-  | 'unregistered'
-  | 'registered'
-  | 'rejected'
-  | 'confirmation'
-  | 'waitlist'
-  | 'coming'
-  | 'not_coming'
-  | 'confirmed'
-  | 'checked_in';