#配置项

import { defineBootstrapConfig } from "vextjs";

export default defineBootstrapConfig({
  providers: [
    {
      name: "remote-config",
      timeoutMs: 10_000,
      async load({ configProfile, signal }) {
        const response = await fetch(
          `https://config.example.com/${configProfile}.json`,
          { signal },
        );
        if (!response.ok)
          throw new Error(`Config service HTTP ${response.status}`);
        const remote = await response.json();
        return {
          database: remote.database,
        };
      },
    },
  ],
});

// src/config/default.ts
import type { VextUserConfig } from "vextjs";

const config: VextUserConfig = {
  port: 3000,
  adapter: "native",
  cors: {
    enabled: true,
    origins: ["http://localhost:3000"],
  },
  logger: {
    level: "debug",
  },
};

export default config;

// src/config/production.ts
import type { VextConfigOverride } from "vextjs";

const config: VextConfigOverride = {
  port: 8080,
  cors: {
    origins: ["https://api.example.com"],
  },
  logger: {
    level: "warn",
  },
  response: {
    hideInternalErrors: true,
  },
};

export default config;

// 方式一：字符串标识（内置 adapter）
export const byName = {
  adapter: "native", // 'native' | 'hono' | 'fastify' | 'express' | 'koa'
};

// 方式二：工厂函数（传入自定义选项）
import { fastifyAdapter } from "vextjs/adapters/fastify";

export const byFactory = {
  adapter: fastifyAdapter({ bodyLimit: 5 * 1024 * 1024 }),
};

// 方式三：自定义 adapter 实例（实现 VextAdapter 接口）
// 应用实现实例后可改为 export default { adapter: myCustomAdapter };
export default byName;

import type { VextUserConfig } from "vextjs";

export default {
  middlewares: [{ name: "framework-auth" }],
} satisfies VextUserConfig;

// src/middlewares/framework-auth.ts
import { auth, defineMiddleware } from "vextjs";

export default defineMiddleware(
  auth({
    async verify(token) {
      return token === "demo-token" ? { userId: "1" } : false;
    },
  }),
);

import type { VextUserConfig } from "vextjs";

export default {
  cors: {
    enabled: true,
    origins: ["https://app.example.com", "https://admin.example.com"],
    credentials: true,
    maxAge: 86400,
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  rateLimit: {
    enabled: true,
    max: 200,
    window: 120,
    keyBy: "ip",
    store: "memory",
  },
} satisfies VextUserConfig;

import { randomUUID } from "node:crypto";

export default {
  requestId: {
    header: "x-trace-id", // 从 x-trace-id 读取（网关注入）
    responseHeader: "x-trace-id", // 写回响应头
    generate: () => randomUUID(),
  },
};

import type { VextUserConfig } from "vextjs";

export default {
  // requestId 保留默认配置（用于日志关联）
  requestId: {
    header: "x-request-id",
    responseHeader: "x-request-id",
  },
  // APM 追踪头通过 propagateHeaders 自动透传到下游服务
  fetch: {
    propagateHeaders: ["traceparent", "tracestate"],
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  accessLog: {
    enabled: true,
    level: "info",
    skipPaths: ["/health", "/readiness", "/metrics"],
    skipPathPrefixes: ["/internal"],
    slowThreshold: 1000,
    warnOn4xx: false,
    logResponseSize: false,
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  openapi: {
    enabled: true,
    title: "My API",
    version: "1.0.0",
    description: "我的 API 文档",
    docs: {
      path: "/docs",
      renderer: "vext",
      code: {
        enabled: "auto",
      },
    },
    servers: [
      { url: "http://localhost:3000", description: "开发环境" },
      { url: "https://api.example.com", description: "生产环境" },
    ],
    tags: [
      { name: "用户", description: "用户管理接口" },
      { name: "订单", description: "订单管理接口" },
    ],
    securitySchemes: {
      bearerAuth: {
        type: "http",
        scheme: "bearer",
        bearerFormat: "JWT",
      },
    },
    guardSecurityMap: {
      auth: "bearerAuth",
    },
  },
} satisfies VextUserConfig;

// 仅用于历史兼容：没有 RouteOptions.auth 的 middleware 名称推断
app.get("/profile", { middlewares: ["auth"] }, handler);
// ↑ OpenAPI 自动推断该路由需要 bearerAuth 认证

import type { VextUserConfig } from "vextjs";

export default {
  requestContext: {
    enabled: false, // 仅在不依赖下列请求级能力时关闭
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  frontend: {
    enabled: true,
    framework: "react",
    publicDir: "public",
    publicPath: "/",
    spaFallback: {
      scopes: [
        {
          basePath: "/admin/app",
          page: "admin/app/shell",
          ssr: true,
          exclude: ["/admin/api/**"],
        },
      ],
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  cluster: {
    enabled: true,
    workers: "auto", // 使用 availableParallelism / cgroup v1 / os.cpus 检测可用 CPU
    autoRestart: true,
    maxRestarts: 5,
    healthCheck: {
      enabled: true,
      interval: 15000,
      timeout: 30000,
    },
    reload: {
      workerDelay: 2000,
      readyTimeout: 30000,
      shutdownTimeout: 10000,
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  cache: {
    enabled: true,
    defaultTtl: 120_000,
    maxEntries: 2000,
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  cache: {
    defaultTtl: 60_000,
    cacheHub: {
      mode: "memory",
      maxEntries: 1000,
      maxMemory: 50 * 1024 * 1024,
      cleanupInterval: 30_000,
      enableStats: true,
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  cache: {
    defaultTtl: 2_000,
    cacheHub: {
      mode: "redis",
      url: "redis://localhost:6379",
      deleteCommand: "unlink",
      lease: {
        waitForOwner: 1_000,
        onTimeout: "fetch",
      },
      distributed: {
        channel: "vext:response-cache",
      },
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  cache: {
    defaultTtl: 60_000,
    cacheHub: {
      mode: "multi-level",
      memory: { maxEntries: 1000 },
      redis: { url: "redis://localhost:6379" },
      writePolicy: "both",
      backfillOnRemoteHit: true,
      remoteTimeout: 50,
      lease: true,
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  dev: {
    errorOverlay: {
      enabled: true,
      theme: "light",
      maxFrames: 10,
    },
  },
} satisfies VextUserConfig;

import type { VextUserConfig } from "vextjs";

export default {
  dev: {
    mcp: {
      enabled: true,
      hosts: ["codex", "grok"],
      sync: "auto",
      http: {
        enabled: false,
        port: 3980,
      },
    },
  },
} satisfies VextUserConfig;

import { DEFAULT_CONFIG } from "vextjs";

// DEFAULT_CONFIG 的完整内容（只读快照）：
const documentedDefaults = {
  port: 3000,
  host: "0.0.0.0",
  adapter: "native",
  trustProxy: false,
  middlewares: [],
  cors: {
    enabled: true,
    origins: ["*"],
    methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
    headers: ["Content-Type", "Authorization", "X-Request-Id"],
    credentials: false,
  },
  rateLimit: {
    enabled: false,
    max: 100,
    window: 60,
    message: "Too Many Requests",
    keyBy: "ip",
    store: "memory",
  },
  requestId: {
    enabled: true,
    header: "x-request-id",
    responseHeader: "x-request-id",
  },
  logger: {
    level: "info",
  },
  shutdown: {
    timeout: 10,
  },
  server: {},
  response: {
    hideInternalErrors: true,
    wrap: true,
  },
  session: {
    enabled: false,
    name: "vext.sid",
    ttl: 86400,
    rolling: false,
    autoCommit: true,
    idLength: 32,
    cookie: {
      httpOnly: true,
      sameSite: "lax",
      path: "/",
      secure: "auto",
    },
  },
  csrf: {
    enabled: false,
    mode: "auto",
    methods: ["POST", "PUT", "PATCH", "DELETE"],
    headerNames: ["x-csrf-token", "x-xsrf-token"],
    bodyField: "_csrf",
    cookie: {
      name: "vext.csrf",
      httpOnly: false,
      sameSite: "lax",
      path: "/",
      secure: "auto",
    },
    fetchMetadata: true,
    origin: false,
  },
  securityHeaders: {
    enabled: false,
    preset: "basic",
  },
  bodyParser: {
    enabled: true,
    maxBodySize: "1mb",
  },
  accessLog: {
    enabled: true,
    level: "info",
    skipPaths: [],
  },
  openapi: {
    enabled: false,
  },
  requestContext: {
    enabled: true,
  },
  frontend: {
    enabled: false,
  },
  jobs: {
    enabled: true,
    dir: "jobs",
    timezone: "UTC",
  },
};

import type { VextUserConfig } from "vextjs";

const config: VextUserConfig = {
  port: 8080,
  logger: { level: "debug" },
};

export default config;

import type { VextConfigOverride } from "vextjs";

const config: VextConfigOverride = {
  database: { findLimit: 50 },
  logger: { level: "debug" },
};

export default config;

import type { VextConfigOverride } from "vextjs";

declare module "vextjs" {
  interface VextConfig {
    myPlugin?: {
      client: {
        name: string;
        request(path: string): Promise<unknown>;
      };
    };
  }

  interface VextConfigOverrideAtomicPathRegistry {
    "myPlugin.client": true;
  }
}

declare const client: NonNullable<
  NonNullable<import("vextjs").VextConfig["myPlugin"]>["client"]
>;

const config: VextConfigOverride = {
  myPlugin: { client },
};

import { loadConfig } from "vextjs";
import { join } from "node:path";

const config = await loadConfig(join(process.cwd(), "src/config"), {
  rootDir: process.cwd(),
  command: "start",
  isBuilt: false,
});
// config: VextConfig（已合并、已冻结）

// types/vext.d.ts
import "vextjs";

declare module "vextjs" {
  interface VextConfig {
    redis?: {
      host: string;
      port: number;
      password?: string;
    };
  }
}

// src/config/default.ts
import type { VextUserConfig } from "vextjs";

export default {
  redis: {
    host: "localhost",
    port: 6379,
  },
} satisfies VextUserConfig;