[PoC] feat: introduce Partial Content Middleware

src/middleware/partial-content/index.test.ts

@@ -0,0 +1,174 @@
+import { Hono } from '../../hono'
+import { partialContent } from './index'
+
+const app = new Hono()
+
+app.use(partialContent())
+
+const body = 'This is a test mock data for range requests.'
+
+app.get('/hello.jpg', (c) => {
+  return c.body(body, {
+    headers: {
+      'Content-Length': body.length.toString(),
+      'Content-Type': 'image/jpeg', // fake content type
+    },
+  })
+})
+
+describe('Partial Content Middleware', () => {
+  it('Should return the first 5 bytes of the mock data (bytes=0-4)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=0-4',
+      },
+    })
+
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(res.headers.get('Content-Range')).toBe('bytes 0-4/44')
+    expect(await res.text()).toBe('This ')
+  })
+
+  it('Should return the bytes from 6 to 10 (bytes=6-10)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=6-10',
+      },
+    })
+
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(res.headers.get('Content-Range')).toBe('bytes 6-10/44')
+    expect(await res.text()).toBe('s a t')
+  })
+
+  it('Should return multiple ranges of the mock data (bytes=0-4, 6-10)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=0-4, 6-10',
+      },
+    })
+
+    expect(res.headers.get('Content-Type')).toBe(
+      'multipart/byteranges; boundary=PARTIAL_CONTENT_BOUNDARY'
+    )
+
+    const expectedResponse = [
+      '--PARTIAL_CONTENT_BOUNDARY',
+      'Content-Type: image/jpeg',
+      'Content-Range: bytes 0-4/44',
+      '',
+      'This ',
+      '--PARTIAL_CONTENT_BOUNDARY',
+      'Content-Type: image/jpeg',
+      'Content-Range: bytes 6-10/44',
+      '',
+      's a t',
+      '--PARTIAL_CONTENT_BOUNDARY--',
+      '',
+    ].join('\r\n')
+    expect(await res.text()).toBe(expectedResponse)
+  })
+
+  it('Should return the last 10 bytes of the mock data (bytes=-10)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=-10',
+      },
+    })
+
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(res.headers.get('Content-Range')).toBe('bytes 34-43/44')
+    expect(await res.text()).toBe(' requests.')
+  })
+
+  it('Should return the remaining bytes starting from byte 10 (bytes=10-)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=10-',
+      },
+    })
+
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(res.headers.get('Content-Range')).toBe('bytes 10-43/44')
+    expect(await res.text()).toBe('test mock data for range requests.')
+  })
+
+  it('Should return 416 Range Not Satisfiable for excessive number of ranges (11 or more)', async () => {
+    const res = await app.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=0-0,1-1,2-2,3-3,4-4,5-5,6-6,7-7,8-8,9-9,10-10',
+      },
+    })
+
+    expect(res.status).toBe(416)
+    expect(res.headers.get('Content-Range')).toBeNull()
+    expect(res.headers.get('Content-Length')).toBe('44')
+  })
+
+  it('Should return 404 if content is not found', async () => {
+    const app = new Hono()
+    app.use(partialContent())
+
+    app.get('/notfound.jpg', (c) => {
+      return c.notFound()
+    })
+
+    const res = await app.request('/notfound.jpg', {
+      headers: {
+        Range: 'bytes=0-10',
+      },
+    })
+
+    expect(res.status).toBe(404)
+  })
+
+  it('Should return full content if Range header is not provided', async () => {
+    const res = await app.request('/hello.jpg')
+
+    expect(res.status).toBe(200)
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(await res.text()).toBe(body) // Full body should be returned
+  })
+
+  it('Should return full content if Content-Length is missing', async () => {
+    const appWithoutContentLength = new Hono()
+    appWithoutContentLength.use(partialContent())
+
+    appWithoutContentLength.get('/hello.jpg', (c) => {
+      return c.body(body, {
+        headers: {
+          'Content-Type': 'image/jpeg',
+        },
+      })
+    })
+
+    const res = await appWithoutContentLength.request('/hello.jpg', {
+      headers: {
+        Range: 'bytes=0-4',
+      },
+    })
+
+    expect(res.status).toBe(200)
+    expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+    expect(await res.text()).toBe(body)
+  })
+
+  it('Should return 204 No Content if body is missing', async () => {
+    const appWithoutBody = new Hono()
+    appWithoutBody.use(partialContent())
+
+    appWithoutBody.get('/empty.jpg', (c) => {
+      return c.body(null, 204)
+    })
+
+    const res = await appWithoutBody.request('/empty.jpg', {
+      headers: {
+        Range: 'bytes=0-4',
+      },
+    })
+
+    expect(res.status).toBe(204)
+    expect(res.headers.get('Content-Type')).toBeNull()
+    expect(await res.text()).toBe('')
+  })
+})

src/middleware/partial-content/index.ts

@@ -0,0 +1,131 @@
+import type { MiddlewareHandler } from '../../types'
+
+type Data = string | ArrayBuffer | ReadableStream
+
+const PARTIAL_CONTENT_BOUNDARY = 'PARTIAL_CONTENT_BOUNDARY'
+
+export type PartialContent = { start: number; end: number; data: Data }
+
+const formatRangeSize = (start: number, end: number, size: number | undefined): string => {
+  return `bytes ${start}-${end}/${size ?? '*'}`
+}
+
+export type RangeRequest =
+  | { type: 'range'; start: number; end: number | undefined }
+  | { type: 'last'; last: number }
+  | { type: 'ranges'; ranges: Array<{ start: number; end: number }> }
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range
+const decodeRangeRequestHeader = (raw: string | undefined): RangeRequest | undefined => {
+  const bytes = raw?.match(/^bytes=(.+)$/)
+  if (bytes) {
+    const bytesContent = bytes[1].trim()
+    const last = bytesContent.match(/^-(\d+)$/)
+    if (last) {
+      return { type: 'last', last: parseInt(last[1]) }
+    }
+
+    const single = bytesContent.match(/^(\d+)-(\d+)?$/)
+    if (single) {
+      return {
+        type: 'range',
+        start: parseInt(single[1]),
+        end: single[2] ? parseInt(single[2]) : undefined,
+      }
+    }
+
+    const multiple = bytesContent.match(/^(\d+-\d+(?:,\s*\d+-\d+)+)$/)
+    if (multiple) {
+      const ranges = multiple[1].split(',').map((range) => {
+        const [start, end] = range.split('-').map((n) => parseInt(n.trim()))
+        return { start, end }
+      })
+      return { type: 'ranges', ranges }
+    }
+  }
+
+  return undefined
+}
+
+export const partialContent = (): MiddlewareHandler =>
+  async function partialContent(c, next) {
+    await next()
+
+    const rangeRequest = decodeRangeRequestHeader(c.req.header('Range'))
+    const contentLength = c.res.headers.get('Content-Length')
+
+    if (rangeRequest && contentLength && c.res.body) {
+      const totalSize = Number(contentLength)
+      const offsetSize = totalSize - 1
+      const bodyStream = c.res.body.getReader()
+
+      const contents =
+        rangeRequest.type === 'ranges'
+          ? rangeRequest.ranges
+          : [
+              {
+                start:
+                  rangeRequest.type === 'last' ? totalSize - rangeRequest.last : rangeRequest.start,
+                end:
+                  rangeRequest.type === 'range'
+                    ? Math.min(rangeRequest.end ?? offsetSize, offsetSize)
+                    : offsetSize,
+              },
+            ]
+
+      if (contents.length > 10) {
+        c.header('Content-Length', totalSize.toString())
+        c.res = c.body(null, 416)
+        return
+      }
+
+      const contentType = c.res.headers.get('Content-Type')
+
+      if (contents.length === 1) {
+        const part = contents[0]
+        const contentRange = formatRangeSize(part.start, part.end, totalSize)
+        c.header('Content-Range', contentRange)
+      } else {
+        c.header('Content-Type', `multipart/byteranges; boundary=${PARTIAL_CONTENT_BOUNDARY}`)
+      }
+
+      const responseBody = new ReadableStream({
+        async start(controller) {
+          const encoder = new TextEncoder()
+          const { done, value } = await bodyStream.read()
+
+          if (done || !value) {
+            controller.close()
+            return
+          }
+
+          for (const part of contents) {
+            const contentRange = formatRangeSize(part.start, part.end, totalSize)
+            const sliceStart = part.start
+            const sliceEnd = part.end + 1
+            const chunk = value.subarray(sliceStart, sliceEnd)
+
+            if (contents.length === 1) {
+              controller.enqueue(chunk)
+            } else {
+              controller.enqueue(
+                encoder.encode(
+                  `--${PARTIAL_CONTENT_BOUNDARY}\r\nContent-Type: ${contentType}\r\nContent-Range: ${contentRange}\r\n\r\n`
+                )
+              )
+              controller.enqueue(chunk)
+              controller.enqueue(encoder.encode('\r\n'))
+            }
+          }
+
+          if (contents.length !== 1) {
+            controller.enqueue(encoder.encode(`--${PARTIAL_CONTENT_BOUNDARY}--\r\n`))
+          }
+
+          controller.close()
+        },
+      })
+
+      c.res = c.body(responseBody, 206)
+    }
+  }