Устранение неполадок

// Проверьте ваш API ключ в Replicate
const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN
})

// Тест подключения
try {
  const models = await replicate.models.list()
  console.log('API ключ работает:', models.results.length > 0)
} catch (error) {
  console.error('Ошибка API:', error.message)
}

// .env.local
REPLICATE_API_TOKEN=r8_***your_token_here***

// Проверка в коде
if (!process.env.REPLICATE_API_TOKEN) {
  throw new Error('REPLICATE_API_TOKEN не установлен')
}

console.log('API Token первые символы:',
  process.env.REPLICATE_API_TOKEN.substring(0, 5))

// Получение информации о модели
const getModelInfo = async (owner, name) => {
  try {
    const model = await replicate.models.get(owner, name)
    console.log('Модель найдена:', model)
    console.log('Доступные версии:', model.latest_version)
    return model
  } catch (error) {
    console.error('Модель не найдена:', error.message)
    return null
  }
}

// Пример использования
await getModelInfo('stability-ai', 'sdxl')

// Получение списка публичных моделей
const listAvailableModels = async () => {
  try {
    const models = await replicate.models.list()
    return models.results.map(model => ({
      id: `${model.owner}/${model.name}`,
      description: model.description,
      latest_version: model.latest_version?.id
    }))
  } catch (error) {
    console.error('Ошибка получения моделей:', error)
    return []
  }
}

// app/api/replicate/webhook/route.ts
import { validateWebhook } from 'replicate'

export async function POST(request) {
  const secret = process.env.REPLICATE_WEBHOOK_SIGNING_SECRET

  // Логирование для отладки
  console.log('Webhook secret exists:', !!secret)
  console.log('Request headers:', Object.fromEntries(request.headers.entries()))

  if (!secret) {
    console.warn('Webhook secret не настроен')
    const body = await request.json()
    console.log('Webhook body (без валидации):', body)
    return Response.json({ detail: 'Webhook получен без валидации' })
  }

  try {
    const isValid = await validateWebhook(request.clone(), secret)
    console.log('Webhook валидация:', isValid ? 'успешна' : 'провалена')

    if (!isValid) {
      return Response.json({ error: 'Invalid signature' }, { status: 401 })
    }

    const body = await request.json()
    console.log('Валидный webhook:', body)

    return Response.json({ success: true })
  } catch (error) {
    console.error('Ошибка валидации webhook:', error)
    return Response.json({ error: 'Validation error' }, { status: 500 })
  }
}

// Тест доступности webhook URL
const testWebhookUrl = async (url) => {
  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'User-Agent': 'Replicate-Webhook/1.0'
      },
      body: JSON.stringify({
        test: true,
        timestamp: new Date().toISOString()
      })
    })

    console.log('Webhook URL статус:', response.status)
    console.log('Webhook URL доступен:', response.ok)
    return response.ok
  } catch (error) {
    console.error('Webhook URL недоступен:', error.message)
    return false
  }
}

// Проверка перед созданием предсказания
const webhookUrl = `${process.env.NEXTAUTH_URL}/api/replicate/webhook`
await testWebhookUrl(webhookUrl)

// Добавление таймингов к запросам
const trackPerformance = async (operation, fn) => {
  const start = Date.now()
  try {
    const result = await fn()
    const duration = Date.now() - start
    console.log(`${operation} завершена за ${duration}мс`)
    return result
  } catch (error) {
    const duration = Date.now() - start
    console.error(`${operation} провалена за ${duration}мс:, error.message`)
    throw error
  }
}

// Использование
const prediction = await trackPerformance('Создание предсказания', () =>
  replicate.predictions.create({
    version: modelVersion,
    input: optimizedInput
  })
)

// Оптимизация изображений перед отправкой
const optimizeImageInput = (imageUrl, maxSize = 1024) => {
  // Для локальных изображений
  if (typeof window !== 'undefined') {
    return new Promise((resolve) => {
      const img = new Image()
      img.onload = () => {
        const canvas = document.createElement('canvas')
        const ctx = canvas.getContext('2d')

        // Масштабирование
        const scale = Math.min(maxSize / img.width, maxSize / img.height)
        canvas.width = img.width * scale
        canvas.height = img.height * scale

        ctx.drawImage(img, 0, 0, canvas.width, canvas.height)
        resolve(canvas.toDataURL('image/jpeg', 0.8))
      }
      img.src = imageUrl
    })
  }

  return imageUrl
}

// Пример использования
const optimizedImage = await optimizeImageInput(originalImage)

// Добавление отладки в NextAuth
// pages/api/auth/[...nextauth].ts или app/api/auth/[...nextauth]/route.ts
export default NextAuth({
  debug: process.env.NODE_ENV === 'development',
  logger: {
    error(code, metadata) {
      console.error('NextAuth Error:', code, metadata)
    },
    warn(code) {
      console.warn('NextAuth Warning:', code)
    },
    debug(code, metadata) {
      console.log('NextAuth Debug:', code, metadata)
    }
  },
  callbacks: {
    async session({ session, token }) {
      console.log('Session callback:', { session, token })
      return session
    },
    async jwt({ token, user }) {
      console.log('JWT callback:', { token, user })
      return token
    }
  }
})

// hooks/useAuthDebug.ts
import { useSession } from 'next-auth/react'
import { useEffect } from 'react'

export function useAuthDebug() {
  const { data: session, status } = useSession()

  useEffect(() => {
    console.log('Auth status:', status)
    console.log('Session data:', session)

    if (status === 'loading') {
      console.log('Загрузка сессии...')
    } else if (status === 'unauthenticated') {
      console.log('Пользователь не аутентифицирован')
    } else if (status === 'authenticated') {
      console.log('Пользователь аутентифицирован:', session?.user?.email)
    }
  }, [session, status])

  return { session, status }
}

// scripts/check-env.js
const requiredEnvVars = [
  'REPLICATE_API_TOKEN',
  'NEXTAUTH_SECRET',
  'NEXTAUTH_URL',
  'DATABASE_URL',
  'REPLICATE_WEBHOOK_SIGNING_SECRET'
]

const missingVars = requiredEnvVars.filter(
  varName => !process.env[varName]
)

if (missingVars.length > 0) {
  console.error('Отсутствуют переменные окружения:')
  missingVars.forEach(varName => {
    console.error(`- ${varName}`)
  })
  process.exit(1)
} else {
  console.log('Все переменные окружения настроены ✓')
}

// package.json
// "scripts": {
//   "build": "node scripts/check-env.js && next build"
// }

// middleware.ts
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  // Разрешенные домены для продакшена
  const allowedOrigins = [
    'https://your-domain.com',
    'https://www.your-domain.com'
  ]

  const origin = request.headers.get('origin')

  if (request.nextUrl.pathname.startsWith('/api/')) {
    const response = NextResponse.next()

    if (origin && allowedOrigins.includes(origin)) {
      response.headers.set('Access-Control-Allow-Origin', origin)
    }

    response.headers.set('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS')
    response.headers.set('Access-Control-Allow-Headers', 'Content-Type,Authorization')

    if (request.method === 'OPTIONS') {
      return new Response(null, { status: 200, headers: response.headers })
    }

    return response
  }

  return NextResponse.next()
}