// ❌ Distributed monolith — three "microservices" sharing one database
// This is a monolith with extra network hops and none of the isolation benefits

// order-service/src/resolvers/getOrderDetail.ts
import { db } from '@company/shared-database-client' // shared schema, shared migrations

async function getOrderDetail(orderId: string) {
  // OrderService reads Users and Products tables directly —
  // it is coupled to their schema at the database level
  return db.query(`
    SELECT o.id, o.status, o.total_cents,
           u.name, u.email, u.billing_address,
           p.sku, p.title, p.inventory_count
    FROM   orders o
    JOIN   users   u ON o.user_id    = u.id
    JOIN   products p ON o.product_id = p.id
    WHERE  o.id = $1
  `, [orderId])
}

// ✅ Correct — Order context holds a reference, not a join target
interface OrderLineItem {
  productId: string        // opaque reference to Catalog context
  productName: string      // denormalized at order-creation time (catalog snapshot)
  unitPriceCents: number   // denormalized from Pricing context at order-creation time
  quantity: number
}
// The Order context never queries the Catalog or Pricing databases.
// Subsequent catalog changes do not mutate historical orders.

// ❌ Big-bang rewrite plan
// Sprint 1–12: Build the new microservice in parallel
// Day N: Flip the switch, turn off the monolith
// Day N+1: Production incident — the new service has no battle-tested edge cases

// ✅ Anti-Corruption Layer — translates legacy monolith response into bounded context model
class MonolithInventoryAdapter {
  async getStock(sku: string): Promise<InventoryItem> {
    const raw = await this.monolithClient.get(`/legacy/product_stock?product_code=${sku}`)
    return {
      sku: raw.product_code,          // legacy field name differs
      quantityOnHand: raw.qty_available,
      reservedCount: raw.qty_reserved ?? 0,
      warehouseId: raw.warehouse_id.toString()
    }
  }
}

// ✅ Consumer-driven contract — Order Service defines what it needs from Inventory
import { PactV3, MatchersV3 } from '@pact-foundation/pact'
const { like, integer } = MatchersV3

const provider = new PactV3({ consumer: 'OrderService', provider: 'InventoryService' })

describe('InventoryClient Pact', () => {
  it('returns stock level for a valid SKU', async () => {
    await provider
      .given('SKU-001 has 42 units in stock')
      .uponReceiving('a request for stock level')
      .withRequest({ method: 'GET', path: '/stock/SKU-001' })
      .willRespondWith({
        status: 200,
        body: { sku: like('SKU-001'), quantityOnHand: integer(42), reservedCount: integer(0) }
      })
      .executeTest(async (mockServer) => {
        const client = new InventoryClient(mockServer.url)
        const result = await client.getStock('SKU-001')
        expect(result.quantityOnHand).toBe(42)
      })
  })
})

// ✅ Every new service ships with structured logging, health checks, and distributed tracing
import { trace } from '@opentelemetry/api'

// Structured logging with trace context
logger.info('reserve stock', {
  traceId: trace.getActiveSpan()?.spanContext().traceId,
  sku, quantity, orderId
})

// Liveness + readiness probes
app.get('/health/live',  (_, res) => res.json({ status: 'ok' }))
app.get('/health/ready', async (_, res) => {
  const dbOk = await db.ping().catch(() => false)
  res.status(dbOk ? 200 : 503).json({ status: dbOk ? 'ready' : 'degraded' })
})