#内置 HTTP 客户端 (app.fetch)

import { defineRoutes } from 'vextjs';

export default defineRoutes((app) => {
  app.get('/users/:id/posts', {
    validate: { param: { id: 'string!' } },
  }, async (req, res) => {
    const { id } = req.valid('param');

    // 使用 app.fetch 调用下游服务
    const response = await app.fetch(`https://api.example.com/users/${id}/posts`);
    const posts = await response.json();

    res.json(posts);
  });
});

const response = await app.fetch.get('https://api.example.com/users');
const users = await response.json();

const response = await app.fetch.post('https://api.example.com/users', {
  name: '张三',
  email: 'zhangsan@example.com',
});
const newUser = await response.json();

const response = await app.fetch.put(`https://api.example.com/users/${id}`, {
  name: '李四',
  email: 'lisi@example.com',
});

const response = await app.fetch.patch(`https://api.example.com/users/${id}`, {
  name: '王五',
});

const response = await app.fetch.delete(`https://api.example.com/users/${id}`);

// vext.config.ts
export default {
  port: 3000,
  fetch: {
    timeout: 10000,          // 全局默认超时（毫秒），默认 10000
    retry: 2,                // 默认重试次数（仅幂等方法），默认 0
    retryDelay: 1000,        // 默认重试间隔（毫秒），默认 1000
    propagateHeaders: [      // 除 x-request-id 外自动从入站请求透传到出站请求的头
      'traceparent',         // W3C Trace Context（APM 分布式追踪）
      'tracestate',          // W3C Trace Context 附加状态
      // 或 'x-trace-id', 'x-tenant-id' 等自定义头
    ],
  },
};

// 单次请求设置 5 秒超时 + 3 次重试
const response = await app.fetch.get('https://api.example.com/data', {
  timeout: 5000,
  retry: 3,
  retryDelay: 500,
});

import { definePlugin } from 'vextjs';

export default definePlugin({
  name: 'api-clients',

  setup(app) {
    // 创建用户服务客户端
    const userServiceClient = app.fetch.create({
      baseURL: 'http://user-service:3001/api/v1',
      headers: {
        'x-service-name': 'order-service',
        'Authorization': `Bearer ${app.config.serviceToken}`,
      },
      timeout: 5000,
      retry: 2,
    });

    // 创建支付服务客户端
    const paymentClient = app.fetch.create({
      baseURL: 'http://payment-service:3002/api/v1',
      headers: {
        'x-service-name': 'order-service',
      },
      timeout: 15000,  // 支付服务超时设长一些
    });

    // 挂载到 app 上供全局使用
    app.extend('clients', {
      userService: userServiceClient,
      payment: paymentClient,
    });
  },
});

export default defineRoutes((app) => {
  app.post('/orders', {
    validate: {
      body: {
        productId: 'string!',
        quantity: 'number:1-99!',
      },
    },
  }, async (req, res) => {
    const body = req.valid('body');

    // 使用预配置的子客户端 — 自动拼接 baseURL + 合并 headers
    const userResp = await app.clients.userService.get(`/users/${req.userId}`);
    const user = await userResp.json();

    const payResp = await app.clients.payment.post('/charges', {
      userId: user.id,
      amount: body.quantity * 100,
    });
    const charge = await payResp.json();

    res.json({ orderId: charge.orderId }, 201);
  });
});

const response = await app.fetch.get('https://third-party-api.com/data', {
  propagateRequestId: false,  // 不注入 x-request-id
  // 注意：propagatedHeaders（如 x-trace-id）仍会透传
});

// src/config/default.ts
export default {
  fetch: {
    propagateHeaders: [
      'traceparent',   // W3C Trace Context（OpenTelemetry / Jaeger / Zipkin）
      'tracestate',    // W3C Trace Context 附加状态
      'x-tenant-id',  // 多租户标识
    ],
  },
};

// 路由中不需要任何额外代码，框架自动处理透传
export default defineRoutes('/orders', [
  {
    method: 'POST',
    handler: async (req, res) => {
      // traceparent 已自动从入站请求透传到 inventory-service
      const stock = await app.fetch.get('http://inventory-service/check');
      // 同样自动透传到 payment-service
      const payment = await app.fetch.post('http://payment-service/charge', req.body);

      res.json({ orderId: 'new-id' });
    },
  },
]);

await app.fetch.get('https://partner-api.com/data', {
  headers: {
    'x-partner-token': req.headers['x-partner-token'] as string,
  },
});

try {
  const response = await app.fetch.get('https://slow-api.example.com/data', {
    timeout: 3000,  // 3 秒超时
  });
  const data = await response.json();
  res.json(data);
} catch (err) {
  // err.message: "[app.fetch] GET https://slow-api.example.com/data timed out after 3000ms"
  app.throw(504, '下游服务超时');
}

// 5xx 最终失败 → 返回 Response（不抛出）
const response = await app.fetch.get('https://api.example.com/data', { retry: 2 });
if (!response.ok) {
  // 3 次尝试（1 + 2 retry）都返回 5xx
  app.logger.error({ status: response.status }, 'API request failed after retries');
}

// 网络错误最终失败 → 抛出 Error
try {
  await app.fetch.get('https://unreachable.example.com/data', { retry: 2 });
} catch (err) {
  // 3 次尝试都连接失败
  app.logger.error({ err }, 'API unreachable after retries');
}

const response = await app.fetch.get('https://api.example.com/data', {
  retry: 3,
  retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 10000),
  // attempt 1: 2000ms
  // attempt 2: 4000ms
  // attempt 3: 8000ms
});

import { definePlugin } from 'vextjs';
import axios from 'axios';

export default definePlugin({
  name: 'axios-fetch',

  setup(app) {
    // 自定义 fetch 实现需符合 VextFetch 接口
    app.setFetch(customFetchImplementation);
  },
});

// src/plugins/service-clients.ts
import { definePlugin } from 'vextjs';

export default definePlugin({
  name: 'service-clients',

  setup(app) {
    app.extend('userClient', app.fetch.create({
      baseURL: process.env.USER_SERVICE_URL ?? 'http://user-service:3001',
      timeout: 5000,
      retry: 2,
    }));

    app.extend('inventoryClient', app.fetch.create({
      baseURL: process.env.INVENTORY_SERVICE_URL ?? 'http://inventory-service:3002',
      timeout: 8000,
      retry: 1,
    }));
  },
});

// src/services/order.ts
export class OrderService {
  constructor(private app: VextApp) {}

  async createOrder(userId: string, productId: string, quantity: number) {
    // 1. 查询用户信息
    const userResp = await this.app.userClient.get(`/api/users/${userId}`);
    if (!userResp.ok) {
      this.app.throw(400, '用户不存在');
    }
    const user = await userResp.json();

    // 2. 检查库存
    const stockResp = await this.app.inventoryClient.get(`/api/stock/${productId}`);
    if (!stockResp.ok) {
      this.app.throw(500, '库存服务不可用');
    }
    const stock = await stockResp.json();

    if (stock.available < quantity) {
      this.app.throw(400, '库存不足', 'INSUFFICIENT_STOCK');
    }

    // 3. 扣减库存
    await this.app.inventoryClient.post(`/api/stock/${productId}/deduct`, {
      quantity,
      orderId: `order-${Date.now()}`,
    });

    // 4. 创建订单记录
    return {
      orderId: `order-${Date.now()}`,
      userId: user.id,
      productId,
      quantity,
      status: 'created',
    };
  }
}