经过大量的挖掘和经历了许多不同的方法，我终于找到了一个工作。

• 我没有找到一个解释，为什么图像数据是损坏的，这意味着我不能使用原来的multipart/form-data文件。
• 使用formidable读取文件，首先将其保存到磁盘，然后使用fs读取该文件，最后在FormData中使用该文件。
• 我不知道这有多好的表现，我发现先把图像保存到磁盘而不是仅仅保存在内存中是不舒服的。
• 需要再检查一遍，确保它不会受到攻击媒介的攻击，例如文件大小

import Cors from 'cors'
import initMiddleware from '../../../../../lib/initMiddleware'
import { NextApiRequest, NextApiResponse } from 'next'
import { getToken } from 'next-auth/jwt'
import fetch from "node-fetch";
import FormData from 'form-data'
import { IncomingForm } from 'formidable'
import { promises as fs } from 'fs';

export const config = {
    api: {
        bodyParser: false,
    },
}

const cors = initMiddleware(
    Cors({
        methods: ['POST']
    })
)

const secret = process.env.NEXTAUTH_SECRET;

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
    await cors(req, res)

    const { userId } = req.query;
    const { accessToken } = await getToken({ req, secret });

    const fData = await new Promise<{ fields: any, files: any }>((resolve, reject) => {
        const form = new IncomingForm({
            multiples: false
        })
        form.parse(req, (err, fields, files) => {
            if (err) return reject(err)
            resolve({ fields, files })
        })
    });

    const imageFile = fData.files.imageFile
    const tempImagePath = imageFile?.filepath

    try {
        const image = await fs.readFile(tempImagePath)

        const data = new FormData()
        data.append('imageFile', image, { filename: 'avatar.png' })

        const response = await fetch(`${process.env.API_HOST}/user/${userId}/media/avatar`, {
            method: 'POST',
            headers: {
                "Authorization": `Bearer ${accessToken}`,
                "Content-Type": `multipart/form-data; boundary=${data.getBoundary()}`
            },
            body: data
        })

        if (!response.ok) {
            
        }

        res.status(response.status);
    }
    catch (error) {

    }
    finally {
        if (tempImagePath) {
            await fs.rm(tempImagePath)
        }
    }

    res.end()
}

我遇到了同样的问题，最后我找到了一个很优雅的方法来解决它。
解决方案来源：https://github.com/vercel/next.js/discussions/15727#discussioncomment-1094126
为了以防万一，我从源代码中复制代码：

文件上载组件

const uploadFile = (file : File) => {
    let url = "http://localhost:3000/api/upload";

    let formData = new FormData();
    formData.set("testFile", file)

    fetch(url, {
        method: "POST",
        body: formData,
    }).then(r => {
        console.log(r);
    })
}

/api/上载.ts：

import {NextApiRequest, NextApiResponse} from "next";
import httpProxyMiddleware from "next-http-proxy-middleware";

// For preventing header corruption, specifically Content-Length header
export const config = {
    api: {
        bodyParser: false,
    },
}

export default (req: NextApiRequest, res: NextApiResponse) => {
    httpProxyMiddleware(req, res, {
        target: 'http://localhost:21942'
    })
}

我也遇到了同样的问题。我使用nextjs api作为另一个api服务器的代理，在我的例子中，我只是传递了整个请求而不是主体，指定nextjs不解析请求。我唯一需要包含的是原始请求的头部。

import Repository, { apiUrl } from "~/repositories/Repository";
import { parse } from 'cookie';

export const config = {
    api: {
      bodyParser: false
    }
  }

export default async (req, res) => {
    const { headers: { cookie, ...rest }, method } = req;
    const { auth } = parse(cookie);
    if (method === 'PUT') {
        const headers = { 
            Authorization: `Bearer ${auth}`, 
            'content-type': rest['content-type'], 
            'content-length': rest['content-length']
        }
        return Repository.put(`${apiUrl}/user/me/files`, req, { headers: headers })
            .then(response => {
                const { data } = response;
                return res.status(200).json(data);
            })
            .catch(error => {
                const { response: { status, data } } = error;
                return res.status(status).json(data);
            })
    }
    else
        return res.status(405);
}

在当前时间内此代码将工作

在/pages/api/upload.ts中找到###

import formidable from "formidable";
import fs from "fs";

export const config = {
  api: {
   bodyParser: false
 }
};

interface IFileStream {
 filepath: string;
 originalFilename: string;
}

const ProcessFiles = (Files: any): IFileStream[] => {
 const data: IFileStream[] = [];
 let index = 0;

 while (Boolean(Files[`file${index}`])) {
  data.push(Files[`file${index}`] as IFileStream)
  index++;
 }

  return data;
 }

export default async function handler(req: any, res: any) {
  if (req.method === "POST") {
  const form = new formidable.IncomingForm();

  form.parse(req, async function (err, fields, files) {
    const filesArray = ProcessFiles(files)

    if (filesArray.length === 0) return 
    res.sendStatus(401).json({massages: "No File Found"});
  
    // create 'uploads' folder if not exist
    fs.mkdirSync("./public/uploads", {recursive: true});

    for (let file of filesArray) {
      const data = fs.readFileSync(file.filepath);
      fs.writeFileSync(`./public/uploads/${Date.now().toString() + 
      file.originalFilename}`, data);
      fs.unlinkSync(file.filepath);
    }

   });

  return res.status(200).json({ massage: "Success" });
 }
};

/pages/index.tsx中的###文件夹

import axios from 'axios';
   import { useState } from 'react';

   const api = axios.create();

   const uploadFile = async (files: File[]) => {
   let formData = new FormData();

   for (let i = 0; i < files.length; i++) {
    formData.set(`file${i}`, files[i]);
   }

   await api.postForm("http://localhost:3000/api/upload", formData)
   .then(res => { console.log(res) }).catch((err) => { 
   console.log(err) }) }

   export default function Home() {
   const [files, setFiles] = useState<File[] | null>([]);

   const HandelUpload = async () => {
    if (files?.length === 0 || files === null) return alert("No 
    file selected");
   await uploadFile(files)
  }

  return (
    <div>
      <input type='file' multiple onChange={(event) => 
      setFiles((event?.target?.files || null) as File[] | null)} />
      <button onClick={HandelUpload}>Upload</button>
   </div>
   )
  }