#Built-in HTTP client (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");

      // Use app.fetch to call downstream services
      const response = await app.fetch(
        `https://api.example.com/users/${id}/posts`,
      );
      const posts = await response.json();

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

import { definePlugin } from "vextjs";

export default definePlugin({
  name: "fetch-observer",
  setup(app) {
    app.hooks.on("fetch:before", ({ headers }) => {
      headers.set("x-client", "billing-service");
    });

    app.hooks.on("fetch:error", ({ url, error }) => {
      app.logger.error({ url, err: error }, "outbound request failed");
    });

    app.hooks.on("proxy:after", ({ target, status, requestId }) => {
      app.logger.info({ target, status, requestId }, "proxy response");
    });
  },
});

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: "Zhang San",
  email: "zhangsan@example.com",
});
const newUser = await response.json();

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

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

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

// vext.config.ts
export default {
  port: 3000,
  fetch: {
    timeout: 10000, // Global default timeout (milliseconds), default 10000
    retry: 2, //Default number of retries (idempotent methods only), default 0
    retryDelay: 1000, //Default retry interval (milliseconds), default 1000
    propagateHeaders: [
      // Automatically transparently transmit headers from inbound requests to outbound requests except x-request-id
      "traceparent", // W3C Trace Context (APM distributed tracing)
      "tracestate", // W3C Trace Context additional state
      // Or 'x-trace-id', 'x-tenant-id' and other custom headers
    ],
    proxy: [
      {
        name: "userService",
        baseURL: "http://user-service:3001/api",
        forwardHeaders: ["x-tenant-id", "traceparent"],
        headers: { "x-source": "gateway" },
        timeout: 5000,
        retry: 1,
      },
    ],
  },
};

//Set a 5-second timeout + 3 retries for a single request
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) {
    //Create user service client
    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,
    });

    // Create payment service client
    const paymentClient = app.fetch.create({
      baseURL: "http://payment-service:3002/api/v1",
      headers: {
        "x-service-name": "order-service",
      },
      timeout: 15000, // Set the payment service timeout to be longer
    });

    //Mount to app for global use
    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");

      // Use pre-configured subclient - automatically concatenate baseURL + merge 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);
    },
  );
});

export default defineRoutes((app) => {
  app.get("/users/:id", async (req, res) => {
    await app.fetch.proxy.userService(req, res, {
      path: `/users/${req.params.id}`,
      query: { includeProfile: true },
    });
  });
});

await app.fetch.proxy.userService(req, res, {
  path: "/profile",
  forwardHeaders: ["authorization"],
  allowAuthorizationForward: true,
});

await app.fetch.proxy(req, res, {
  url: "https://partner.example.com/status",
});

const response = await app.fetch.get("https://third-party-api.com/data", {
  propagateRequestId: false, // Do not inject x-request-id
  // Note: propagatedHeaders (such as x-trace-id) will still be transparently transmitted
});

// src/config/default.ts
export default {
  fetch: {
    propagateHeaders: [
      "traceparent", // W3C Trace Context (OpenTelemetry / Jaeger / Zipkin)
      "tracestate", // W3C Trace Context additional state
      "x-tenant-id", // Multi-tenant ID
    ],
  },
};

// No additional code is required in routing, the framework automatically handles transparent transmission
export default defineRoutes("/orders", [
  {
    method: "POST",
    handler: async (req, res) => {
      // traceparent has automatically been transparently passed from inbound request to inventory-service
      const stock = await app.fetch.get("http://inventory-service/check");
      // Also automatically transparently transmitted to 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 seconds timeout
  });
  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, "Downstream service timeout");
}

// 5xx ultimately fails → returns Response (does not throw)
const response = await app.fetch.get("https://api.example.com/data", {
  retry: 2,
});
if (!response.ok) {
  // 3 attempts (1 + 2 retry) all return 5xx
  app.logger.error(
    { status: response.status },
    "API request failed after retries",
  );
}

// Network error eventually fails → throw Error
try {
  await app.fetch.get("https://unreachable.example.com/data", { retry: 2 });
} catch (err) {
  // Failed to connect after 3 attempts
  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) {
    app.extend(
      "axios",
      axios.create({
        baseURL: process.env.API_BASE_URL,
        timeout: 5000,
      }),
    );
  },
});

// 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. Query user information
    const userResp = await this.app.userClient.get(`/api/users/${userId}`);
    if (!userResp.ok) {
      this.app.throw(400, "User does not exist");
    }
    const user = await userResp.json();

    // 2. Check inventory
    const stockResp = await this.app.inventoryClient.get(
      `/api/stock/${productId}`,
    );
    if (!stockResp.ok) {
      this.app.throw(500, "Inventory service is not available");
    }
    const stock = await stockResp.json();

    if (stock.available < quantity) {
      this.app.throw(400, "Insufficient Stock", "INSUFFICIENT_STOCK");
    } // 3. Deduct inventory
    await this.app.inventoryClient.post(`/api/stock/${productId}/deduct`, {
      quantity,
      orderId: `order-${Date.now()}`,
    });

    // 4. Create order record
    return {
      orderId: `order-${Date.now()}`,
      userId: user.id,
      productId,
      quantity,
      status: "created",
    };
  }
}