feat(fetch): auto-serialize request bodies based on content type

Author: owjs3901

packages/fetch/src/__tests__/api-body-type.test.ts

@@ -0,0 +1,222 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: any is used to allow for flexibility in the type */
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import type { UrlMapValue } from '@devup-api/core'
+
+// Mock the url-map module to return custom bodyType values
+const mockUrlMap: Record<string, Record<string, UrlMapValue>> = {
+  'openapi.json': {
+    submitForm: { method: 'POST', url: '/submit', bodyType: 'form' },
+    uploadFile: { method: 'POST', url: '/upload', bodyType: 'multipart' },
+    jsonEndpoint: { method: 'POST', url: '/json', bodyType: 'json' },
+  },
+}
+
+mock.module('../url-map', () => ({
+  DEVUP_API_URL_MAP: mockUrlMap,
+  getApiEndpointInfo: (key: string, serverName: string): UrlMapValue => {
+    const result = mockUrlMap[serverName]?.[key] ?? {
+      method: 'GET' as const,
+      url: key,
+    }
+    result.url ||= key
+    return result
+  },
+}))
+
+// Import DevupApi AFTER mock.module so it picks up the mocked url-map
+const { DevupApi } = await import('../api')
+
+const originalFetch = globalThis.fetch
+
+beforeEach(() => {
+  globalThis.fetch = mock(() =>
+    Promise.resolve(
+      new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    ),
+  ) as unknown as typeof fetch
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+describe('bodyType-aware serialization', () => {
+  test('bodyType form: plain object body serialized as URLSearchParams', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    await api.post(
+      'submitForm' as never,
+      { body: { name: 'test', age: 25 } } as never,
+    )
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      expect(request.headers.get('Content-Type')).toBe(
+        'application/x-www-form-urlencoded',
+      )
+      const body = await request.text()
+      const params = new URLSearchParams(body)
+      expect(params.get('name')).toBe('test')
+      expect(params.get('age')).toBe('25')
+    }
+  })
+
+  test('bodyType multipart: plain object body serialized as FormData', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    await api.post(
+      'uploadFile' as never,
+      { body: { name: 'test', value: 123 } } as never,
+    )
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      // Content-Type should NOT be explicitly set for multipart
+      // (browser auto-sets with boundary)
+      const contentType = request.headers.get('Content-Type')
+      expect(
+        contentType === null || contentType.includes('multipart/form-data'),
+      ).toBe(true)
+      expect(request.body).not.toBeNull()
+    }
+  })
+
+  test('bodyType undefined (default): plain object body serialized as JSON', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    // Use a path that is NOT in the URL map, so bodyType will be undefined
+    await api.post(
+      '/test' as never,
+      { body: { name: 'test', value: 123 } } as never,
+    )
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      expect(request.headers.get('Content-Type')).toBe('application/json')
+      const body = await request.text()
+      expect(body).toBe(JSON.stringify({ name: 'test', value: 123 }))
+    }
+  })
+
+  test('bodyType json: plain object body serialized as JSON', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    await api.post('jsonEndpoint' as never, { body: { name: 'test' } } as never)
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      expect(request.headers.get('Content-Type')).toBe('application/json')
+      const body = await request.text()
+      expect(body).toBe(JSON.stringify({ name: 'test' }))
+    }
+  })
+
+  test('FormData body passthrough regardless of bodyType', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+    const formData = new FormData()
+    formData.append('file', 'test')
+
+    await api.post('submitForm' as never, { body: formData } as never)
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      // FormData should be passed through as-is, not re-serialized
+      expect(request.body).not.toBeNull()
+      expect(request.body).toBeDefined()
+    }
+  })
+
+  test('bodyType form: nested objects are JSON.stringified in URLSearchParams', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    await api.post(
+      'submitForm' as never,
+      { body: { data: { nested: true }, items: [1, 2] } } as never,
+    )
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      const body = await request.text()
+      const params = new URLSearchParams(body)
+      expect(params.get('data')).toBe(JSON.stringify({ nested: true }))
+      expect(params.get('items')).toBe(JSON.stringify([1, 2]))
+    }
+  })
+
+  test('bodyType form: null/undefined values are skipped', async () => {
+    const api = new DevupApi(
+      'https://api.example.com',
+      undefined,
+      'openapi.json',
+    )
+    const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
+
+    await api.post(
+      'submitForm' as never,
+      { body: { name: 'test', empty: null, missing: undefined } } as never,
+    )
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const call = mockFetch.mock.calls[0]
+    expect(call).toBeDefined()
+    if (call) {
+      const request = call[0] as Request
+      const body = await request.text()
+      const params = new URLSearchParams(body)
+      expect(params.get('name')).toBe('test')
+      expect(params.has('empty')).toBe(false)
+      expect(params.has('missing')).toBe(false)
+    }
+  })
+})

packages/fetch/src/__tests__/utils.test.ts

@@ -1,5 +1,11 @@
-import { expect, test } from 'bun:test'
-import { getApiEndpoint, getQueryString, isPlainObject } from '../utils'
+import { describe, expect, test } from 'bun:test'
+import {
+  getApiEndpoint,
+  getQueryString,
+  isPlainObject,
+  objectToFormData,
+  objectToURLSearchParams,
+} from '../utils'
 
 test.each([
   [{}, true],
@@ -160,3 +166,117 @@ test.each([
   )
   expect(result.toString()).toBe(expected)
 })
+
+describe('objectToURLSearchParams', () => {
+  test('converts simple key-value pairs', () => {
+    const params = objectToURLSearchParams({ name: 'test', age: 25 })
+    expect(params.get('name')).toBe('test')
+    expect(params.get('age')).toBe('25')
+  })
+
+  test('skips null values', () => {
+    const params = objectToURLSearchParams({ name: 'test', skip: null })
+    expect(params.get('name')).toBe('test')
+    expect(params.has('skip')).toBe(false)
+  })
+
+  test('skips undefined values', () => {
+    const params = objectToURLSearchParams({ name: 'test', skip: undefined })
+    expect(params.get('name')).toBe('test')
+    expect(params.has('skip')).toBe(false)
+  })
+
+  test('JSON.stringifies nested objects', () => {
+    const nested = { key: 'value' }
+    const params = objectToURLSearchParams({ data: nested })
+    expect(params.get('data')).toBe(JSON.stringify(nested))
+  })
+
+  test('JSON.stringifies arrays', () => {
+    const arr = [1, 2, 3]
+    const params = objectToURLSearchParams({ items: arr })
+    expect(params.get('items')).toBe(JSON.stringify(arr))
+  })
+
+  test('converts boolean values to string', () => {
+    const params = objectToURLSearchParams({ active: true, deleted: false })
+    expect(params.get('active')).toBe('true')
+    expect(params.get('deleted')).toBe('false')
+  })
+
+  test('converts number values to string', () => {
+    const params = objectToURLSearchParams({ count: 42, price: 9.99 })
+    expect(params.get('count')).toBe('42')
+    expect(params.get('price')).toBe('9.99')
+  })
+
+  test('handles empty object', () => {
+    const params = objectToURLSearchParams({})
+    expect(params.toString()).toBe('')
+  })
+})
+
+describe('objectToFormData', () => {
+  test('converts simple key-value pairs', () => {
+    const formData = objectToFormData({ name: 'test', age: 25 })
+    expect(formData.get('name')).toBe('test')
+    expect(formData.get('age')).toBe('25')
+  })
+
+  test('skips null values', () => {
+    const formData = objectToFormData({ name: 'test', skip: null })
+    expect(formData.get('name')).toBe('test')
+    expect(formData.has('skip')).toBe(false)
+  })
+
+  test('skips undefined values', () => {
+    const formData = objectToFormData({ name: 'test', skip: undefined })
+    expect(formData.get('name')).toBe('test')
+    expect(formData.has('skip')).toBe(false)
+  })
+
+  test('JSON.stringifies nested objects', () => {
+    const nested = { key: 'value' }
+    const formData = objectToFormData({ data: nested })
+    expect(formData.get('data')).toBe(JSON.stringify(nested))
+  })
+
+  test('JSON.stringifies arrays', () => {
+    const arr = [1, 2, 3]
+    const formData = objectToFormData({ items: arr })
+    expect(formData.get('items')).toBe(JSON.stringify(arr))
+  })
+
+  test('appends Blob values directly', () => {
+    const blob = new Blob(['hello'], { type: 'text/plain' })
+    const formData = objectToFormData({ file: blob })
+    const result = formData.get('file')
+    expect(result).toBeInstanceOf(Blob)
+  })
+
+  test('appends File values directly', () => {
+    const file = new File(['content'], 'test.txt', { type: 'text/plain' })
+    const formData = objectToFormData({ document: file })
+    const result = formData.get('document')
+    expect(result).toBeInstanceOf(File)
+    expect((result as File).name).toBe('test.txt')
+  })
+
+  test('converts boolean values to string', () => {
+    const formData = objectToFormData({ active: true, deleted: false })
+    expect(formData.get('active')).toBe('true')
+    expect(formData.get('deleted')).toBe('false')
+  })
+
+  test('converts number values to string', () => {
+    const formData = objectToFormData({ count: 42, price: 9.99 })
+    expect(formData.get('count')).toBe('42')
+    expect(formData.get('price')).toBe('9.99')
+  })
+
+  test('handles empty object', () => {
+    const formData = objectToFormData({})
+    const entries = Array.from(formData.entries())
+    expect(entries).toHaveLength(0)
+  })
+})