chore(client): improve node-fetch file upload errors

chore: unknown commit message

Author: stainless-bot

src/internal/uploads.ts

@@ -1,6 +1,7 @@
 import { type RequestOptions } from './request-options';
-import { type FilePropertyBag } from './builtin-types';
+import type { FilePropertyBag, Fetch } from './builtin-types';
 import { isFsReadStreamLike, type FsReadStreamLike } from './shims';
+import type { OpenAI } from '../client';
 import './polyfill/file.node.js';
 
 type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
@@ -203,21 +204,65 @@ const isAsyncIterableIterator = (value: any): value is AsyncIterableIterator<unk
  * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
  * Otherwise returns the request as is.
  */
-export const maybeMultipartFormRequestOptions = async (opts: RequestOptions): Promise<RequestOptions> => {
+export const maybeMultipartFormRequestOptions = async (
+  opts: RequestOptions,
+  fetch: OpenAI | Fetch,
+): Promise<RequestOptions> => {
   if (!hasUploadableValue(opts.body)) return opts;
 
-  return { ...opts, body: await createForm(opts.body) };
+  return { ...opts, body: await createForm(opts.body, fetch) };
 };
 
 type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & { body: unknown };
 
 export const multipartFormRequestOptions = async (
   opts: MultipartFormRequestOptions,
+  fetch: OpenAI | Fetch,
 ): Promise<RequestOptions> => {
-  return { ...opts, body: await createForm(opts.body) };
+  return { ...opts, body: await createForm(opts.body, fetch) };
 };
 
-export const createForm = async <T = Record<string, unknown>>(body: T | undefined): Promise<FormData> => {
+const supportsFormDataMap = new WeakMap<Fetch, Promise<boolean>>();
+
+/**
+ * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending
+ * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]".
+ * This function detects if the fetch function provided supports the global FormData object to avoid
+ * confusing error messages later on.
+ */
+function supportsFormData(fetchObject: OpenAI | Fetch): Promise<boolean> {
+  const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch;
+  const cached = supportsFormDataMap.get(fetch);
+  if (cached) return cached;
+  const promise = (async () => {
+    try {
+      const FetchResponse = (
+        'Response' in fetch ?
+          fetch.Response
+        : (await fetch('data:,')).constructor) as typeof Response;
+      const data = new FormData();
+      if (data.toString() === (await new FetchResponse(data).text())) {
+        return false;
+      }
+      return true;
+    } catch {
+      // avoid false negatives
+      return true;
+    }
+  })();
+  supportsFormDataMap.set(fetch, promise);
+  return promise;
+}
+
+export const createForm = async <T = Record<string, unknown>>(
+  body: T | undefined,
+  fetch: OpenAI | Fetch,
+): Promise<FormData> => {
+  if (!(await supportsFormData(fetch))) {
+    throw new TypeError(
+      'The provided fetch function does not support file uploads with the current global FormData class.',
+    );
+  }
   const form = new FormData();
   await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
   return form;

src/resources/audio/transcriptions.ts

@@ -28,7 +28,10 @@ export class Transcriptions extends APIResource {
     body: TranscriptionCreateParams,
     options?: RequestOptions,
   ): APIPromise<TranscriptionCreateResponse | string> {
-    return this._client.post('/audio/transcriptions', multipartFormRequestOptions({ body, ...options }));
+    return this._client.post(
+      '/audio/transcriptions',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
   }
 }
 

src/resources/audio/translations.ts

@@ -26,7 +26,10 @@ export class Translations extends APIResource {
     body: TranslationCreateParams,
     options?: RequestOptions,
   ): APIPromise<TranslationCreateResponse | string> {
-    return this._client.post('/audio/translations', multipartFormRequestOptions({ body, ...options }));
+    return this._client.post(
+      '/audio/translations',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
   }
 }
 

src/resources/files.ts

@@ -34,7 +34,7 @@ export class Files extends APIResource {
    * storage limits.
    */
   create(body: FileCreateParams, options?: RequestOptions): APIPromise<FileObject> {
-    return this._client.post('/files', multipartFormRequestOptions({ body, ...options }));
+    return this._client.post('/files', multipartFormRequestOptions({ body, ...options }, this._client));
   }
 
   /**

src/resources/images.ts

@@ -11,14 +11,20 @@ export class Images extends APIResource {
    * Creates a variation of a given image.
    */
   createVariation(body: ImageCreateVariationParams, options?: RequestOptions): APIPromise<ImagesResponse> {
-    return this._client.post('/images/variations', multipartFormRequestOptions({ body, ...options }));
+    return this._client.post(
+      '/images/variations',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
   }
 
   /**
    * Creates an edited or extended image given an original image and a prompt.
    */
   edit(body: ImageEditParams, options?: RequestOptions): APIPromise<ImagesResponse> {
-    return this._client.post('/images/edits', multipartFormRequestOptions({ body, ...options }));
+    return this._client.post(
+      '/images/edits',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
   }
 
   /**

src/resources/uploads/parts.ts

@@ -21,7 +21,10 @@ export class Parts extends APIResource {
    * [complete the Upload](https://platform.openai.com/docs/api-reference/uploads/complete).
    */
   create(uploadID: string, body: PartCreateParams, options?: RequestOptions): APIPromise<UploadPart> {
-    return this._client.post(`/uploads/${uploadID}/parts`, multipartFormRequestOptions({ body, ...options }));
+    return this._client.post(
+      `/uploads/${uploadID}/parts`,
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
   }
 }
 

tests/form.test.ts

@@ -3,62 +3,83 @@ import { toFile } from 'openai/uploads';
 
 describe('form data validation', () => {
   test('valid values do not error', async () => {
-    await multipartFormRequestOptions({
-      body: {
-        foo: 'foo',
-        string: 1,
-        bool: true,
-        file: await toFile(Buffer.from('some-content')),
-        blob: new Blob(['Some content'], { type: 'text/plain' }),
+    await multipartFormRequestOptions(
+      {
+        body: {
+          foo: 'foo',
+          string: 1,
+          bool: true,
+          file: await toFile(Buffer.from('some-content')),
+          blob: new Blob(['Some content'], { type: 'text/plain' }),
+        },
       },
-    });
+      fetch,
+    );
   });
 
   test('null', async () => {
     await expect(() =>
-      multipartFormRequestOptions({
-        body: {
-          null: null,
+      multipartFormRequestOptions(
+        {
+          body: {
+            null: null,
+          },
         },
-      }),
+        fetch,
+      ),
     ).rejects.toThrow(TypeError);
   });
 
   test('undefined is stripped', async () => {
-    const form = await createForm({
-      foo: undefined,
-      bar: 'baz',
-    });
+    const form = await createForm(
+      {
+        foo: undefined,
+        bar: 'baz',
+      },
+      fetch,
+    );
     expect(form.has('foo')).toBe(false);
     expect(form.get('bar')).toBe('baz');
   });
 
   test('nested undefined property is stripped', async () => {
-    const form = await createForm({
-      bar: {
-        baz: undefined,
+    const form = await createForm(
+      {
+        bar: {
+          baz: undefined,
+        },
       },
-    });
+      fetch,
+    );
     expect(Array.from(form.entries())).toEqual([]);
 
-    const form2 = await createForm({
-      bar: {
-        foo: 'string',
-        baz: undefined,
+    const form2 = await createForm(
+      {
+        bar: {
+          foo: 'string',
+          baz: undefined,
+        },
       },
-    });
+      fetch,
+    );
     expect(Array.from(form2.entries())).toEqual([['bar[foo]', 'string']]);
   });
 
   test('nested undefined array item is stripped', async () => {
-    const form = await createForm({
-      bar: [undefined, undefined],
-    });
+    const form = await createForm(
+      {
+        bar: [undefined, undefined],
+      },
+      fetch,
+    );
     expect(Array.from(form.entries())).toEqual([]);
 
-    const form2 = await createForm({
-      bar: [undefined, 'foo'],
-    });
+    const form2 = await createForm(
+      {
+        bar: [undefined, 'foo'],
+      },
+      fetch,
+    );
     expect(Array.from(form2.entries())).toEqual([['bar[]', 'foo']]);
   });
 });