Web系エンジニアの業務
8割をカバーする
アルゴリズム

// CakePHP の Table クラスをラップした Repository
interface RepositoryInterface
{
    public function findById(int $id): ?EntityInterface;
    public function findAll(array $conditions = []): array;
    public function save(EntityInterface $entity): EntityInterface;
    public function delete(int $id): bool;
}

// CakePHP 実装
class UserRepository implements RepositoryInterface
{
    public function __construct(
        private UsersTable $table
    ) {}

    public function findById(int $id): ?User
    {
        return $this->table->find()
            ->where(['id' => $id])
            ->first();
    }

    public function findAll(array $conditions = []): array
    {
        return $this->table->find()
            ->where($conditions)
            ->toArray();
    }

    public function save(EntityInterface $entity): User
    {
        $result = $this->table->save($entity);
        if (!$result) {
            throw new \RuntimeException('保存に失敗しました');
        }
        return $result;
    }

    // テスト用: 条件付き検索を Repository に集約
    public function findActiveByDept(string $dept): array
    {
        return $this->table->find()
            ->where(['dept' => $dept, 'is_active' => true])
            ->order(['name' => 'ASC'])
            ->toArray();
    }
}

// フロント向け: API クライアントを Repository として抽象化
class UserApiRepository {
  constructor(baseUrl = '/api/users') {
    this.baseUrl = baseUrl
  }

  async findById(id) {
    const res = await fetch(`${this.baseUrl}/${id}`)
    if (!res.ok) return null
    return res.json()
  }

  async findAll(params = {}) {
    const qs = new URLSearchParams(params)
    const res = await fetch(`${this.baseUrl}?${qs}`)
    return res.json()
  }

  async create(data) {
    const res = await fetch(this.baseUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data),
    })
    if (!res.ok) throw new Error(await res.text())
    return res.json()
  }

  async update(id, data) {
    const res = await fetch(`${this.baseUrl}/${id}`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data),
    })
    return res.json()
  }
}

// Vue 3 での使用例
const userRepo = new UserApiRepository()
const users = ref([])

onMounted(async () => {
  users.value = await userRepo.findAll({ dept: 'engineering' })
})

// バリデーション + DTO 変換クラス（CakePHP 風）
class CreateOrderDTO
{
    public function __construct(
        public readonly int    $customerId,
        public readonly array  $items,
        public readonly ?string $note,
        public readonly DateTimeImmutable $deliveryDate,
    ) {}

    /**
     * リクエストデータからDTOを生成（バリデーション込み）
     * @throws ValidationException
     */
    public static function fromRequest(array $data): self
    {
        $errors = [];

        // customerId
        if (!isset($data['customer_id']) || !is_int($data['customer_id'])) {
            $errors['customer_id'] = '正の整数が必要です';
        }

        // items
        if (empty($data['items']) || !is_array($data['items'])) {
            $errors['items'] = '1件以上の商品が必要です';
        } else {
            foreach ($data['items'] as $i => $item) {
                if (($item['quantity'] ?? 0) < 1 || ($item['quantity'] ?? 0) > 99) {
                    $errors["items.{$i}.quantity"] = '1〜99の範囲で指定';
                }
            }
        }

        // note
        if (isset($data['note']) && mb_strlen($data['note']) > 500) {
            $errors['note'] = '500文字以内で入力してください';
        }

        if (!empty($errors)) {
            throw new ValidationException($errors);
        }

        return new self(
            customerId:   (int)$data['customer_id'],
            items:        $data['items'],
            note:         $data['note'] ?? null,
            deliveryDate: new DateTimeImmutable($data['delivery_date']),
        );
    }
}

// Controller での使用
public function add(): void
{
    try {
        $dto = CreateOrderDTO::fromRequest($this->request->getData());
        $order = $this->orderService->create($dto);
        $this->set('order', $order);
    } catch (ValidationException $e) {
        $this->response = $this->response->withStatus(422);
        $this->set('errors', $e->getErrors());
    }
}

// フロント側：送信前のバリデーション（Vue 3 composable）
function useOrderValidation() {
  const errors = ref({})

  const rules = {
    customerId: (v) => {
      if (!v || v <= 0) return '顧客IDは必須です'
      return null
    },
    items: (v) => {
      if (!Array.isArray(v) || v.length === 0) return '商品を1つ以上追加してください'
      for (const item of v) {
        if (item.quantity < 1 || item.quantity > 99)
          return '数量は1〜99の範囲で指定'
      }
      return null
    },
    note: (v) => {
      if (v && v.length > 500) return '500文字以内で入力してください'
      return null
    },
  }

  function validate(data) {
    const newErrors = {}
    for (const [field, rule] of Object.entries(rules)) {
      const error = rule(data[field])
      if (error) newErrors[field] = error
    }
    errors.value = newErrors
    return Object.keys(newErrors).length === 0
  }

  // API エラーレスポンスを errors にマージ
  function setServerErrors(serverErrors) {
    errors.value = { ...errors.value, ...serverErrors }
  }

  return { errors, validate, setServerErrors }
}

// コンポーネントでの使用
const { errors, validate, setServerErrors } = useOrderValidation()

async function handleSubmit() {
  if (!validate(formData.value)) return // フロント検証

  const res = await fetch('/api/orders', { /* ... */ })
  if (res.status === 422) {
    const { errors: srvErr } = await res.json()
    setServerErrors(srvErr) // サーバー検証エラーを反映
  }
}

// CakePHP でのサービスクラス
class OrderService
{
    public function __construct(
        private OrdersTable $orders,
        private StocksTable $stocks,
        private MailerFactory $mailer,
    ) {}

    /**
     * 注文作成：在庫チェック → 注文保存 → 在庫引当 → メール送信
     * @throws InsufficientStockException
     */
    public function createOrder(CreateOrderDTO $dto): Order
    {
        // トランザクションで一括管理
        return $this->orders->getConnection()->transactional(
            function () use ($dto) {
                // 1. 在庫チェック
                foreach ($dto->items as $item) {
                    $stock = $this->stocks->get($item['product_id']);
                    if ($stock->quantity < $item['quantity']) {
                        throw new InsufficientStockException(
                            $item['product_id']
                        );
                    }
                }

                // 2. 注文エンティティ作成 + 保存
                $order = $this->orders->newEntity([
                    'customer_id' => $dto->customerId,
                    'status'      => 'pending',
                    'items'       => $dto->items,
                ]);
                $this->orders->saveOrFail($order);

                // 3. 在庫引当
                foreach ($dto->items as $item) {
                    $this->stocks->decrement(
                        $item['product_id'], $item['quantity']
                    );
                }

                // 4. メール送信（キューに投入）
                $this->mailer->create('OrderConfirmation')
                    ->send('confirm', [$order]);

                return $order;
            }
        );
    }
}

// Controller は薄く保つ
class OrdersController extends AppController
{
    public function add(): void
    {
        $dto = CreateOrderDTO::fromRequest($this->request->getData());
        $order = $this->orderService->createOrder($dto);
        $this->set(compact('order'));
    }
}

// フロント: API呼び出しのビジネスロジックを集約
class OrderService {
  constructor(orderRepo, notifier) {
    this.orderRepo = orderRepo
    this.notifier = notifier
  }

  /**
   * 注文フロー全体をオーケストレーション
   * UI層はこのメソッドを呼ぶだけでよい
   */
  async submitOrder(formData) {
    // 1. 楽観的UI更新（即座に一覧に反映）
    const tempId = `temp_${Date.now()}`
    this.notifier.emit('order:optimistic-add', {
      id: tempId, ...formData, status: 'pending'
    })

    try {
      // 2. API送信
      const order = await this.orderRepo.create(formData)

      // 3. 楽観的データを実データで置換
      this.notifier.emit('order:confirmed', { tempId, order })

      // 4. 成功通知
      this.notifier.emit('toast:show', {
        type: 'success', message: '注文が完了しました'
      })

      return order
    } catch (error) {
      // 5. 楽観的更新をロールバック
      this.notifier.emit('order:rollback', { tempId })
      throw error
    }
  }
}

// PHP 版 Result クラス（readonly + enum で堅牢に）
class Result
{
    private function __construct(
        public readonly bool   $ok,
        public readonly mixed  $value = null,
        public readonly ?array $error = null,
    ) {}

    public static function ok(mixed $value): self
    {
        return new self(ok: true, value: $value);
    }

    public static function fail(string $code, array $context = []): self
    {
        return new self(ok: false, error: ['code' => $code, ...$context]);
    }
}

// Service での使用
class OrderService
{
    public function createOrder(CreateOrderDTO $dto): Result
    {
        $customer = $this->customers->get($dto->customerId);
        if (!$customer) {
            return Result::fail('CUSTOMER_NOT_FOUND', [
                'customerId' => $dto->customerId,
            ]);
        }

        foreach ($dto->items as $item) {
            $stock = $this->stocks->get($item['product_id']);
            if ($stock->quantity < $item['quantity']) {
                return Result::fail('INSUFFICIENT_STOCK', [
                    'productId' => $item['product_id'],
                ]);
            }
        }

        $order = $this->orders->saveOrFail(/* ... */);
        return Result::ok($order);
    }
}

// Controller でパターンマッチ
$result = $this->orderService->createOrder($dto);
if ($result->ok) {
    $this->set('order', $result->value);
} else {
    match ($result->error['code']) {
        'CUSTOMER_NOT_FOUND'  => $this->Flash->error('顧客が見つかりません'),
        'INSUFFICIENT_STOCK' => $this->Flash->error('在庫不足です'),
    };
}

// JavaScript 版 Result パターン（フロント向け）
const Ok  = (value) => ({ ok: true, value })
const Err = (error) => ({ ok: false, error })

// API呼び出しを Result でラップ
async function safeApiCall(url, options = {}) {
  try {
    const res = await fetch(url, {
      headers: { 'Content-Type': 'application/json' },
      ...options,
    })

    if (!res.ok) {
      const body = await res.json().catch(() => ({}))
      return Err({
        code: body.code ?? 'API_ERROR',
        status: res.status,
        ...body,
      })
    }

    return Ok(await res.json())
  } catch (e) {
    return Err({ code: 'NETWORK_ERROR', message: e.message })
  }
}

// Vue コンポーネントでの使用
async function handleCreateOrder() {
  loading.value = true
  const result = await safeApiCall('/api/orders', {
    method: 'POST',
    body: JSON.stringify(formData.value),
  })

  if (result.ok) {
    router.push(`/orders/${result.value.id}`)
  } else {
    switch (result.error.code) {
      case 'INSUFFICIENT_STOCK':
        toast.error('在庫不足です'); break
      case 'NETWORK_ERROR':
        toast.error('通信エラー。再試行してください'); break
      default:
        toast.error('予期しないエラーが発生しました')
    }
  }
  loading.value = false
}

// PHP 版 シンプル EventDispatcher
class EventDispatcher
{
    private array $listeners = [];

    public function on(string $event, callable $handler): void
    {
        $this->listeners[$event][] = $handler;
    }

    public function dispatch(string $event, array $payload = []): void
    {
        foreach ($this->listeners[$event] ?? [] as $handler) {
            $handler($payload);
        }
    }
}

// イベントクラスで構造化（PSR-14 的アプローチ）
class OrderCreatedEvent
{
    public function __construct(
        public readonly int $orderId,
        public readonly int $customerId,
    ) {}
}

// リスナー登録（bootstrap 等で）
$dispatcher = new EventDispatcher();

$dispatcher->on('order.created', function ($e) {
    // 確認メール送信
    $mailer = new OrderConfirmationMailer();
    $mailer->send($e['customerId']);
});

$dispatcher->on('order.created', function ($e) {
    // 監査ログ記録
    AuditLog::write('order.created', $e);
});

$dispatcher->on('order.created', function ($e) {
    // Slack 通知
    SlackNotifier::notify("#orders", "新規注文: #{$e['orderId']}");
});

// Service 内で発火
$dispatcher->dispatch('order.created', [
    'orderId'    => $order->id,
    'customerId' => $order->customer_id,
]);

// フロント向け: mitt ライクな軽量 EventBus
function createEventBus() {
  const handlers = new Map()

  return {
    on(event, handler) {
      const list = handlers.get(event) ?? []
      list.push(handler)
      handlers.set(event, list)
      return () => { // unsubscribe 関数を返す
        const i = list.indexOf(handler)
        if (i > -1) list.splice(i, 1)
      }
    },
    emit(event, payload) {
      (handlers.get(event) ?? []).forEach(h => h(payload))
    },
  }
}

// Vue 3 の provide/inject と組み合わせ
// main.js
const bus = createEventBus()
app.provide('eventBus', bus)

// OrderForm.vue
const bus = inject('eventBus')
async function onSubmit() {
  const order = await api.createOrder(form)
  bus.emit('order:created', order)
}

// OrderList.vue（別コンポーネントでリアクティブに反映）
const bus = inject('eventBus')
onMounted(() => {
  const unsub = bus.on('order:created', (order) => {
    orders.value.unshift(order)
  })
  onUnmounted(unsub) // メモリリーク防止
})

// CakePHP での楽観的ロック実装
// テーブルに version (INT, DEFAULT 1) カラムを追加しておく

class OptimisticLockBehavior
{
    /**
     * version 付き更新（影響行数 0 = 競合検出）
     */
    public static function updateWithLock(
        Table $table,
        int $id,
        int $currentVersion,
        array $data
    ): EntityInterface {
        $conn = $table->getConnection();

        // UPDATE ... WHERE id = ? AND version = ?
        $affected = $conn->update(
            $table->getTable(),
            array_merge($data, [
                'version'    => $currentVersion + 1,
                'modified'   => date('Y-m-d H:i:s'),
            ]),
            ['id' => $id, 'version' => $currentVersion]
        );

        if ($affected->rowCount() === 0) {
            throw new OptimisticLockException(
                "レコード #{$id} は他のユーザーに更新されました。"
                . "画面をリロードしてください。"
            );
        }

        return $table->get($id);
    }
}

// Controller での使用
public function edit(int $id): void
{
    $order = $this->Orders->get($id);

    if ($this->request->is('put')) {
        try {
            $order = OptimisticLockBehavior::updateWithLock(
                $this->Orders,
                $id,
                (int)$this->request->getData('version'),
                $this->request->getData()
            );
            $this->Flash->success('保存しました');
        } catch (OptimisticLockException $e) {
            $this->Flash->error($e->getMessage());
        }
    }
    // フォームに hidden field で version を埋め込む
    $this->set(compact('order'));
}

// フロント: version をフォームに保持して送信
const order = ref(null) // { id, name, version, ... }

async function loadOrder(id) {
  order.value = await fetch(`/api/orders/${id}`).then(r => r.json())
}

async function saveOrder() {
  const res = await fetch(`/api/orders/${order.value.id}`, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      ...order.value,
      version: order.value.version, // 取得時の version を送信
    }),
  })

  if (res.status === 409) {
    // 競合検出 → ユーザーに選択肢を提示
    const latest = await res.json()
    const overwrite = confirm(
      '他のユーザーが更新しています。上書きしますか？'
    )
    if (overwrite) {
      // 最新 version で再送信
      order.value.version = latest.version
      return saveOrder() // リトライ
    } else {
      // 最新データでリフレッシュ
      order.value = latest
    }
    return
  }

  // 成功 → レスポンスの新しい version を保持
  order.value = await res.json()
  alert('保存しました')
}

// PHP 版 Exponential Backoff + Jitter
class RetryHandler
{
    public function __construct(
        private int $maxAttempts = 3,
        private int $baseDelayMs = 1000,
        private int $maxDelayMs = 10000,
    ) {}

    /**
     * @template T
     * @param callable(): T $fn
     * @param callable(\Throwable): bool $shouldRetry
     * @return T
     */
    public function execute(callable $fn, ?callable $shouldRetry = null): mixed
    {
        $lastException = null;

        for ($attempt = 0; $attempt < $this->maxAttempts; $attempt++) {
            try {
                return $fn();
            } catch (\Throwable $e) {
                $lastException = $e;

                // リトライ対象でなければ即座に throw
                if ($shouldRetry && !$shouldRetry($e)) {
                    throw $e;
                }

                if ($attempt < $this->maxAttempts - 1) {
                    // Exponential backoff + jitter
                    $delay = min(
                        $this->baseDelayMs * (2 ** $attempt) + random_int(0, 100),
                        $this->maxDelayMs
                    );
                    usleep($delay * 1000); // ms → μs

                    Log::warning("Retry #{$attempt}: {$e->getMessage()}");
                }
            }
        }

        throw $lastException;
    }
}

// 使用例：外部決済API
$retry = new RetryHandler(maxAttempts: 3, baseDelayMs: 500);

$payment = $retry->execute(
    fn() => $gateway->charge($amount, $token),
    fn(\Throwable $e) => $e instanceof TimeoutException
        || $e instanceof ServiceUnavailableException
);

// JavaScript 版 Retry with Exponential Backoff
async function withRetry(fn, options = {}) {
  const {
    maxAttempts = 3,
    baseDelay = 1000,
    maxDelay = 10000,
    shouldRetry = () => true,
  } = options

  let lastError

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await fn()
    } catch (error) {
      lastError = error
      if (!shouldRetry(error)) throw error
      if (attempt === maxAttempts - 1) break

      const delay = Math.min(
        baseDelay * 2 ** attempt + Math.random() * 100,
        maxDelay
      )
      await new Promise(r => setTimeout(r, delay))
      console.warn(`Retry #${attempt + 1}:`, error.message)
    }
  }
  throw lastError
}

// 使用例：fetch のリトライラッパー
async function fetchWithRetry(url, options = {}) {
  return withRetry(
    async () => {
      const res = await fetch(url, options)
      if (res.status >= 500) {
        throw new Error(`Server Error: ${res.status}`)
      }
      return res
    },
    {
      maxAttempts: 3,
      baseDelay: 1000,
      // 4xx はリトライしない（サーバーエラーのみ）
      shouldRetry(error) {
        return error.message.includes('Server Error')
            || error.name === 'TypeError' // ネットワーク断
      }
    }
  )
}

// Vue composable として
function useRetryFetch() {
  const retrying = ref(false)
  const attempt = ref(0)

  async function execute(url, opts) {
    retrying.value = true
    try {
      return await fetchWithRetry(url, opts)
    } finally {
      retrying.value = false
    }
  }
  return { execute, retrying, attempt }
}