new parseRangeHeader function and tests

Author: kensnyder

packages/bunshine/src/HttpRouter/HttpRouter.spec.ts

@@ -14,6 +14,7 @@ type SseTestEvent = {
 const server: Server = {};
 
 describe('HttpRouter', () => {
+  let port = 7500;
   describe('handlers', () => {
     let app: HttpRouter;
     let oldEnv: string | undefined;
@@ -295,28 +296,131 @@ describe('HttpRouter', () => {
       expect(await resp2.text()).toBe('Hi');
     });
   });
-  describe('server', () => {
-    let app: HttpRouter;
+  describe('listening', () => {
     let server: Server;
-    beforeEach(() => {
-      app = new HttpRouter();
-    });
     afterEach(() => {
       server.stop(true);
     });
     it('should assign random port', async () => {
+      const app = new HttpRouter();
+      server = app.listen();
       app.get('/', () => new Response('Hi'));
-      server = app.listen({ port: 7769 });
-      const resp = await fetch(`http://localhost:${server.port}/`);
+      const resp = await fetch(server.url);
       expect(typeof server.port).toBe('number');
       expect(server.port).toBeGreaterThan(0);
       expect(resp.status).toBe(200);
       expect(await resp.text()).toBe('Hi');
     });
+  });
+  describe('server', () => {
+    let app: HttpRouter;
+    let server: Server;
+    beforeEach(() => {
+      app = new HttpRouter();
+      server = app.listen({ port: port++ });
+    });
+    afterEach(() => {
+      server.stop(true);
+    });
+    it('should return correct statuses, headers, and bytes', async () => {
+      app.headGet('/bun-logo.jpg', c => {
+        return c.file(`${import.meta.dirname}/../../testFixtures/bun-logo.jpg`);
+      });
+      const url = `${server.url}/bun-logo.jpg`;
+
+      // Step 1: Fetch entire file
+      const fullResponse = await fetch(url);
+      const fullFileBytes = await fullResponse.blob();
+      const fileSize = Number(fullResponse.headers.get('content-length'));
+
+      expect(fullResponse.status).toBe(200);
+      expect(fullFileBytes.size).toBe(fileSize);
+      expect(fullResponse.headers.get('accept-ranges')).toBe('bytes');
+      expect(fullResponse.headers.get('content-type')).toBe('image/jpeg');
+
+      // Step 2: Fetch HEAD and validate
+      const headResponse = await fetch(url, { method: 'HEAD' });
+
+      expect(headResponse.status).toBe(200);
+      expect(headResponse.headers.get('content-length')).toBe(String(fileSize));
+      expect(headResponse.headers.get('accept-ranges')).toBe('bytes');
+
+      // Step 3: Fetch range "bytes=0-" and validate
+      const rangeResponse1 = await fetch(url, {
+        headers: { Range: 'bytes=0-' },
+      });
+      const range1Bytes = await rangeResponse1.blob();
+
+      expect(rangeResponse1.status).toBe(206);
+      expect(rangeResponse1.headers.get('accept-ranges')).toBe('bytes');
+      expect(rangeResponse1.headers.get('content-type')).toBe('image/jpeg');
+      expect(range1Bytes.size).toBe(fileSize);
+      expect(rangeResponse1.headers.get('content-length')).toBe(
+        String(fileSize)
+      );
+      expect(range1Bytes).toEqual(fullFileBytes);
+
+      // Step 4: Fetch range "bytes=0-999" and validate
+      const rangeResponse2 = await fetch(url, {
+        headers: { Range: 'bytes=0-999' },
+      });
+      const range2Bytes = await rangeResponse2.blob();
+
+      expect(rangeResponse2.status).toBe(206);
+      expect(rangeResponse2.headers.get('accept-ranges')).toBe('bytes');
+      expect(rangeResponse2.headers.get('content-length')).toBe('1000');
+      expect(range2Bytes.size).toBe(1000);
+      expect(rangeResponse2.headers.get('content-range')).toBe(
+        `bytes 0-999/${fileSize}`
+      );
+      expect(range2Bytes).toEqual(fullFileBytes.slice(0, 1000));
+      expect(rangeResponse2.headers.get('content-type')).toBe('image/jpeg');
+
+      // Step 5: Fetch range "bytes=1000-1999" and validate
+      const rangeResponse3 = await fetch(url, {
+        headers: { Range: 'bytes=1000-1999' },
+      });
+      const range3Bytes = await rangeResponse3.blob();
+
+      expect(rangeResponse3.status).toBe(206);
+      expect(rangeResponse3.headers.get('accept-ranges')).toBe('bytes');
+      expect(rangeResponse3.headers.get('content-length')).toBe('1000');
+      expect(range3Bytes.size).toBe(1000);
+      expect(rangeResponse3.headers.get('content-range')).toBe(
+        `bytes 1000-1999/${fileSize}`
+      );
+      expect(range3Bytes).toEqual(fullFileBytes.slice(1000, 2000));
+      expect(rangeResponse3.headers.get('content-type')).toBe('image/jpeg');
+
+      // Step 5: Fetch range "bytes=-1000" and validate
+      const rangeResponse4 = await fetch(url, {
+        headers: { Range: 'bytes=-1000' },
+      });
+      const range4Bytes = await rangeResponse4.blob();
+
+      expect(rangeResponse4.status).toBe(206);
+      expect(rangeResponse4.headers.get('accept-ranges')).toBe('bytes');
+      expect(rangeResponse4.headers.get('content-length')).toBe('1000');
+      expect(range4Bytes.size).toBe(1000);
+      expect(rangeResponse4.headers.get('content-range')).toBe(
+        `bytes ${fileSize - 1001}-${fileSize - 1}/${fileSize}`
+      );
+      expect(range4Bytes).toEqual(fullFileBytes.slice(-1000));
+      expect(rangeResponse4.headers.get('content-type')).toBe('image/jpeg');
+
+      // Step 7: Request invalid range
+      const rangeResponse5 = await fetch(url, {
+        headers: { Range: 'bytes=9999999-' },
+      });
+      expect(rangeResponse5.status).toBe(416);
+      expect(rangeResponse5.statusText).toBe('Range Not Satisfiable');
+      expect(rangeResponse5.headers.get('content-range')).toBe(
+        `bytes */${fileSize}`
+      );
+    });
     it('should get client ip info', async () => {
       app.get('/', c => c.json(c.ip));
-      server = app.listen({ port: 7770 });
-      const resp = await fetch(`http://localhost:${server.port}/`);
+      const resp = await fetch(server.url);
       const info = (await resp.json()) as {
         address: string;
         family: string;
@@ -328,33 +432,28 @@ describe('HttpRouter', () => {
     });
     it('should emit url', async () => {
       app.all('/', () => new Response('Hi'));
-      server = app.listen({ port: 7771 });
-      let output: string;
+      let output: string = '';
       const to = (message: string) => (output = message);
       app.emitUrl({ to });
-      // @ts-expect-error
       expect(output).toContain(String(server.url));
     });
     it('should handle all', async () => {
       app.all('/', () => new Response('Hi'));
-      server = app.listen({ port: 7772 });
-      const resp = await fetch('http://localhost:7772/');
+      const resp = await fetch(server.url);
       expect(resp.status).toBe(200);
       expect(await resp.text()).toBe('Hi');
     });
     it('should handle GET', async () => {
       app.get('/', () => new Response('Hi'));
-      server = app.listen({ port: 7773 });
-      const resp = await fetch('http://localhost:7773/');
+      const resp = await fetch(server.url);
       expect(resp.status).toBe(200);
       expect(await resp.text()).toBe('Hi');
     });
     it('should handle PUT', async () => {
       app.put('/', async ({ request, json }) => {
         return json(await request.json());
       });
-      server = app.listen({ port: 7774 });
-      const resp = await fetch('http://localhost:7774/', {
+      const resp = await fetch(server.url, {
         method: 'PUT',
         headers: {
           'Content-Type': 'application/json',
@@ -376,8 +475,7 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7775 });
-      const resp = await fetch('http://localhost:7775/hi?name=Bob', {
+      const resp = await fetch(`${server.url}/hi?name=Bob`, {
         method: 'HEAD',
       });
       expect(resp.status).toBe(204);
@@ -394,10 +492,9 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7776 });
       const formData = new URLSearchParams();
       formData.append('key', 'secret');
-      const resp = await fetch('http://localhost:7776/parrot', {
+      const resp = await fetch(`${server.url}/parrot`, {
         method: 'POST',
         headers: {
           'Content-type': 'application/x-www-form-urlencoded',
@@ -418,10 +515,9 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7777 });
       const formData = new FormData();
       formData.append('key2', 'secret2');
-      const resp = await fetch('http://localhost:7777/parrot', {
+      const resp = await fetch(`${server.url}/parrot`, {
         method: 'POST',
         body: formData,
       });
@@ -432,8 +528,7 @@ describe('HttpRouter', () => {
       app.patch('/', async ({ request, json }) => {
         return json(await request.json());
       });
-      server = app.listen({ port: 7778 });
-      const resp = await fetch('http://localhost:7778/', {
+      const resp = await fetch(server.url, {
         method: 'PATCH',
         headers: {
           'Content-Type': 'application/json',
@@ -453,8 +548,7 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7779 });
-      const resp = await fetch('http://localhost:7779/', {
+      const resp = await fetch(server.url, {
         method: 'TRACE',
         headers: {
           'Max-Forwards': '0',
@@ -474,8 +568,7 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7780 });
-      const resp = await fetch('http://localhost:7780/users/42', {
+      const resp = await fetch(`${server.url}/users/42`, {
         method: 'DELETE',
       });
       expect(resp.status).toBe(204);
@@ -490,8 +583,7 @@ describe('HttpRouter', () => {
           },
         });
       });
-      server = app.listen({ port: 7781 });
-      const resp = await fetch('http://localhost:7781/users/42', {
+      const resp = await fetch(`${server.url}/users/42`, {
         method: 'OPTIONS',
       });
       expect(resp.status).toBe(204);
@@ -501,9 +593,8 @@ describe('HttpRouter', () => {
       app.get('/home', ({ app }) => {
         return new Response(app.locals.foo);
       });
-      server = app.listen({ port: 7782 });
       app.locals.foo = 'bar';
-      const resp = await fetch('http://localhost:7782/home');
+      const resp = await fetch(`${server.url}/home`);
       expect(resp.status).toBe(200);
       expect(await resp.text()).toBe('bar');
     });
@@ -573,7 +664,7 @@ describe('HttpRouter', () => {
     it('should handle unnamed data', async () => {
       const events = await sseTest({
         event: 'message',
-        port: 7784,
+        port: port++,
         payloads: [['Hello'], ['World']],
       });
       expect(events.length).toBe(2);
@@ -583,7 +674,7 @@ describe('HttpRouter', () => {
     it('should send last event id and origin', async () => {
       const events = await sseTest({
         event: 'myEvent',
-        port: 7785,
+        port: port++,
         payloads: [
           ['myEvent', 'hi1', 'id1'],
           ['myEvent', 'hi2', 'id2'],
@@ -594,13 +685,13 @@ describe('HttpRouter', () => {
       expect(events[1].data).toBe('hi2');
       expect(events[0].lastEventId).toBe('id1');
       expect(events[1].lastEventId).toBe('id2');
-      expect(events[0].origin).toBe('http://localhost:7785');
-      expect(events[1].origin).toBe('http://localhost:7785');
+      expect(events[0].origin).toBe(`http://localhost:${port - 1}`);
+      expect(events[1].origin).toBe(`http://localhost:${port - 1}`);
     });
     it('should JSON encode data if needed', async () => {
       const events = await sseTest({
         event: 'myEvent',
-        port: 7786,
+        port: port++,
         payloads: [['myEvent', { name: 'Bob' }]],
       });
       expect(events.length).toBe(1);
@@ -610,7 +701,7 @@ describe('HttpRouter', () => {
       spyOn(console, 'warn').mockImplementation(() => {});
       await sseTest({
         event: 'myEvent',
-        port: 7787,
+        port: port++,
         payloads: [['myEvent', { name: 'Bob' }]],
         headers: {
           'Content-Type': 'text/plain',
@@ -626,7 +717,7 @@ describe('HttpRouter', () => {
       spyOn(console, 'warn').mockImplementation(() => {});
       await sseTest({
         event: 'myEvent',
-        port: 7788,
+        port: port++,
         payloads: [['myEvent', { name: 'Bob' }]],
         headers: {
           'Content-Type': 'text/event-stream',

packages/bunshine/src/getMimeType/getMimeType.ts

@@ -3,5 +3,5 @@ import { BunFile } from 'bun';
 export default function getMimeType(file: BunFile) {
   // Currently, we let Bun.file handle looking up mime types
   // So far Bun has all the types you'd expect
-  return file.type;
+  return file.type || 'application/octet-stream';
 }

packages/bunshine/src/middleware/serveFiles/serveFiles.ts

@@ -1,7 +1,6 @@
 import path from 'path';
 import type { Middleware } from '../../HttpRouter/HttpRouter';
 import ms from '../../ms/ms';
-import buildFileResponse from '../../responseFactories/buildFileResponse';
 
 // see https://expressjs.com/en/4x/api.html#express.static
 // and https://www.npmjs.com/package/send#dotfiles
@@ -74,14 +73,7 @@ export function serveFiles(
       }
       return new Response('404 Not Found', { status: 404 });
     }
-    const rangeHeader = c.request.headers.get('range');
-    const response = await buildFileResponse({
-      file,
-      acceptRanges,
-      chunkSize: 0,
-      rangeHeader,
-      method: c.request.method,
-    });
+    const response = await c.file(file);
     // add last modified
     if (lastModified) {
       response.headers.set(