按业务模块拆分

// src/modules/users/types.ts
// 只暴露给外部使用的类型放这里，模块内部使用的类型不导出
 
export type User = {
  id: number
  email: string
  name: string
  role: 'admin' | 'member'
  createdAt: string
}
 
// 给外部调用方看的精简视图
export type UserProfile = Pick<User, 'id' | 'name' | 'role'>

// src/modules/users/schema.ts
import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
 
export const usersTable = sqliteTable('users', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  role: text('role', { enum: ['admin', 'member'] }).notNull().default('member'),
  createdAt: text('created_at').notNull(),
})

// src/modules/users/validation.ts
import { z } from 'zod'
 
// 创建用户的请求体校验
export const createUserSchema = z.object({
  email: z.string().email(),
  name: z.string().min(1).max(50),
  role: z.enum(['admin', 'member']).optional(),
})
 
// 更新用户的请求体校验
export const updateUserSchema = z.object({
  name: z.string().min(1).max(50).optional(),
  role: z.enum(['admin', 'member']).optional(),
})
 
// 路由参数校验
export const userIdParamSchema = z.object({
  userId: z.string().regex(/^\d+$/).transform(Number),
})

// src/modules/users/service.ts
import { eq } from 'drizzle-orm'
import type { DrizzleD1Database } from 'drizzle-orm/d1'
import { usersTable } from './schema'
import type { User } from './types'
 
type Db = DrizzleD1Database
 
// service 只依赖自己的 schema 和 types，不直接碰路由和 Context
export async function findAllUsers(db: Db): Promise<User[]> {
  return db.select().from(usersTable).all()
}
 
export async function findUserById(db: Db, id: number): Promise<User | null> {
  const rows = await db.select().from(usersTable).where(eq(usersTable.id, id)).all()
  return rows[0] ?? null
}
 
export async function createUser(
  db: Db,
  input: { email: string; name: string; role?: 'admin' | 'member' }
): Promise<User> {
  const result = await db
    .insert(usersTable)
    .values({
      email: input.email,
      name: input.name,
      role: input.role ?? 'member',
      createdAt: new Date().toISOString(),
    })
    .returning()
  return result[0]
}

// src/modules/users/routes.ts
import { Hono } from 'hono'
import { validator } from 'hono/validator'
import type { AppEnv } from '../../shared/types'
import { authMiddleware } from '../../shared/middleware/auth'
import { createUserSchema, updateUserSchema, userIdParamSchema } from './validation'
import * as userService from './service'
 
export const usersApp = new Hono<AppEnv>()
 
// 列表查询
usersApp.get('/', async (c) => {
  const db = c.get('db')
  const users = await userService.findAllUsers(db)
  return c.json({ users })
})
 
// 单条查询——参数校验和处理逻辑分开了
usersApp.get(
  '/:userId',
  validator('param', (value, c) => {
    const result = userIdParamSchema.safeParse(value)
    if (!result.success) return c.json({ error: 'invalid userId' }, 400)
    return result.data
  }),
  async (c) => {
    const { userId } = c.req.valid('param')
    const db = c.get('db')
    const user = await userService.findUserById(db, userId)
    if (!user) return c.json({ error: 'not found' }, 404)
    return c.json({ user })
  }
)
 
// 创建——需要鉴权
usersApp.post(
  '/',
  authMiddleware,
  validator('json', (value, c) => {
    const result = createUserSchema.safeParse(value)
    if (!result.success) return c.json({ error: result.error.flatten() }, 400)
    return result.data
  }),
  async (c) => {
    const body = c.req.valid('json')
    const db = c.get('db')
    const user = await userService.createUser(db, body)
    return c.json({ user }, 201)
  }
)

// src/index.ts
import { Hono } from 'hono'
import { logger } from 'hono/logger'
import { cors } from 'hono/cors'
import type { AppEnv } from './shared/types'
 
import { usersApp } from './modules/users/routes'
import { postsApp } from './modules/posts/routes'
import { authApp } from './modules/auth/routes'
import { billingApp } from './modules/billing/routes'
 
const app = new Hono<AppEnv>()
 
// 全局中间件
app.use('*', logger())
app.use('*', cors())
 
// 挂载业务模块
app.route('/api/users', usersApp)
app.route('/api/posts', postsApp)
app.route('/api/auth', authApp)
app.route('/api/billing', billingApp)
 
app.get('/health', (c) => c.json({ status: 'ok' }))
 
export default app

// src/modules/users/index.ts
// 模块的公开入口——外部只需要 import 这个文件
 
export { usersApp } from './routes'
export type { User, UserProfile } from './types'
 
// 如果其他模块需要调用用户相关的业务逻辑（比如 posts 模块需要在创建文章时查用户）
// 从这里导出 service 函数，而不是让外部直接 import ./service
export { findUserById } from './service'

// src/modules/posts/service.ts
import { findUserById } from '../users'
// 不是 import { findUserById } from '../users/service'

// src/modules/posts/service.ts
import { findUserById } from '../users'
 
export async function createPost(
  db: Db,
  input: { title: string; content: string; authorId: number }
) {
  // 跨模块调用——通过 users 模块的公开接口查用户
  const author = await findUserById(db, input.authorId)
  if (!author) throw new Error('author not found')
 
  // ...创建文章的逻辑
}