sleepy-serv 0.2.1 → 0.3.1

package/README.md

@@ -73,11 +73,19 @@ The route's logic is implemented in the route definition files. These must `expo
 Here's an example of a simple handler function:
 
 ```js
-export default function (req) {
+export default function (req, res) {
+  console.log('res:', res)
+
   return new Response('Hello world')
 }
 ```
 
+These functions take two parameters:
+- `req`: a `BunRequest` object
+- `res`: a results object
+
+The `res` parameter might seem familiar if coming from ExpressJS, but this parameter has a different purpose. The `res` parameter is meant to act as a dedicated, persistent object that middleware can write their results to. This way, the `req` object stays as a lean `BunRequest`.
+
 These handlers can also be `async` functions and `sleepy-serv` will wait for them to finish before moving on.
 
 ### Middleware
@@ -86,13 +94,13 @@ As mentioned earlier, method definition files can also export an array of functi
 
 ```js
 export default [
-  async req => {
-    req.parsedBody = await req.json()
+  async (req, res) => {
+    res.body = await req.json()
   },
-  req => {
-    console.log('JSON body:', req.parsedBody)
+  (req, res) => {
+    console.log('JSON body:', res.body)
 
-    return new Response('Hello world', )
+    return new Response('Hello world')
   },
 ]
 ```
@@ -219,6 +227,72 @@ The middleware defined in `/api/users/:userId/meta.js` will be applied the follo
 
 At the time of this writing, `meta.js` only exports middleware functions.
 
+## Build-In Middleware
+
+`sleepy-serv` also comes built-in with a few useful middleware functions that are commonly used.
+
+### parseJson(req, _res)
+
+This middleware parses the request's `body` property as a JSON string, and then stores the results in `res.body`. Additional body parsers can be written in the future a accommodate other body encoding schemes.
+
+### validateSchema(schemas)
+
+This function takes a `schemas` object. Each property is optional:
+- `headers`: takes a string formatter schema to evaulate `req.headers`
+- `params`: takes a string formatter schema to evaulate `req.params`
+- `query`: takes a string foramtter schema to evaulate `req.query`
+- `body`: takes a JSON validation schema to evaulate `res.body`
+
+Here's an example of the schema in action:
+
+```
+PUT /contacts/123/addresses
+
+{
+  street1: '123 Main St.',
+  street2: '#100',
+  city: 'Las Vegas',
+  state: 'NV',
+  postalCode: '12345',
+}
+```
+
+***
+TODO: add JSON schema example.
+
+Please take a look at the `lib/src/middleware.test.js` test file for a far a comprehensive set of examples on how to use this middleware.
+***
+
+The `headers`, `params`, and `query` (querystrings) can only be strings, so they're evaulated using a simplified _string format schema_ instead of a full JSON schema.
+
+The string formatter schema looks like this:
+
+```javascript
+{
+  type: 'format',
+  value: 'email',
+}
+```
+
+**`type`**
+
+Can either set to `'format'` or `'pattern'`. The value of `type` determines how the `value` property is used.
+
+**`value`**
+
+This determines how to evaulate the string based on the `type` parameter. If `type` is set to `'format'`, then `value` can be set to one of the pre-defined formats that's provided by the JSON schema specification. If `type` is set to `'pattern'`, then `value` can be set to a regex pattern instead.
+
+Custom formats can also be provided by using the `setValidationFormats()` during app initialization. Here's an example:
+
+```javascript
+middleware.setValidationFormats({
+  phone: /^\d{10}$/, /* 10-digit, numeric string */
+  postalCode: /^\d{5}$/, /* 5-digit, numeric string */
+})
+```
+
+Calling `setValidationFormats()` extends the possible values that can be passed to the `value` property when evaulating strings in either the string formatter schema, or the `res.body`'s JSON schema.
+
 ## `createApp()` Options
 
 ### `hostname`

package/package.json

@@ -2,7 +2,7 @@
   "name": "sleepy-serv",
   "description": "A more opinionated web server for building REST-ful applications",
   "author": "Travis J True",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "exports": "./src/index.js",
   "type": "module",
   "keywords": [

package/src/index.js

@@ -45,17 +45,18 @@ function methodNotAllowedHandler (_req) {
   throw new MethodNotAllowedError()
 }
 
+/* TODO: add whitelist support */
 function validateDirectoryIllegalFiles (targetPath, filenames) {
-  const hasInvalidFiles = filenames.some(filename =>
-    !ALLOWED_FILES_ALL.includes(filename)
-  )
-
-  if (hasInvalidFiles) {
-    throw new TypeError(`
-Directory contains illegal files:
-${targetPath}
-    `.trim())
-  }
+//   const hasInvalidFiles = filenames.some(filename =>
+//     !ALLOWED_FILES_ALL.includes(filename)
+//   )
+
+//   if (hasInvalidFiles) {
+//     throw new TypeError(`
+// Directory contains illegal files:
+// ${targetPath}
+//     `.trim())
+//   }
 }
 
 function validateLeafDirectory (targetPath, filenames, entries) {
@@ -187,14 +188,15 @@ ${route.modulePath}
 
   const handler = async req => {
     const query = req.url.split('?')[1]
+    const res = {}
 
     req.query = query ? querystring.parse(query) : {}
 
     for (const fn of middlewareChain) {
-      const res = await fn(req)
+      const response = await fn(req, res)
 
-      if (res) {
-        return res
+      if (response) {
+        return response
       }
     }
   }

package/src/middleware.js

@@ -46,14 +46,14 @@ function buildFormatterSchema (schema) {
   }
 }
 
-export async function parseJson (req) {
+export async function parseJson (req, res) {
   const contentType = req.headers.get('content-type')
 
   if (req.method !== 'GET' && contentType !== 'application/json') {
     throw new UnsupportedMediaTypeError('content-type')
   }
 
-  req.parsedBody = await req.json()
+  res.body = await req.json()
 }
 
 export function setValidationFormats (formats) {
@@ -61,12 +61,12 @@ export function setValidationFormats (formats) {
 }
 
 export function validateSchema (schemas) {
-  return function (req) {
+  return function (req, res) {
     const formattedSchemas = {
       headers: buildFormatterSchema(schemas.headers),
       params: buildFormatterSchema(schemas.params),
       query: buildFormatterSchema(schemas.query),
-      parsedBody: schemas.parsedBody || SCHEMA_EMPTY,
+      body: schemas.body || SCHEMA_EMPTY,
     }
 
     const ajv = new Ajv({
@@ -83,7 +83,7 @@ export function validateSchema (schemas) {
     const errors = Object
       .entries(formattedSchemas)
       .reduce((accum, [key, schema]) => {
-        const data = req[key]
+        const data = key === 'body' ? res[key] : req[key]
         const valid = schema ? ajv.validate(schema, data) : true
 
         return !valid