多租户 SaaS 架构基础：隔离级别先想清楚

// 每个查询都手动加 tenant_id，迟早会漏
async function getOrders(userId: string, tenantId: string) {
  // 风险：如果某个开发者忘了加 tenantId 参数，就造成数据越权
  return db.query(
    'SELECT * FROM orders WHERE user_id = ? AND tenant_id = ?',
    [userId, tenantId]
  )
}
 
async function getOrderStats(tenantId: string) {
  // 更危险：统计查询忘了加 tenant_id
  return db.query('SELECT COUNT(*) FROM orders')
}

// 基于请求上下文自动注入 tenant_id，消除人为遗漏
// 使用 Prisma 中间件示例
prisma.$use(async (params, next) => {
  const tenantId = ctx.get('tenantId')
  if (!tenantId) {
    throw new Error('Missing tenant context')
  }
 
  // 自动给所有查询追加 tenant_id 条件
  if (params.model && TENANT_SCOPED_MODELS.includes(params.model)) {
    params.args.where = {
      ...params.args.where,
      tenantId,
    }
  }
 
  return next(params)
})

// 缓存键只用业务 ID，不同租户的数据会互相覆盖
function getUserCacheKey(userId: string) {
  return `user:${userId}`
}
// 租户 A 的 user:123 和租户 B 的 user:123 命中同一个缓存

function getUserCacheKey(tenantId: string, userId: string) {
  return `tenant:${tenantId}:user:${userId}`
}

// 修复后的查询 —— 通过中间件自动注入，不再依赖开发者手动添加
// 中间件确保所有 TENANT_SCOPED_MODELS 的查询都带 tenant_id
const TENANT_SCOPED_MODELS = ['Order', 'User', 'Product', 'Invoice']
 
prisma.$use(async (params, next) => {
  const tenantId = ctx.get('tenantId')
 
  // 写操作也要拦截
  if (params.action === 'create' && params.model && TENANT_SCOPED_MODELS.includes(params.model)) {
    params.args.data = { ...params.args.data, tenantId }
  }
 
  return next(params)
})

// ❌ 坏做法：全局限流，无法区分租户
const rateLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 1000, // 所有租户共享 1000 次/分钟
})
 
// ✅ 好做法：按租户独立限流
const tenantRateLimiter = rateLimit({
  windowMs: 60 * 1000,
  // 每个租户独立配额
  keyGenerator: (req) => req.headers['x-tenant-id'],
  max: (req) => {
    // 根据租户套餐返回不同配额
    const plan = getTenantPlan(req.headers['x-tenant-id'])
    return PLAN_LIMITS[plan].requestsPerMinute
  },
  handler: (req, res) => {
    res.status(429).json({
      error: 'RATE_LIMITED',
      retryAfter: 60,
      message: '请求频率超出套餐限额，请稍后重试',
    })
  },
})

// ❌ 坏做法：同步导出，长时间占用连接池
app.get('/api/export/orders', async (req, res) => {
  const orders = await db.query(
    'SELECT * FROM orders WHERE tenant_id = $1',
    [req.tenantId]
  )
  res.json(orders) // 数据量大时这个请求会卡几十秒
})
 
// ✅ 好做法：异步导出，不阻塞主流程
app.post('/api/export/orders', async (req, res) => {
  const job = await exportQueue.add('export-orders', {
    tenantId: req.tenantId,
    filters: req.body.filters,
  }, {
    priority: getTenantPriority(req.tenantId),
  })
 
  res.status(202).json({
    jobId: job.id,
    statusUrl: `/api/export/status/${job.id}`,
  })
})

// ✅ 在连接建立时设置 Schema 搜索路径
function createTenantConnection(tenantId: string, schemaName: string) {
  const conn = pool.connect()
  // PostgreSQL: 设置当前连接的 Schema 搜索路径
  await conn.query(`SET search_path TO ${schemaName}, public`)
  return conn
}
 
// 请求级别：从租户配置获取 Schema 名
app.use(async (req, res, next) => {
  const tenant = await getTenantConfig(req.tenantId)
  if (tenant.isolationLevel === 'schema') {
    req.db = await createTenantConnection(tenant.id, tenant.schemaName)
  } else {
    req.db = pool // 共享表模式的租户走默认连接
  }
  next()
})

// 迁移脚本：对所有租户 Schema 执行相同的 DDL 变更
async function migrateAllTenants(ddl: string) {
  const tenants = await db.query(
    "SELECT schema_name FROM tenants WHERE isolation_level = 'schema'"
  )
 
  for (const tenant of tenants.rows) {
    // 幂等设计：每个 Schema 独立执行，失败可重试
    await db.query(`SET search_path TO ${tenant.schema_name}`)
    await db.query(ddl)
    console.log(`Migrated schema: ${tenant.schema_name}`)
  }
}

// 跨租户查询使用专用连接，不走租户路由
const adminPool = new Pool({
  connectionString: config.adminDbUrl,
  // 不设置 search_path，可以跨 Schema 查询
})
 
// 运营看板：汇总所有租户数据
async function getPlatformStats() {
  const result = await adminPool.query(`
    SELECT t.name, COUNT(u.id) as user_count
    FROM tenants t
    JOIN ${t.schema_name}.users u ON u.tenant_id = t.id
    GROUP BY t.name
  `)
  return result.rows
}

// 每个功能点都写 if-else，维护成本随租户数量线性增长
function getDashboardFeatures(tenantId: string) {
  const features = ['basic-chart']
  if (tenantId === 'tenant-premium-a' || tenantId === 'tenant-enterprise-b') {
    features.push('advanced-analytics')
  }
  if (tenantId === 'tenant-enterprise-b') {
    features.push('custom-branding', 'api-access')
  }
  return features
}

// 套餐定义功能集合，功能开关控制灰度和实验
// 套餐是产品层面的概念，功能开关是技术层面的概念
 
// 套餐配置（存在数据库或配置中心）
const PLAN_FEATURES = {
  free: ['basic-chart', 'up-to-5-users'],
  pro: ['basic-chart', 'advanced-analytics', 'up-to-50-users', 'api-access'],
  enterprise: ['basic-chart', 'advanced-analytics', 'unlimited-users', 'api-access', 'custom-branding', 'sso'],
}
 
// 运行时查询：从套餐解析功能列表
function getTenantFeatures(tenantId: string): string[] {
  const plan = getTenantPlan(tenantId) // 从缓存或数据库获取
  return PLAN_FEATURES[plan] ?? PLAN_FEATURES.free
}
 
// 功能判断统一入口
function hasFeature(tenantId: string, feature: string): boolean {
  return getTenantFeatures(tenantId).includes(feature)
}

// 只知道系统整体慢了多少，不知道是哪个租户引起的
metrics.histogram('request_duration', duration)
metrics.counter('request_errors', 1)

// 每个指标都带 tenant_id 标签，支持按租户聚合和告警
metrics.histogram('request_duration', duration, {
  tenant_id: req.tenantId,
  endpoint: req.path,
})
 
metrics.counter('request_errors', 1, {
  tenant_id: req.tenantId,
  error_code: err.code,
})
 
// 可以设置按租户的告警规则
// 例：某个租户的 P95 延迟超过 2 秒时触发告警