🌐 Social API — Backend Complet

🏗️ Architecture de l'Application

social-api/
├── src/
│   ├── app.module.ts
│   ├── main.ts
│   ├── auth/
│   │   ├── auth.module.ts
│   │   ├── auth.controller.ts        ← /auth/register, login, refresh, logout, me
│   │   ├── auth.service.ts
│   │   ├── strategies/
│   │   │   ├── local.strategy.ts
│   │   │   ├── jwt.strategy.ts
│   │   │   └── jwt-refresh.strategy.ts
│   │   └── guards/
│   │       ├── jwt-auth.guard.ts     ← global (+ @Public())
│   │       ├── roles.guard.ts
│   │       └── resource-owner.guard.ts
│   ├── users/
│   │   ├── users.module.ts
│   │   ├── users.controller.ts       ← GET /users/:id, PUT /users/:id, follow/unfollow
│   │   ├── users.service.ts
│   │   ├── entities/user.entity.ts
│   │   └── dto/
│   │       ├── create-user.dto.ts
│   │       └── update-user.dto.ts
│   ├── posts/
│   │   ├── posts.module.ts
│   │   ├── posts.controller.ts       ← CRUD + feed + timeline
│   │   ├── posts.service.ts
│   │   ├── entities/post.entity.ts
│   │   └── dto/
│   │       ├── create-post.dto.ts
│   │       └── update-post.dto.ts
│   ├── likes/
│   │   ├── likes.module.ts
│   │   ├── likes.controller.ts       ← POST /posts/:id/like, DELETE /posts/:id/like
│   │   ├── likes.service.ts
│   │   └── entities/like.entity.ts
│   ├── comments/
│   │   ├── comments.module.ts
│   │   ├── comments.controller.ts    ← CRUD + nested replies
│   │   ├── comments.service.ts
│   │   └── entities/comment.entity.ts
│   ├── notifications/
│   │   ├── notifications.module.ts
│   │   ├── notifications.gateway.ts  ← WebSocket temps réel
│   │   ├── notifications.service.ts
│   │   └── entities/notification.entity.ts
│   ├── mail/
│   │   ├── mail.module.ts            ← dynamic module
│   │   ├── mail.service.ts
│   │   └── processors/mail.processor.ts ← BullMQ
│   ├── common/
│   │   ├── decorators/
│   │   │   ├── current-user.decorator.ts
│   │   │   ├── public.decorator.ts
│   │   │   └── roles.decorator.ts
│   │   ├── interceptors/
│   │   │   ├── transform.interceptor.ts
│   │   │   ├── logging.interceptor.ts
│   │   │   └── timeout.interceptor.ts
│   │   ├── filters/
│   │   │   └── all-exceptions.filter.ts
│   │   ├── middleware/
│   │   │   └── logger.middleware.ts
│   │   └── pipes/
│   │       └── parse-positive-int.pipe.ts
│   └── health/
│       └── health.controller.ts
├── test/
│   ├── auth.e2e-spec.ts
│   └── posts.e2e-spec.ts
├── Dockerfile
├── docker-compose.yml
├── docker-compose.prod.yml
├── .env.example
└── .github/
    └── workflows/
        ├── ci.yml
        └── deploy.yml

🗃️ Entités TypeORM

// user.entity.ts
@Entity('users')
export class User {
  @PrimaryGeneratedColumn('uuid') id: string;

  @Column({ unique: true }) email: string;
  @Column({ unique: true }) username: string;
  @Column({ select: false }) passwordHash: string;
  @Column({ nullable: true }) bio: string;
  @Column({ nullable: true }) avatarUrl: string;
  @Column({ type: 'enum', enum: Role, default: Role.USER }) role: Role;
  @Column({ nullable: true, select: false }) refreshTokenHash: string;

  @OneToMany(() => Post, post => post.author) posts: Post[];
  @OneToMany(() => Like, like => like.user) likes: Like[];
  @OneToMany(() => Notification, n => n.recipient) notifications: Notification[];

  // Self-referential ManyToMany for follows
  @ManyToMany(() => User, user => user.following)
  @JoinTable({ name: 'user_follows', joinColumn: { name: 'follower_id' }, inverseJoinColumn: { name: 'following_id' } })
  followers: User[];

  @ManyToMany(() => User, user => user.followers)
  following: User[];

  @CreateDateColumn() createdAt: Date;
  @UpdateDateColumn() updatedAt: Date;
}

// post.entity.ts
@Entity('posts')
export class Post {
  @PrimaryGeneratedColumn('uuid') id: string;
  @Column({ type: 'text' }) content: string;
  @Column({ nullable: true }) imageUrl: string;
  @Column({ type: 'simple-array', default: '' }) tags: string[];

  @ManyToOne(() => User, user => user.posts, { eager: true, onDelete: 'CASCADE' })
  author: User;

  @OneToMany(() => Like, like => like.post) likes: Like[];
  @OneToMany(() => Comment, comment => comment.post) comments: Comment[];

  @Column({ default: 0 }) likesCount: number;
  @Column({ default: 0 }) commentsCount: number;

  @CreateDateColumn() createdAt: Date;
  @UpdateDateColumn() updatedAt: Date;
  @DeleteDateColumn() deletedAt: Date;  // soft delete
}

// like.entity.ts
@Entity('likes')
@Unique(['user', 'post'])   // empêche les doublons
export class Like {
  @PrimaryGeneratedColumn('uuid') id: string;
  @ManyToOne(() => User, user => user.likes, { onDelete: 'CASCADE' }) user: User;
  @ManyToOne(() => Post, post => post.likes, { onDelete: 'CASCADE' }) post: Post;
  @CreateDateColumn() createdAt: Date;
}

// notification.entity.ts
@Entity('notifications')
export class Notification {
  @PrimaryGeneratedColumn('uuid') id: string;
  @Column({ type: 'enum', enum: NotificationType }) type: NotificationType;
  @Column({ type: 'jsonb' }) payload: Record<string, any>;
  @Column({ default: false }) read: boolean;
  @ManyToOne(() => User, user => user.notifications, { onDelete: 'CASCADE' })
  recipient: User;
  @Column({ nullable: true }) actorId: string;
  @CreateDateColumn() createdAt: Date;
}

📡 Endpoints REST

⚡ WebSocket — Notifications Temps Réel

// notifications.gateway.ts
@WebSocketGateway({ namespace: '/notifications', cors: { origin: '*' } })
export class NotificationsGateway implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer() server: Server;

  async handleConnection(client: Socket) {
    const user = await this.authService.validateWsToken(client.handshake.auth.token);
    if (!user) return client.disconnect();
    client.join(`user:${user.id}`);   // salle privée par userId
    await this.notificationsService.markSocketConnected(user.id, client.id);
  }

  // Envoyer une notif en temps réel
  sendToUser(userId: string, notification: NotificationDto) {
    this.server.to(`user:${userId}`).emit('notification:new', notification);
  }

  // Marquer comme lu côté client
  @SubscribeMessage('notification:read')
  async markRead(@ConnectedSocket() client: Socket, @MessageBody() id: string) {
    const user = this.getUser(client);
    return this.notificationsService.markAsRead(user.id, id);
  }
}

// Types de notifications émises
// → 'notification:new'  { type, message, actorUsername, link, createdAt }
// → 'post:liked'        quand un post de l'user reçoit un like
// → 'post:commented'    quand un post de l'user reçoit un commentaire
// → 'user:followed'     quand un user suit l'utilisateur courant

📬 Queue BullMQ — Emails

// Types de jobs dans la queue 'mail'
type MailJob =
  | { type: 'welcome';      to: string; username: string }
  | { type: 'notification'; to: string; subject: string; items: string[] }
  | { type: 'digest';       to: string; username: string; unreadCount: number };

// mail.processor.ts
@Processor('mail')
export class MailProcessor {
  @Process('welcome')
  async sendWelcome(job: Job<WelcomeJobData>) {
    await this.mailService.send({ to: job.data.to, subject: 'Bienvenue sur Social API', ... });
  }

  @Process('notification')
  async sendNotification(job: Job<NotifJobData>) {
    await this.mailService.send({ to: job.data.to, subject: job.data.subject, ... });
  }
}

// Jobs déclenchés automatiquement
// register → 'welcome' job (délai 0s)
// like/comment/follow → 'notification' job si user offline (délai 30s)
// daily digest cron → 'digest' jobs pour users avec notifs non lues

🧪 Suite de Tests Attendue

src/
├── auth/
│   └── auth.service.spec.ts        ← register, login, refresh, reuse detection
├── posts/
│   ├── posts.service.spec.ts       ← CRUD, timeline, soft delete
│   └── posts.controller.spec.ts    ← routes, guards, transformations
├── likes/
│   └── likes.service.spec.ts       ← toggle like, doublon @Unique
├── notifications/
│   └── notifications.gateway.spec.ts ← WS connect/disconnect, emit
└── common/
    ├── interceptors/transform.interceptor.spec.ts
    └── filters/all-exceptions.filter.spec.ts
test/
├── auth.e2e-spec.ts     ← register → login → refresh → logout
└── posts.e2e-spec.ts    ← create → like → comment → delete

🐳 Déploiement

# docker-compose.yml (dev)
services:
  api:
    build: .
    ports: ["3000:3000"]
    env_file: .env
    depends_on:
      postgres: { condition: service_healthy }
      redis:    { condition: service_started }

  postgres:
    image: postgres:16-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
      interval: 5s

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass $$REDIS_PASSWORD

  pgadmin:
    image: dpage/pgadmin4:latest
    ports: ["5050:80"]

# Pipeline CI/CD (GitHub Actions)
# ┌──────────┐     ┌──────────────────┐     ┌──────────────┐
# │  ci.yml  │────▶│  build-push.yml  │────▶│  deploy.yml  │
# │ lint+test│     │ Docker → GHCR    │     │  SSH + pull  │
# └──────────┘     └──────────────────┘     └──────────────┘

✅ Critères de Validation