28a - AI辅助后端开发概览

开发者："帮我创建一个用户注册和登录的 API，用 FastAPI + PostgreSQL，
        包含邮箱验证和 JWT 认证"

AI Agent：[自动生成项目结构、数据库模型、API 端点、认证逻辑]

1. 需求定义（Requirements）
   → 用户故事 + 验收标准（EARS 格式）

2. 技术设计（Design）
   → API 接口定义 + 数据模型 + 架构决策

3. 任务分解（Tasks）
   → 可执行的微任务列表

4. 逐任务执行
   → AI 按任务生成代码 + 人工审查

探索阶段（自由对话）→ 确认方向后（Spec 驱动）→ 细节实现（自由对话 + 人工审查）

┌─────────────────────────────────────────────────────────┐
│                  后端 Vibe Coding 工作流                   │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 需求分析与 API 设计                                    │
│     ├── 用自然语言描述业务需求                               │
│     ├── AI 生成 API 端点列表和数据模型                       │
│     └── 人工审查并确认 API 契约                             │
│                                                         │
│  2. 项目脚手架生成                                         │
│     ├── AI 生成项目结构、配置文件、依赖                       │
│     ├── 数据库 schema 和迁移文件                            │
│     └── Docker/docker-compose 配置                       │
│                                                         │
│  3. 核心业务逻辑实现                                       │
│     ├── 按 Spec 任务逐个实现                               │
│     ├── AI 生成代码 → 人工审查 → 修正                       │
│     └── 每个任务完成后运行测试                               │
│                                                         │
│  4. 安全加固                                              │
│     ├── AI 辅助安全审查（输入验证、认证、授权）                 │
│     ├── 自动化安全扫描（Snyk、Semgrep）                     │
│     └── 人工审查安全关键路径                                 │
│                                                         │
│  5. 测试与验证                                            │
│     ├── AI 生成单元测试和集成测试                            │
│     ├── API 契约测试                                      │
│     └── 性能基准测试                                       │
│                                                         │
│  6. 部署配置                                              │
│     ├── AI 生成 CI/CD 配置                                │
│     ├── 基础设施即代码（IaC）                               │
│     └── 监控和告警配置                                     │
│                                                         │
└─────────────────────────────────────────────────────────┘

你的后端项目是什么类型？
│
├── 快速原型 / MVP
│   ├── 需要数据库？
│   │   ├── 是 → Supabase + AI App Builder（Bolt.new/Lovable）
│   │   └── 否 → Claude Code / Cursor 自由对话模式
│   └── 需要部署？
│       ├── Serverless → Vercel/Netlify Functions + AI 生成
│       └── 容器化 → Railway/Fly.io + AI 配置生成
│
├── 生产项目（中等复杂度）
│   ├── 团队开发 → Kiro Spec 驱动 + GitHub Copilot
│   ├── 个人开发 → Claude Code + Spec 驱动
│   └── 需要深度框架集成 → JetBrains AI（Java/Kotlin/Python）
│
└── 大型系统 / 微服务
    ├── 架构设计 → Claude Code Plan Mode / Kiro Spec
    ├── 服务实现 → Cursor Agent + 人工审查
    └── 基础设施 → Amazon Q Developer（AWS）/ AI + Terraform

                    AI 生成质量高
                         │
            ┌────────────┼────────────┐
            │            │            │
            │   绿区      │   黄区      │
            │  AI 主导    │  AI 辅助    │
            │  人工审查    │  人工主导    │
  业务       │            │            │
  风险低 ────┼────────────┼────────────┤── 业务风险高
            │            │            │
            │   灰区      │   红区      │
            │  评估后决定  │  人工主导    │
            │            │  AI 参考    │
            │            │            │
            └────────────┼────────────┘
                         │
                    AI 生成质量低

你是一个资深后端工程师。请为以下业务需求生成 API 端点：

## 业务需求
[描述业务需求]

## 技术约束
- 语言/框架：[例如 TypeScript + NestJS]
- 数据库：[例如 PostgreSQL + Prisma]
- 认证方式：[例如 JWT Bearer Token]
- API 风格：[例如 RESTful / GraphQL / tRPC]

## 必须包含
- 输入验证（使用 [验证库]）
- 统一错误处理（自定义异常 + 错误响应格式）
- 适当的 HTTP 状态码
- 请求/响应的 TypeScript 类型定义
- 日志记录（关键操作）
- 单元测试（至少覆盖正常路径和主要错误路径）

## 安全要求
- 所有用户输入必须验证和清理
- SQL 查询必须参数化（通过 ORM）
- 敏感数据不得出现在日志中
- 实现适当的速率限制

请为以下业务领域设计数据库 schema：

## 业务领域
[描述业务领域和核心实体]

## 技术约束
- 数据库：[例如 PostgreSQL 16]
- ORM：[例如 Prisma / SQLAlchemy / TypeORM]
- 预期数据量：[例如 百万级用户，十亿级记录]

## 要求
- 合理的范式化（至少 3NF，说明任何有意的反范式化及原因）
- 适当的索引策略（包含复合索引的考虑）
- 外键约束和级联策略
- 软删除支持（如需要）
- 审计字段（created_at, updated_at, created_by）
- 数据库迁移文件

## 请同时提供
- ER 图（Mermaid 格式）
- 索引策略说明
- 预期查询模式和对应的索引

请为以下系统设计微服务架构：

## 系统描述
[描述系统功能和业务领域]

## 约束条件
- 预期 QPS：[例如 1000 QPS]
- 可用性要求：[例如 99.9%]
- 数据一致性要求：[例如 最终一致性可接受]
- 团队规模：[例如 3 人]

## 要求
- 服务边界定义（基于领域驱动设计）
- 服务间通信方式（同步 REST/gRPC vs 异步消息队列）
- 数据所有权（每个服务拥有自己的数据库）
- API 网关配置
- 服务发现和负载均衡
- 断路器和降级策略
- 分布式追踪

## 请同时提供
- 架构图（Mermaid 格式）
- 服务依赖关系
- 部署拓扑建议

请对以下后端代码进行安全审查：

## 审查范围
[粘贴代码或指定文件路径]

## 审查清单
- [ ] SQL 注入防护
- [ ] XSS 防护（如果返回 HTML）
- [ ] CSRF 防护
- [ ] 认证/授权逻辑正确性
- [ ] 输入验证完整性
- [ ] 敏感数据处理（密码、Token、PII）
- [ ] 错误信息泄露（不应暴露内部细节）
- [ ] 速率限制
- [ ] 文件上传安全
- [ ] 依赖安全（已知漏洞）
- [ ] 日志安全（不记录敏感信息）
- [ ] CORS 配置

## 输出格式
对每个发现的问题，请提供：
1. 严重程度（Critical/High/Medium/Low）
2. 问题描述
3. 影响范围
4. 修复建议（含代码示例）

# 后端开发 Steering 规则
 
## 技术栈
- 语言：[语言和版本]
- 框架：[框架和版本]
- 数据库：[数据库和版本]
- ORM：[ORM 和版本]
 
## 安全规则（最高优先级）
- 所有用户输入必须通过验证 schema（[Zod/Pydantic/Joi]）验证
- SQL 查询必须通过 ORM 参数化，禁止字符串拼接
- 密码必须使用 bcrypt（cost factor ≥ 12）哈希
- JWT 密钥必须从环境变量读取，禁止硬编码
- API 响应禁止暴露内部错误堆栈
- 敏感数据（密码、Token、PII）禁止出现在日志中
- 文件上传必须验证类型和大小
 
## 代码规范
- 使用依赖注入，避免全局状态
- 每个 API 端点必须有输入验证和错误处理
- 数据库操作必须在事务中执行（涉及多表修改时）
- 所有异步操作必须有超时和错误处理
- 使用统一的错误响应格式
 
## 测试要求
- 每个 Service 方法必须有单元测试
- API 端点必须有集成测试
- 测试必须覆盖正常路径和主要错误路径
 
## 禁止行为
- 禁止使用 eval() 或动态代码执行
- 禁止在代码中硬编码密钥、密码、连接字符串
- 禁止使用 SELECT *（必须明确指定字段）
- 禁止忽略错误（空 catch 块）
- 禁止在生产代码中使用 console.log（使用结构化日志）

我需要构建一个多租户项目管理 SaaS 的后端服务。核心功能包括：
1. 用户注册/登录（邮箱 + 密码，支持 Google OAuth）
2. 组织管理（创建组织、邀请成员、角色管理）
3. 项目 CRUD（属于组织，支持归档）
4. 任务管理（属于项目，支持分配、状态流转、优先级）
5. 实时通知（WebSocket）

技术栈：TypeScript + NestJS + Prisma + PostgreSQL + Redis
部署：Docker + Railway

// schema.prisma — AI 生成的多租户数据模型
 
generator client {
  provider = "prisma-client-js"
}
 
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
 
model User {
  id            String   @id @default(cuid())
  email         String   @unique
  passwordHash  String?
  name          String
  avatarUrl     String?
  emailVerified Boolean  @default(false)
  createdAt     DateTime @default(now())
  updatedAt     DateTime @updatedAt
 
  memberships   Membership[]
  assignedTasks Task[]       @relation("TaskAssignee")
  createdTasks  Task[]       @relation("TaskCreator")
  oauthAccounts OAuthAccount[]
 
  @@index([email])
}
 
model Organization {
  id        String   @id @default(cuid())
  name      String
  slug      String   @unique
  plan      Plan     @default(FREE)
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
 
  memberships Membership[]
  projects    Project[]
 
  @@index([slug])
}
 
model Membership {
  id             String       @id @default(cuid())
  role           MemberRole   @default(MEMBER)
  userId         String
  organizationId String
  createdAt      DateTime     @default(now())
 
  user         User         @relation(fields: [userId], references: [id], onDelete: Cascade)
  organization Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade)
 
  @@unique([userId, organizationId])
  @@index([organizationId])
}
 
model Project {
  id             String        @id @default(cuid())
  name           String
  description    String?
  archived       Boolean       @default(false)
  organizationId String
  createdAt      DateTime      @default(now())
  updatedAt      DateTime      @updatedAt
 
  organization Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade)
  tasks        Task[]
 
  @@index([organizationId])
}
 
model Task {
  id          String     @id @default(cuid())
  title       String
  description String?
  status      TaskStatus @default(TODO)
  priority    Priority   @default(MEDIUM)
  projectId   String
  assigneeId  String?
  creatorId   String
  dueDate     DateTime?
  createdAt   DateTime   @default(now())
  updatedAt   DateTime   @updatedAt
 
  project  Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
  assignee User?   @relation("TaskAssignee", fields: [assigneeId], references: [id])
  creator  User    @relation("TaskCreator", fields: [creatorId], references: [id])
 
  @@index([projectId])
  @@index([assigneeId])
  @@index([status])
}
 
enum Plan {
  FREE
  PRO
  ENTERPRISE
}
 
enum MemberRole {
  OWNER
  ADMIN
  MEMBER
  VIEWER
}
 
enum TaskStatus {
  TODO
  IN_PROGRESS
  IN_REVIEW
  DONE
  CANCELLED
}
 
enum Priority {
  LOW
  MEDIUM
  HIGH
  URGENT
}

// tasks.controller.ts — AI 生成的任务管理 API
 
@Controller('organizations/:orgId/projects/:projectId/tasks')
@UseGuards(JwtAuthGuard, OrgMemberGuard)
@ApiTags('Tasks')
export class TasksController {
  constructor(private readonly tasksService: TasksService) {}
 
  @Post()
  @Roles(MemberRole.OWNER, MemberRole.ADMIN, MemberRole.MEMBER)
  @ApiOperation({ summary: '创建任务' })
  async create(
    @Param('projectId') projectId: string,
    @CurrentUser() user: User,
    @Body() dto: CreateTaskDto,
  ): Promise<TaskResponseDto> {
    return this.tasksService.create(projectId, user.id, dto);
  }
 
  @Get()
  @ApiOperation({ summary: '获取任务列表' })
  @ApiQuery({ name: 'status', required: false, enum: TaskStatus })
  @ApiQuery({ name: 'assigneeId', required: false })
  @ApiQuery({ name: 'page', required: false, type: Number })
  @ApiQuery({ name: 'limit', required: false, type: Number })
  async findAll(
    @Param('projectId') projectId: string,
    @Query() query: TaskQueryDto,
  ): Promise<PaginatedResponse<TaskResponseDto>> {
    return this.tasksService.findAll(projectId, query);
  }
 
  @Patch(':taskId')
  @Roles(MemberRole.OWNER, MemberRole.ADMIN, MemberRole.MEMBER)
  @ApiOperation({ summary: '更新任务' })
  async update(
    @Param('taskId') taskId: string,
    @CurrentUser() user: User,
    @Body() dto: UpdateTaskDto,
  ): Promise<TaskResponseDto> {
    return this.tasksService.update(taskId, user.id, dto);
  }
 
  @Delete(':taskId')
  @Roles(MemberRole.OWNER, MemberRole.ADMIN)
  @ApiOperation({ summary: '删除任务' })
  @HttpCode(HttpStatus.NO_CONTENT)
  async remove(@Param('taskId') taskId: string): Promise<void> {
    return this.tasksService.remove(taskId);
  }
}