Node.js

import { Server, Socket } from 'socket.io';
import { MessageService } from '../services/message.service';
import { RoomService } from '../services/room.service';
import { logger } from '../utils/logger';

interface JoinPayload  { roomId: string; }
interface SendPayload  { roomId: string; content: string; replyTo?: string; }
interface TypingPayload { roomId: string; }

export function registerChatHandlers(
  io: Server,
  socket: Socket,
  messageService: MessageService,
  roomService: RoomService,
): void {
  const userId = socket.data.userId as string;

  // ─── Odaya Katıl ──────────────────────────────────────────
  socket.on('room:join', async ({ roomId }: JoinPayload) => {
    const isMember = await roomService.isMember(roomId, userId);
    if (!isMember) {
      socket.emit('error', { code: 'FORBIDDEN', message: 'Bu odaya erişim izniniz yok.' });
      return;
    }

    await socket.join(roomId);
    await roomService.setOnline(roomId, userId);

    // Odadaki diğer kullanıcılara bildir
    socket.to(roomId).emit('user:joined', { userId, roomId, at: new Date().toISOString() });
    logger.info({ userId, roomId }, 'Socket odaya katıldı');
  });

  // ─── Mesaj Gönder ─────────────────────────────────────────
  socket.on('message:send', async (payload: SendPayload, ack) => {
    try {
      const message = await messageService.create({
        roomId:  payload.roomId,
        senderId: userId,
        content: payload.content,
        replyTo: payload.replyTo,
      });

      // Odanın tüm üyelerine yayınla (gönderen dahil)
      io.to(payload.roomId).emit('message:new', {
        id:        message.id,
        content:   message.content,
        senderId:  message.senderId,
        roomId:    message.roomId,
        replyTo:   message.replyTo,
        createdAt: message.createdAt,
      });

      // ACK ile client'a onay
      ack?.({ success: true, messageId: message.id });
    } catch (err) {
      logger.error({ err, payload }, 'Mesaj gönderilemedi');
      ack?.({ success: false, error: 'Mesaj gönderilemedi.' });
    }
  });

  // ─── Yazıyor Göstergesi ───────────────────────────────────
  socket.on('typing:start', ({ roomId }: TypingPayload) => {
    socket.to(roomId).emit('typing:update', { userId, roomId, isTyping: true });

    // 3 sn sonra otomatik kapat
    setTimeout(() => {
      socket.to(roomId).emit('typing:update', { userId, roomId, isTyping: false });
    }, 3000);
  });

  // ─── Bağlantı Kesme Temizliği ─────────────────────────────
  socket.on('disconnect', async (reason) => {
    logger.info({ userId, reason }, 'Socket bağlantısı kesildi');

    // Kullanıcının bulunduğu tüm odalarda offline yap
    const rooms = Array.from(socket.rooms).filter((r) => r !== socket.id);
    await Promise.allSettled(
      rooms.map((roomId) =>
        roomService.setOffline(roomId, userId).then(() =>
          io.to(roomId).emit('user:left', { userId, roomId }),
        ),
      ),
    );
  });
}

import { Queue, Worker, Job, QueueEvents } from 'bullmq';
import { redisConnection } from '../config/redis';
import { EmailService } from '../services/email.service';
import { logger } from '../utils/logger';

// ─── Job Tipleri ──────────────────────────────────────────────
export interface WelcomeEmailJob {
  type: 'welcome';
  userId: string;
  email: string;
  firstName: string;
}

export interface OrderConfirmEmailJob {
  type: 'order_confirm';
  orderId: string;
  email: string;
  items: { name: string; qty: number; price: number }[];
}

export type EmailJob = WelcomeEmailJob | OrderConfirmEmailJob;

// ─── Queue Tanımı ─────────────────────────────────────────────
export const emailQueue = new Queue('email', {
  connection: redisConnection,
  defaultJobOptions: {
    attempts: 3,
    backoff: { type: 'exponential', delay: 5000 },
    removeOnComplete: { count: 500, age: 24 * 3600 },
    removeOnFail:    { count: 200, age: 72 * 3600 },
  },
});

// ─── Worker ───────────────────────────────────────────────────
const emailWorker = new Worker(
  'email',
  async (job: Job) => {
    const emailService = new EmailService();

    await job.updateProgress(10);

    switch (job.data.type) {
      case 'welcome': {
        const { email, firstName } = job.data;
        logger.info({ jobId: job.id, email }, 'Hoşgeldin maili gönderiliyor');

        await emailService.sendWelcome({ to: email, firstName });
        await job.updateProgress(100);
        break;
      }

      case 'order_confirm': {
        const { orderId, email, items } = job.data;
        logger.info({ jobId: job.id, orderId }, 'Sipariş onay maili gönderiliyor');

        await job.updateProgress(30);
        const total = items.reduce((s, i) => s + i.qty * i.price, 0);
        await emailService.sendOrderConfirmation({ to: email, orderId, items, total });
        await job.updateProgress(100);
        break;
      }

      default:
        throw new Error(`Bilinmeyen email job tipi`);
    }
  },
  {
    connection: redisConnection,
    concurrency: 5,
    limiter: { max: 50, duration: 60_000 }, // dakikada maks 50 mail
  },
);

// ─── Worker Event Dinleyicileri ───────────────────────────────
emailWorker.on('completed', (job) => {
  logger.info({ jobId: job.id, type: job.data.type }, 'Email job tamamlandı');
});

emailWorker.on('failed', (job, err) => {
  logger.error(
    { jobId: job?.id, attempt: job?.attemptsMade, err: err.message },
    'Email job başarısız',
  );
});

// ─── Queue Events (dışarıdan izleme) ─────────────────────────
export const emailQueueEvents = new QueueEvents('email', { connection: redisConnection });

// ─── Helper: Job Ekle ─────────────────────────────────────────
export async function enqueueEmail(data: EmailJob, delay = 0) {
  return emailQueue.add(data.type, data, { delay });
}

import { PrismaClient, Order, OrderStatus, Prisma } from '@prisma/client';
import { Injectable } from '../di/injectable';
import { PaginatedResult, PaginationParams } from '../types/pagination';

export interface OrderFilters {
  userId?:   string;
  status?:   OrderStatus;
  fromDate?: Date;
  toDate?:   Date;
  minTotal?: number;
  maxTotal?: number;
}

// Prisma include tipi — UI'ye döndürülecek ilişkiler
const orderWithRelations = Prisma.validator()({
  include: {
    items: { include: { product: { select: { id: true, name: true, sku: true } } } },
    user:  { select: { id: true, firstName: true, lastName: true, email: true } },
    shippingAddress: true,
  },
});
type OrderWithRelations = Prisma.OrderGetPayload;

@Injectable()
export class OrderRepository {
  constructor(private readonly prisma: PrismaClient) {}

  async findMany(
    filters: OrderFilters,
    pagination: PaginationParams,
  ): Promise> {
    const where: Prisma.OrderWhereInput = {
      ...(filters.userId && { userId: filters.userId }),
      ...(filters.status && { status: filters.status }),
      ...(filters.minTotal !== undefined && {
        total: { gte: filters.minTotal },
      }),
      ...(filters.maxTotal !== undefined && {
        total: { ...(filters.minTotal !== undefined ? { gte: filters.minTotal } : {}), lte: filters.maxTotal },
      }),
      ...((filters.fromDate || filters.toDate) && {
        createdAt: {
          ...(filters.fromDate && { gte: filters.fromDate }),
          ...(filters.toDate  && { lte: filters.toDate  }),
        },
      }),
      deletedAt: null, // soft-delete filtresi
    };

    const { page, limit } = pagination;
    const skip = (page - 1) * limit;

    // Tek transaction içinde count + data — tutarlılık garantisi
    const [total, orders] = await this.prisma.$transaction([
      this.prisma.order.count({ where }),
      this.prisma.order.findMany({
        where,
        ...orderWithRelations,
        orderBy: { createdAt: 'desc' },
        skip,
        take: limit,
      }),
    ]);

    return {
      data: orders,
      meta: {
        total,
        page,
        limit,
        totalPages: Math.ceil(total / limit),
        hasNextPage: page * limit < total,
      },
    };
  }

  async findByIdOrThrow(id: string, userId?: string): Promise {
    const order = await this.prisma.order.findFirst({
      where: { id, ...(userId && { userId }), deletedAt: null },
      ...orderWithRelations,
    });

    if (!order) {
      throw new Error(`Sipariş bulunamadı: ${id}`);
    }
    return order;
  }

  async updateStatus(id: string, status: OrderStatus): Promise {
    return this.prisma.order.update({
      where: { id },
      data:  { status, updatedAt: new Date() },
    });
  }
}