Design Decision Toolkit

type BookingState string

const (
	WaitingRouteApproval BookingState = "waiting_route_approval"
	WaitingReroute       BookingState = "waiting_reroute"
	BookingFlight        BookingState = "booking_flight"
	BookingHotel         BookingState = "booking_hotel"
	Compensating         BookingState = "compensating"
	Completed            BookingState = "completed"
)

type TravelBookingProcess struct {
	ID        string
	Traveler  string
	RouteID   string
	RejectedRoutes []string
	State     BookingState
	Deadline  time.Time
	Attempts  int
}

type BookingEvent interface{ bookingEvent() }
type RouteConfirmed struct{ RouteID string }
type RouteRejected struct{}
type ReroutingConfirmed struct{ RouteID string }
type FlightBooked struct{}
type HotelBooked struct{}
type HotelUnavailable struct{}
type FlightCanceled struct{}
type BookingTimedOut struct{}

type TravelBookingResultMessage struct {
	ProcessID string
	Event     BookingEvent
}

type Command interface{ bookingCommand() }
type StartTravelBooking struct{ ProcessID, Traveler, InitialRouteID string }
type RequestRouteApproval struct{ ProcessID, Traveler, RouteID string }
type RequestRerouting struct{ ProcessID, Traveler string; RejectedRoutes []string }
type BookFlight struct{ ProcessID, RouteID string }
type BookHotel struct{ ProcessID, Traveler string }
type CancelFlight struct{ ProcessID string }
type NotifyManualReview struct{ ProcessID string }

func InitializeTravelBooking(command StartTravelBooking, now time.Time) (TravelBookingProcess, []Command) {
	process := TravelBookingProcess{
		ID:       command.ProcessID,
		Traveler: command.Traveler,
		RouteID:  command.InitialRouteID,
		State:    WaitingRouteApproval,
		Deadline: now.Add(48 * time.Hour),
	}
	return process, []Command{RequestRouteApproval{
		ProcessID: process.ID,
		Traveler:  process.Traveler,
		RouteID:   process.RouteID,
	}}
}

type ProcessStore interface {
	Load(ctx context.Context, processID string) (TravelBookingProcess, error)
	SaveWithCommands(ctx context.Context, process TravelBookingProcess, commands []Command) error
}

func StartTravelBookingProcess(
	ctx context.Context,
	store ProcessStore,
	command StartTravelBooking,
	now time.Time,
) error {
	process, commands := InitializeTravelBooking(command, now)
	return store.SaveWithCommands(ctx, process, commands)
}

func (p TravelBookingProcess) Apply(event BookingEvent) (TravelBookingProcess, []Command) {
	switch p.State {
	case WaitingRouteApproval:
		return p.applyWaitingRouteApproval(event)
	case WaitingReroute:
		return p.applyWaitingReroute(event)
	case BookingFlight:
		return p.applyBookingFlight(event)
	case BookingHotel:
		return p.applyBookingHotel(event)
	default:
		return p.applyTimeoutOrIgnore(event)
	}
}

func (p TravelBookingProcess) applyWaitingRouteApproval(event BookingEvent) (TravelBookingProcess, []Command) {
	switch e := event.(type) {
	case RouteConfirmed:
		p.State = BookingFlight
		p.RouteID = e.RouteID
		return p, []Command{BookFlight{ProcessID: p.ID, RouteID: e.RouteID}}
	case RouteRejected:
		p.State = WaitingReroute
		p.RejectedRoutes = append(p.RejectedRoutes, p.RouteID)
		return p, []Command{RequestRerouting{
			ProcessID:      p.ID,
			Traveler:       p.Traveler,
			RejectedRoutes: p.RejectedRoutes,
		}}
	default:
		return p, nil
	}
}

func (p TravelBookingProcess) applyWaitingReroute(event BookingEvent) (TravelBookingProcess, []Command) {
	if e, ok := event.(ReroutingConfirmed); ok {
		p.State = WaitingRouteApproval
		p.RouteID = e.RouteID
		return p, []Command{RequestRouteApproval{
			ProcessID: p.ID,
			Traveler:  p.Traveler,
			RouteID:   e.RouteID,
		}}
	}
	return p, nil
}

func (p TravelBookingProcess) applyBookingFlight(event BookingEvent) (TravelBookingProcess, []Command) {
	if _, ok := event.(FlightBooked); ok {
		p.State = BookingHotel
		return p, []Command{BookHotel{ProcessID: p.ID, Traveler: p.Traveler}}
	}
	return p, nil
}

func (p TravelBookingProcess) applyBookingHotel(event BookingEvent) (TravelBookingProcess, []Command) {
	switch event.(type) {
	case HotelBooked:
		p.State = Completed
		return p, nil
	case HotelUnavailable:
		p.State = Compensating
		return p, []Command{CancelFlight{ProcessID: p.ID}, NotifyManualReview{ProcessID: p.ID}}
	default:
		return p, nil
	}
}

func (p TravelBookingProcess) applyTimeoutOrIgnore(event BookingEvent) (TravelBookingProcess, []Command) {
	if _, ok := event.(BookingTimedOut); ok {
		p.State = Compensating
		return p, []Command{NotifyManualReview{ProcessID: p.ID}}
	}
	return p, nil
}

func HandleBookingEvent(ctx context.Context, store ProcessStore, processID string, event BookingEvent) error {
	process, err := store.Load(ctx, processID)
	if err != nil { return err }
	next, commands := process.Apply(event)
	return store.SaveWithCommands(ctx, next, commands)
}

type ProcessStoreDB interface {
	WithTx(ctx context.Context, fn func(ProcessStoreTx) error) error
}

type ProcessStoreTx interface {
	LoadProcess(ctx context.Context, processID string) (TravelBookingProcess, error)
	SaveProcess(ctx context.Context, process TravelBookingProcess) error
	AppendCommands(ctx context.Context, processID string, commands []Command) error
}

type PostgresProcessStore struct{ db ProcessStoreDB }

func (s PostgresProcessStore) Load(ctx context.Context, processID string) (TravelBookingProcess, error) {
	var process TravelBookingProcess
	err := s.db.WithTx(ctx, func(tx ProcessStoreTx) error {
		loaded, err := tx.LoadProcess(ctx, processID)
		if err != nil { return err }
		process = loaded
		return nil
	})
	return process, err
}

func (s PostgresProcessStore) SaveWithCommands(
	ctx context.Context,
	process TravelBookingProcess,
	commands []Command,
) error {
	return s.db.WithTx(ctx, func(tx ProcessStoreTx) error {
		if err := tx.SaveProcess(ctx, process); err != nil {
			return err
		}
		return tx.AppendCommands(ctx, process.ID, commands)
	})
}

type CommandSender interface {
	Send(ctx context.Context, command Command) error
}

type RouteApprovalClient interface {
	RequestRouteApproval(ctx context.Context, command RequestRouteApproval) error
}

type RoutePlanningClient interface {
	RequestRerouting(ctx context.Context, command RequestRerouting) error
}

type FlightBookingClient interface {
	BookFlight(ctx context.Context, command BookFlight) error
	CancelFlight(ctx context.Context, command CancelFlight) error
}

type HotelBookingClient interface {
	BookHotel(ctx context.Context, command BookHotel) error
}

type ContextCommandSender struct {
	RouteApproval RouteApprovalClient
	RoutePlanning RoutePlanningClient
	FlightBooking FlightBookingClient
	HotelBooking  HotelBookingClient
}

func (s ContextCommandSender) Send(ctx context.Context, command Command) error {
	switch c := command.(type) {
	case RequestRouteApproval:
		return s.RouteApproval.RequestRouteApproval(ctx, c)
	case RequestRerouting:
		return s.RoutePlanning.RequestRerouting(ctx, c)
	case BookFlight:
		return s.FlightBooking.BookFlight(ctx, c)
	case BookHotel:
		return s.HotelBooking.BookHotel(ctx, c)
	case CancelFlight:
		return s.FlightBooking.CancelFlight(ctx, c)
	default:
		return ErrUnsupportedCommand
	}
}

type RouteApprovalAPIClient interface {
	RequestRouteApproval(
		ctx context.Context,
		req *connect.Request[routeapprovalv1.RequestRouteApprovalRequest],
	) (*connect.Response[routeapprovalv1.RequestRouteApprovalResponse], error)
}

type ConnectRouteApprovalClient struct {
	client RouteApprovalAPIClient
}

func (c ConnectRouteApprovalClient) RequestRouteApproval(
	ctx context.Context,
	command RequestRouteApproval,
) error {
	req := connect.NewRequest(toProtoRouteApprovalRequest(command))
	_, err := c.client.RequestRouteApproval(ctx, req)
	return err
}

func toProtoRouteApprovalRequest(
	command RequestRouteApproval,
) *routeapprovalv1.RequestRouteApprovalRequest {
	return &routeapprovalv1.RequestRouteApprovalRequest{
		ProcessId: command.ProcessID,
		Traveler:  command.Traveler,
		RouteId:   command.RouteID,
	}
}

type PendingCommand struct {
	ID        string
	ProcessID string
	Command   Command
}

type CommandOutbox interface {
	TakePending(ctx context.Context) (PendingCommand, error)
	MarkSent(ctx context.Context, commandID string) error
}

func RelayPendingCommand(
	ctx context.Context,
	outbox CommandOutbox,
	sender CommandSender,
) error {
	pending, err := outbox.TakePending(ctx)
	if err != nil { return err }
	if err := sender.Send(ctx, pending.Command); err != nil {
		return err
	}
	return outbox.MarkSent(ctx, pending.ID)
}

type PendingRouteApprovalResult struct {
	ID     string
	Result TravelBookingResultMessage
}

type RouteApprovalResultOutbox interface {
	SaveResult(ctx context.Context, result TravelBookingResultMessage) error
	TakePendingResult(ctx context.Context) (PendingRouteApprovalResult, error)
	MarkResultSent(ctx context.Context, resultID string) error
}

type RouteApprovalAPI struct {
	application RouteApprovalApplication
}

func (h RouteApprovalAPI) RequestRouteApproval(
	ctx context.Context,
	req *connect.Request[routeapprovalv1.RequestRouteApprovalRequest],
) (*connect.Response[routeapprovalv1.RequestRouteApprovalResponse], error) {
	command := fromProtoRouteApprovalRequest(req.Msg)
	if err := h.application.HandleRequestRouteApproval(ctx, command); err != nil {
		return nil, err
	}
	return connect.NewResponse(&routeapprovalv1.RequestRouteApprovalResponse{}), nil
}

func fromProtoRouteApprovalRequest(
	msg *routeapprovalv1.RequestRouteApprovalRequest,
) RequestRouteApproval {
	return RequestRouteApproval{
		ProcessID: msg.ProcessId,
		Traveler:  msg.Traveler,
		RouteID:   msg.RouteId,
	}
}

type RouteApprovalService interface {
	ConfirmRoute(ctx context.Context, processID string, traveler string, routeID string) (RouteDecision, error)
}

type RouteDecision struct {
	RouteID  string
	Rejected bool
}

type RouteApprovalApplication struct {
	service RouteApprovalService
	outbox  RouteApprovalResultOutbox
}

func (a RouteApprovalApplication) HandleRequestRouteApproval(
	ctx context.Context,
	command RequestRouteApproval,
) error {
	decision, err := a.service.ConfirmRoute(ctx, command.ProcessID, command.Traveler, command.RouteID)
	if err != nil { return err }

	result := TravelBookingResultMessage{ProcessID: command.ProcessID}
	if decision.Rejected {
		result.Event = RouteRejected{}
	} else {
		result.Event = RouteConfirmed{RouteID: decision.RouteID}
	}
	return a.outbox.SaveResult(ctx, result)
}

type TravelBookingAPI struct {
	store ProcessStore
}

func (a TravelBookingAPI) ReportRouteApprovalResult(
	ctx context.Context,
	req *connect.Request[travelbookingv1.ReportRouteApprovalResultRequest],
) (*connect.Response[travelbookingv1.ReportRouteApprovalResultResponse], error) {
	message := fromProtoRouteApprovalResult(req.Msg)
	if err := HandleRouteApprovalResult(ctx, a.store, message); err != nil {
		return nil, err
	}
	return connect.NewResponse(&travelbookingv1.ReportRouteApprovalResultResponse{}), nil
}

func HandleRouteApprovalResult(
	ctx context.Context,
	store ProcessStore,
	message TravelBookingResultMessage,
) error {
	return HandleBookingEvent(ctx, store, message.ProcessID, message.Event)
}

func fromProtoRouteApprovalResult(
	req *travelbookingv1.ReportRouteApprovalResultRequest,
) TravelBookingResultMessage {
	return TravelBookingResultMessage{
		ProcessID: req.ProcessId,
		Event:     toBookingEvent(req.Event),
	}
}

type TravelBookingClient interface {
	ReportRouteApprovalResult(ctx context.Context, message TravelBookingResultMessage) error
}

type TravelBookingAPIClient interface {
	ReportRouteApprovalResult(
		ctx context.Context,
		req *connect.Request[travelbookingv1.ReportRouteApprovalResultRequest],
	) (*connect.Response[travelbookingv1.ReportRouteApprovalResultResponse], error)
}

type ConnectTravelBookingClient struct {
	client TravelBookingAPIClient
}

func (c ConnectTravelBookingClient) ReportRouteApprovalResult(
	ctx context.Context,
	message TravelBookingResultMessage,
) error {
	req := connect.NewRequest(toProtoRouteApprovalResult(message))
	_, err := c.client.ReportRouteApprovalResult(ctx, req)
	return err
}

func toProtoRouteApprovalResult(
	message TravelBookingResultMessage,
) *travelbookingv1.ReportRouteApprovalResultRequest {
	return &travelbookingv1.ReportRouteApprovalResultRequest{
		ProcessId: message.ProcessID,
		Event:     toProtoBookingEvent(message.Event),
	}
}

func RelayRouteApprovalResult(
	ctx context.Context,
	outbox RouteApprovalResultOutbox,
	client TravelBookingClient,
) error {
	pending, err := outbox.TakePendingResult(ctx)
	if err != nil { return err }
	if err := client.ReportRouteApprovalResult(ctx, pending.Result); err != nil {
		return err
	}
	return outbox.MarkResultSent(ctx, pending.ID)
}

type ProcessRelayDeps struct {
	Outbox   CommandOutbox
	Sender   CommandSender
	Interval time.Duration
}

type RouteApprovalResultRelayDeps struct {
	Outbox   RouteApprovalResultOutbox
	Client   TravelBookingClient
	Interval time.Duration
}

func WireProcessCommandSender(
	httpClient *http.Client,
	routeApprovalBaseURL string,
	routePlanning RoutePlanningClient,
	flightBooking FlightBookingClient,
	hotelBooking HotelBookingClient,
) CommandSender {
	routeApprovalClient := routeapprovalv1connect.NewRouteApprovalServiceClient(
		httpClient,
		routeApprovalBaseURL,
	)
	return ContextCommandSender{
		RouteApproval: ConnectRouteApprovalClient{client: routeApprovalClient},
		RoutePlanning: routePlanning,
		FlightBooking: flightBooking,
		HotelBooking:  hotelBooking,
	}
}

func WireRouteApprovalResultClient(
	httpClient *http.Client,
	travelBookingBaseURL string,
) TravelBookingClient {
	client := travelbookingv1connect.NewTravelBookingServiceClient(
		httpClient,
		travelBookingBaseURL,
	)
	return ConnectTravelBookingClient{client: client}
}

func RunProcessRelay(ctx context.Context, deps ProcessRelayDeps) error {
	return Every(ctx, deps.Interval, func() error {
		return RelayPendingCommand(ctx, deps.Outbox, deps.Sender)
	})
}

func RunRouteApprovalResultRelay(ctx context.Context, deps RouteApprovalResultRelayDeps) error {
	return Every(ctx, deps.Interval, func() error {
		return RelayRouteApprovalResult(ctx, deps.Outbox, deps.Client)
	})
}

func TestStartTravelBookingProcessSavesInitialStateAndFirstCommand(t *testing.T) {
	// 検証: 開始時に初期状態と最初の送信予定を同じ保存境界へ渡す。
	store := fakeProcessStore(TravelBookingProcess{})

	err := StartTravelBookingProcess(context.Background(), store, StartTravelBooking{
		ProcessID:      "booking-1",
		Traveler:       "employee-1",
		InitialRouteID: "route-a",
	}, fixedNow())
	if err != nil {
		t.Fatal(err)
	}

	assertState(t, store.SavedProcess, WaitingRouteApproval)
	assertCommandType[RequestRouteApproval](t, store.SavedCommands)
	assertCommandRouteID(t, store.SavedCommands, "route-a")
}

func TestRouteConfirmedBooksFlight(t *testing.T) {
	// 検証: 経路承認の結果で状態が進み、航空券手配コマンドが出る。
	process := TravelBookingProcess{ID: "booking-1", State: WaitingRouteApproval}

	next, commands := process.Apply(RouteConfirmed{RouteID: "route-a"})

	assertState(t, next, BookingFlight)
	assertCommandType[BookFlight](t, commands)
}

func TestRouteRejectedRequestsRerouting(t *testing.T) {
	// 検証: 拒否された経路と手配対象者を保持し、再手配へ進む。
	process := TravelBookingProcess{
		ID: "booking-1", Traveler: "employee-1",
		State: WaitingRouteApproval, RouteID: "route-a",
	}

	next, commands := process.Apply(RouteRejected{})

	assertState(t, next, WaitingReroute)
	assertCommandType[RequestRerouting](t, commands)
	assertCommandTraveler(t, commands, "employee-1")
}

func TestReroutingConfirmedReturnsToApproval(t *testing.T) {
	// 検証: 再手配の結果で、再び経路承認へ戻る。
	process := TravelBookingProcess{ID: "booking-1", State: WaitingReroute}

	next, commands := process.Apply(ReroutingConfirmed{RouteID: "route-b"})

	assertState(t, next, WaitingRouteApproval)
	assertCommandType[RequestRouteApproval](t, commands)
	assertCommandRouteID(t, commands, "route-b")
}

func TestHotelUnavailableCompensates(t *testing.T) {
	// 検証: ホテル不可では航空券取消と手動確認を補償として出す。
	process := TravelBookingProcess{ID: "booking-1", State: BookingHotel}

	next, commands := process.Apply(HotelUnavailable{})

	assertState(t, next, Compensating)
	assertCommandTypes(t, commands, CancelFlight{}, NotifyManualReview{})
}

func TestRelaySendsPendingCommand(t *testing.T) {
	// 検証: relayが送信予定コマンドを連係先送信へ渡す。
	outbox := fakeOutboxWith(BookFlight{ProcessID: "booking-1", RouteID: "route-a"})
	sender := fakeCommandSender{}

	if err := RelayPendingCommand(context.Background(), outbox, sender); err != nil {
		t.Fatal(err)
	}
	assertSent(t, sender, "booking-1")
}

func TestRouteApprovalClientSendsPublicRequest(t *testing.T) {
	// 検証: adapterが内部コマンドを公開APIリクエストへ変換する。
	apiClient := fakeRouteApprovalAPIClient{}
	client := ConnectRouteApprovalClient{client: apiClient}

	err := client.RequestRouteApproval(context.Background(), RequestRouteApproval{
		ProcessID: "booking-1",
		Traveler:  "employee-1",
		RouteID:   "route-a",
	})
	if err != nil {
		t.Fatal(err)
	}
	assertRequestSent(t, apiClient, "booking-1", "route-a")
}

func TestRouteApprovalAPIHandlerCallsApplication(t *testing.T) {
	// 検証: 公開API handlerがリクエストをapplication入口へ渡し、結果を保存する。
	outbox := fakeRouteApprovalResultOutbox{}
	api := RouteApprovalAPI{
		application: RouteApprovalApplication{
			service: fakeRouteApprovalService{RouteID: "route-a"},
			outbox:  outbox,
		},
	}

	_, err := api.RequestRouteApproval(context.Background(), connect.NewRequest(
		&routeapprovalv1.RequestRouteApprovalRequest{
			ProcessId: "booking-1",
			Traveler:  "employee-1",
			RouteId:   "route-a",
		},
	))
	if err != nil {
		t.Fatal(err)
	}
	assertSavedResult(t, outbox, RouteConfirmed{RouteID: "route-a"})
}

func TestRouteApprovalResultRelaySendsToPublicAPI(t *testing.T) {
	// 検証: 経路承認結果のrelayが出張手配の公開APIへ返す。
	outbox := fakeRouteApprovalOutboxWith(TravelBookingResultMessage{
		ProcessID: "booking-1",
		Event:     RouteConfirmed{RouteID: "route-a"},
	})
	apiClient := fakeTravelBookingAPIClient{}
	client := ConnectTravelBookingClient{client: apiClient}

	if err := RelayRouteApprovalResult(context.Background(), outbox, client); err != nil {
		t.Fatal(err)
	}
	assertResultSent(t, apiClient, "booking-1")
	assertResultSent(t, outbox)
}

func TestTravelBookingAPIReportsRouteApprovalResult(t *testing.T) {
	// 検証: 戻った経路承認結果を公開API経由で受け、保存済み状態を進める。
	store := fakeProcessStore(TravelBookingProcess{ID: "booking-1", State: WaitingRouteApproval})
	api := TravelBookingAPI{store: store}

	_, err := api.ReportRouteApprovalResult(context.Background(), connect.NewRequest(
		toProtoRouteApprovalResult(TravelBookingResultMessage{
			ProcessID: "booking-1",
			Event:     RouteConfirmed{RouteID: "route-a"},
		}),
	))
	if err != nil {
		t.Fatal(err)
	}
	assertState(t, store.SavedProcess, BookingFlight)
}

export type BookingState =
  | "waiting_route_approval"
  | "waiting_reroute"
  | "booking_flight"
  | "booking_hotel"
  | "compensating"
  | "completed";

export type TravelBookingProcess = Readonly<{
  id: string;
  traveler: string;
  routeId?: string;
  rejectedRoutes: ReadonlyArray<string>;
  state: BookingState;
  deadline: Date;
  attempts: number;
}>;

export type BookingEvent =
  | { type: "route_confirmed"; routeId: string }
  | { type: "route_rejected" }
  | { type: "rerouting_confirmed"; routeId: string }
  | { type: "flight_booked" }
  | { type: "hotel_booked" }
  | { type: "hotel_unavailable" }
  | { type: "flight_canceled" }
  | { type: "booking_timed_out" };

export type TravelBookingResultMessage = Readonly<{
  processId: string;
  event: BookingEvent;
}>;

export type StartTravelBooking = Readonly<{
  processId: string;
  traveler: string;
  initialRouteId: string;
}>;
export type Command =
  | { type: "request_route_approval"; processId: string; traveler: string; routeId: string }
  | { type: "request_rerouting"; processId: string; traveler: string; rejectedRoutes: ReadonlyArray<string> }
  | { type: "book_flight"; processId: string; routeId: string }
  | { type: "book_hotel"; processId: string; traveler: string }
  | { type: "cancel_flight"; processId: string }
  | { type: "notify_manual_review"; processId: string };

export const initializeTravelBooking = (
  command: StartTravelBooking,
  now: Date
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => [{
  id: command.processId,
  traveler: command.traveler,
  routeId: command.initialRouteId,
  state: "waiting_route_approval",
  rejectedRoutes: [],
  deadline: new Date(now.getTime() + 48 * 60 * 60 * 1000),
  attempts: 0
}, [{
  type: "request_route_approval",
  processId: command.processId,
  traveler: command.traveler,
  routeId: command.initialRouteId
	}]];

export type ProcessStore = Readonly<{
  load: (processId: string) => Promise<TravelBookingProcess>;
  saveWithCommands: (
    process: TravelBookingProcess,
    commands: ReadonlyArray<Command>
  ) => Promise<void>;
}>;

export const startTravelBookingProcess = async (
  store: ProcessStore,
  command: StartTravelBooking,
  now: Date
): Promise<void> => {
  const [process, commands] = initializeTravelBooking(command, now);
  await store.saveWithCommands(process, commands);
};

export const applyBookingEvent = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  switch (process.state) {
    case "waiting_route_approval":
      return applyWaitingRouteApproval(process, event);
    case "waiting_reroute":
      return applyWaitingReroute(process, event);
    case "booking_flight":
      return applyBookingFlight(process, event);
    case "booking_hotel":
      return applyBookingHotel(process, event);
    default:
      return applyTimeoutOrIgnore(process, event);
  }
};

const applyWaitingRouteApproval = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  if (event.type === "route_confirmed") {
    return [{ ...process, state: "booking_flight", routeId: event.routeId }, [
      { type: "book_flight", processId: process.id, routeId: event.routeId }
    ]];
  }
  if (event.type === "route_rejected") {
    const rejectedRoutes = process.routeId ? [...process.rejectedRoutes, process.routeId] : process.rejectedRoutes;
    return [{ ...process, state: "waiting_reroute", rejectedRoutes }, [
      { type: "request_rerouting", processId: process.id, traveler: process.traveler, rejectedRoutes }
    ]];
  }
  return [process, []];
};

const applyWaitingReroute = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  if (event.type !== "rerouting_confirmed") return [process, []];
  return [{ ...process, state: "waiting_route_approval", routeId: event.routeId }, [
    { type: "request_route_approval", processId: process.id, traveler: process.traveler, routeId: event.routeId }
  ]];
};

const applyBookingFlight = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  if (event.type !== "flight_booked") return [process, []];
  return [{ ...process, state: "booking_hotel" }, [
    { type: "book_hotel", processId: process.id, traveler: process.traveler }
  ]];
};

const applyBookingHotel = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  if (event.type === "hotel_booked") return [{ ...process, state: "completed" }, []];
  if (event.type !== "hotel_unavailable") return [process, []];
  return [{ ...process, state: "compensating" }, [
    { type: "cancel_flight", processId: process.id },
    { type: "notify_manual_review", processId: process.id }
  ]];
};

const applyTimeoutOrIgnore = (
  process: TravelBookingProcess,
  event: BookingEvent
): readonly [TravelBookingProcess, ReadonlyArray<Command>] => {
  if (event.type !== "booking_timed_out") return [process, []];
  return [{ ...process, state: "compensating" }, [
    { type: "notify_manual_review", processId: process.id }
  ]];
};

export const handleBookingEvent = async (
  store: ProcessStore,
  processId: string,
  event: BookingEvent
): Promise<void> => {
  const process = await store.load(processId);
  const [next, commands] = applyBookingEvent(process, event);
  await store.saveWithCommands(next, commands);
};

export type ProcessStoreTransaction = Readonly<{
  loadProcess: (processId: string) => Promise<TravelBookingProcess>;
  saveProcess: (process: TravelBookingProcess) => Promise<void>;
  appendCommands: (
    processId: string,
    commands: ReadonlyArray<Command>
  ) => Promise<void>;
}>;

export type TransactionalDatabase = Readonly<{
  withTransaction: <A>(
    fn: (tx: ProcessStoreTransaction) => Promise<A>
  ) => Promise<A>;
}>;

export const postgresProcessStore = (db: TransactionalDatabase): ProcessStore => ({
  load: (processId) =>
    db.withTransaction((tx) => tx.loadProcess(processId)),

  saveWithCommands: (process, commands) =>
    db.withTransaction(async (tx) => {
      await tx.saveProcess(process);
      await tx.appendCommands(process.id, commands);
    })
});

export type CommandSender = Readonly<{
  send: (command: Command) => Promise<void>;
}>;

export type RouteApprovalClient = Readonly<{
  requestRouteApproval: (command: Extract<Command, { type: "request_route_approval" }>) => Promise<void>;
}>;

export type RoutePlanningClient = Readonly<{
  requestRerouting: (command: Extract<Command, { type: "request_rerouting" }>) => Promise<void>;
}>;

export type FlightBookingClient = Readonly<{
  bookFlight: (command: Extract<Command, { type: "book_flight" }>) => Promise<void>;
  cancelFlight: (command: Extract<Command, { type: "cancel_flight" }>) => Promise<void>;
}>;

export type HotelBookingClient = Readonly<{
  bookHotel: (command: Extract<Command, { type: "book_hotel" }>) => Promise<void>;
}>;

export const contextCommandSender = ({
  routeApproval,
  routePlanning,
  flightBooking,
  hotelBooking
}: {
  routeApproval: RouteApprovalClient;
  routePlanning: RoutePlanningClient;
  flightBooking: FlightBookingClient;
  hotelBooking: HotelBookingClient;
}): CommandSender => ({
  send: async (command) => {
    switch (command.type) {
      case "request_route_approval":
        return routeApproval.requestRouteApproval(command);
      case "request_rerouting":
        return routePlanning.requestRerouting(command);
      case "book_flight":
        return flightBooking.bookFlight(command);
      case "book_hotel":
        return hotelBooking.bookHotel(command);
      case "cancel_flight":
        return flightBooking.cancelFlight(command);
      default:
        throw new Error(`unsupported command: ${command.type}`);
    }
  }
});

export type RouteApprovalRequest = Readonly<{
  processId: string;
  traveler: string;
  routeId: string;
}>;

export type RouteApprovalApiClient = Readonly<{
  requestRouteApproval: (request: RouteApprovalRequest) => Promise<void>;
}>;

export const routeApprovalApiClient = (
  client: RouteApprovalApiClient
): RouteApprovalClient => ({
  requestRouteApproval: (command): Promise<void> =>
    client.requestRouteApproval(toRouteApprovalRequest(command))
});

const toRouteApprovalRequest = (
  command: Extract<Command, { type: "request_route_approval" }>
): RouteApprovalRequest => ({
  processId: command.processId,
  traveler: command.traveler,
  routeId: command.routeId
});

export type PendingCommand = Readonly<{
  id: string;
  processId: string;
  command: Command;
}>;

export type CommandOutbox = Readonly<{
  takePending: () => Promise<PendingCommand>;
  markSent: (commandId: string) => Promise<void>;
}>;

export const relayPendingCommand = async (
  outbox: CommandOutbox,
  sender: CommandSender
): Promise<void> => {
  const pending = await outbox.takePending();
  await sender.send(pending.command);
  await outbox.markSent(pending.id);
};

export type PendingRouteApprovalResult = Readonly<{
  id: string;
  result: TravelBookingResultMessage;
}>;

export type RouteApprovalResultOutbox = Readonly<{
  saveResult: (result: TravelBookingResultMessage) => Promise<void>;
  takePendingResult: () => Promise<PendingRouteApprovalResult>;
  markResultSent: (resultId: string) => Promise<void>;
}>;

export type RouteApprovalApi = Readonly<{
  requestRouteApproval: (request: RouteApprovalRequest) => Promise<void>;
}>;

type RequestRouteApprovalCommand = Extract<Command, { type: "request_route_approval" }>;

export type RouteApprovalApplication = Readonly<{
  handleRequestRouteApproval: (command: RequestRouteApprovalCommand) => Promise<void>;
}>;

export const routeApprovalApi = (
  application: RouteApprovalApplication
): RouteApprovalApi => ({
  requestRouteApproval: (request): Promise<void> =>
    application.handleRequestRouteApproval(fromRouteApprovalRequest(request))
});

const fromRouteApprovalRequest = (
  request: RouteApprovalRequest
): RequestRouteApprovalCommand => ({
  type: "request_route_approval",
  processId: request.processId,
  traveler: request.traveler,
  routeId: request.routeId
});

export type RouteApprovalService = Readonly<{
  confirmRoute: (command: RequestRouteApprovalCommand) => Promise<Readonly<{
    routeId?: string;
    rejected: boolean;
  }>>;
}>;

export const routeApprovalApplication = ({
  service,
  outbox
}: {
  service: RouteApprovalService;
  outbox: RouteApprovalResultOutbox;
}) => ({
  handleRequestRouteApproval: async (command: RequestRouteApprovalCommand): Promise<void> => {
    const decision = await service.confirmRoute(command);
    await outbox.saveResult({
      processId: command.processId,
      event: decision.rejected
        ? { type: "route_rejected" }
        : { type: "route_confirmed", routeId: decision.routeId ?? "" }
    });
  }
});

export type ReportRouteApprovalResultRequest = Readonly<{
  processId: string;
  event: TravelBookingResultMessage["event"];
}>;

export const travelBookingApi = (store: ProcessStore) => ({
  reportRouteApprovalResult: (request: ReportRouteApprovalResultRequest): Promise<void> =>
    handleRouteApprovalResult(store, fromRouteApprovalResultRequest(request))
});

export const handleRouteApprovalResult = async (
  store: ProcessStore,
  message: TravelBookingResultMessage
): Promise<void> =>
  handleBookingEvent(store, message.processId, message.event);

const fromRouteApprovalResultRequest = (
  request: ReportRouteApprovalResultRequest
): TravelBookingResultMessage => ({
  processId: request.processId,
  event: request.event
});

export type TravelBookingClient = Readonly<{
  reportRouteApprovalResult: (message: TravelBookingResultMessage) => Promise<void>;
}>;

export type TravelBookingApiClient = Readonly<{
  reportRouteApprovalResult: (request: ReportRouteApprovalResultRequest) => Promise<void>;
}>;

export const travelBookingApiClient = (
  client: TravelBookingApiClient
): TravelBookingClient => ({
  reportRouteApprovalResult: (message): Promise<void> =>
    client.reportRouteApprovalResult(toRouteApprovalResultRequest(message))
});

const toRouteApprovalResultRequest = (
  message: TravelBookingResultMessage
): ReportRouteApprovalResultRequest => ({
  processId: message.processId,
  event: message.event
});

export const relayRouteApprovalResult = async (
  outbox: RouteApprovalResultOutbox,
  client: TravelBookingClient
): Promise<void> => {
  const pending = await outbox.takePendingResult();
  await client.reportRouteApprovalResult(pending.result);
  await outbox.markResultSent(pending.id);
};

export const runProcessRelay = ({
  outbox,
  sender,
  intervalMs
}: {
  outbox: CommandOutbox;
  sender: CommandSender;
  intervalMs: number;
}): ReturnType<typeof setInterval> =>
  setInterval(() => {
    void relayPendingCommand(outbox, sender).catch(recordRelayFailure);
  }, intervalMs);

export const runRouteApprovalResultRelay = ({
  outbox,
  client,
  intervalMs
}: {
  outbox: RouteApprovalResultOutbox;
  client: TravelBookingClient;
  intervalMs: number;
}): ReturnType<typeof setInterval> =>
  setInterval(() => {
    void relayRouteApprovalResult(outbox, client).catch(recordRelayFailure);
  }, intervalMs);

export const wireProcessCommandSender = ({
  routeApprovalClient,
  routePlanning,
  flightBooking,
  hotelBooking
}: {
  routeApprovalClient: RouteApprovalApiClient;
  routePlanning: RoutePlanningClient;
  flightBooking: FlightBookingClient;
  hotelBooking: HotelBookingClient;
}): CommandSender =>
  contextCommandSender({
    routeApproval: routeApprovalApiClient(routeApprovalClient),
    routePlanning,
    flightBooking,
    hotelBooking
  });

export const wireRouteApprovalResultClient = (
  client: TravelBookingApiClient
): TravelBookingClient =>
  travelBookingApiClient(client);

it("saves the initial state and first command when starting", async () => {
  // 検証: 開始時に初期状態と最初の送信予定を同じ保存境界へ渡す。
  const store = fakeProcessStore();

  await startTravelBookingProcess(store, {
    processId: "booking-1",
    traveler: "employee-1",
    initialRouteId: "route-a"
  }, fixedNow());

  expect(store.savedProcess.state).toBe("waiting_route_approval");
  expect(store.savedCommands[0]).toMatchObject({
    type: "request_route_approval",
    routeId: "route-a"
  });
});

it("books a flight after route approval", () => {
  // 検証: 経路承認の結果で状態が進み、航空券手配コマンドが出る。
  const [next, commands] = applyBookingEvent(
    travelBookingFixture({ state: "waiting_route_approval" }),
    { type: "route_confirmed", routeId: "route-a" }
  );

  expect(next.state).toBe("booking_flight");
  expect(commands).toEqual([{ type: "book_flight", processId: next.id, routeId: "route-a" }]);
});

it("requests rerouting when the selected route is rejected", () => {
  // 検証: 拒否された経路を保持し、再手配へ進む。
  const process = travelBookingFixture({
    state: "waiting_route_approval",
    routeId: "route-a",
    rejectedRoutes: []
  });

  const [next, commands] = applyBookingEvent(process, { type: "route_rejected" });

  expect(next.state).toBe("waiting_reroute");
  expect(commands).toEqual([
    {
      type: "request_rerouting",
      processId: process.id,
      traveler: process.traveler,
      rejectedRoutes: ["route-a"]
    }
  ]);
});

it("returns to approval after rerouting", () => {
  // 検証: 再手配の結果で、再び経路承認へ戻る。
  const [next, commands] = applyBookingEvent(
    travelBookingFixture({ state: "waiting_reroute" }),
    { type: "rerouting_confirmed", routeId: "route-b" }
  );

  expect(next.state).toBe("waiting_route_approval");
  expect(commands[0]).toMatchObject({
    type: "request_route_approval",
    routeId: "route-b"
  });
});

it("compensates when the hotel is unavailable", () => {
  // 検証: ホテル不可では航空券取消と手動確認を補償として出す。
  const [next, commands] = applyBookingEvent(
    travelBookingFixture({ state: "booking_hotel" }),
    { type: "hotel_unavailable" }
  );

  expect(next.state).toBe("compensating");
  expect(commands.map((command) => command.type)).toEqual(["cancel_flight", "notify_manual_review"]);
});

it("sends a pending command through the relay", async () => {
  // 検証: relayが送信予定コマンドを連係先送信へ渡す。
  const sender = fakeCommandSender();
  await relayPendingCommand(
    fakeOutboxWith({ type: "book_flight", processId: "booking-1", routeId: "route-a" }),
    sender
  );

  expect(sender.sent).toEqual([{ type: "book_flight", processId: "booking-1", routeId: "route-a" }]);
});

it("sends route approval through the public API client", async () => {
  // 検証: adapterが内部コマンドを公開APIリクエストへ変換する。
  const apiClient = fakeRouteApprovalApiClient();
  const client = routeApprovalApiClient(apiClient);

  await client.requestRouteApproval({
    type: "request_route_approval",
    processId: "booking-1",
    traveler: "employee-1",
    routeId: "route-a"
  });

  expect(apiClient.sentRequest).toEqual({
    processId: "booking-1",
    traveler: "employee-1",
    routeId: "route-a"
  });
});

it("routes the public API request into the route approval application", async () => {
  // 検証: 公開API handlerがリクエストをapplication入口へ渡し、結果を保存する。
  const outbox = fakeRouteApprovalResultOutbox();
  const api = routeApprovalApi(
    routeApprovalApplication({
      service: fakeRouteApprovalService({ routeId: "route-a" }),
      outbox
    })
  );

  await api.requestRouteApproval({
    processId: "booking-1",
    traveler: "employee-1",
    routeId: "route-a"
  });

  expect(outbox.savedResult).toEqual({
    processId: "booking-1",
    event: { type: "route_confirmed", routeId: "route-a" }
  });
});

it("relays a route approval result to the travel booking API", async () => {
  // 検証: 経路承認結果のrelayが出張手配の公開APIへ返す。
  const apiClient = fakeTravelBookingApiClient();
  const client = travelBookingApiClient(apiClient);

  await relayRouteApprovalResult(
    fakeRouteApprovalOutboxWith({
      processId: "booking-1",
      event: { type: "route_confirmed", routeId: "route-a" }
    }),
    client
  );

  expect(apiClient.sentRequest).toEqual({
    processId: "booking-1",
    event: { type: "route_confirmed", routeId: "route-a" }
  });
});

it("reports a route approval result into the travel booking API", async () => {
  // 検証: 戻った経路承認結果を公開API経由で受け、保存済み状態を進める。
  const store = fakeProcessStore(travelBookingFixture({ state: "waiting_route_approval" }));
  const api = travelBookingApi(store);

  await api.reportRouteApprovalResult({
    processId: "booking-1",
    event: { type: "route_confirmed", routeId: "route-a" }
  });

  expect(store.savedProcess.state).toBe("booking_flight");
});