Wrong content type for file upload about kubb HOT 3 CLOSED

import client from "@kubb/swagger-client/client";
import { useMutation } from "@tanstack/react-query";
import type { UploadFileMutationRequest, UploadFileMutationResponse, UploadFile400 } from "../types/UploadFile";
import type { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";

 type UploadFileClient = typeof client<UploadFileMutationResponse, UploadFile400, UploadFileMutationRequest>;
type UploadFile = {
    data: UploadFileMutationResponse;
    error: UploadFile400;
    request: UploadFileMutationRequest;
    pathParams: never;
    queryParams: never;
    headerParams: never;
    response: UploadFileMutationResponse;
    client: {
        parameters: Partial<Parameters<UploadFileClient>[0]>;
        return: Awaited<ReturnType<UploadFileClient>>;
    };
};
/**
 * @description Upload file
 * @link /api/v1/upload
 */
export function useUploadFile(options: {
    mutation?: UseMutationOptions<UploadFile["response"], UploadFile["error"], {
        data: UploadFile["request"];
    }>;
    client?: UploadFile["client"]["parameters"];
} = {}): UseMutationResult<UploadFile["response"], UploadFile["error"], {
    data: UploadFile["request"];
}> {
    const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {};
    return useMutation<UploadFile["response"], UploadFile["error"], {
        data: UploadFile["request"];
    }>({
        mutationFn: async ({ data }) => {
            const res = await client<UploadFile["data"], UploadFile["error"], UploadFile["request"]>({
                method: "post",
                url: `/api/v1/upload`,
                data,
                ...clientOptions
            });
            return res.data;
        },
        ...mutationOptions
    });
}

 export type UploadFileMutationRequest = {
    /**
     * @type string, binary
    */
    file: Blob;
}; 

function Template({ name, generics, returnType, params, mutateParams, JSDoc, client, hook, dataReturnType }: TemplateProps): ReactNode {
  const isV5 = new PackageManager().isValidSync(/@tanstack/, '>=5')
  const operation = useOperation()
  const { getSchemas } = useOperationManager()
  const schemas = getSchemas(operation);
  const dataTransform = [];

  if (!('application/json' in schemas.request?.operation?.schema?.requestBody?.content)){
    const acceptedHeaders = Object.keys(schemas.request?.operation?.schema?.requestBody?.content);
    if (acceptedHeaders.includes('multipart/form-data')){
      dataTransform.push(`
      const transformedData = new FormData();
      transformedData.append('file', data.file);
      `);
    } else {
      // some kind of log that lets the developer know that we does not support the request header type application/json by default
      // ad just send the data as is
    }
  }

  const clientOptions = [
    `method: "${client.method}"`,
    `url: ${client.path.template}`,
    client.withQueryParams ? 'params' : undefined,
    client.withData ? dataTransform.length > 0 ? 'data: transformedData' : 'data' : undefined,
    client.withHeaders ? 'headers: { ...headers, ...clientOptions.headers }' : undefined,
    '...clientOptions',
  ].filter(Boolean)

  const resolvedClientOptions = `${transformers.createIndent(4)}${clientOptions.join(`,\n${transformers.createIndent(4)}`)}`

  if (isV5) {
    return (
      <Function export name={name} params={params} JSDoc={JSDoc}>
        {`
         const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}

         return ${hook.name}({
           mutationFn: async(${mutateParams}) => {
            ${dataTransform ? dataTransform.join('\n') : null}
            ${hook.children || ''}
             const res = await client<${client.generics}>({
              ${resolvedClientOptions}
             })

             return ${dataReturnType === 'data' ? 'res.data' : 'res'}
           },
           ...mutationOptions
         })`}
      </Function>
    )
  }

  return (
    <Function export name={name} generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
      {`
       const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}

       return ${hook.name}<${hook.generics}>({
         mutationFn: async(${mutateParams}) => {
          ${dataTransform ? dataTransform.join('\n') : null}
          ${hook.children || ''}
           const res = await client<${client.generics}>({
            ${resolvedClientOptions}
           })

           return ${dataReturnType === 'data' ? 'res.data' : 'res'}
         },
         ...mutationOptions
       })`}
    </Function>
  )
}