Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

import { NextRequest, NextResponse } from 'next/server'; import axios from 'axios';…

  1. User

    import { NextRequest, NextResponse } from 'next/server'; import axios from 'axios'; import { getServerSession } from 'next-auth'; import { authOptions } from '@/utils/authOptions';

    const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL;

    if (!API_BASE_URL) { throw new Error('NEXT_PUBLIC_API_BASE_URL is not defined'); }

    const handleRequest = async ( request: NextRequest, params: { path: string[] }, method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' ) => { const { path } = params; const url = new URL(request.url); const queryParams = Object.fromEntries(url.searchParams.entries()); const targetUrl = ${API_BASE_URL}/${path.join('/')};

    const session = await getServerSession(authOptions); const token = session?.access_token;

    try { let bodyData; if (method !== 'GET' && method !== 'DELETE') { const contentType = request.headers.get('content-type'); try { if (contentType && contentType.includes('application/json')) { bodyData = await request.json(); } else if (contentType && contentType.includes('application/x-www-form-urlencoded')) { bodyData = Object.fromEntries(await request.formData()); } else { bodyData = await request.text(); } } catch (error) { console.error('Error parsing request body:', error); return NextResponse.json({ message: 'Invalid or missing request body' }, { status: 400 }); } }

    const config: any = {
      method,
      url: targetUrl,
      params: queryParams,
      headers: {
        ...Object.fromEntries(request.headers.entries()),
        Authorization: token ? `Bearer ${token}` : '',
      },
      data: bodyData
    };
    
    const response = await axios(config);
    return NextResponse.json(response.data, { status: response.status });
    

    } catch (error) { console.log('error: ', error) if (axios.isAxiosError(error) && error.response) { return NextResponse.json(error.response.data, { status: error.response.status }); } return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 }); } };

    export async function GET( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'GET'); }

    export async function POST( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'POST'); }

    export async function PUT( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'PUT'); }

    export async function DELETE( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'DELETE'); }

    export async function PATCH( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'PATCH'); }

    как убрать редирект с например /api/prpxy/images/ на /api/prpxy/images

  2. Assistant

    Чтобы удалить редирект с /api/proxy/images/ на /api/proxy/images, вы можете изменить конфигурацию вашего сервера или маршрутизации в Next.js.

    Next.js по умолчанию может делать неявный редирект с окончания / на URL без него, и это может быть связано с некоторыми настройками роутера. Если вы хотите, чтобы запросы с прямым слэшем в конце не вызывали редирект, вам нужно убедиться, что маршруты настроены правильно.

    Вот основное, что вы можете сделать:

    1. Настройка в файле next.config.js: Убедитесь, что у вас не настроены автоматические редиректы или rewrites, которые могут вызывать это поведение. Если у вас есть настройки по умолчанию, проверьте их.

    2. Добавьте обработку в handleRequest: Если вы хотите, чтобы ваш обработчик не перенаправлял напрямую, вы можете обработать этот случай внутри функции handleRequest. Например, просто убедитесь, что когда вы формируете targetUrl, он не содержит лишнего слэша.

    3. Используйте path массива правильно: Вы можете использовать path в качестве элемента массива, чтобы избежать ситуаций, когда добавляется лишний слэш. Пример:

    const targetUrl = `${API_BASE_URL}/${path.join('/')}`;
    
    1. Проверьте наличие middleware: Если у вас настроены дополнительные middleware или маршруты в вашем приложении, которые могут вызывать редиректы, проверьте их.

    2. Проверка тестирования: Проверьте работу вашего API через Postman или curl и убедитесь, что вы получаете желаемое поведение.

    Пример кода

    Вот общее предложение, как это может выглядеть внутри вашего кода:

    const targetUrl = `${API_BASE_URL}/${path.join('/')}`.replace(/\/+$/, '');
    

    Эта строка уберет лишние слэши в конце URL, что может решить проблему редиректа. Это простой способ предотвратить частые проблемы с URL в API запросах.

    После выполнения этих шагов, действительно, нужно протестировать API, чтобы убедиться, что редирект не происходит.

  3. User

    308 Permanent Redirect как убрать в next js

  4. Assistant

    В Next.js, если вы сталкиваетесь с проблемой "308 Permanent Redirect", это может быть связано с тем, как ваш сервер или маршрутизатор обрабатывает URL-адреса, содержащие завершающиe слэши. Чтобы избавиться от этой проблемы и предотвратить редиректы на уровне приложения, вы можете выполнить несколько шагов:

    1. Проверьте настройки маршрутизации

    Убедитесь, что ваше приложение не отправляет запросы с завершающими слэшами (например, /api/proxy/images/) к вашему API. Если ваш клиентский код делает такие запросы, измените его на:

    // Избегайте завершающего слэша в запросах
    fetch('/api/proxy/images');
    

    2. Настройка API-обработчиков

    В вашем обработчике API, особенно в функциях, которые используют маршрутизацию, постарайтесь убедиться, что вы передаете URL без лишнего слэша. Например, убедитесь, что при формировании targetUrl, вы убираете лишние слэши:

    const targetUrl = `${API_BASE_URL}/${path.join('/').replace(/\/+$/, '')}`;
    

    3. Использование Middleware (по желанию)

    Если вы все еще сталкиваетесь с проблемами, возможно, стоит рассмотреть использование Middleware для перехвата запросов и удаления завершающих слэшей. Например, вы можете создать middleware для проверки условий:

    import { NextResponse } from 'next/server';
    
    export function middleware(req) {
      const url = req.nextUrl.clone();
      // Убираем завершающий слэш, если он есть и если это не корень
      if (url.pathname.endsWith('/') && url.pathname !== '/') {
        url.pathname = url.pathname.slice(0, -1);
        return NextResponse.redirect(url);
      }
      return NextResponse.next();
    }
    

    4. Обработка редиректов на уровне сервера

    Если вы используете сервер (например, Nginx, Vercel или другой веб-сервер) перед сервером Next.js, убедитесь, что он не настроен на автоматическое добавление завершающих слэшей или на переадресацию на URL без них.

    5. Проверьте заголовки и конфигурации сети

    Иногда такие редиректы могут также вызваны неправильно настроенными заголовками CORS, прокси-сервером или сетью. Поэтому проверьте, не взаимодействует ли ваш API с промежуточными серверами, которые могут перенаправлять ваши запросы.

    Заключение

    Следуя этим шагам, вы сможете устранить проблему с "308 Permanent Redirect" в вашем Next.js приложении. Для успешного решения важно понять, откуда именно происходит редирект и правильно конфигурировать маршрутизацию и обработчики вашего API.

  5. User

    Мне не надо убирать слеш, надо чтобы он остался

  6. Assistant

    Если вы хотите, чтобы завершающий слэш оставался в URL и чтобы не происходило 308 Permanent Redirect, но ваш сервер или фреймворк делает это поведение по умолчанию, вам нужно убедиться, что:

    1. Конфигурация сервера: Проверьте настройки вашего сервера или прокси (например, Nginx, Vercel и т.д.), чтобы убедиться, что они не создают перенаправления на URL без завершающего слэша.

    2. Фреймворк Next.js: В самой Next.js вам не нужно ничего специального делать, чтобы сохранить слэш. Система роутинга должна правильно обрабатывать маршруты с завершающим слэшем.

    Примеры возможных решений

    1. Next.js Middleware: Если у вас настроено код для маршрутов, который иногда приводит к перенаправлению, вы можете создать middleware, чтобы избежать этого поведения.

      Пример middleware, который позволяет слэшам остаться в URL:

      import { NextResponse } from 'next/server';
      
      export function middleware(req) {
        const url = req.nextUrl.clone();
      
        // Проверяет, чтобы не было редиректа, если путь уже заканчивается на "/"
        if (!url.pathname.endsWith('/') && !url.pathname.includes('.')) {
          url.pathname += '/';
          return NextResponse.redirect(url);
        }
      
        return NextResponse.next();
      }
      
    2. Обработчики API: Убедитесь, что ваши API-обработчики не вызывают перенаправлений из-за логики обработки запросов. Ваш код для формирования URL, который вы уже имеете, должен работать правильно, если вы делаете запросы к интерфейсу API с завершающим слэшем.

    Примеры API маршрутов

    Вот как вы можете реализовать обработчик API с поддержкой завершающего слэша:

    export async function GET(request, context) {
      const params = await context.params;
      // Здесь сделайте запрос к вашему API с нужным параметром
      return handleRequest(request, params, 'GET');
    }
    

    Проверка запросов

    При отправке запросов убедитесь, что вы всегда запрашиваете URL с завершающим слэшем:

    const response = await fetch('/api/proxy/images/');
    

    Итог

    Если вы делаете все правильно, используя слэш в URL и не вызывая перенаправления в API или других частях приложения, то ваш сервер должен обрабатывать запросы корректно. Если проблема с 308 перенаправлением сохраняется, имеет смысл посмотреть на уровень настройки вашего веб-сервера или среду развертывания (например, Vercel или аналогичные), чтобы убедиться, что там нет таких конфигураций.

  7. User

    напиши файл /api/proxy для next js 15, чтобы отправлять некоторые запросы не с клиента, а с сервера

  8. Assistant

    Для создания API маршрута в Next.js 15, который будет обрабатывать запросы и отправлять их на другой сервер с сервера (server-side), вам нужно создать соответствующий файл в папке pages/api. Давайте построим простой пример, который будет принимать запросы к вашему API и перенаправлять их на внешний API.

    Шаг 1: Создание файла API

    Создайте файл proxy.js в директории pages/api вашего проекта:

    /pages/api/proxy.js
    

    Шаг 2: Реализация логики проксирования

    Вот пример реализации, который обрабатывает запросы и перенаправляет их на внешний API, передавая заголовки и тело запроса:

    import axios from 'axios';
    
    const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL; // Убедитесь, что у вас установлена эта переменная окружения
    
    if (!API_BASE_URL) {
      throw new Error('NEXT_PUBLIC_API_BASE_URL is not defined');
    }
    
    export default async function handler(req, res) {
      const { method, body, headers } = req;
    
      // Определите URL для запроса к внешнему API
      const url = `${API_BASE_URL}${req.query.path || ''}`;
    
      try {
        // Настраиваем конфигурацию для Axios
        const response = await axios({
          method: method,
          url: url,
          data: body,
          headers: {
            ...headers,
            // Можно добавить или модифицировать заголовки при необходимости
          },
        });
    
        // Возвращаем ответ от внешнего API к клиенту
        res.status(response.status).json(response.data);
      } catch (error) {
        console.error('Error in proxy:', error);
        
        // Обработка ошибок от внешнего API
        if (axios.isAxiosError(error) && error.response) {
          res.status(error.response.status).json(error.response.data);
        } else {
          res.status(500).json({ message: 'Internal Server Error' });
        }
      }
    }
    

    Шаг 3: Использование прокси

    Теперь вы можете делать запросы к вашему прокси API, используя Next.js как промежуточное звено. В зависимости от того, какой метод вы используете (GET, POST и т. д.), вы можете использовать fetch API на стороне клиента:

    // Пример использования в компоненте Next.js
    async function fetchData() {
      const response = await fetch('/api/proxy?path=/images', {
        method: 'GET', // или 'POST', 'PUT' и т. д.
        headers: {
          'Content-Type': 'application/json',
        },
        // body: JSON.stringify(data), // Если это POST или другой метод, где требуется тело
      });
    
      const data = await response.json();
      console.log(data);
    }
    

    Шаг 4: Настройки окружения

    Убедитесь, что в вашем .env.local файле указана переменная окружения NEXT_PUBLIC_API_BASE_URL, указывающая на адрес вашего внешнего API. Пример:

    NEXT_PUBLIC_API_BASE_URL=https://example.com/api
    

    Дополнительные примечания

    • Убедитесь, что axios установлен в вашем проекте. Если он не установлен, добавьте его:
    npm install axios
    
    • Если ваш внешний API требует аутентификации или специальных заголовков, вам нужно будет добавить их в headers в конфигурации axios.
    • Также убедитесь, что ваш внешний API позволяет кросс-доменные запросы (CORS), если ваш сервер и API находятся на разных доменах.

    Теперь у вас есть базовый API маршрут в Next.js, который будет проксировать запросы к другому API серверу, отрабатывая их на сервере.

  9. User

    Давай без query, чтобы /api/proxy/images/ делал редирект на https://example.com/images/

  10. Assistant

    Если вы хотите, чтобы запросы к вашему API маршруту /api/proxy/images/ перенаправлялись на https://example.com/images/ без использования query параметров, вы можете просто изменить реализацию обработчика в Next.js. Вот пример того, как это можно сделать:

    Шаг 1: Создание файла API

    Создайте файл proxy.js в директории pages/api вашего проекта, если его еще нет:

    /pages/api/proxy/images.js
    

    Шаг 2: Реализация логики проксирования

    Вот пример реализации, который будет обрабатывать GET запросы и перенаправлять их на https://example.com/images/:

    import axios from 'axios';
    
    // Предполагаем, что у вас есть базовый URL вашего внешнего API
    const EXTERNAL_API_URL = 'https://example.com/images';
    
    export default async function handler(req, res) {
      // Получение метода запроса
      const { method } = req;
    
      // Здесь вы можете добавить отладочную информацию если надо
      console.log(`Received ${method} request to API Proxy`);
    
      try {
        // Настройка запроса к внешнему API
        const response = await axios({
          method: method,
          url: EXTERNAL_API_URL,
          data: method !== 'GET' ? req.body : undefined, // Убедитесь, что данные передаются только для POST/PUT/DELETE
          headers: {
            ...req.headers,
            // Удалите любые заголовки, которые могут нарушить запрос
            host: undefined,
            'content-length': undefined,
          },
        });
    
        // Возвращаем ответ от внешнего API к клиенту
        res.status(response.status).json(response.data);
      } catch (error) {
        console.error('Error in proxy:', error);
    
        // Обработка ошибок от внешнего API
        if (axios.isAxiosError(error) && error.response) {
          res.status(error.response.status).json(error.response.data);
        } else {
          res.status(500).json({ message: 'Internal Server Error' });
        }
      }
    }
    

    Шаг 3: Использование прокси

    Теперь, когда вы отправите GET запрос на /api/proxy/images, он будет проксировать его на https://example.com/images. Вы можете использовать следующий код на клиентской стороне для проверки:

    async function fetchData() {
      const response = await fetch('/api/proxy/images', {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    
      const data = await response.json();
      console.log(data);
    }
    

    Примечания

    1. Методы: В этом примере поддерживаются все методы (GET, POST, PUT, DELETE и т.д.). Для POST и других методов данные будут отправляться в теле запроса.

    2. Заголовки: Важно убрать заголовки, которые могут вызвать проблемы, такие как Host и Content-Length. Это позволит избежать ошибок, связанных с неправильным форматированием запросов.

    3. Обработка ошибок: Код содержит обработку ошибок, которая сообщает о том, что произошло при обращении к внешнему API.

    4. Безопасность: Убедитесь, что ваше прокси-API используется ответственно и не открывает уязвимости для ваших серверов или баз данных.

    Таким образом, когда вы отправите запрос на /api/proxy/images, он будет правильно обрабатываться и перенаправляться на указанный внешний API.

  11. User

    Исправь для next js 15 app router реализации

  12. Assistant

    В Next.js 13 и более поздних версиях (включая Next.js 15) был введён App Router, который использует новую структуру папок и файлов для управления маршрутизацией и серверными функциями. Если вы хотите реализовать API-прокси с использованием нового App Router, ниже приведён правильный пример.

    Шаг 1: Создание структуры папок

    Создайте структуру папок для вашего API-прокси. Например, создайте папку app/api/proxy/images/route.js:

    /app/api/proxy/images/route.js
    

    Шаг 2: Реализация логики проксирования

    Вот пример реализации API-прокси, который будет обрабатывать запросы к /api/proxy/images и перенаправлять их на https://example.com/images:

    import axios from 'axios';
    
    // URL вашего внешнего API
    const EXTERNAL_API_URL = 'https://example.com/images';
    
    export async function GET(req) {
      try {
        const response = await axios.get(EXTERNAL_API_URL, {
          headers: {
            // Вы можете перенаправить заголовки, если это необходимо
            // Убедитесь, что не добавляете заголовок 'host', который может вызвать проблемы
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        // Возвращаем данные от внешнего API
        return new Response(JSON.stringify(response.data), {
          status: response.status,
          headers: { 'Content-Type': 'application/json' },
        });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        // Обработка ошибок от внешнего API
        if (axios.isAxiosError(error) && error.response) {
          return new Response(JSON.stringify(error.response.data), {
            status: error.response.status,
            headers: { 'Content-Type': 'application/json' },
          });
        }
        return new Response(JSON.stringify({ message: 'Internal Server Error' }), {
          status: 500,
          headers: { 'Content-Type': 'application/json' },
        });
      }
    }
    
    export async function POST(req) {
      try {
        const body = await req.json(); // Получаем данные из тела запроса
    
        const response = await axios.post(EXTERNAL_API_URL, body, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return new Response(JSON.stringify(response.data), {
          status: response.status,
          headers: { 'Content-Type': 'application/json' },
        });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return new Response(JSON.stringify(error.response.data), {
            status: error.response.status,
            headers: { 'Content-Type': 'application/json' },
          });
        }
        return new Response(JSON.stringify({ message: 'Internal Server Error' }), {
          status: 500,
          headers: { 'Content-Type': 'application/json' },
        });
      }
    }
    

    Шаг 3: Использование прокси

    Теперь, когда вы отправите запрос на /api/proxy/images, он будет проксировать его на https://example.com/images. Вы можете использовать следующий код на клиентской стороне для проверки:

    async function fetchData() {
      const response = await fetch('/api/proxy/images', {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    
      const data = await response.json();
      console.log(data);
    }
    

    Примечания

    1. Методы: В этом примере поддерживаются как GET, так и POST методы. Вы можете добавить аналогичные функции для других методов (PUT, DELETE и т. д.) по аналогии с POST.

    2. Заголовки: Важно избегать передачи заголовка Host, который может привести к ошибкам. Используйте только необходимые заголовки.

    3. Обработка ошибок: Код содержит логику для обработки ошибок при обращении к внешнему API.

    Теперь у вас есть правильно реализованный API-прокси с использованием нового подхода App Router в Next.js 15.

  13. User

    Используй typescript

  14. Assistant

    Конечно! Давайте преобразуем предыдущий пример в TypeScript, чтобы использовать строгую типизацию и повысить качество кода. В этом примере мы создадим API-прокси с использованием App Router и TypeScript в Next.js.

    Шаг 1: Создание структуры папок

    Создайте файл route.ts в директории app/api/proxy/images/:

    /app/api/proxy/images/route.ts
    

    Шаг 2: Реализация логики проксирования с использованием TypeScript

    Вот как может выглядеть реализация API-прокси с TypeScript:

    import axios from 'axios';
    import { NextResponse } from 'next/server';
    
    const EXTERNAL_API_URL = 'https://example.com/images';
    
    export async function GET(req: Request) {
      try {
        const response = await axios.get(EXTERNAL_API_URL, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    
    export async function POST(req: Request) {
      try {
        const body = await req.json(); // Получаем данные из тела запроса
    
        const response = await axios.post(EXTERNAL_API_URL, body, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    

    Шаг 3: Обработка других методов (по желанию)

    Если вы хотите поддерживать другие HTTP методы, такие как PUT или DELETE, вы можете добавить аналогичные функции:

    export async function PUT(req: Request) {
      try {
        const body = await req.json();
    
        const response = await axios.put(EXTERNAL_API_URL, body, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    
    export async function DELETE(req: Request) {
      try {
        const response = await axios.delete(EXTERNAL_API_URL, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    

    Шаг 4: Использование прокси на клиенте

    Для клиентской части вы по-прежнему можете использовать следующий код:

    async function fetchData() {
      const response = await fetch('/api/proxy/images', {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    
      const data = await response.json();
      console.log(data);
    }
    

    Примечания

    1. Типы: TypeScript помогает с типизацией - мы используем Request для запроса, а также указываем правительное название, которое возвращается из NextResponse.json().

    2. Axios: Убедитесь, что у вас установлена библиотека axios. Если её нет, установите с помощью:

      npm install axios
      
    3. Типы Axios: Если вам нужно, вы также можете расширить ваши типы Axios, добавив дополнительные настройки для заголовков или параметров.

    Теперь у вас есть API-прокси, реализованный с использованием TypeScript в Next.js 15 с App Router. Вы можете добавлять более сложные типы и логику в зависимости от потребностей вашего приложения.

  15. User

    Ты не используешь сам путь...

  16. Assistant

    Извините за недоразумение! Давайте обновим код так, чтобы он использовал путь, указанный в запросе. Это позволит проксировать запросы к пути, который следует за /api/proxy/images, и добавлять его к URL внешнего API.

    Пример прокси с использованием пути

    Вот как будет выглядеть новый код в app/api/proxy/images/route.ts, учитывающий путь, который вы указали:

    import axios from 'axios';
    import { NextResponse } from 'next/server';
    
    const EXTERNAL_API_BASE_URL = 'https://example.com/images'; // Базовый URL вашего внешнего API
    
    export async function GET(req: Request) {
      // Получение пути из запроса
      const url = new URL(req.url);
      const path = url.pathname.replace('/api/proxy/images', ''); // Убираем путь прокси
      const externalApiUrl = `${EXTERNAL_API_BASE_URL}${path}`;
    
      try {
        const response = await axios.get(externalApiUrl, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    
    export async function POST(req: Request) {
      // Получение пути из запроса
      const url = new URL(req.url);
      const path = url.pathname.replace('/api/proxy/images', ''); // Убираем путь прокси
      const externalApiUrl = `${EXTERNAL_API_BASE_URL}${path}`;
    
      try {
        const body = await req.json();
    
        const response = await axios.post(externalApiUrl, body, {
          headers: {
            'Content-Type': req.headers.get('Content-Type') || 'application/json',
          },
        });
    
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        console.error('Error in proxy:', error);
    
        if (axios.isAxiosError(error) && error.response) {
          return NextResponse.json(error.response.data, { status: error.response.status });
        }
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    }
    

    Объяснение кода

    1. Получение пути: Мы используем класс URL, чтобы анализировать URL запроса. Из него мы получаем pathname и заменяем часть /api/proxy/images, чтобы получить путь, который мы должны добавить к базовому URL внешнего API.

    2. Сборка URL: Затем мы собран новый URL, который включает базовый URL и путь, который был запрошен.

    3. Обработка GET и POST: Для GET и POST мы проксируем запросы к правильному внутреннему API, передавая заголовки и тело запроса, если это необходимо.

    Примеры использования

    Если вы отправите запрос на /api/proxy/images/some-image, он будет проксироваться на https://example.com/images/some-image. То же самое будет происходить для POST запросов.

    Вот пример клиентского кода:

    async function fetchImage() {
      const response = await fetch('/api/proxy/images/some-image', {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    
      const data = await response.json();
      console.log(data);
    }
    

    Теперь ваш API-прокси полностью использует указанный путь и корректно проксирует запросы на фронтенде. Если у вас есть дополнительные вопросы, не стесняйтесь спрашивать!

  17. User

    xhr / Redirect 308 Permanent Redirect как убрать в next js

  18. Assistant

    Проблема с 308 Permanent Redirect в Next.js может возникать, когда сервер автоматически перенаправляет запросы из-за неправильной маршрутизации или конфигурации. Чтобы избежать этой проблемы, особенно если вы хотите поддерживать URL с завершающим слэшем, следует правильно настроить маршруты и обработчики.

    Причины и решения для 308 Permanent Redirect

    1. Проверка маршрутов: Убедитесь, что ваши маршруты работают должным образом, и вы не конфликтуете с автоматическим редиректом. Если вы хотите, чтобы запросы к https://yourdomain.com/api/proxy/images/ не перенаправлялись на https://yourdomain.com/api/proxy/images, убедитесь, что:

      • Вы не создаете конфликты с другими маршрутами.
      • Ваш обработчик API настроен на правильный путь.
    2. Использование App Router в Next.js: Если вы используете следующий API в app/api/proxy/images/route.ts, проверьте, что вы используете его корректно.

      Пример структуры вашего API маршрута:

      /app/api
        └── /proxy
            └── /images
                └── route.ts
      
    3. Настройка вашего обработчика API: Важно убедиться, что ваш код обрабатывает запросы верно и возвращает нужные данные без лишнего редиректа:

      import axios from 'axios';
      import { NextResponse } from 'next/server';
      
      const EXTERNAL_API_BASE_URL = 'https://example.com/images'; // Замените на нужный вам API
      
      export async function GET(req: Request) {
        // Получаем путь для проксирования
        const url = new URL(req.url);
        const path = url.pathname.replace('/api/proxy/images', '');
        const externalApiUrl = `${EXTERNAL_API_BASE_URL}${path}`;
      
        try {
          const response = await axios.get(externalApiUrl, {
            headers: {
              'Content-Type': req.headers.get('Content-Type') || 'application/json',
            },
          });
      
          return NextResponse.json(response.data, { status: response.status });
        } catch (error) {
          console.error('Proxy error:', error); // Логи ошибок
      
          // Обработка ошибок
          return error.response
            ? NextResponse.json(error.response.data, { status: error.response.status })
            : NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
        }
      }
      
    4. Использование next.config.js: В некоторых случаях ваши настройки в файле next.config.js могут вызывать различные редиректы. Проверьте, нет ли у вас правил редиректов и перезаписей, которые могут быть причиной проблемы.

    5. Проверка запросов на стороне клиента: Убедитесь, что вы правильно делаете запросы к вашему API на стороне клиента, используя нужные методы и URL. Например:

      async function fetchData() {
        const response = await fetch('/api/proxy/images/some-image', {
          method: 'GET',
          headers: {
            'Content-Type': 'application/json',
          },
        });
      
        const data = await response.json();
        console.log(data);
      }
      

      Запросы должны соответствовать вашему обработчику API.

    Как избежать 308 Redirectы

    1. Проверьте маршруты: Убедитесь в правильности маршрутов в вашем проекте и их конфигах.
    2. Проверьте окружение: Если ваш проект развернут (например, на Vercel или других хостингах), убедитесь, что нет перенастроек на уровне сервера или конфигурации DNS.
    3. Удалите лишние редиректы: Если вы не хотите, чтобы определенные URL-адреса перенаправлялись, убедитесь, что никаких дополнительных настроек для этой цели нет.

    Если после выполнения всех этих шагов проблема остаётся, вам стоит обратить внимание на детали вашего проекта, возможно, стоит также предоставить больше информации о вашем окружении и конфигурациях.

  19. User

    import { NextRequest, NextResponse } from 'next/server'; import axios from 'axios'; import { getServerSession } from 'next-auth'; import { authOptions } from '@/utils/authOptions';

    const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL;

    if (!API_BASE_URL) { throw new Error('NEXT_PUBLIC_API_BASE_URL is not defined'); }

    const handleRequest = async ( request: NextRequest, params: { path: string[] }, method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' ) => { const { path } = params; console.log('path: ', params) const url = new URL(request.url); console.log('request: ', request) const queryParams = Object.fromEntries(url.searchParams.entries()); const targetUrl = ${API_BASE_URL}/${path.join('/')}/;

    const session = await getServerSession(authOptions); const token = session?.access_token;

    try { let bodyData; if (method !== 'GET' && method !== 'DELETE') { const contentType = request.headers.get('content-type'); try { if (contentType && contentType.includes('application/json')) { bodyData = await request.json(); } else if (contentType && contentType.includes('application/x-www-form-urlencoded')) { bodyData = Object.fromEntries(await request.formData()); } else { bodyData = await request.text(); } } catch (error) { // console.error('Error parsing request body:', error); return NextResponse.json({ message: 'Invalid or missing request body' }, { status: 400 }); } }

    const config: any = {
      method,
      url: targetUrl,
      params: queryParams,
      headers: {
        ...Object.fromEntries(request.headers.entries()),
        Authorization: token ? `Bearer ${token}` : '',
      },
      data: bodyData
    };
    
    const response = await axios(config);
    return NextResponse.json(response.data, { status: response.status });
    

    } catch (error) { console.log('error: ', error) if (axios.isAxiosError(error) && error.response) { return NextResponse.json(error.response.data, { status: error.response.status }); } return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 }); } };

    export async function GET( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'GET'); }

    export async function POST( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'POST'); }

    export async function PUT( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'PUT'); }

    export async function DELETE( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'DELETE'); }

    export async function PATCH( request: NextRequest, context: { params: Promise<{ path: string[] }> } ) { const params = await context.params; return handleRequest(request, params, 'PATCH'); }

    Модифицируй так, чтобы если запрос /image/ возвращал 404, отправлялся второй запрос на /image

  20. Assistant

    Чтобы реализовать функциональность, при которой если запрос на /api/proxy/images/ возвращает 404, отправляется второй запрос на /api/proxy/images без завершающего слэша, вы можете изменить обработку ошибок в коде. Если первый запрос к целевому API вернет статус 404, вам следует повторить запрос, убирая завершающий слэш.

    Вот модифицированный код:

    import { NextRequest, NextResponse } from 'next/server';
    import axios from 'axios';
    import { getServerSession } from 'next-auth';
    import { authOptions } from '@/utils/authOptions';
    
    const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL;
    
    if (!API_BASE_URL) {
      throw new Error('NEXT_PUBLIC_API_BASE_URL is not defined');
    }
    
    const handleRequest = async (
      request: NextRequest,
      params: { path: string[] },
      method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
    ) => {
      const { path } = params;
      const url = new URL(request.url);
      const queryParams = Object.fromEntries(url.searchParams.entries());
      let targetUrl = `${API_BASE_URL}/${path.join('/')}/`;
    
      const session = await getServerSession(authOptions);
      const token = session?.access_token;
    
      try {
        let bodyData;
    
        if (method !== 'GET' && method !== 'DELETE') {
          const contentType = request.headers.get('content-type');
          try {
            if (contentType && contentType.includes('application/json')) {
              bodyData = await request.json();
            } else if (contentType && contentType.includes('application/x-www-form-urlencoded')) {
              bodyData = Object.fromEntries(await request.formData());
            } else {
              bodyData = await request.text();
            }
          } catch (error) {
            return NextResponse.json({ message: 'Invalid or missing request body' }, { status: 400 });
          }
        }
    
        const config: any = {
          method,
          url: targetUrl,
          params: queryParams,
          headers: {
            ...Object.fromEntries(request.headers.entries()),
            Authorization: token ? `Bearer ${token}` : '',
          },
          data: bodyData
        };
    
        // Первый запрос
        let response = await axios(config);
        return NextResponse.json(response.data, { status: response.status });
    
      } catch (error) {
        if (axios.isAxiosError(error)) {
          // Если получаем 404, отправляем второй запрос без завершающего слэша
          if (error.response?.status === 404) {
            // Обновляем целевой URL без завершающего слэша
            const newTargetUrl = `${API_BASE_URL}/${path.join('/')}`;
    
            const retryConfig = {
              method,
              url: newTargetUrl,
              params: queryParams,
              headers: {
                ...Object.fromEntries(request.headers.entries()),
                Authorization: token ? `Bearer ${token}` : '',
              },
              data: bodyData
            };
    
            try {
              const retryResponse = await axios(retryConfig);
              return NextResponse.json(retryResponse.data, { status: retryResponse.status });
            } catch (retryError) {
              // Обработка ошибок при повторном запросе
              return retryError.response ? 
                NextResponse.json(retryError.response.data, { status: retryError.response.status }) : 
                NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
            }
          }
        }
    
        // Обработка других ошибок
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    };
    
    // Обработчики методов
    export async function GET(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'GET');
    }
    
    export async function POST(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'POST');
    }
    
    export async function PUT(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'PUT');
    }
    
    export async function DELETE(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'DELETE');
    }
    
    export async function PATCH(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'PATCH');
    }
    

    Объяснение изменений:

    1. Обработка 404: В catch блоке, если получен 404 статус ошибки, мы создаем новый URL, убирая завершающий слэш.
    2. Повторный запрос: Отправляем новый запрос к API, используя axios и конфигурацию, сохраненную ранее. Если второй запрос успешен, возвращаем данные.
    3. Обработка ошибок: Если второй запрос также завершился ошибкой, то мы обрабатываем эту ошибку аналогично первымзапросу.

    Теперь ваш код будет корректно обрабатывать ситуацию, когда первоначальный запрос возвращает 404, и повторять запрос без завершающего слэша.

  21. User

    bodyData при ошибке теряется

  22. Assistant

    Спасибо за замечание! Давайте убедимся, что данные в bodyData (если это не GET или DELETE запрос) сохраняются и используются правильно даже при возникновении ошибки.

    В случае, если возникает ошибка при первом запросе, мы должны убедиться, что bodyData сохраняется и используется повторно в новом запросе, если это необходимо.

    Вот обновленный код, в котором мы корректно сохраняем и используем bodyData, даже если происходит ошибка:

    import { NextRequest, NextResponse } from 'next/server';
    import axios from 'axios';
    import { getServerSession } from 'next-auth';
    import { authOptions } from '@/utils/authOptions';
    
    const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL;
    
    if (!API_BASE_URL) {
      throw new Error('NEXT_PUBLIC_API_BASE_URL is not defined');
    }
    
    const handleRequest = async (
      request: NextRequest,
      params: { path: string[] },
      method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
    ) => {
      const { path } = params;
      const url = new URL(request.url);
      const queryParams = Object.fromEntries(url.searchParams.entries());
      let targetUrl = `${API_BASE_URL}/${path.join('/')}/`;
    
      const session = await getServerSession(authOptions);
      const token = session?.access_token;
    
      let bodyData;
    
      // Пытаемся собрать bodyData независимо от метода запроса
      if (method !== 'GET' && method !== 'DELETE') {
        const contentType = request.headers.get('content-type');
    
        try {
          if (contentType && contentType.includes('application/json')) {
            bodyData = await request.json();
          } else if (contentType && contentType.includes('application/x-www-form-urlencoded')) {
            bodyData = Object.fromEntries(await request.formData());
          } else {
            bodyData = await request.text();
          }
        } catch (error) {
          return NextResponse.json({ message: 'Invalid or missing request body' }, { status: 400 });
        }
      }
    
      const config: any = {
        method,
        url: targetUrl,
        params: queryParams,
        headers: {
          ...Object.fromEntries(request.headers.entries()),
          Authorization: token ? `Bearer ${token}` : '',
        },
        data: bodyData
      };
    
      try {
        // Первый запрос
        const response = await axios(config);
        return NextResponse.json(response.data, { status: response.status });
      } catch (error) {
        if (axios.isAxiosError(error) && error.response?.status === 404) {
          // Второй запрос без завершающего слэша
          const fallbackUrl = `${API_BASE_URL}/${path.join('/')}`;
          const retryConfig = {
            method,
            url: fallbackUrl,
            params: queryParams,
            headers: {
              ...Object.fromEntries(request.headers.entries()),
              Authorization: token ? `Bearer ${token}` : '',
            },
            data: bodyData, // Использование тех же данных для второго запроса
          };
    
          try {
            const retryResponse = await axios(retryConfig);
            return NextResponse.json(retryResponse.data, { status: retryResponse.status });
          } catch (retryError) {
            return retryError.response
              ? NextResponse.json(retryError.response.data, { status: retryError.response.status })
              : NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
          }
        }
    
        // Обработка других ошибок
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }
    };
    
    // Обработчики методов
    export async function GET(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'GET');
    }
    
    export async function POST(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'POST');
    }
    
    export async function PUT(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'PUT');
    }
    
    export async function DELETE(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'DELETE');
    }
    
    export async function PATCH(request: NextRequest, context: { params: Promise<{ path: string[] }> }) {
      const params = await context.params;
      return handleRequest(request, params, 'PATCH');
    }
    

    Объяснение изменений:

    1. Сохранение bodyData: Мы инициализировали bodyData заранее и сохраняем данные вне блока try, чтобы эти данные были доступны при повторном запросе, если это необходимо.

    2. Упрощение конфигурации: Используем bodyData из первой попытки запроса и при повторной попытке при получении 404.

    Теперь, если происходит ошибка с кодом 404, и вы решите повторно отправить запрос, все данные будут сохранены и повторно использованы, что помогает избегать потери информации при ошибках.