#配置

// src/config/default.ts
export default {
  port: Number(process.env.PORT) || 3000,
  host: "0.0.0.0",
  logger: { level: "info" },
  openapi: { enabled: true, title: "My App API", version: "1.0.0" },
  frontend: { enabled: false },
  // 自定义字段只演示合并；框架不会据此连接 Redis。
  redis: { url: process.env.REDIS_URL || "redis://localhost:6379" },
};

// src/config/production.ts
export default {
  logger: { level: "warn" },
  cors: { origins: ["https://myapp.com"], credentials: true },
  openapi: { enabled: false },
  // logger.level: "warn" 会抑制普通 info/debug 访问日志；5xx 仍会提升为 error。
  accessLog: { level: "info", warnOn4xx: true },
  cluster: {
    enabled: false, // 本例单进程；生产多 worker 配置见后文 Cluster 节
  },
};

// src/config/local.ts
export default {
  port: 8080,
  redis: {
    url: "redis://localhost:6380",
  },
};

// src/routes/config-info.ts
import { defineRoutes } from "vextjs";

export default defineRoutes((app) => {
  app.get("/", {}, async (_req, res) => {
    res.json({
      port: app.config.port,
      logLevel: app.config.logger.level,
      docsEnabled: app.config.openapi.enabled,
    });
  });
});

import { defineBootstrapConfig } from "vextjs";

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

        const remote = await response.json();
        return {
          database: remote.database,
          logger: {
            lifecycleLevel: baseConfig.logger?.lifecycleLevel ?? "concise",
          },
        };
      },
    },
  ],
});

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

const config: VextUserConfig = {
  port: 3000,
  host: "0.0.0.0",
  logger: {
    level: "info",
    lifecycleLevel: "concise",
  },
  cors: {
    origins: ["*"],
  },
  openapi: {
    enabled: true,
  },
  session: {
    name: "vext.sid",
    ttl: 86400,
    cookie: {
      httpOnly: true,
      sameSite: "lax",
      path: "/",
      secure: "auto",
    },
  },
  csrf: {
    enabled: false,
  },
  securityHeaders: {
    enabled: false,
    preset: "basic",
  },
};

export default config;

// src/config/production.ts — 仅覆盖需要变更的字段
import type { VextConfigOverride } from "vextjs";

const config: VextConfigOverride = {
  logger: {
    level: "warn", // 生产环境减少日志输出
  },
  cors: {
    origins: ["https://myapp.com"], // 生产环境限制来源
  },
  openapi: {
    enabled: false, // 生产环境关闭文档
  },
};

export default config;

// src/config/local.ts — 本地开发特殊配置（不提交 Git）
import type { VextConfigOverride } from "vextjs";

const config: VextConfigOverride = {
  port: 8080, // 本地使用其他端口
};

export default config;

// src/config/default.ts
export default {
  middlewares: [
    "auth",
    { name: "check-role", options: { roles: ["user"] } },
    { name: "rate-limit-api", options: { max: 100 } },
  ],
};

// src/config/development.ts
export default {
  middlewares: [
    // 只需声明要覆盖的中间件，其余保留
    { name: "check-role", options: { roles: [] } }, // 空数组的业务含义由工厂实现决定
    { name: "rate-limit-api", options: { max: 10000 } }, // 放宽限流
  ],
};

middlewares: [
  "auth", // 保留
  { name: "check-role", options: { roles: [] } }, // 被覆盖
  { name: "rate-limit-api", options: { max: 10000 } }, // 被覆盖
];

// src/config/default.ts — 使用 Hono Adapter
import { honoAdapter } from "vextjs/adapters/hono";

export default {
  adapter: honoAdapter(),
  port: 3000,
};

// src/config/default.ts — 使用 Fastify Adapter
import { fastifyAdapter } from "vextjs/adapters/fastify";

export default {
  adapter: fastifyAdapter(),
  port: 3000,
};

// src/config/default.ts — 使用 Express Adapter
import { expressAdapter } from "vextjs/adapters/express";

export default {
  adapter: expressAdapter(),
  port: 3000,
};

// src/config/default.ts — 使用 Koa Adapter
import { koaAdapter } from "vextjs/adapters/koa";

export default {
  adapter: koaAdapter(),
  port: 3000,
};

export default {
  frontend: {
    enabled: true,
    framework: "react",
    root: "src/frontend",
    publicDir: "public",
    publicPath: "/",
    styles: {
      jscss: {
        enabled: true,
      },
    },
    i18n: {
      enabled: true,
      defaultLocale: "en-US",
    },
    spaFallback: {
      scopes: [
        {
          basePath: "/admin/app",
          page: "admin/app/shell",
          exclude: ["/admin/api/**"],
        },
      ],
    },
    apiClient: {
      enabled: true,
    },
    build: {
      target: "es2022",
      minify: true,
      sourcemap: false,
      client: {
        external: [],
        externalRuntime: {},
      },
      vendorChunks: {
        enabled: true,
      },
      budgets: {
        maxTotalBytes: 5_000_000,
      },
    },
    deploy: {
      integrity: true,
      upload: {
        enabled: false,
        adapter: "filesystem",
        targetDir: ".vext/deploy/frontend-assets",
        prefix: "my-app",
        exclude: ["**/*.map"],
      },
    },
  },
};

export default {
  port: 3000,
  host: "0.0.0.0",
  trustProxy: false,
};

export default {
  cors: {
    origins: ["https://myapp.com"], // 生产环境限制来源（数组格式）
    credentials: true,
    methods: ["GET", "POST", "PUT", "DELETE"],
  },
};

export default {
  rateLimit: {
    enabled: true,
    max: 100,
    window: 60, // 1 分钟（单位：秒）
    message: "Too many requests, please try again later",
    keyBy: "ip",
  },
};

export default {
  securityHeaders: {
    enabled: true,
    preset: "basic",
    headers: {
      "X-App-Security": "vext",
    },
  },
};

export default {
  requestId: {
    enabled: true,
    header: "x-request-id",
  },
};

export default {
  logger: {
    level: "info", // 生产环境建议 'warn'
    lifecycleLevel: "concise", // 如需排障可设为 'verbose'
    pretty: true, // 开发环境开启可读格式化（生产环境默认关闭）
    // prettyColor: 'auto',              // TTY 或 FORCE_COLOR=1 时给 level label 加色
    // prettySingleLine: true,              // 额外字段压缩到同行（默认）
    // prettyIgnore: 'pid,hostname,requestId',  // 默认隐藏字段
    // redactKeys: ['password', 'token'],    // exact key 脱敏
    // redactPaths: ['headers.authorization'], // exact path 脱敏
    // mixin: () => ({ service_name: 'my-app' }), // 自定义结构化字段
  },
};

export default {
  shutdown: {
    timeout: 15, // 15 秒超时（单位：秒）
  },
};

export default {
  server: {
    requestTimeout: 120_000,
    headersTimeout: 60_000,
    keepAliveTimeout: 5_000,
    socketTimeout: 0,
    maxHeaderSize: 16 * 1024,
    maxRequestsPerSocket: 0,
    connectionsCheckingInterval: 30_000,
  },
};

export default {
  response: {
    wrap: true,
    hideInternalErrors: true,
    logErrors: {
      unknownErrors: true, // 未知错误必须记录
      http5xx: true, // 5xx 是服务端责任
      http4xx: false, // 4xx 默认不记录（高流量场景避免噪音）
    },
  },
};

export default {
  bodyParser: {
    enabled: true,
    maxBodySize: "5mb", // 允许更大的请求体
  },
};

export default {
  multipart: {
    enabled: true, // 开启内置解析
    maxFileSize: 10 * 1024 * 1024, // 10MB
    maxFiles: 5,
    allowedMimeTypes: ["image/jpeg", "image/png", "application/pdf"],
  },
};

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

export default {
  openapi: {
    enabled: true,
    title: "My App API",
    description: "我的应用 API 文档",
    version: "1.0.0",
    docs: {
      path: "/docs",
      renderer: "vext",
      code: {
        enabled: "auto",
      },
    },
    jsonPath: "/openapi.json",
    servers: [
      { url: "http://localhost:3000", description: "本地开发" },
      { url: "https://api.myapp.com", description: "生产环境" },
    ],
    tags: [
      { name: "用户", description: "用户管理相关接口" },
      { name: "订单", description: "订单管理相关接口" },
    ],
    securitySchemes: {
      bearerAuth: {
        type: "http",
        scheme: "bearer",
        bearerFormat: "JWT",
      },
    },
    contact: {
      name: "API Support",
      email: "support@myapp.com",
    },
    license: {
      name: "Apache-2.0",
      url: "https://www.apache.org/licenses/LICENSE-2.0",
    },
  },
};

export default {
  database: {
    config: { uri: "mongodb://localhost:27017/myapp" },
    maxTimeMS: 2_000,
    monsqlizeOptions: {
      findMaxLimit: 2_000,
      transaction: { enableRetry: true, maxRetries: 2 },
      writePathPolicy: { default: "model-only" },
    },
  },
};

export default {
  requestContext: {
    enabled: true,
  },
};

export default {
  cluster: {
    enabled: true,
    workers: "auto", // 自动检测可用 CPU，最多 64 个 Worker
    autoRestart: true,
    maxRestarts: 5,
    healthCheck: { enabled: true },
    reload: { workerDelay: 2000 },
  },
};

export default {
  dev: {
    errorOverlay: {
      enabled: true, // 设为 false 可禁用 HTML 错误覆盖层
      theme: "dark",
      maxFrames: 25,
    },
  },
};

export default {
  middlewares: [
    // 普通中间件 — 字符串声明
    "auth",
    "timing",

    // 工厂中间件 — 对象声明（附带默认参数）
    { name: "check-role", options: { roles: ["user"] } },
    { name: "cache-control", options: { maxAge: 3600 } },
  ],
};

import { defineRoutes } from "vextjs";

export default defineRoutes((app) => {
  app.get("/info", {}, async (_req, res) => {
    res.json({
      port: app.config.port,
      openapi: app.config.openapi.enabled,
    });
  });
});

import type { VextApp } from "vextjs";

export default class MyService {
  constructor(private app: VextApp) {}

  getListenAddress() {
    const { host, port } = this.app.config;
    const address = host.includes(":") ? `[${host}]` : host;
    return `http://${address}:${port}`;
  }
}

import { definePlugin } from "vextjs";

export default definePlugin({
  name: "my-plugin",
  setup(app) {
    const myConfig = app.config.myPlugin ?? { enabled: false };
    if (!myConfig.enabled) return;
    // ...
  },
});

// src/config/default.ts
export default {
  port: 3000,

  // 自定义字段
  redis: {
    url: "redis://localhost:6379",
    db: 0,
  },
  mailer: {
    smtp: "smtp://localhost:1025",
    from: "noreply@myapp.com",
  },
};

// src/types/config.d.ts
import "vextjs";

declare module "vextjs" {
  interface VextConfig {
    redis?: {
      url: string;
      db?: number;
    };
    mailer?: {
      smtp: string;
      from: string;
    };
  }
}

// src/config/default.ts — 使用环境变量
export default {
  port: Number(process.env.PORT) || 3000,
  logger: {
    level: process.env.LOG_LEVEL || "info",
  },
};