隐私政策与 GDPR 基础：小团队出海要先补哪些课

// ❌ 页面加载即初始化所有追踪脚本，不给用户任何选择
// 这种写法在很多教程里常见，因为「简单」
import ReactGA from 'react-ga4'
import posthog from 'posthog-js'
 
export function initAnalytics() {
  // 页面一加载就调用，没有任何前置检查
  ReactGA.initialize('G-XXXXXXXXXX')
  posthog.init('phc_xxxxx', {
    api_host: 'https://app.posthog.com',
    // IP 地址、浏览器指纹全部发送到第三方
  })
}
 
// 在 App 入口直接执行
initAnalytics()

// ✅ 先检查同意状态，再初始化追踪脚本
import type { ConsentState } from '@/lib/consent'
 
interface TrackingConfig {
  ga4Id?: string
  posthogKey?: string
  metaPixelId?: string
}
 
export async function initAnalytics(
  consent: ConsentState,
  config: TrackingConfig
) {
  // 只有用户明确同意的服务才初始化
  if (consent.analytics && config.ga4Id) {
    const { default: ReactGA } = await import('react-ga4')
    ReactGA.initialize(config.ga4Id)
  }
 
  if (consent.analytics && config.posthogKey) {
    const { default: posthog } = await import('posthog-js')
    posthog.init(config.posthogKey, {
      api_host: 'https://app.posthog.com',
      // 关键：在同意之前不设置任何 Cookie
      disable_session_recording: !consent.analytics,
    })
  }
 
  if (consent.marketing && config.metaPixelId) {
    // Meta Pixel 属于营销类，需要单独的营销同意
    await loadMetaPixel(config.metaPixelId)
  }
}

// ✅ 同意偏好的存储和读取
interface ConsentState {
  necessary: true       // 必要类，始终为 true
  analytics: boolean    // 分析类，用户可选
  marketing: boolean    // 营销类，用户可选
  functional: boolean   // 功能类，用户可选
  timestamp: number     // 记录同意时间，用于审计
  version: string       // 同意策略版本号
}
 
const CONSENT_COOKIE = 'consent_preferences'
const COOKIE_MAX_AGE = 180 * 24 * 60 * 60 // 180 天
 
export function saveConsent(state: ConsentState): void {
  const value = JSON.stringify(state)
  document.cookie = `${CONSENT_COOKIE}=${encodeURIComponent(value)}; \
    path=/; \
    max-age=${COOKIE_MAX_AGE}; \
    SameSite=Lax; \
    Secure`
}
 
export function readConsent(): ConsentState | null {
  const match = document.cookie
    .split('; ')
    .find(row => row.startsWith(`${CONSENT_COOKIE}=`))
  
  if (!match) return null
  
  try {
    return JSON.parse(decodeURIComponent(match.value ?? match.split('=')[1]))
  } catch {
    return null
  }
}

// ❌ 只删除 users 表记录，其他表的数据成了孤儿
export async function deleteAccount(userId: string) {
  await db.user.delete({ where: { id: userId } })
  // 完成了吗？没有。
  // - user_profiles 表里还有头像 URL
  // - projects 表里还有用户创建的项目
  // - analytics_events 表里还有行为记录
  // - stripe_customers 表里还有支付关联
  // - posthog 里还有这个用户的全部 session
  // - sendgrid 里还有这个邮箱的订阅状态
}

// ✅ 数据删除编排器——先建地图，再按图删除
interface DataStore {
  name: string           // 存储位置名称
  type: 'database' | 'third-party' | 'backup'
  delete(userId: string): Promise<DeleteResult>
  verify(userId: string): Promise<boolean> // 确认删除完成
}
 
interface DeleteResult {
  success: boolean
  deletedRecords: number
  errorMessage?: string
  requiresManualAction?: boolean  // 标记需要人工处理的项目
}
 
class AccountDeletionOrchestrator {
  private stores: DataStore[] = []
 
  register(store: DataStore) {
    this.stores.push(store)
  }
 
  async execute(userId: string): Promise<DeletionReport> {
    const results: DeleteResult[] = []
    const errors: Array<{ store: string; error: string }> = []
 
    // 第一阶段：软删除——立即停止数据处理
    await this.softDelete(userId)
 
    // 第二阶段：逐存储删除
    for (const store of this.stores) {
      try {
        const result = await store.delete(userId)
        results.push(result)
 
        if (result.requiresManualAction) {
          errors.push({
            store: store.name,
            error: '需要人工处理（如备份数据）',
          })
        }
      } catch (err) {
        errors.push({
          store: store.name,
          error: err instanceof Error ? err.message : '未知错误',
        })
      }
    }
 
    // 第三阶段：验证
    const verification = await this.verifyAll(userId)
 
    return {
      userId,
      timestamp: new Date().toISOString(),
      results,
      errors,
      verified: verification,
      // 需要人工跟进的项目
      pendingActions: errors.filter(e => e.includes('人工')),
    }
  }
 
  private async softDelete(userId: string) {
    // 立即标记用户为「已请求删除」，停止所有数据处理活动
    await db.user.update({
      where: { id: userId },
      data: {
        deletionRequestedAt: new Date(),
        status: 'pending_deletion',
        // 停止营销邮件、停止数据收集
      },
    })
  }
 
  private async verifyAll(userId: string): Promise<boolean> {
    // 逐一验证每个存储是否已删除
    const checks = await Promise.all(
      this.stores.map(store => store.verify(userId))
    )
    return checks.every(Boolean)
  }
}

// 主数据库
orchestrator.register({
  name: 'primary-database',
  type: 'database',
  async delete(userId) {
    // 使用事务确保原子性
    return db.$transaction(async (tx) => {
      await tx.apiKey.deleteMany({ where: { userId } })
      await tx.project.deleteMany({ where: { ownerId: userId } })
      await tx.userProfile.delete({ where: { userId } })
      // 审计日志不删除，脱敏处理
      await tx.auditLog.updateMany({
        where: { userId },
        data: { userId: 'REDACTED', email: 'REDACTED' },
      })
      await tx.user.delete({ where: { id: userId } })
      return { success: true, deletedRecords: -1 }
    })
  },
  async verify(userId) {
    const user = await db.user.findUnique({ where: { id: userId } })
    return user === null
  },
})
 
// PostHog 第三方数据
orchestrator.register({
  name: 'posthog',
  type: 'third-party',
  async delete(userId) {
    // PostHog 提供 API 删除特定用户的数据
    const response = await fetch(
      `https://app.posthog.com/api/projects/${POSTHOG_PROJECT_ID}/persons/`,
      {
        method: 'DELETE',
        headers: { Authorization: `Bearer ${POSTHOG_API_KEY}` },
        // 按 distinct_id 删除，这就是用户的 user ID
      }
    )
    return {
      success: response.ok,
      deletedRecords: response.ok ? 1 : 0,
    }
  },
  async verify() {
    // PostHog 没有单独的验证 API，依赖删除响应
    return true
  },
})

// ❌ 隐私政策是单个 Markdown 文件，每次更新直接覆盖
// 无法追溯用户注册时看到的是哪个版本
export const privacyPolicy = `
# Privacy Policy
Last updated: ${new Date().toISOString().split('T')[0]}
 
We collect your email, usage data, and share with Stripe...
`
 
// 问题：
// 1. 用户 A 在 2024 年注册时看到的是「不收集 IP」
// 2. 2025 年改成「收集 IP 用于安全」，直接覆盖
// 3. 用户 A 从未同意过 IP 收集，但页面上已经是新版本了
// 4. 如果有人问「用户 A 同意过收集 IP 吗」，无法回答

// ✅ 隐私政策版本化，用户同意绑定具体版本号
 
// 数据库模型（Prisma schema）
// model PrivacyPolicyVersion {
//   id          String   @id @default(cuid())
//   version     String   @unique  // "v1", "v2", ...
//   content     String            // Markdown 内容
//   summary     String            // 变更摘要（给用户看的）
//   publishedAt DateTime
//   effectiveAt DateTime          // 生效日期
// }
//
// model UserConsent {
//   id                String   @id @default(cuid())
//   userId            String
//   policyVersion     String   // 同意的政策版本号
//   cookieConsent     Json     // Cookie 偏好
//   marketingConsent  Boolean
//   consentedAt       DateTime
//   @@unique([userId, policyVersion])
// }
 
interface PolicyChange {
  oldVersion: string
  newVersion: string
  changes: Array<{
    type: 'new_service' | 'retention_change' | 'new_collection' | 'purpose_change'
    description: string
  }>
}
 
async function publishNewPolicy(
  content: string,
  summary: string,
  changes: PolicyChange['changes']
) {
  // 1. 创建新版本
  const newVersion = await createNextVersion(content, summary)
 
  // 2. 找出受影响的用户——上一版同意者中，
  //    需要检查哪些用户的同意版本低于新版本
  const affectedUsers = await db.userConsent.groupBy({
    by: ['userId'],
    where: {
      policyVersion: { not: newVersion.version },
    },
  })
 
  // 3. 标记需要重新同意的用户
  await db.user.updateMany({
    where: {
      id: { in: affectedUsers.map(u => u.userId) },
    },
    data: {
      requiresPolicyReconsent: true,
      pendingPolicyVersion: newVersion.version,
    },
  })
 
  // 4. 下次用户登录时，弹出政策变更通知
  return { newVersion, affectedCount: affectedUsers.length }
}
 
// 用户重新同意的处理
async function recordPolicyConsent(
  userId: string,
  version: string
) {
  await db.userConsent.upsert({
    where: {
      userId_policyVersion: { userId, policyVersion: version },
    },
    update: { consentedAt: new Date() },
    create: {
      userId,
      policyVersion: version,
      marketingConsent: false, // 营销需要单独同意，不继承
      consentedAt: new Date(),
    },
  })
 
  // 清除待办标记
  await db.user.update({
    where: { id: userId },
    data: {
      requiresPolicyReconsent: false,
      pendingPolicyVersion: null,
    },
  })
}