演習：PRをレビューしよう

// src/controllers/userController.ts
import { Request, Response } from 'express';
import { db } from '../database';

export class UserController {
  async searchUsers(req: Request, res: Response) {
    const { keyword, role } = req.query;

    const query = `
      SELECT id, name, email, password_hash, role, created_at
      FROM users
      WHERE name LIKE '%${keyword}%'
      AND role = '${role}'
      ORDER BY created_at DESC
    `;

    const users = await db.raw(query);
    res.json({ users, total: users.length });
  }
}

// src/services/orderService.ts
export class OrderService {
  async createOrder(
    userId: string,
    productId: string,
    quantity: number,
    shippingAddress: string,
    paymentMethod: string,
    couponCode: string | null,
    giftMessage: string | null,
    isExpressDelivery: boolean,
  ) {
    // 在庫チェック
    const product = await fetch(`http://inventory-service/products/${productId}`);
    const productData = await product.json();
    if (productData.stock < quantity) {
      throw new Error('Out of stock');
    }

    // 金額計算
    let total = productData.price * quantity;
    if (couponCode) {
      const coupon = await fetch(`http://coupon-service/coupons/${couponCode}`);
      const couponData = await coupon.json();
      total = total * (1 - couponData.discountRate);
    }
    if (isExpressDelivery) {
      total += 1500;
    }
    total = total * 1.1; // 税込み

    // 決済
    const payment = await fetch('http://payment-service/charge', {
      method: 'POST',
      body: JSON.stringify({ userId, amount: total, method: paymentMethod }),
    });
    if (!payment.ok) {
      throw new Error('Payment failed');
    }

    // 注文保存
    const order = await fetch('http://order-db-service/orders', {
      method: 'POST',
      body: JSON.stringify({
        userId, productId, quantity, total, shippingAddress,
        giftMessage, isExpressDelivery, status: 'confirmed',
      }),
    });

    // メール送信
    await fetch('http://email-service/send', {
      method: 'POST',
      body: JSON.stringify({
        to: userId,
        template: 'order-confirmation',
        data: { orderId: (await order.json()).id },
      }),
    });

    return order.json();
  }
}

// src/utils/transform.ts
export function t(d: any[], f: string, o?: any) {
  const r: any[] = [];
  for (let i = 0; i < d.length; i++) {
    if (f === 'f') {
      if (o.fn(d[i])) r.push(d[i]);
    } else if (f === 'm') {
      r.push(o.fn(d[i]));
    } else if (f === 'g') {
      const k = o.fn(d[i]);
      const existing = r.find((x: any) => x.k === k);
      if (existing) {
        existing.v.push(d[i]);
      } else {
        r.push({ k, v: [d[i]] });
      }
    } else if (f === 's') {
      // bubble sort
      const arr = [...d];
      for (let j = 0; j < arr.length; j++) {
        for (let k = 0; k < arr.length - j - 1; k++) {
          if (o.fn(arr[k], arr[k + 1]) > 0) {
            const tmp = arr[k];
            arr[k] = arr[k + 1];
            arr[k + 1] = tmp;
          }
        }
      }
      return arr;
    }
  }
  return r;
}

// src/auth/login.ts
export async function login(email: string, password: string) {
  const user = await userRepository.findByEmail(email);

  if (!user) {
    throw new AuthenticationError('Invalid credentials');
  }

  const isValidPassword = await bcrypt.compare(password, user.passwordHash);
  if (!isValidPassword) {
    throw new AuthenticationError('Invalid credentials');
  }

  if (user.isLocked) {
    throw new AccountLockedError('Account is locked');
  }

  await userRepository.updateLastLogin(user.id);

  const token = jwt.sign(
    { userId: user.id, role: user.role },
    process.env.JWT_SECRET!,
    { expiresIn: '24h' }
  );

  return { token, user: { id: user.id, name: user.name, role: user.role } };
}

// tests/auth/login.test.ts
describe('login', () => {
  it('should return token for valid credentials', async () => {
    const result = await login('test@example.com', 'password123');
    expect(result.token).toBeDefined();
  });
});

// src/services/reportService.ts
export class ReportService {
  async generateMonthlyReport(year: number, month: number) {
    const orders = await orderRepository.findAll();

    // 対象月のフィルタ
    const monthlyOrders = orders.filter(order => {
      const d = new Date(order.createdAt);
      return d.getFullYear() === year && d.getMonth() + 1 === month;
    });

    // 各注文の詳細を取得
    const detailedOrders = [];
    for (const order of monthlyOrders) {
      const user = await userRepository.findById(order.userId);
      const products = await productRepository.findByOrderId(order.id);
      detailedOrders.push({ ...order, user, products });
    }

    // カテゴリ別集計
    const categoryTotals: Record<string, number> = {};
    for (const order of detailedOrders) {
      for (const product of order.products) {
        const category = product.category;
        if (!categoryTotals[category]) {
          categoryTotals[category] = 0;
        }
        categoryTotals[category] += product.price * product.quantity;
      }
    }

    return {
      year,
      month,
      totalOrders: monthlyOrders.length,
      totalRevenue: monthlyOrders.reduce((sum, o) => sum + o.total, 0),
      categoryBreakdown: categoryTotals,
      orders: detailedOrders,
    };
  }
}