{
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env main.ts",
    "start": "deno run --allow-net --allow-env main.ts",
    "test": "deno test --allow-net --allow-read",
    "test:coverage": "deno test --coverage=coverage",
    "lint": "deno lint",
    "fmt": "deno fmt",
    "check": "deno lint && deno fmt --check && deno test"
  },
  "lint": {
    "rules": {
      "tags": ["recommended"]
    }
  },
  "fmt": {
    "options": {
      "lineWidth": 100,
      "indentWidth": 2
    }
  },
  "imports": {
    "std/": "jsr:@std/",
    "oak": "jsr:@oak/oak@^16",
    "hono": "jsr:@hono/hono@^4"
  },
  "compilerOptions": {
    "strict": true,
    "lib": ["deno.window"]
  }
}

// ❌ 错误：每次请求重新创建连接
app.get("/users", async (c) => {
  const db = await createConnection();
  const users = await db.query("SELECT * FROM users");
  return c.json(users);
});

// ✅ 正确：使用连接池
const db = await createConnectionPool();
app.get("/users", async (c) => {
  const users = await db.query("SELECT * FROM users");
  return c.json(users);
});

// 内存缓存（简单场景）
const cache = new Map<string, { data: unknown; expiry: number }>();

async function getCached<T>(key: string, fetcher: () => Promise<T>, ttlMs: number): Promise<T> {
  const cached = cache.get(key);
  if (cached && cached.expiry > Date.now()) {
    return cached.data as T;
  }
  
  const data = await fetcher();
  cache.set(key, { data, expiry: Date.now() + ttlMs });
  return data;
}

// 使用
const users = await getCached("users", () => db.query("SELECT * FROM users"), 60_000);

// ❌ 错误：全部加载到内存
const content = await Deno.readTextFile("large-file.txt");

// ✅ 正确：流式处理
const file = await Deno.open("large-file.txt");
for await (const line of file.readable.pipeThrough(new TextDecoderStream())) {
  // 逐行处理
}
file.close();

{
  "tasks": {
    "dev": "deno run --watch --allow-net=localhost:8000 --allow-env=PORT,DB_URL main.ts",
    "test": "deno test --allow-read=./testdata",
    "prod": "deno run --allow-net --allow-env=PORT,DB_URL main.ts"
  }
}

import { z } from "npm:zod";

const UserSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
  age: z.number().int().positive(),
});

app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
  
  if (!result.success) {
    return c.json({ error: result.error.flatten() }, 400);
  }
  
  const user = await createUser(result.data);
  return c.json(user, 201);
});

// ❌ 错误：硬编码密钥
const API_KEY = "sk-1234567890";

// ✅ 正确：使用环境变量
const API_KEY = Deno.env.get("API_KEY");
if (!API_KEY) throw new Error("API_KEY 未设置");

// 使用 HTTPS
const cert = await Deno.readTextFile("./cert.pem");
const key = await Deno.readTextFile("./key.pem");

Deno.serve({ port: 443, cert, key }, handler);

// 全局未捕获错误处理
globalThis.addEventListener("unhandledrejection", (e) => {
  console.error("未处理的 Promise 拒绝：", e.reason);
  e.preventDefault();
});

globalThis.addEventListener("error", (e) => {
  console.error("未捕获的错误：", e.error);
  e.preventDefault();
});

import { Hono, HTTPException } from "jsr:@hono/hono";

const app = new Hono();

// 全局错误处理中间件
app.onError((err, c) => {
  console.error(`[Error] ${err.message}`, err.stack);
  
  if (err instanceof HTTPException) {
    return c.json({ error: err.message }, err.status);
  }
  
  return c.json({ error: "服务器内部错误" }, 500);
});

// 404 处理
app.notFound((c) => {
  return c.json({ error: "页面未找到" }, 404);
});

// 结构化日志
interface LogEntry {
  timestamp: string;
  level: "info" | "warn" | "error";
  message: string;
  meta?: Record<string, unknown>;
}

function log(level: LogEntry["level"], message: string, meta?: Record<string, unknown>) {
  const entry: LogEntry = {
    timestamp: new Date().toISOString(),
    level,
    message,
    meta,
  };
  
  if (level === "error") {
    console.error(JSON.stringify(entry));
  } else {
    console.log(JSON.stringify(entry));
  }
}

// 使用
log("info", "用户登录", { userId: "123", ip: "192.168.1.1" });
log("error", "数据库连接失败", { host: "localhost", port: 5432 });

app.get("/health", (c) => {
  return c.json({
    status: "healthy",
    timestamp: new Date().toISOString(),
    version: Deno.env.get("APP_VERSION") || "dev",
  });
});

app.get("/ready", async (c) => {
  try {
    await db.query("SELECT 1");
    return c.json({ status: "ready" });
  } catch {
    return c.json({ status: "not ready" }, 503);
  }
});

// 请求计时中间件
app.use("*", async (c, next) => {
  const start = performance.now();
  await next();
  const duration = performance.now() - start;
  
  c.header("X-Response-Time", `${duration.toFixed(2)}ms`);
  
  // 记录慢请求
  if (duration > 1000) {
    console.warn(`Slow request: ${c.req.method} ${c.req.url} took ${duration.toFixed(2)}ms`);
  }
});