Client: "I need the product name, the first image URL, the current stock level,
         and whether this product is in the user's wishlist — as a single request."

API Gateway: "I can route you to Product Service, Image Service, Inventory Service,
              and Wishlist Service. Make four requests."

Desktop Web BFF    → serves apps/web (desktop browser, rich interactions)
Mobile BFF         → serves apps/mobile (React Native, battery-constrained, offline)
Partner API BFF    → serves third-party integrators (stable versioned API, OpenAPI spec)

// src/server.ts
import Fastify from 'fastify'
import { Type, type Static } from '@sinclair/typebox'
import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'

const app = Fastify({
  logger: {
    transport: {
      target: 'pino-pretty',
      options: { colorize: true }
    }
  }
}).withTypeProvider<TypeBoxTypeProvider>()

// Register plugins
await app.register(import('./plugins/downstream-clients.js'))
await app.register(import('./routes/product-page.js'))
await app.register(import('./routes/health.js'))

export default app

// src/plugins/downstream-clients.ts
import fp from 'fastify-plugin'

export default fp(async function downstreamClients(app) {
  // Typed fetch wrappers for each downstream service
  app.decorate('services', {
    product: createServiceClient('https://product-service.internal'),
    inventory: createServiceClient('https://inventory-service.internal'),
    recommendations: createServiceClient('https://rec-service.internal'),
    wishlist: createServiceClient('https://wishlist-service.internal')
  })
})

function createServiceClient(baseUrl: string) {
  return {
    async get<T>(path: string, options?: RequestInit): Promise<T> {
      const res = await fetch(`${baseUrl}${path}`, {
        ...options,
        signal: AbortSignal.timeout(3000)  // 3-second per-service timeout
      })
      if (!res.ok) throw new Error(`${res.status} from ${baseUrl}${path}`)
      return res.json() as Promise<T>
    }
  }
}

// src/routes/product-page.ts
import { Type, type Static } from '@sinclair/typebox'
import fp from 'fastify-plugin'

// Request schema
const ProductPageParams = Type.Object({
  productId: Type.String({ minLength: 1, maxLength: 64 })
})

const ProductPageQuery = Type.Object({
  userId: Type.Optional(Type.String())
})

// Response schema — only the fields the client UI actually needs
const ProductPageResponse = Type.Object({
  product: Type.Object({
    id: Type.String(),
    name: Type.String(),
    description: Type.String(),
    price: Type.Number(),
    imageUrl: Type.String()
  }),
  stock: Type.Object({
    available: Type.Boolean(),
    quantity: Type.Integer()
  }),
  recommendations: Type.Array(Type.Object({
    id: Type.String(),
    name: Type.String(),
    price: Type.Number(),
    imageUrl: Type.String()
  })),
  isWishlisted: Type.Boolean()
})

export type ProductPageResponse = Static<typeof ProductPageResponse>

export default fp(async function productPageRoutes(app) {
  app.get<{
    Params: Static<typeof ProductPageParams>
    Querystring: Static<typeof ProductPageQuery>
  }>(
    '/api/product/:productId',
    {
      schema: {
        params: ProductPageParams,
        querystring: ProductPageQuery,
        response: { 200: ProductPageResponse }
      }
    },
    async (request, reply) => {
      const { productId } = request.params
      const { userId } = request.query

      // Fan-out: call all services concurrently
      const [productResult, stockResult, recsResult, wishlistResult] =
        await Promise.allSettled([
          app.services.product.get<RawProduct>(`/products/${productId}`),
          app.services.inventory.get<RawStock>(`/stock/${productId}`),
          app.services.recommendations.get<RawRec[]>(`/recommendations?productId=${productId}&limit=4`),
          userId
            ? app.services.wishlist.get<RawWishlist>(`/wishlist/${userId}?productId=${productId}`)
            : Promise.resolve({ contains: false })
        ])

      // Critical service failures → 503
      if (productResult.status === 'rejected') {
        request.log.error({ err: productResult.reason }, 'Product service unavailable')
        return reply.status(503).send({ error: 'Product information unavailable' })
      }

      // Non-critical service failures → graceful degradation
      const stock = stockResult.status === 'fulfilled'
        ? stockResult.value
        : { available: true, quantity: 0 }    // Assume in-stock on inventory failure

      const recommendations = recsResult.status === 'fulfilled'
        ? recsResult.value.slice(0, 4)
        : []                                    // Empty recommendations on failure

      const isWishlisted = wishlistResult.status === 'fulfilled'
        ? wishlistResult.value.contains
        : false                                 // Assume not wishlisted on failure

      if (stockResult.status === 'rejected') {
        request.log.warn({ productId }, 'Inventory service degraded — serving default stock response')
      }

      const product = productResult.value
      
      return reply.send({
        product: {
          id: product.id,
          name: product.name,
          description: product.description,
          price: product.pricing.basePrice,   // Slim: flatten nested pricing object
          imageUrl: product.images[0]?.url ?? ''
        },
        stock,
        recommendations: recommendations.map(r => ({
          id: r.productId,
          name: r.title,
          price: r.pricing.basePrice,
          imageUrl: r.images[0]?.url ?? ''
        })),
        isWishlisted
      })
    }
  )
})

// ❌ Using Promise.all — one failure aborts everything
const [product, stock, recommendations, wishlist] = await Promise.all([
  app.services.product.get(`/products/${productId}`),
  app.services.inventory.get(`/stock/${productId}`),
  app.services.recommendations.get(`/recommendations?productId=${productId}`),
  app.services.wishlist.get(`/wishlist/${userId}`)
])
// If recommendations service is down, this throws.
// User sees a 500 error for a product page that COULD have rendered.

// ✅ Using Promise.allSettled — each failure is handled independently
const results = await Promise.allSettled([...])
// Classify each result: fulfilled → use value, rejected → use safe default

// src/plugins/circuit-breakers.ts
import CircuitBreaker from 'opossum'
import fp from 'fastify-plugin'

export default fp(async function circuitBreakers(app) {
  const options = {
    timeout: 3000,          // Mark call as failure if it exceeds 3s
    errorThresholdPercentage: 50,  // Open circuit when 50% of requests fail
    resetTimeout: 30000     // After 30s, attempt to close circuit (half-open state)
  }

  const recommendationsBreaker = new CircuitBreaker(
    (productId: string) => 
      app.services.recommendations.get<RawRec[]>(`/recommendations?productId=${productId}`),
    options
  )

  recommendationsBreaker.on('open', () => {
    app.log.warn('Recommendations circuit breaker OPEN — all calls will fast-fail')
  })
  recommendationsBreaker.on('halfOpen', () => {
    app.log.info('Recommendations circuit breaker HALF-OPEN — testing recovery')
  })
  recommendationsBreaker.on('close', () => {
    app.log.info('Recommendations circuit breaker CLOSED — service recovered')
  })

  app.decorate('breakers', { recommendations: recommendationsBreaker })
})

// src/index.ts — Cloudflare Worker + Hono
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono<{ Bindings: CloudflareBindings }>()

const ProductParamsSchema = z.object({
  productId: z.string().min(1).max(64)
})

app.get(
  '/api/product/:productId',
  zValidator('param', ProductParamsSchema),
  async (c) => {
    const { productId } = c.req.valid('param')
    const userId = c.req.query('userId')

    // Edge-compatible concurrent fetch with Web Standards AbortSignal
    const controller = new AbortController()
    const timeout = setTimeout(() => controller.abort(), 5000)

    const [productRes, stockRes, recsRes] = await Promise.allSettled([
      fetch(`${c.env.PRODUCT_SERVICE_URL}/products/${productId}`, {
        signal: controller.signal
      }),
      fetch(`${c.env.INVENTORY_SERVICE_URL}/stock/${productId}`, {
        signal: controller.signal
      }),
      fetch(`${c.env.REC_SERVICE_URL}/recommendations?productId=${productId}`, {
        signal: controller.signal
      })
    ])

    clearTimeout(timeout)

    if (productRes.status === 'rejected' || !productRes.value.ok) {
      return c.json({ error: 'Product information unavailable' }, 503)
    }

    const product = await productRes.value.json<RawProduct>()

    const stock = stockRes.status === 'fulfilled' && stockRes.value.ok
      ? await stockRes.value.json<RawStock>()
      : { available: true, quantity: 0 }

    const recs = recsRes.status === 'fulfilled' && recsRes.value.ok
      ? (await recsRes.value.json<RawRec[]>()).slice(0, 4)
      : []

    return c.json({
      product: {
        id: product.id,
        name: product.name,
        description: product.description,
        price: product.pricing.basePrice,
        imageUrl: product.images[0]?.url ?? ''
      },
      stock,
      recommendations: recs.map(r => ({
        id: r.productId,
        name: r.title,
        price: r.pricing.basePrice,
        imageUrl: r.images[0]?.url ?? ''
      }))
    })
  }
)

export default app

// src/plugins/tracing.ts
import fp from 'fastify-plugin'

export default fp(async function tracing(app) {
  app.addHook('onRequest', async (request, reply) => {
    // Extract incoming traceparent from browser (if set by OpenTelemetry browser SDK)
    const traceparent = request.headers['traceparent'] ?? generateTraceparent()
    
    // Make it available to route handlers
    request.traceparent = traceparent
  })
})

function generateTraceparent(): string {
  const traceId = crypto.randomUUID().replace(/-/g, '')
  const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16)
  return `00-${traceId}-${spanId}-01`
}

// Pass traceparent to every downstream call
function createServiceClient(baseUrl: string) {
  return {
    async get<T>(path: string, traceparent: string): Promise<T> {
      const res = await fetch(`${baseUrl}${path}`, {
        headers: {
          'traceparent': traceparent,
          'Content-Type': 'application/json'
        },
        signal: AbortSignal.timeout(3000)
      })
      if (!res.ok) throw new Error(`${res.status} from ${baseUrl}${path}`)
      return res.json() as Promise<T>
    }
  }
}

// src/routes/health.ts
import fp from 'fastify-plugin'

export default fp(async function healthRoutes(app) {
  // Liveness: is the process running?
  app.get('/health/live', async () => ({ status: 'ok' }))

  // Readiness: can the BFF serve traffic? (checks downstream connectivity)
  app.get('/health/ready', async (request, reply) => {
    const checks = await Promise.allSettled([
      app.services.product.get('/health'),
      app.services.inventory.get('/health')
    ])

    const allReady = checks.every(c => c.status === 'fulfilled')

    if (!allReady) {
      return reply.status(503).send({ status: 'degraded' })
    }

    return { status: 'ready' }
  })
})

// src/main.ts
import app from './server.js'

const port = parseInt(process.env.PORT ?? '3001', 10)

await app.listen({ port, host: '0.0.0.0' })

// Graceful shutdown: wait for in-flight requests to complete
const shutdown = async (signal: string) => {
  app.log.info(`${signal} received — graceful shutdown`)
  await app.close()
  process.exit(0)
}

process.on('SIGTERM', () => shutdown('SIGTERM'))
process.on('SIGINT', () => shutdown('SIGINT'))