feat: added upload profile picture feature

Author: shanuvr

backend/package.json

@@ -8,10 +8,12 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.962.0",
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
     "form-data": "^4.0.5",
     "mailgun.js": "^12.4.1",
+    "multer": "^2.0.2",
     "pg": "^8.16.3",
     "pino": "^10.1.0",
     "pino-http": "^11.0.0",
@@ -23,6 +25,7 @@
     "@commitlint/config-conventional": "^20.2.0",
     "@eslint/js": "^9.39.2",
     "@types/express": "^5.0.6",
+    "@types/multer": "^2.0.0",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.16.0",
     "@typescript-eslint/eslint-plugin": "^8.51.0",

backend/src/app.ts

@@ -4,8 +4,8 @@ import { logger } from './utils/logger';
 import { notFound } from './middleware/notFound';
 import { errorHandler } from './middleware/errorHandler';
 import Healthrouter from './modules/health/health';
-import authRouter from './modules/auth/auth.routes'
-
+import authRouter from './modules/auth/auth.routes';
+import userRouter from './modules/user/user.routes';
 
 const app = express();
 app.use(express.json());
@@ -14,6 +14,7 @@ app.use(
 );
 app.use('/health', Healthrouter);
 app.use('/auth', authRouter);
+app.use('/user', userRouter);
 app.use(notFound);
 app.use(errorHandler);
 export default app;

backend/src/data-source.ts

@@ -11,6 +11,6 @@ export const appDataSouce = new DataSource({
   ssl: {
     rejectUnauthorized: false,
   },
-  entities: [User,Otp],
+  entities: [User, Otp],
   synchronize: true,
 });

backend/src/entities/User.ts

@@ -1,8 +1,33 @@
-import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
-@Entity()
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+} from 'typeorm';
+
+@Entity('users')
 export class User {
-  @PrimaryGeneratedColumn()
-  id!: number;
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ unique: true })
+  email!: string;
+
   @Column()
-  phone!: string;
+  name!: string;
+
+  @Column({ nullable: true })
+  age?: number;
+
+  @Column({ nullable: true })
+  gender?: string;
+
+  @Column('text', { array: true, nullable: true })
+  interests?: string[];
+
+  @Column({ nullable: true })
+  profileImageUrl?: string;
+
+  @CreateDateColumn()
+  createdAt!: Date;
 }

backend/src/entities/opt.ts

@@ -15,7 +15,7 @@ export class Otp {
   otp!: string;
   @Column({ type: 'timestamp' })
   expiresAt!: Date;
-  @Column({default:false})
+  @Column({ default: false })
   verified!: boolean;
   @CreateDateColumn()
   createdAt!: Date;

backend/src/middleware/upload.ts

@@ -0,0 +1,8 @@
+import multer from 'multer';
+
+export const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 5 * 1024 * 1024,
+  },
+});

backend/src/modules/auth/auth.controller.ts

@@ -1,10 +1,12 @@
 import { Request, Response, NextFunction } from 'express';
 import { logger } from '../../utils/logger';
-import { emailSchema } from './auth.schema';
+import { emailSchema, registerSchema } from './auth.schema';
 import { sendOtpEmail } from '../../Services/email.service';
 import { generateotp } from '../../utils/otp';
 import { appDataSouce } from '../../data-source';
 import { Otp } from '../../entities/opt';
+import { User } from '../../entities/User';
+
 export const sendOtp = async (
   req: Request,
   res: Response,
@@ -16,22 +18,123 @@ export const sendOtp = async (
     if (!result.success) {
       return res
         .status(400)
-        .json({ message: 'validation vailed', error: result.error?.format() });}
-        const otpRep = appDataSouce.getRepository(Otp)
-      const otpcode = generateotp()
-      logger.debug({otpcode},"otp is")
-      const email = result.data?.email;
-      await sendOtpEmail(email.toString(),otpcode.toString())
-      await otpRep.delete({email})
-      await otpRep.save({
+        .json({ message: 'validation vailed', error: result.error?.format() });
+    }
+    const otpRep = appDataSouce.getRepository(Otp);
+    const otpcode = generateotp();
+    logger.debug({ otpcode }, 'otp is');
+    const email = result.data?.email;
+    await sendOtpEmail(email.toString(), otpcode.toString());
+    await otpRep.delete({ email });
+    await otpRep.save({
+      email,
+      otp: otpcode.toString(),
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000),
+    });
+    res.status(200).json({ message: 'otp sent success fully ', success: true });
+  } catch (err) {
+    logger.error('error in register');
+    next(err);
+  }
+};
+
+export const verifyotp = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  try {
+    const { email, otp } = req.body;
+    if (!otp || !email) {
+      return res.status(400).json({ message: ' otp and email are required' });
+    }
+
+    const otpRepo = appDataSouce.getRepository(Otp);
+    const otpRecord = await otpRepo.findOne({
+      where: {
         email,
-        otp:otpcode.toString(),
-        expiresAt: new Date(Date.now()+5*60*1000)
+        verified: false,
+      },
+      order: {
+        createdAt: 'DESC',
+      },
+    });
+    if (!otpRecord) {
+      return res.status(400).json({
+        messge: 'Ivalid or expired OTP',
+      });
+    }
 
-      })
-    res.status(200).json({ message: "otp sent success fully ",success:true });
+    if (otpRecord.expiresAt < new Date()) {
+      return res.status(400).json({ message: 'OTP has expired' });
+    }
+    if (otpRecord.otp != otp.toString()) {
+      return res.status(400).json({ message: 'Invalid OTP' });
+    }
+    otpRecord.verified = true;
+    await otpRepo.save(otpRecord);
+    res.status(200).json({
+      message: 'OTP verified successfully',
+      success: true,
+      otpId: otpRecord.id,
+    });
   } catch (err) {
-    logger.error('error in register');
+    logger.error({ err }, 'error in verify-otp');
+    next(err);
+  }
+};
+
+export const register = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  try {
+    const result = registerSchema.safeParse(req.body);
+    if (!result.success) {
+      return res.status(400).json({
+        message: 'invalid registation data',
+        errors: result.error.format(),
+      });
+    }
+    const { otpId, name, age, gender, interests } = result.data;
+    if (!otpId) {
+      return res.status(400).json({ message: 'otpid requuired' });
+    }
+    const otpRepo = appDataSouce.getRepository(Otp);
+    const userRepo = appDataSouce.getRepository(User);
+
+    const otpRecord = await otpRepo.findOne({
+      where: { id: otpId },
+    });
+    if (!otpRecord) {
+      return res.status(400).json({ message: 'invalid registration ' });
+    }
+    if (!otpRecord.verified) {
+      return res.status(400).json({
+        message: 'OTP not verified',
+      });
+    }
+
+    const email = otpRecord.email;
+
+    const existingUser = await userRepo.findOne({
+      where: { email },
+    });
+
+    if (existingUser) {
+      return res.status(409).json({ message: 'User already exists' });
+    }
+
+    const user = userRepo.create({ email, name, age, gender, interests });
+
+    await userRepo.save(user);
+    await otpRepo.delete({ id: otpId });
+    return res
+      .status(201)
+      .json({ message: 'User registered successfully', success: true });
+  } catch (err) {
+    logger.error({ err }, 'error in register');
     next(err);
   }
 };

backend/src/modules/auth/auth.routes.ts

@@ -1,6 +1,8 @@
 import express from 'express';
-import { sendOtp } from './auth.controller';
+import { sendOtp, verifyotp, register } from './auth.controller';
 const authRouter = express.Router();
 authRouter.post('/send-otp', sendOtp);
+authRouter.post('/verify-otp', verifyotp);
+authRouter.post('/register', register);
 
 export default authRouter;

backend/src/modules/auth/auth.schema.ts

@@ -2,3 +2,11 @@ import { z } from 'zod';
 export const emailSchema = z.object({
   email: z.string().email('Invalid email'),
 });
+
+export const registerSchema = z.object({
+  otpId: z.string().uuid(),
+  name: z.string().min(1, 'name is required'),
+  age: z.number().int().positive().optional(),
+  gender: z.enum(['male', 'female', 'other']).optional(),
+  interests: z.array(z.string()).optional(),
+});

backend/src/modules/user/user.controller.ts

@@ -0,0 +1,37 @@
+import { NextFunction, Request, Response } from 'express';
+import { PutObjectCommand } from '@aws-sdk/client-s3';
+import { r2 } from '../../utils/r2';
+import { appDataSouce } from '../../data-source';
+import { User } from '../../entities/User';
+import { logger } from '../../utils/logger';
+export const uploadAvatar = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ message: 'Avatar is required' });
+    }
+    const userId = req.body.userId; // this is temp
+    const file = req.file;
+    const key = `avatars/${userId}-${Date.now()}`;
+    await r2.send(
+      new PutObjectCommand({
+        Bucket: process.env.R2_BUCKET_NAME,
+        Key: key,
+        Body: file.buffer,
+        ContentType: file.mimetype,
+      }),
+    );
+    const imageUrl = `${process.env.R2_ENDPOINT}/${process.env.R2_BUCKET_NAME}/${key}`;
+    const userRepo = appDataSouce.getRepository(User);
+    await userRepo.update(userId, { profileImageUrl: imageUrl });
+    res
+      .status(200)
+      .json({ message: 'profile picture uploaded', url: imageUrl });
+  } catch (err) {
+    logger.error({ err }, 'error in upload image');
+    next(err);
+  }
+};