Next.js 16 + BetterAuth: Кінець епохи middleware, Prisma 7 та GDPR-безпека

// prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

// ==============================
// BETTER AUTH: ADMIN & USER
// ==============================

model User {
  id            String   @id
  name          String?
  email         String   @unique
  emailVerified Boolean  @default(false)
  image         String?
  createdAt     DateTime @default(now())
  updatedAt     DateTime @updatedAt

  // 🟢 КАСТОМНІ ПОЛЯ (Розширення базової моделі)
  username String? @unique
  bio      String? @db.Text
  website  String?
  linkedin String?
  role     String  @default("USER")
  isActive Boolean @default(true)

  // 🟢 ЗВ'ЯЗКИ З ІНШИМИ СУТНОСТЯМИ ПРОЕКТУ
  accounts               Account[]
  sessions               Session[]
  softwareComments       SoftwareComment[]
  blogComments           BlogComment[]
  techStack              UserTechStack[]
  unitEconomicsSnapshots UnitEconomicsSnapshot[]
  compareHistory         CompareHistory[]
  ownedWorkspaces        Workspace[]             @relation("WorkspaceOwner")
  workspaceMemberships   WorkspaceMember[]
  addedWorkspaceSoftware WorkspaceTechStack[]
  workspaceVotes         WorkspaceVote[]

  @@map("users")
}

model Session {
  id        String   @id
  expiresAt DateTime
  token     String   @unique
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  ipAddress String?
  userAgent String?
  userId    String
  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@map("sessions")
}

model Account {
  id                    String    @id
  accountId             String
  providerId            String
  userId                String
  user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
  accessToken           String?   @db.Text
  refreshToken          String?   @db.Text
  idToken               String?   @db.Text
  accessTokenExpiresAt  DateTime?
  refreshTokenExpiresAt DateTime?
  scope                 String?
  password              String?
  createdAt             DateTime  @default(now())
  updatedAt             DateTime  @updatedAt

  @@map("accounts")
}

model Verification {
  id         String    @id
  identifier String
  value      String    @unique
  expiresAt  DateTime
  createdAt  DateTime? @default(now())
  updatedAt  DateTime? @updatedAt

  @@map("verifications")
}

pnpm prisma migrate dev --name init_better_auth
pnpm prisma generate

// src/auth.ts

import bcrypt from 'bcryptjs'
import { betterAuth } from 'better-auth'
import { prismaAdapter } from 'better-auth/adapters/prisma'
import { prisma } from '@/lib/prisma'
import { sendNewUserNotification } from '@/lib/telegram/telegramBot'

// 🟢 Типізація для body у хуку
interface SignInBody {
  email?: string
  password?: string
}

export const auth = betterAuth({
  database: prismaAdapter(prisma, {
    provider: 'postgresql',
  }),

  emailAndPassword: {
    enabled: true,
    requireEmailVerification: true,
    password: {
      hash: async (password) => await bcrypt.hash(password, 10),
      verify: async ({ hash, password }) => await bcrypt.compare(password, hash),
    },
  },

  // 🟢 Прибрали блок emailVerification. Ми будемо відправляти лист вручну,
  // щоб Next.js не обривав процес відправки (timeout issues)!

  socialProviders: {
    google: {
      clientId: process.env.GOOGLE_CLIENT_ID ?? '',
      clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? '',
    },
    linkedin: {
      clientId: process.env.LINKEDIN_CLIENT_ID ?? '',
      clientSecret: process.env.LINKEDIN_CLIENT_SECRET ?? '',
    },
  },

  user: {
    // 🟢 Магія BetterAuth: ці поля автоматично потраплять у TypeScript-інтерфейс Session
    additionalFields: {
      role: { type: 'string', defaultValue: 'USER' },
      username: { type: 'string', required: false },
      isActive: { type: 'boolean', defaultValue: true },
    },
  },

  plugins: [
    {
      id: 'custom-credentials-enhancements',
      hooks: {
        before: [
          {
            // Перехоплюємо запит ДО того, як BetterAuth почне перевіряти хеші
            matcher: (ctx) => ctx.path?.startsWith('/sign-in/email') || false,
            handler: async (ctx) => {
              const bodyData = ctx.body as SignInBody | undefined
              if (!bodyData?.email) return

              const inputLogin = String(bodyData.email)
              const inputPassword = String(bodyData.password || '')

              const adminUserEnv = process.env.ADMIN_USER ?? ''
              const adminPassEnv = process.env.ADMIN_PASSWORD ?? ''

              // 🟢 MASTER ADMIN БЕКДОР: 
              // Ідеально для першого деплою на VPS. Якщо логін і пароль збігаються з .env, 
              // ми створюємо або оновлюємо адміна "на льоту".
              if (
                adminUserEnv &&
                adminPassEnv &&
                inputLogin === adminUserEnv &&
                inputPassword === adminPassEnv
              ) {
                let adminUser = await prisma.user.findUnique({
                  where: { email: 'admin@upart.club' },
                })

                if (!adminUser) {
                  adminUser = await prisma.user.create({
                    data: {
                      id: 'master-admin',
                      name: 'Master Admin',
                      email: 'admin@upart.club',
                      role: 'SUPERADMIN',
                      username: 'admin',
                      emailVerified: true,
                    },
                  })
                }

                const passwordHash = await bcrypt.hash(adminPassEnv, 10)
                const account = await prisma.account.findFirst({
                  where: { userId: adminUser.id, providerId: 'credential' },
                })

                if (!account) {
                  await prisma.account.create({
                    data: {
                      id: 'master-admin-account',
                      accountId: 'admin@upart.club',
                      providerId: 'credential',
                      userId: adminUser.id,
                      password: passwordHash,
                    },
                  })
                } else {
                  const isMatch = await bcrypt.compare(adminPassEnv, account.password || '')
                  if (!isMatch) {
                    await prisma.account.update({
                      where: { id: account.id },
                      data: { password: passwordHash },
                    })
                  }
                }

                // Підміняємо body, щоб BetterAuth продовжив логін вже з правильною поштою
                bodyData.email = 'admin@upart.club'
                return { context: ctx }
              }

              // 🟢 ЛОГІН ЗА USERNAME АБО EMAIL
              const user = await prisma.user.findFirst({
                where: { OR: [{ email: inputLogin }, { username: inputLogin }] },
              })

              if (user) {
                // 🟢 GDPR М'ЯКЕ ВИДАЛЕННЯ: Блокуємо доступ, якщо акаунт деактивовано
                if (!user.isActive) {
                  throw new Error('Account is blocked.')
                }
                bodyData.email = user.email
                return { context: ctx }
              }
            },
          },
        ],
      },
    },
  ],

  databaseHooks: {
    user: {
      create: {
        after: async (user) => {
          // 🟢 АВТОГЕНЕРАЦІЯ USERNAME
          const usernameStr = typeof user.username === 'string' ? user.username : null
          let finalUsername: string | null = usernameStr

          if (user.email && !finalUsername) {
            const baseUsername = user.email
              .split('@')[0]
              .toLowerCase()
              .replace(/[^a-z0-9]/g, '')

            let usernameExists = await prisma.user.findUnique({
              where: { username: baseUsername },
            })
            let newUsername = baseUsername

            while (usernameExists) {
              newUsername = `${baseUsername}${Math.floor(Math.random() * 1000)}`
              usernameExists = await prisma.user.findUnique({
                where: { username: newUsername },
              })
            }

            await prisma.user.update({
              where: { id: user.id },
              data: { username: newUsername },
            })

            finalUsername = newUsername
          }

          // 🟢 ТЕЛЕГРАМ-СПОВІЩЕННЯ ПРО РЕЄСТРАЦІЮ
          // Відправляємо сповіщення власнику платформи тільки для верифікованих акаунтів (Social)
          if (user.email && user.emailVerified) {
            await sendNewUserNotification({
              name: user.name || null,
              username: finalUsername,
              email: user.email,
              provider: 'Social Auth (Google / LinkedIn)',
            })
          }
        },
      },
    },
  },
})

// src/proxy.ts

import { type NextRequest, NextResponse } from 'next/server'
import { redis } from '@/lib/redis'

/* -------------------------------------------------------------------------- */
/* Типи                                                                       */
/* -------------------------------------------------------------------------- */

interface RateLimitInfo {
  count: number
  resetTime: number
}

declare global {
  var rateLimitCleanerStarted: boolean | undefined
}

/* -------------------------------------------------------------------------- */
/* Rate Limiter Storage                                                       */
/* -------------------------------------------------------------------------- */

const rateLimitMap = new Map<string, RateLimitInfo>()

// Раз на годину очищаємо пам'ять від старих IP-адрес, щоб запобігти витоку пам'яті
if (!globalThis.rateLimitCleanerStarted) {
  setInterval(
    () => {
      const now = Date.now()
      for (const [ip, data] of rateLimitMap.entries()) {
        if (now > data.resetTime) {
          rateLimitMap.delete(ip)
        }
      }
    },
    60 * 60 * 1000,
  )
  globalThis.rateLimitCleanerStarted = true
}

/* -------------------------------------------------------------------------- */
/* Middleware                                                                 */
/* -------------------------------------------------------------------------- */

export default async function middleware(req: NextRequest) {
  const { nextUrl } = req
  const pathname = nextUrl.pathname

  // --- 1. RATE LIMITING ДЛЯ API (ОКРІМ АВТОРИЗАЦІЇ) ---
  // Виключаємо /api/auth, щоб запити BetterAuth проходили без затримок
  if (pathname.startsWith('/api') && !pathname.startsWith('/api/auth')) {
    const ip =
      req.headers.get('x-forwarded-for')?.split(',')[0] ||
      req.headers.get('x-real-ip') ||
      '127.0.0.1'

    const now = Date.now()
    const limit = 50
    const windowMs = 60 * 1000 // 1 хвилина

    const userRate = rateLimitMap.get(ip)

    if (!userRate || now > userRate.resetTime) {
      rateLimitMap.set(ip, { count: 1, resetTime: now + windowMs })
    } else {
      userRate.count++
      if (userRate.count > limit) {
        return new NextResponse(
          JSON.stringify({
            error: 'Too many requests. Please try again later.',
          }),
          { status: 429, headers: { 'Content-Type': 'application/json' } },
        )
      }
    }
  }

  // --- 2. ЛОГІКА КОНТРОЛЮ ДОСТУПУ В АДМІНКУ ---
  const isAdminLoginPage = pathname === '/admin/login'
  const isAdminArea = pathname.startsWith('/admin') && !isAdminLoginPage

  if (isAdminLoginPage || isAdminArea) {
    // 🟢 Хак для Docker: Жорстко прописуємо локальну HTTP-адресу контейнера!
    // Це оминає зовнішній Nginx та HTTPS, уникаючи жахливої помилки SSL NAT Loopback.
    const localBaseUrl = 'http://127.0.0.1:3005'

    // Запитуємо сесію безпосередньо у локального екземпляра сервера
    const sessionRes = await fetch(`${localBaseUrl}/api/auth/get-session`, {
      headers: { cookie: req.headers.get('cookie') || '' },
    })

    const sessionData = await sessionRes.json()
    const isLoggedIn = !!sessionData?.session
    const userRole = sessionData?.user?.role || 'GUEST'

    const allowedAdminRoles = ['SUPERADMIN', 'ADMIN', 'EDITOR', 'MODERATOR']
    const hasAdminAccess = allowedAdminRoles.includes(userRole)

    // Якщо авторизований адмін намагається зайти на сторінку логіну адмінки
    if (isAdminLoginPage) {
      if (isLoggedIn && hasAdminAccess) {
        return NextResponse.redirect(new URL('/admin', nextUrl))
      }
      return NextResponse.next()
    }

    // Якщо намагаються зайти в закриту адмін-панель
    if (isAdminArea) {
      if (!isLoggedIn) {
        const url = new URL('/admin/login', nextUrl)
        url.searchParams.set('callbackUrl', pathname)
        return NextResponse.redirect(url)
      }

      if (!hasAdminAccess) {
        // Звичайних користувачів без прав адміна викидаємо на головну
        return NextResponse.redirect(new URL('/', nextUrl))
      }
    }
  }

  // --- 3. SEO 308 РЕДІРЕКТИ (КЕШ REDIS + ФОЛБЕК НА PRISMA) ---
  if (
    !pathname.startsWith('/_next') &&
    !pathname.startsWith('/api') &&
    !pathname.startsWith('/admin')
  ) {
    try {
      const cacheKey = `redirect:${pathname}`

      // Шукаємо правило редіректу в кеші Redis
      let targetUrl = await redis.get(cacheKey)

      // Якщо в кеші порожньо - звертаємось до БД через лінивий (lazy) імпорт Prisma
      if (!targetUrl) {
        const { prisma } = await import('@/lib/prisma')
        const redirectRule = await prisma.redirect.findUnique({
          where: { sourceUrl: pathname },
        })

        if (redirectRule) {
          targetUrl = redirectRule.targetUrl
          // Зберігаємо в кеш назавжди
          await redis.set(cacheKey, targetUrl)
        }
      }

      // Якщо правило редіректу спрацювало, повертаємо чистий постійний SEO-редірект 308
      if (targetUrl) {
        return NextResponse.redirect(new URL(targetUrl, nextUrl), 308)
      }
    } catch (e) {
      console.error('Redirect Logic Error:', e)
    }
  }

  return NextResponse.next()
}

/* -------------------------------------------------------------------------- */
/* Config                                                                     */
/* -------------------------------------------------------------------------- */

export const config = {
  // Matcher виключає системні файли, шрифти та статику для економії ресурсів сервера
  matcher: [
    '/((?!_next/static|_next/image|favicon.ico|assets-admin|assets-main|uploads|.*\\..*).*)',
  ],
}

// src/app/api/auth/[...all]/route.ts
import { toNextJsHandler } from 'better-auth/next-js'
import { auth } from '@/auth'

// toNextJsHandler автоматично розкидає методи GET, POST і т.д.
export const { GET, POST } = toNextJsHandler(auth)

// src/actions/register.ts
'use server'

import { headers } from 'next/headers'
import { auth } from '@/auth'
import { generateVerificationToken } from '@/lib/auth/tokens'
import { sendVerificationEmail } from '@/lib/mail'
import { prisma } from '@/lib/prisma'

export async function registerUser(formData: FormData) {
  // 1. Захист від ботів (Honeypot + reCAPTCHA)
  // ... (логіка перевірки капчі)

  try {
    // 2. Реєстрація юзера через API Better Auth
    await auth.api.signUpEmail({
      body: { email, password, name, username, role: 'USER', isActive: true },
      headers: await headers(),
    })

    // 3. Генеруємо токен вручну
    const verificationToken = await generateVerificationToken(email)

    // 4. Відправляємо листа вручну з очікуванням (await)
    await sendVerificationEmail(email, verificationToken.value, name || '')

    return { success: 'Confirmation email sent!', needsVerification: true }
  } catch (error) {
    return { error: 'Registration failed.' }
  }
}

// src/actions/user-settings.ts
export async function updatePassword(formData: PasswordData): Promise<ActionResponse> {
  // 1. Отримуємо сесію через auth.api
  const session = await auth.api.getSession({ headers: await headers() })
  if (!session?.user?.id) return { error: 'Unauthorized' }

  // 2. І шукаємо саме обліковий запис email (credentials)
  const account = await prisma.account.findFirst({
    where: { userId: session.user.id, providerId: 'email' },
  })

  if (!account?.password) return { error: 'Account does not use password auth.' }

  // 3. Порівнюємо старий пароль і хешуємо новий
  const passwordsMatch = await bcrypt.compare(currentPassword, account.password)
  if (!passwordsMatch) return { error: 'Current password incorrect.' }

  const hashedPassword = await bcrypt.hash(newPassword, 10)

  // 4. Оновлюємо таблицю Account
  await prisma.account.update({
    where: { id: account.id },
    data: { password: hashedPassword },
  })

  return { success: 'Password updated successfully!' }
}

// src/lib/auth-client.ts
import { createAuthClient } from 'better-auth/react'

export const authClient = createAuthClient({
  baseURL: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
})

// Експортуємо хуки для використання у компонентах
export const { useSession, signIn, signOut } = authClient