style: apply consistent formatting across multiple files

Author: jkyberneees

demos/basic.js

@@ -1,10 +1,10 @@
 /* global Response */
 const http = require('../index')
 
-const { router } = http({})
+const {router} = http({})
 router.use((req, next) => {
   req.ctx = {
-    engine: 'bun'
+    engine: 'bun',
   }
 
   return next()
@@ -17,7 +17,7 @@ router.post('/', async (req) => {
 })
 router.delete('/:id', async (req) => {
   return Response.json(req.params, {
-    status: 200
+    status: 200,
   })
 })
 

demos/minimal.js

@@ -1,7 +1,7 @@
 /* global Response */
 const http = require('../index')
 
-const { router } = http({})
+const {router} = http({})
 
 router.get('/hi', async (req) => {
   return new Response('Hello World!')

lib/next.js

@@ -1,4 +1,10 @@
-module.exports = function next (middlewares, req, index, defaultRoute, errorHandler) {
+module.exports = function next(
+  middlewares,
+  req,
+  index,
+  defaultRoute,
+  errorHandler,
+) {
   if (index >= middlewares.length) {
     return defaultRoute(req)
   }

package.json

@@ -4,10 +4,10 @@
   "description": "0http for Bun",
   "main": "index.js",
   "scripts": {
-    "lint": "bun x standard",
+    "lint": "prettier --check **/*.js",
     "test": "bun test",
     "bench": "bun run bench.js",
-    "format": "prettier --write *.js"
+    "format": "prettier --write **/*.js"
   },
   "dependencies": {
     "fast-querystring": "^1.1.2",

test/config.test.js

@@ -1,22 +1,22 @@
 /* global describe, it, expect, beforeAll */
 
 const http = require('../index')
-const { router } = http({
+const {router} = http({
   port: 3000,
   defaultRoute: (req) => {
     const res = new Response('Not Found!', {
-      status: 404
+      status: 404,
     })
 
     return res
   },
   errorHandler: (err) => {
     const res = new Response('Error: ' + err.message, {
-      status: 500
+      status: 500,
     })
 
     return res
-  }
+  },
 })
 
 describe('Router Configuration', () => {
@@ -27,17 +27,21 @@ describe('Router Configuration', () => {
   })
 
   it('should return a 500 response for a route that throws an error', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/error', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/error', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(500)
     expect(await response.text()).toEqual('Error: Unexpected error')
   })
 
   it('should return a 404 response for a route that does not exist', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/does-not-exist', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/does-not-exist', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(404)
     expect(await response.text()).toEqual('Not Found!')
   })

test/smoke.test.js

@@ -1,13 +1,13 @@
 /* global describe, it, expect, beforeAll */
 
 const http = require('../index')
-const { router } = http({ port: 3000 })
+const {router} = http({port: 3000})
 
 describe('Router', () => {
   beforeAll(async () => {
     router.use((req, next) => {
       req.ctx = {
-        engine: 'bun'
+        engine: 'bun',
       }
 
       return next()
@@ -41,58 +41,72 @@ describe('Router', () => {
   })
 
   it('should return a JSON response with the request parameters for GET requests', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/get-params/123', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/get-params/123', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ id: '123' })
+    expect(await response.json()).toEqual({id: '123'})
   })
 
   it('should return a JSON response with the request parameters for DELETE requests', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/get-params/123', {
-      method: 'DELETE'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/get-params/123', {
+        method: 'DELETE',
+      }),
+    )
     expect(response.status).toBe(200)
     expect(await response.json()).toEqual('OK')
   })
 
   it('should return a JSON response with the request body for POST requests', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/create', {
-      method: 'POST',
-      body: JSON.stringify({ foo: 'bar' })
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/create', {
+        method: 'POST',
+        body: JSON.stringify({foo: 'bar'}),
+      }),
+    )
     expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ foo: 'bar' })
+    expect(await response.json()).toEqual({foo: 'bar'})
   })
 
   it('should return a 404 response for a non-existent route', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/non-existent', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/non-existent', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(404)
   })
 
   it('should return a 500 response for a route that throws an error', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/error', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/error', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(500)
     expect(await response.text()).toEqual('Unexpected error')
   })
 
   it('should return a 200 response for a route that returns a Response object', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ engine: 'bun' })
+    expect(await response.json()).toEqual({engine: 'bun'})
   })
 
   it('should return a JSON response with the query string parameters', async () => {
-    const response = await router.fetch(new Request('http://localhost:3000/qs?foo=bar', {
-      method: 'GET'
-    }))
+    const response = await router.fetch(
+      new Request('http://localhost:3000/qs?foo=bar', {
+        method: 'GET',
+      }),
+    )
     expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ foo: 'bar' })
+    expect(await response.json()).toEqual({foo: 'bar'})
   })
 })