// tsconfig.json —— 经典的“睁眼瞎”配置{  "compilerOptions": {    "strict": false
  }
}

{  "compilerOptions": {    "strict": true
  }
}

// ❌ 典型的“我回头一定重构”式写法function formatUser(user: any) {  return user.profile.name.toLowerCase();
}

// ✅ 严格校验数据后再享受类型红利type User = {  profile: {    name: string;
  };
};function isUser(data: unknown): data is User {  if (typeof data !== "object" || data === null) return false;  const maybe = data as { profile?: unknown };  if (typeof maybe.profile !== "object" || maybe.profile === null) {    return false;
  }  return typeof (maybe.profile as { name?: unknown }).name === "string";
}function formatUser(user: unknown) {  if (!isUser(user)) {    throw new Error("无效的用户数据");
  }  return user.profile.name.toLowerCase();
}

// ✅ 清爽且可复用的泛型设计function getLastItem<T>(list: T[]): T | undefined {  return list[list.length - 1];
}

// ❌ 所有人都是可选的... 约等于什么约束都没有type RequestState = {
  data?: string[];
  error?: string;
  isLoading?: boolean;
};

{ data: ["A"], error: "服务器崩了", isLoading: false } // 既成功又失败？{ isLoading: true, data: ["怎么还有老数据？"] }

// ✅ 每种状态的边界，白纸黑字划分得清清楚楚type RequestState =
  | { status: "loading" }
  | { status: "success"; data: string[] }
  | { status: "error"; message: string };

function renderState(state: RequestState) {  switch (state.status) {    case "loading":      return "加载中...";    case "success":      return state.data.join(", "); // data 绝对存在，不需要 ?.
    case "error":      return `错误: ${state.message}`; // message 绝对存在
  }
}

// ❌ 看着挺清爽，其实埋下了隐性错误export async function fetchUser(userId: string) {  const result = await database
    .query("users")
    .findById(userId);  if (!result) {    throw new Error("用户未找到");
  }  return result;
}

type User = {  id: string;
  name: string;
  email: string;
};// ✅ 哪怕底层翻江倒海，对外的契约坚如磐石export async function fetchUser(userId: string): Promise<User> {  const result = await database
    .query("users")
    .findById(userId);  if (!result) {    throw new Error("用户未找到");
  }  return result;
}

// ❌ 异步任务启动了，但没有任何人在这儿盯着它app.post("/webhook", (req, res) => {
  syncWebhookEvent(req.body); 
  res.sendStatus(200);
});

// ✅ 妥善等待，并把可能的异常交由框架的错误中间件接管app.post("/webhook", async (req, res, next) => {  try {    await syncWebhookEvent(req.body);
    res.sendStatus(200);
  } catch (err) {
    next(err);
  }
});

// ✅ 虽然我不等它执行完，但我做好了随时兜底失败的准备syncWebhookEvent(req.body).catch((err) => {
  logger.error("Webhook 同步彻底失败", {    webhookId: req.body.id,
    err,
  });
});
res.sendStatus(202); // 202 Accepted 往往比 200 更符合这种“已受理未完成”的语境

// ❌ 开发一分钟，后面写单元测试痛苦一整天import { database } from "../infra/database";import { mailer } from "../infra/mailer";export async function placeOrder(input: NewOrderInput) {  const order = await database.orders.insert(input);  await mailer.send({    to: order.customerEmail,    subject: "订单已收到",    body: buildOrderEmail(order),
  });  return order;
}

jest.mock("../infra/database"); // 脆弱的路径 Mock

// ✅ 业务函数只认工具的“形状”（接口），不认具体的牌子type OrderDeps = {  orders: {
    insert(input: NewOrderInput): Promise<Order>;
  };
  email: {
    send(message: { to: string; subject: string; body: string }): Promise<void>;
  };
};export function makeOrderService({ orders, email }: OrderDeps) {  return {    async placeOrder(input: NewOrderInput) {      const order = await orders.insert(input);      await email.send({        to: order.customerEmail,        subject: "订单已收到",        body: buildOrderEmail(order),
      });      return order;
    },
  };
}

const fakeOrders = {  insert: async (input: NewOrderInput) => ({ id: "order_123", ...input }),
};const sentEmails: unknown[] = [];const fakeEmail = {  send: async (msg: unknown) => { sentEmails.push(msg); },
};// 没有任何黑魔法，纯粹的参数传递const service = makeOrderService({ orders: fakeOrders, email: fakeEmail });await service.placeOrder({ customerEmail: "test@qq.com", total: 499 });

apps/
  gateway-api/
  auth-service/
  product-service/
  billing-service/
  email-service/

src/
  modules/
    auth/          # 专注鉴权
    orders/        # 专注订单规则
    billing/       # 专注支付行为
    notifications/ # 专注触达

// ❌ 订单模块直接伸手去篡改计费模块的流水表（大忌）await db.billingTransactions.findMany({ where: { orderId } });

// ✅ 走正规渠道，隔着清晰的模块边界进行调用await billingService.getTransactionsForOrder(orderId);

// ❌ 一个函数把五个人的活儿全干了export async function completePurchase(req: Request, res: Response) {  // 1. 读取请求体...
  // 2. 校验客户身份信息...
  // 3. 校验购物车里的商品...
  // 4. 查库存...
  // 5. 计算原价...
  // 6. 校验并扣减优惠券...
  // 7. 算税率...
  // 8. 调第三方网关扣款...
  // 9. 落库保存订单...
  // 10. 发送确认邮件...
  // 11. 给大数据团队报送埋点...
  res.json({ success: true });
}

// ✅ 核心流程的主线任务，一眼望到底export async function completePurchase(req: Request, res: Response) {  const checkout = parseCheckoutRequest(req.body);  await reserveStock(checkout.items);  
  const invoice = buildInvoice({    items: checkout.items,    couponCode: checkout.couponCode,    shippingAddress: checkout.shippingAddress,
  });  
  const payment = await chargePaymentMethod({    amount: invoice.total,    method: checkout.paymentMethod,
  });  
  const order = await saveOrder({ checkout, invoice, payment });  await sendOrderReceipt(order);
  recordCheckoutEvent(order);
  
  res.json({ orderId: order.id });
}

// ❌ 整个应用的业务生命线全被捏死在了一个特定的 HTTP 路由里app.post("/orders", async (req, res) => {  const cartItems = req.body.items;  let finalAmount = 0;  
  // 疯狂的查库、算价、判断库存逻辑...
  for (const item of cartItems) {    const product = await productRepository.findById(item.productId);    if (product.availableStock < item.quantity) {      return res.status(400).json({ error: "库存不足" });
    }
    finalAmount += product.price * item.quantity;
  }  
  const order = await orderRepository.create({ userId: req.user.id, total: finalAmount });
  res.json(order);
});

// ✅ 控制器：只负责和网络协议打交道，保持清爽app.post("/orders", async (req, res) => {  const input = parseOrderRequest(req.body);  const order = await orderService.createOrder({
    input,    userId: req.user.id,
  });
  res.json(toOrderResponse(order));
});

// ✅ 纯净的业务服务类：可以被任何触发渠道（HTTP、消息队列、命令行）高频复用class OrderService {  async createOrder(params: { input: CreateOrderInput; userId: string }) {    const { input, userId } = params;    await this.ensureItemsAreAvailable(input.items);    const total = await this.calculateFinalAmount(input.items, input.couponCode);    
    return this.orders.create({ userId, items: input.items, total });
  }  // 拆分出来的私有业务逻辑细节...}

// customer.tsimport { Purchase } from "./purchase";export class Customer {  purchases: Purchase[] = [];
}// purchase.tsimport { Customer } from "./customer";// ❌ 致命继承：在执行到这一行时，基类 Customer 很有可能还是一个未定义的 undefined 占位符export class Purchase extends Customer {
  createdAt = new Date();
}

// contracts.ts —— 没有任何运行时逻辑的纯契约定义export interface CustomerInfo {  id: string;
  name: string;
}export interface PurchaseInfo {  id: string;
  customer: CustomerInfo;
}

// customer.ts —— 只导入纯类型，这类导入在编译成 JS 后会被完全抹去import type { PurchaseInfo } from "./contracts";export class Customer {  purchases: PurchaseInfo[] = [];
}