API Gateway Pattern in FTGO: REST and GraphQL

// OrderConfiguration.java
@Configuration
@EnableConfigurationProperties(OrderDestinations.class)
public class OrderConfiguration {

  @Bean
  public RouteLocator orderProxyRouting(RouteLocatorBuilder builder,
                                        OrderDestinations orderDestinations) {
    return builder.routes()
        // POST/PUT /orders  → Order Service
        .route(r -> r.path("/orders").and().method("POST")
                     .uri(orderDestinations.getOrderServiceUrl()))
        .route(r -> r.path("/orders").and().method("PUT")
                     .uri(orderDestinations.getOrderServiceUrl()))
        .route(r -> r.path("/orders/**").and().method("POST")
                     .uri(orderDestinations.getOrderServiceUrl()))
        .route(r -> r.path("/orders/**").and().method("PUT")
                     .uri(orderDestinations.getOrderServiceUrl()))
        // GET /orders  → Order History Service (CQRS read model)
        .route(r -> r.path("/orders").and().method("GET")
                     .uri(orderDestinations.getOrderHistoryServiceUrl()))
        .build();
  }

  @Bean
  public RouterFunction<ServerResponse> orderHandlerRouting(
      OrderHandlers orderHandlers) {
    // GET /orders/{orderId} → composed response
    return RouterFunctions.route(
        GET("/orders/{orderId}"),
        orderHandlers::getOrderDetails);
  }
}

// OrderHandlers.java
public Mono<ServerResponse> getOrderDetails(ServerRequest serverRequest) {
  String orderId = serverRequest.pathVariable("orderId");

  Mono<OrderInfo> orderInfo =
      orderService.findOrderById(orderId);

  Mono<Optional<TicketInfo>> ticketInfo =
      kitchenService.findTicketById(orderId)
          .map(Optional::of)
          .onErrorReturn(Optional.empty());

  Mono<Optional<DeliveryInfo>> deliveryInfo =
      deliveryService.findDeliveryByOrderId(orderId)
          .map(Optional::of)
          .onErrorReturn(Optional.empty());

  Mono<Optional<BillInfo>> billInfo =
      accountingService.findBillByOrderId(orderId)
          .map(Optional::of)
          .onErrorReturn(Optional.empty());

  Mono<Tuple4<OrderInfo,
              Optional<TicketInfo>,
              Optional<DeliveryInfo>,
              Optional<BillInfo>>> combined =
      Mono.zip(orderInfo, ticketInfo, deliveryInfo, billInfo);

  Mono<OrderDetails> orderDetails =
      combined.map(OrderDetails::makeOrderDetails);

  return orderDetails
      .flatMap(od -> ServerResponse.ok()
          .contentType(MediaType.APPLICATION_JSON)
          .body(fromObject(od)))
      .onErrorResume(OrderNotFoundException.class,
          e -> ServerResponse.notFound().build());
}

// ftgo-api-gateway-graphql/src/schema.js
const typeDefs = gql`
  type Query {
    orders(consumerId: Int!): [Order]
    order(orderId: Int!): Order
    consumer(consumerId: Int!): Consumer
  }

  type Mutation {
    createConsumer(c: ConsumerInfo): Consumer
  }

  type Order {
    orderId: ID
    consumerId: Int
    consumer: Consumer
    restaurant: Restaurant
    deliveryInfo: DeliveryInfo
  }

  type Restaurant {
    id: ID
    name: String
  }

  type Consumer {
    id: ID
    firstName: String
    lastName: String
    orders: [Order]
  }

  input ConsumerInfo {
    firstName: String
    lastName: String
  }

  type DeliveryInfo {
    status: DeliveryStatus
    estimatedDeliveryTime: Int
    assignedCourier: String
  }

  enum DeliveryStatus {
    PREPARING
    READY_FOR_PICKUP
    PICKED_UP
    DELIVERED
  }
`;

// Root query resolvers
function resolveOrders(_, { consumerId }, context) {
  return context.orderServiceProxy.findOrders(consumerId);
}

function resolveOrder(_, { orderId }, context) {
  return context.orderServiceProxy.findOrder(orderId);
}

function resolveConsumer(_, { consumerId }, context) {
  return context.consumerServiceProxy.findConsumer(consumerId);
}

// Field resolvers on Order
function resolveOrderConsumer({ consumerId }, args, context) {
  return context.consumerServiceProxy.findConsumer(consumerId);
}

function resolveOrderRestaurant({ restaurantId }, args, context) {
  return context.restaurantServiceProxy.findRestaurant(restaurantId);
}

function resolveOrderDeliveryInfo({ orderId }, args, context) {
  return context.deliveryServiceProxy.findDeliveryForOrder(orderId);
}

// Field resolver on Consumer — reuse pre-fetched orders if available
function resolveConsumerOrders({ id, orders }, args, context) {
  return orders || context.orderServiceProxy.findOrders(id);
}

const resolvers = {
  Query:    { orders: resolveOrders, consumer: resolveConsumer, order: resolveOrder },
  Mutation: { createConsumer: createConsumer },
  Order:    { consumer: resolveOrderConsumer, restaurant: resolveOrderRestaurant,
              deliveryInfo: resolveOrderDeliveryInfo },
  Consumer: { orders: resolveConsumerOrders },
};