feat: constructing new Request object method

**Problem**

After using Hono validators, the `raw` Request obejct gets consumed
during body parsing, making it unusable for external libraries like
`better-auth`.
This results in the error:

```shell
TypeError: Cannot construct a Request with a Request object that has already been used.
```

**Root Cause**

The issue occurs in the `#cachedBody` method in `HonoRequest`. When parsing request
bodies (json, text, etc.), the method directly calls parsing methods on the raw Request
object, which consumes its body stream. Once consumed, the Request cannot be cloned or
reused by external libraries.

**Solution**

In a `new` method within `HonoRequest`, constructing a new Request
object that can be used even after it has been consumed by the validator
middleware.

If the `raw` Request object has already been consumed, then we store the
cached body in to the newly constructed Request object, and if it hasn't
then consume the body, cache it and then return it along the newly
constructed Request object.

Because we have created a new method, this should not degrade current
performance and should not introduce any breaking change.

Signed-off-by: Kamaal Farah <[email protected]>

Author: kamaal111

src/request.test.ts

@@ -187,6 +187,97 @@ const text = '{"foo":"bar"}'
 const json = { foo: 'bar' }
 const buffer = new TextEncoder().encode('{"foo":"bar"}').buffer
 
+describe('Raw Request preservation', () => {
+  test('raw Request remains unconsumed after body parsing', async () => {
+    const originalRequest = new Request('http://localhost/', {
+      method: 'POST',
+      body: JSON.stringify({ test: 'data' }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const req = new HonoRequest(originalRequest)
+
+    await req.json()
+    await req.text()
+    await req.arrayBuffer()
+
+    expect(() => req.raw.clone(), 'The raw request should still be usable').not.toThrow()
+    expect(
+      () => new Request(req.raw.url, { method: req.raw.method, headers: req.raw.headers }),
+      'Should be able to create a new Request from the raw request'
+    ).not.toThrow()
+    expect(req.raw.method).toBe('POST')
+    expect(req.raw.url).toBe('http://localhost/')
+    expect(req.raw.headers.get('Content-Type')).toBe('application/json')
+  })
+
+  test('raw Request can be cloned multiple times after body parsing', async () => {
+    const originalRequest = new Request('http://localhost/', {
+      method: 'POST',
+      body: JSON.stringify({ data: 'test' }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const req = new HonoRequest(originalRequest)
+
+    await req.json()
+    await req.text()
+    const clone1 = req.raw.clone()
+    const clone2 = req.raw.clone()
+    const clone3 = req.raw.clone()
+
+    expect(clone1).toBeInstanceOf(Request)
+    expect(clone2).toBeInstanceOf(Request)
+    expect(clone3).toBeInstanceOf(Request)
+    expect(clone1.method).toBe(clone2.method)
+    expect(clone1.url).toBe(clone2.url)
+    expect(clone1.method).toBe(clone3.method)
+  })
+
+  test('external libraries can use raw Request after validation', async () => {
+    const originalRequest = new Request('http://localhost/api/test', {
+      method: 'POST',
+      body: JSON.stringify({ username: 'test', password: 'secret' }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const req = new HonoRequest(originalRequest)
+
+    const data = await req.json()
+    expect(data).toStrictEqual({ username: 'test', password: 'secret' })
+
+    function externalLibraryRequest() {
+      return new Request(req.raw.url, {
+        method: req.raw.method,
+        headers: req.raw.headers,
+      })
+    }
+
+    const newRequest = externalLibraryRequest()
+
+    expect(newRequest.method).toBe('POST')
+    expect(newRequest.url).toBe('http://localhost/api/test')
+    expect(newRequest.headers.get('Content-Type')).toBe('application/json')
+  })
+
+  test('different body types can be accessed after raw Request preservation', async () => {
+    const formData = new FormData()
+    formData.append('field1', 'value1')
+    formData.append('field2', 'value2')
+    const originalRequest = new Request('http://localhost', {
+      method: 'POST',
+      body: formData,
+    })
+
+    const req = new HonoRequest(originalRequest)
+
+    const parsedFormData = await req.formData()
+
+    expect(parsedFormData.get('field1')).toBe('value1')
+    expect(parsedFormData.get('field2')).toBe('value2')
+    expect(() => req.raw.clone(), 'Raw request should still be usable').not.toThrow()
+    const clonedForExternal = req.raw.clone()
+    expect(clonedForExternal.method).toBe('POST')
+  })
+})
+
 describe('Body methods with caching', () => {
   test('req.text()', async () => {
     const req = new HonoRequest(

src/request.ts

@@ -23,7 +23,19 @@ type Body = {
   blob: Blob
   formData: FormData
 }
-type BodyCache = Partial<Body & { parsedBody: BodyData }>
+type BodyCache = Partial<
+  {
+    [K in keyof Body]: Promise<Body[K]>
+  } & { parsedBody: BodyData }
+>
+
+const BODY_TYPE_TO_TRANSFORMER_MAPPING: { [K in keyof Body]: (body: unknown) => Body[K] } = {
+  json: (body) => JSON.stringify(body),
+  text: (body) => body as string,
+  arrayBuffer: (body) => body as ArrayBuffer,
+  blob: (body) => body as Blob,
+  formData: (body) => body as FormData,
+}
 
 const tryDecodeURIComponent = (str: string) => tryDecode(str, decodeURIComponent_)
 
@@ -230,6 +242,41 @@ export class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
     return (bodyCache[key] = raw[key]())
   }
 
+  /**
+   * `.new()` creates a new Request object with the same properties as the current request.
+   * This method reconstructs the request body from cached data if it has been consumed,
+   * or consumes and caches the body if it hasn't been consumed yet but is available.
+   *
+   * @example
+   * ```ts
+   * app.post('/clone', async (c) => {
+   *   const newRequest = await c.req.new()
+   *   // Use the new request for further processing
+   * })
+   * ```
+   */
+  new = async () => {
+    const requestInit: RequestInit = { method: this.method, headers: this.header() }
+    const cachedKeys = Object.keys(this.bodyCache) as Array<keyof typeof this.bodyCache>
+    // If no body is cached but the raw request has a body and it's not consumed, consume it
+    if (cachedKeys.length === 0 && this.raw.body && !this.raw.bodyUsed) {
+      const bodyPromise = this.raw.text()
+      this.bodyCache.text = bodyPromise
+      const body = await bodyPromise
+      requestInit.body = body
+      return new Request(this.url, requestInit)
+    }
+
+    const firstKey = cachedKeys[0] as keyof Body | undefined
+    // If no cached body, return request without body
+    if (firstKey == null) return new Request(this.url, requestInit)
+
+    const cachedBody = await this.bodyCache[firstKey]
+    requestInit.body = BODY_TYPE_TO_TRANSFORMER_MAPPING[firstKey](cachedBody) ?? cachedBody
+
+    return new Request(this.url, requestInit)
+  }
+
   /**
    * `.json()` can parse Request body of type `application/json`
    *

src/validator/validator.test.ts

@@ -1092,6 +1092,87 @@ describe('Clone Request object', () => {
       expect(await res.json()).toEqual({ foo: 'bar' })
     })
   })
+
+  describe('Raw Request preservation after validation', () => {
+    it('Should preserve raw Request after JSON validation for external libraries', async () => {
+      const app = new Hono()
+
+      app.post(
+        '/json-validation',
+        validator('json', (value) => value),
+        async (c) => {
+          function createExternalRequest() {
+            return new Request(c.req.raw.url, {
+              method: c.req.raw.method,
+              headers: c.req.raw.headers,
+            })
+          }
+
+          const externalRequest = createExternalRequest()
+          const clone1 = c.req.raw.clone()
+          const clone2 = c.req.raw.clone()
+
+          return c.json({
+            success: true,
+            externalRequestMethod: externalRequest.method,
+            originalMethod: c.req.raw.method,
+            cloned: clone1 instanceof Request && clone2 instanceof Request,
+          })
+        }
+      )
+
+      const testData = { message: 'test', userId: 123 }
+      const res = await app.request('/json-validation', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(testData),
+      })
+
+      expect(res.status).toBe(200)
+
+      const result = await res.json()
+
+      expect(result.success).toBe(true)
+      expect(result.externalRequestMethod).toBe('POST')
+      expect(result.originalMethod).toBe('POST')
+      expect(result.cloned).toBe(true)
+    })
+
+    it('Should preserve raw Request after form validation for external libraries', async () => {
+      const app = new Hono()
+
+      app.post(
+        '/form-validation',
+        validator('form', (value) => value),
+        async (c) => {
+          expect(() => {
+            return new Request(c.req.raw.url, {
+              method: c.req.raw.method,
+              headers: c.req.raw.headers,
+            })
+          }, 'Test that raw request can be used by external libraries after form validation').not.toThrow()
+          expect(() => c.req.raw.clone()).not.toThrow()
+
+          return c.json({ success: true })
+        }
+      )
+
+      const formData = new FormData()
+      formData.append('username', 'testuser')
+      formData.append('email', '[email protected]')
+
+      const res = await app.request('/form-validation', {
+        method: 'POST',
+        body: formData,
+      })
+
+      expect(res.status).toBe(200)
+
+      const result = await res.json()
+
+      expect(result.success).toBe(true)
+    })
+  })
 })
 
 describe('Async validator function', () => {

src/validator/validator.ts

@@ -97,7 +97,7 @@ export const validator = <
           try {
             const arrayBuffer = await c.req.arrayBuffer()
             formData = await bufferToFormData(arrayBuffer, contentType)
-            c.req.bodyCache.formData = formData
+            c.req.bodyCache.formData = Promise.resolve(formData)
           } catch (e) {
             let message = 'Malformed FormData request.'
             message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`