コードスメル

SOLID原則違反

品質上の問題

• テスト容易性: console.log による副作用、外部依存の注入不可
• 信頼性: エラー処理が文字列返却、例外なし
• 保守性: 変更理由が多すぎ、影響範囲が不明

// === 値オブジェクト ===
type CustomerType = 'guest' | 'regular' | 'premium' | 'vip';
type OrderStatus = 'pending' | 'confirmed' | 'shipped' | 'delivered' | 'cancelled';

interface OrderItem {
  productId: string;
  name: string;
  price: number;
  quantity: number;
}

interface ShippingAddress {
  fullAddress: string;
  region: string;
}

// === ポート（インターフェース） ===
interface InventoryService {
  checkAvailability(items: OrderItem[]): boolean;
  reserveItems(items: OrderItem[]): void;
  releaseItems(items: OrderItem[]): void;
}

interface PricingService {
  calculateSubtotal(items: OrderItem[]): number;
  calculateDiscount(subtotal: number, customerType: CustomerType, couponCode: string | null): number;
  calculateShipping(subtotal: number, discount: number, address: ShippingAddress): number;
  calculateTax(taxableAmount: number): number;
}

interface PaymentGateway {
  charge(amount: number, paymentDetails: PaymentDetails): PaymentResult;
}

interface NotificationService {
  sendOrderConfirmation(email: string, order: Order): void;
}

interface LoyaltyService {
  addPoints(customerId: string, amount: number): void;
}

interface OrderRepository {
  save(order: Order): void;
  findById(id: string): Order | null;
}

// === クーポン（OCP） ===
interface CouponStrategy {
  readonly code: string;
  calculateDiscount(subtotal: number): number;
}

// === 決済（OCP） ===
interface PaymentMethod {
  readonly name: string;
  validate(details: PaymentDetails): boolean;
  process(amount: number, details: PaymentDetails): PaymentResult;
}

// === ユースケース ===
interface PlaceOrderUseCase {
  execute(request: PlaceOrderRequest): PlaceOrderResult;
}

// === Strategy: クーポン割引 ===
class PercentageCoupon implements CouponStrategy {
  constructor(readonly code: string, private rate: number) {}
  calculateDiscount(subtotal: number): number {
    return subtotal * this.rate;
  }
}

class FixedAmountCoupon implements CouponStrategy {
  constructor(readonly code: string, private amount: number) {}
  calculateDiscount(subtotal: number): number {
    return Math.min(this.amount, subtotal);
  }
}

class CouponRegistry {
  private coupons: Map<string, CouponStrategy> = new Map();

  register(coupon: CouponStrategy): void {
    this.coupons.set(coupon.code, coupon);
  }

  find(code: string): CouponStrategy | undefined {
    return this.coupons.get(code);
  }
}

// 登録
const couponRegistry = new CouponRegistry();
couponRegistry.register(new PercentageCoupon('SAVE10', 0.1));
couponRegistry.register(new PercentageCoupon('SAVE20', 0.2));
couponRegistry.register(new FixedAmountCoupon('FLAT1000', 1000));

// === Factory: 決済方法 ===
class CreditCardPayment implements PaymentMethod {
  readonly name = 'credit_card';
  validate(details: PaymentDetails): boolean {
    return details.cardNumber !== undefined && details.cardNumber.length === 16;
  }
  process(amount: number, details: PaymentDetails): PaymentResult {
    return { success: true, transactionId: `cc-${Date.now()}` };
  }
}

class BankTransferPayment implements PaymentMethod {
  readonly name = 'bank_transfer';
  validate(details: PaymentDetails): boolean { return true; }
  process(amount: number, details: PaymentDetails): PaymentResult {
    return { success: true, transactionId: `bt-${Date.now()}` };
  }
}

class CodPayment implements PaymentMethod {
  readonly name = 'cod';
  validate(details: PaymentDetails): boolean { return true; }
  process(amount: number, details: PaymentDetails): PaymentResult {
    if (amount > 300000) return { success: false, error: 'COD limit exceeded' };
    return { success: true, transactionId: `cod-${Date.now()}` };
  }
}

class PaymentMethodFactory {
  private methods: Map<string, PaymentMethod> = new Map();

  register(method: PaymentMethod): void {
    this.methods.set(method.name, method);
  }

  create(name: string): PaymentMethod {
    const method = this.methods.get(name);
    if (!method) throw new Error(`Unknown payment method: ${name}`);
    return method;
  }
}

// === Observer: 注文完了通知 ===
interface OrderEventHandler {
  onOrderPlaced(order: Order): void;
}

class EmailNotificationHandler implements OrderEventHandler {
  onOrderPlaced(order: Order): void {
    console.log(`Sending confirmation email for ${order.id}`);
  }
}

class LoyaltyPointHandler implements OrderEventHandler {
  onOrderPlaced(order: Order): void {
    const points = Math.floor(order.total * 0.01);
    console.log(`Adding ${points} points`);
  }
}

class OrderEventDispatcher {
  private handlers: OrderEventHandler[] = [];

  subscribe(handler: OrderEventHandler): void {
    this.handlers.push(handler);
  }

  dispatchOrderPlaced(order: Order): void {
    for (const handler of this.handlers) {
      handler.onOrderPlaced(order);
    }
  }
}

interface PlaceOrderRequest {
  customerId: string;
  customerEmail: string;
  customerType: CustomerType;
  items: OrderItem[];
  paymentMethodName: string;
  paymentDetails: PaymentDetails;
  shippingAddress: ShippingAddress;
  couponCode: string | null;
}

interface PlaceOrderResult {
  success: boolean;
  orderId?: string;
  total?: number;
  error?: string;
}

class PlaceOrderService implements PlaceOrderUseCase {
  constructor(
    private inventoryService: InventoryService,
    private pricingService: PricingService,
    private paymentFactory: PaymentMethodFactory,
    private orderRepository: OrderRepository,
    private eventDispatcher: OrderEventDispatcher
  ) {}

  execute(request: PlaceOrderRequest): PlaceOrderResult {
    // 在庫チェック
    if (!this.inventoryService.checkAvailability(request.items)) {
      return { success: false, error: 'One or more items are out of stock' };
    }

    // 価格計算
    const subtotal = this.pricingService.calculateSubtotal(request.items);
    const discount = this.pricingService.calculateDiscount(
      subtotal, request.customerType, request.couponCode
    );
    const shippingFee = this.pricingService.calculateShipping(
      subtotal, discount, request.shippingAddress
    );
    const taxableAmount = subtotal - discount + shippingFee;
    const tax = this.pricingService.calculateTax(taxableAmount);
    const total = taxableAmount + tax;

    // 決済処理
    const paymentMethod = this.paymentFactory.create(request.paymentMethodName);
    if (!paymentMethod.validate(request.paymentDetails)) {
      return { success: false, error: 'Invalid payment details' };
    }
    const paymentResult = paymentMethod.process(total, request.paymentDetails);
    if (!paymentResult.success) {
      return { success: false, error: paymentResult.error };
    }

    // 在庫確保
    this.inventoryService.reserveItems(request.items);

    // 注文保存
    const order: Order = {
      id: `ORD-${Date.now()}`,
      customerId: request.customerId,
      customerEmail: request.customerEmail,
      items: request.items,
      subtotal,
      discount,
      shippingFee,
      tax,
      total,
      status: 'confirmed',
      createdAt: new Date(),
    };
    this.orderRepository.save(order);

    // イベント発行（通知、ポイント付与など）
    this.eventDispatcher.dispatchOrderPlaced(order);

    return { success: true, orderId: order.id, total };
  }
}