AIペアプロ実践術 - 生産性を最大化する次世代開発手法

// プロンプト: "先ほどの検索APIにエラーハンドリングを追加"

import { ErrorRequestHandler } from 'express';

// カスタムエラークラス
export class APIError extends Error {
constructor(
  public statusCode: number,
  message: string,
  public code?: string
) {
  super(message);
  this.name = 'APIError';
}
}

// エラーハンドリングミドルウェア
export const errorHandler: ErrorRequestHandler = (err, req, res, next) => {
console.error('Error:', err);

// Zodバリデーションエラー
if (err.name === 'ZodError') {
  return res.status(400).json({
    error: {
      code: 'VALIDATION_ERROR',
      message: 'Invalid request parameters',
      details: err.errors.map(e => ({
        field: e.path.join('.'),
        message: e.message
      }))
    }
  });
}

// Prismaエラー
if (err.code === 'P2002') {
  return res.status(409).json({
    error: {
      code: 'DUPLICATE_ERROR',
      message: 'Resource already exists'
    }
  });
}

// カスタムAPIエラー
if (err instanceof APIError) {
  return res.status(err.statusCode).json({
    error: {
      code: err.code || 'API_ERROR',
      message: err.message
    }
  });
}

// 予期しないエラー
res.status(500).json({
  error: {
    code: 'INTERNAL_SERVER_ERROR',
    message: process.env.NODE_ENV === 'production' 
      ? 'An unexpected error occurred' 
      : err.message
  }
});
};

// 改善された検索関数
export async function searchProductsWithErrorHandling(req: Request, res: Response, next: NextFunction) {
try {
  const params = searchSchema.parse(req.query);
  
  // タイムアウト処理
  const timeoutPromise = new Promise((_, reject) => 
    setTimeout(() => reject(new APIError(504, 'Request timeout')), 5000)
  );

  const searchPromise = performSearch(params);
  
  const result = await Promise.race([searchPromise, timeoutPromise]);
  
  res.json(result);
} catch (error) {
  next(error);
}
}

// プロンプト: "検索APIのパフォーマンスを最適化"

import { Redis } from 'ioredis';
import { compress, decompress } from 'lz-string';

const redis = new Redis();

// キャッシュキー生成
function generateCacheKey(params: any): string {
return `search:${JSON.stringify(params)}`;
}

// 最適化された検索関数
export async function optimizedSearchProducts(req: Request, res: Response, next: NextFunction) {
try {
  const params = searchSchema.parse(req.query);
  const cacheKey = generateCacheKey(params);

  // キャッシュチェック
  const cached = await redis.get(cacheKey);
  if (cached) {
    const data = JSON.parse(decompress(cached));
    res.set('X-Cache', 'HIT');
    return res.json(data);
  }

  // 検索クエリの最適化
  const products = await prisma.product.findMany({
    where: buildWhereClause(params),
    skip: (params.page - 1) * params.limit,
    take: params.limit,
    select: {
      id: true,
      name: true,
      price: true,
      description: true,
      thumbnail: true,
      category: {
        select: { id: true, name: true }
      },
      _count: {
        select: { reviews: true }
      }
    }
  });

  // 集計を別クエリで実行（並列化）
  const [enrichedProducts, totalCount] = await Promise.all([
    // 画像URLを一括取得
    enrichProductsWithImages(products),
    // カウントクエリ（インデックス使用）
    prisma.product.count({
      where: buildWhereClause(params)
    })
  ]);

  const result = {
    products: enrichedProducts,
    pagination: {
      page: params.page,
      limit: params.limit,
      totalCount,
      totalPages: Math.ceil(totalCount / params.limit)
    }
  };

  // 圧縮してキャッシュ
  await redis.setex(
    cacheKey,
    300, // 5分間キャッシュ
    compress(JSON.stringify(result))
  );

  res.set('X-Cache', 'MISS');
  res.json(result);
} catch (error) {
  next(error);
}
}

// インデックスを考慮したWHERE句構築
function buildWhereClause(params: SearchParams) {
const conditions: any[] = [];

// フルテキスト検索の利用
if (params.query) {
  conditions.push({
    OR: [
      { searchVector: { search: params.query } },
      { name: { contains: params.query, mode: 'insensitive' } }
    ]
  });
}

// インデックスされたフィールドでのフィルタリング
if (params.category) {
  conditions.push({ categoryId: params.category });
}

// 範囲検索の最適化
if (params.minPrice || params.maxPrice) {
  conditions.push({
    price: {
      ...(params.minPrice && { gte: params.minPrice }),
      ...(params.maxPrice && { lte: params.maxPrice })
    }
  });
}

return conditions.length > 0 ? { AND: conditions } : {};
}

// プロンプト: "検索APIの包括的なテストを作成"

import request from 'supertest';
import { app } from '../app';
import { prisma } from '../prisma';

describe('Product Search API', () => {
beforeEach(async () => {
  // テストデータのセットアップ
  await prisma.product.createMany({
    data: [
      {
        name: 'iPhone 15 Pro',
        description: '最新のiPhone',
        price: 159800,
        categoryId: 'electronics'
      },
      {
        name: 'MacBook Pro',
        description: '高性能ノートPC',
        price: 248800,
        categoryId: 'electronics'
      },
      {
        name: 'プログラミング入門',
        description: 'Python/JavaScript対応',
        price: 2980,
        categoryId: 'books'
      }
    ]
  });
});

afterEach(async () => {
  await prisma.product.deleteMany();
});

describe('基本的な検索機能', () => {
  test('キーワードで商品を検索できる', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({ query: 'iPhone' })
      .expect(200);

    expect(response.body.products).toHaveLength(1);
    expect(response.body.products[0].name).toBe('iPhone 15 Pro');
  });

  test('大文字小文字を区別せずに検索できる', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({ query: 'iphone' })
      .expect(200);

    expect(response.body.products).toHaveLength(1);
  });
});

describe('フィルタリング機能', () => {
  test('カテゴリーでフィルタリングできる', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({ 
        query: '',
        category: 'electronics' 
      })
      .expect(200);

    expect(response.body.products).toHaveLength(2);
  });

  test('価格範囲でフィルタリングできる', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({
        query: '',
        minPrice: 100000,
        maxPrice: 200000
      })
      .expect(200);

    expect(response.body.products).toHaveLength(1);
    expect(response.body.products[0].name).toBe('iPhone 15 Pro');
  });
});

describe('ページネーション', () => {
  test('ページサイズを指定できる', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({
        query: '',
        limit: 2,
        page: 1
      })
      .expect(200);

    expect(response.body.products).toHaveLength(2);
    expect(response.body.pagination.totalCount).toBe(3);
    expect(response.body.pagination.totalPages).toBe(2);
  });
});

describe('エラーハンドリング', () => {
  test('無効なパラメータでエラーを返す', async () => {
    const response = await request(app)
      .get('/api/products/search')
      .query({
        query: '', // 必須パラメータが空
        page: 'invalid' // 数値であるべき
      })
      .expect(400);

    expect(response.body.error.code).toBe('VALIDATION_ERROR');
  });
});

describe('パフォーマンス', () => {
  test('大量データでも高速に動作する', async () => {
    // 1000件のテストデータを作成
    const products = Array.from({ length: 1000 }, (_, i) => ({
      name: `Product ${i}`,
      description: `Description ${i}`,
      price: Math.random() * 100000,
      categoryId: i % 2 === 0 ? 'electronics' : 'books'
    }));
    
    await prisma.product.createMany({ data: products });

    const start = Date.now();
    
    await request(app)
      .get('/api/products/search')
      .query({
        query: 'Product',
        limit: 20
      })
      .expect(200);
    
    const duration = Date.now() - start;
    expect(duration).toBeLessThan(100); // 100ms以内
  });
});
});

// プロンプト: "テストを通すための最小限の実装"

export interface Product {
id: string;
name: string;
price: number;
stock: number;
}

export interface CartItem {
product: Product;
quantity: number;
}

export interface TotalOptions {
taxRate?: number;
shippingFee?: number;
}

export class ShoppingCart {
private items: Map<string, CartItem> = new Map();

addItem(product: Product, quantity: number): void {
  if (quantity <= 0) {
    throw new Error('数量は1以上である必要があります');
  }
  
  const existingItem = this.items.get(product.id);
  const totalQuantity = existingItem 
    ? existingItem.quantity + quantity 
    : quantity;
  
  if (totalQuantity > product.stock) {
    throw new Error('在庫が不足しています');
  }
  
  if (existingItem) {
    existingItem.quantity = totalQuantity;
  } else {
    this.items.set(product.id, { product, quantity });
  }
}

removeItem(productId: string): void {
  this.items.delete(productId);
}

updateQuantity(productId: string, quantity: number): void {
  if (quantity === 0) {
    this.removeItem(productId);
    return;
  }
  
  const item = this.items.get(productId);
  if (!item) {
    throw new Error('商品がカートに存在しません');
  }
  
  if (quantity > item.product.stock) {
    throw new Error('在庫が不足しています');
  }
  
  item.quantity = quantity;
}

getItems(): CartItem[] {
  return Array.from(this.items.values());
}

getSubtotal(): number {
  return Array.from(this.items.values()).reduce(
    (total, item) => total + item.product.price * item.quantity,
    0
  );
}

getTotal(options: TotalOptions = {}): number {
  const subtotal = this.getSubtotal();
  const tax = subtotal * (options.taxRate || 0);
  const shipping = options.shippingFee || 0;
  
  return subtotal + tax + shipping;
}

clear(): void {
  this.items.clear();
}

isEmpty(): boolean {
  return this.items.size === 0;
}
}

// プロンプト: "ShoppingCartクラスをリファクタリングして、より拡張性の高い設計に"

// リファクタリング後の実装

// 戦略パターンで税計算を拡張可能に
interface TaxCalculator {
calculate(amount: number): number;
}

class JapaneseTaxCalculator implements TaxCalculator {
constructor(private rate: number = 0.1) {}

calculate(amount: number): number {
  return Math.floor(amount * this.rate);
}
}

// 送料計算も戦略パターンで
interface ShippingCalculator {
calculate(items: CartItem[], subtotal: number): number;
}

class FlatRateShipping implements ShippingCalculator {
constructor(private fee: number) {}

calculate(): number {
  return this.fee;
}
}

class FreeShippingOver implements ShippingCalculator {
constructor(
  private threshold: number,
  private fee: number
) {}

calculate(items: CartItem[], subtotal: number): number {
  return subtotal >= this.threshold ? 0 : this.fee;
}
}

// イベント駆動で拡張性を向上
type CartEventType = 'item-added' | 'item-removed' | 'item-updated' | 'cart-cleared';

interface CartEvent {
type: CartEventType;
data: any;
}

type CartEventListener = (event: CartEvent) => void;

// 改善されたShoppingCart
export class ShoppingCart {
private items: Map<string, CartItem> = new Map();
private listeners: Map<CartEventType, CartEventListener[]> = new Map();

constructor(
  private taxCalculator: TaxCalculator = new JapaneseTaxCalculator(),
  private shippingCalculator: ShippingCalculator = new FlatRateShipping(0)
) {}

on(event: CartEventType, listener: CartEventListener): void {
  if (!this.listeners.has(event)) {
    this.listeners.set(event, []);
  }
  this.listeners.get(event)!.push(listener);
}

private emit(event: CartEvent): void {
  const listeners = this.listeners.get(event.type) || [];
  listeners.forEach(listener => listener(event));
}

addItem(product: Product, quantity: number): void {
  this.validateQuantity(quantity);
  this.validateStock(product, quantity);
  
  const existingItem = this.items.get(product.id);
  
  if (existingItem) {
    const newQuantity = existingItem.quantity + quantity;
    this.validateStock(product, newQuantity);
    existingItem.quantity = newQuantity;
  } else {
    this.items.set(product.id, { product, quantity });
  }
  
  this.emit({
    type: 'item-added',
    data: { product, quantity }
  });
}

private validateQuantity(quantity: number): void {
  if (quantity <= 0) {
    throw new CartError('INVALID_QUANTITY', '数量は1以上である必要があります');
  }
}

private validateStock(product: Product, quantity: number): void {
  if (quantity > product.stock) {
    throw new CartError('INSUFFICIENT_STOCK', '在庫が不足しています');
  }
}

// その他のメソッドも同様にリファクタリング

getTotalBreakdown(): {
  subtotal: number;
  tax: number;
  shipping: number;
  total: number;
} {
  const subtotal = this.getSubtotal();
  const tax = this.taxCalculator.calculate(subtotal);
  const shipping = this.shippingCalculator.calculate(
    this.getItems(),
    subtotal
  );
  
  return {
    subtotal,
    tax,
    shipping,
    total: subtotal + tax + shipping
  };
}
}

// カスタムエラークラス
class CartError extends Error {
constructor(public code: string, message: string) {
  super(message);
  this.name = 'CartError';
}
}

// プロンプト: "ショッピングカートの統合テストを作成"

import { ShoppingCart } from '../ShoppingCart';
import { InventoryService } from '../services/InventoryService';
import { PriceService } from '../services/PriceService';
import { PromotionService } from '../services/PromotionService';

// モックサービス
jest.mock('../services/InventoryService');
jest.mock('../services/PriceService');
jest.mock('../services/PromotionService');

describe('ShoppingCart統合テスト', () => {
let cart: ShoppingCart;
let inventoryService: jest.Mocked<InventoryService>;
let priceService: jest.Mocked<PriceService>;
let promotionService: jest.Mocked<PromotionService>;

beforeEach(() => {
  inventoryService = new InventoryService() as jest.Mocked<InventoryService>;
  priceService = new PriceService() as jest.Mocked<PriceService>;
  promotionService = new PromotionService() as jest.Mocked<PromotionService>;
  
  cart = new ShoppingCart({
    inventoryService,
    priceService,
    promotionService
  });
});

describe('在庫連携', () => {
  test('リアルタイム在庫チェック', async () => {
    const product = {
      id: '1',
      name: 'Limited Edition',
      price: 5000,
      stock: 3
    };
    
    inventoryService.checkStock.mockResolvedValue({
      available: 2,
      reserved: 1
    });
    
    await expect(cart.addItemAsync(product, 3))
      .rejects.toThrow('在庫が不足しています');
    
    await cart.addItemAsync(product, 2);
    expect(cart.getItems()).toHaveLength(1);
  });
  
  test('在庫予約処理', async () => {
    const product = {
      id: '1',
      name: 'Popular Item',
      price: 3000,
      stock: 10
    };
    
    inventoryService.reserveStock.mockResolvedValue({
      reservationId: 'res-123',
      expiresAt: new Date(Date.now() + 10 * 60 * 1000)
    });
    
    await cart.addItemAsync(product, 2);
    
    expect(inventoryService.reserveStock)
      .toHaveBeenCalledWith(product.id, 2);
  });
});

describe('価格連携', () => {
  test('動的価格の適用', async () => {
    const product = {
      id: '1',
      name: 'Dynamic Price Item',
      price: 1000,
      stock: 10
    };
    
    priceService.getCurrentPrice.mockResolvedValue({
      basePrice: 1000,
      currentPrice: 900,
      discount: 10
    });
    
    await cart.addItemAsync(product, 1);
    const total = await cart.calculateTotalAsync();
    
    expect(total.subtotal).toBe(900);
  });
});

describe('プロモーション連携', () => {
  test('クーポンコードの適用', async () => {
    const items = [
      { id: '1', name: 'Item 1', price: 1000, stock: 10 },
      { id: '2', name: 'Item 2', price: 2000, stock: 10 }
    ];
    
    for (const item of items) {
      await cart.addItemAsync(item, 1);
    }
    
    promotionService.applyPromotion.mockResolvedValue({
      type: 'percentage',
      value: 20,
      appliedAmount: 600
    });
    
    const result = await cart.applyPromotionCode('SAVE20');
    
    expect(result.discount).toBe(600);
    expect(result.finalAmount).toBe(2400);
  });
  
  test('複数プロモーションの組み合わせ', async () => {
    promotionService.getApplicablePromotions.mockResolvedValue([
      {
        id: 'promo1',
        type: 'buy-one-get-one',
        conditions: { productId: '1' }
      },
      {
        id: 'promo2',
        type: 'percentage',
        value: 10,
        conditions: { minAmount: 5000 }
      }
    ]);
    
    const product = {
      id: '1',
      name: 'BOGO Item',
      price: 3000,
      stock: 10
    };
    
    await cart.addItemAsync(product, 2);
    const promotions = await cart.getApplicablePromotions();
    
    expect(promotions).toHaveLength(2);
    expect(promotions[0].type).toBe('buy-one-get-one');
  });
});

describe('チェックアウトフロー', () => {
  test('完全なチェックアウトプロセス', async () => {
    // 商品追加
    await cart.addItemAsync(
      { id: '1', name: 'Product 1', price: 2000, stock: 5 },
      2
    );
    
    // プロモーション適用
    await cart.applyPromotionCode('WELCOME10');
    
    // 送料計算
    const shippingOptions = await cart.getShippingOptions({
      zipCode: '100-0001',
      country: 'JP'
    });
    
    await cart.selectShipping(shippingOptions[0].id);
    
    // 最終確認
    const checkout = await cart.prepareCheckout();
    
    expect(checkout).toMatchObject({
      items: expect.any(Array),
      subtotal: 4000,
      discount: 400,
      shipping: expect.any(Number),
      tax: expect.any(Number),
      total: expect.any(Number),
      reservations: expect.any(Array)
    });
  });
});
});

// ❌ 悪い例：曖昧で危険なプロンプト
"管理者機能を実装して。DBのパスワードは'admin123'です。"

// ✅ 良い例：明確で安全なプロンプト
"Next.js 14のApp Routerで管理者向けダッシュボードのルート保護を実装してください。
要件：
- middleware.tsでJWTトークンの検証
- 管理者ロールのチェック（roles: ['admin', 'super_admin']）
- 未認証時は/loginへリダイレクト
- 環境変数からJWT_SECRETを読み込む
- エラーハンドリングとログ出力を含める"

// ❌ 悪い例：巨大な一括生成
"ECサイト全体を作って"

// ✅ 良い例：段階的なアプローチ
"ECサイトの商品一覧ページのコンポーネントを作成してください。
まずは以下の機能から始めます：
1. 商品カードコンポーネント（画像、タイトル、価格）
2. グリッドレイアウト（レスポンシブ対応）
3. ページネーション（1ページ20件）
使用技術：React 18, TypeScript, Tailwind CSS"