sleepy-serv 0.4.0 → 0.6.0

package/src/middleware.js

@@ -1,37 +1,33 @@
 import Ajv from 'ajv'
 import addFormats from 'ajv-formats'
 
+import { formatError } from './utils'
+
 import {
   BadRequestError,
   UnsupportedMediaTypeError,
   UnprocessableContentError,
 } from './errors'
 
-const SCHEMA_EMPTY = {
-  type: 'object',
-  properties: {},
-}
-
-let _customFormats = {}
+let _schemasCompiled = false
+let _customFormats = null
 
-function formatError (prefix, input) {
-  const fixedPath = input.instancePath || '/'
-  const suffixPath = fixedPath.replace(/\//g, '.').replace('.', '')
+async function parseBody (req) {
+  try {
+    const result = await req.json()
 
-  return {
-    path: [prefix, suffixPath].filter(item => item).join('.'),
-    message: input.message,
+    return result
+  } catch {
+    throw new BadRequestError('Invalid JSON')
   }
 }
 
 function buildFormatterSchema (schema) {
-  if (!schema) {
-    return SCHEMA_EMPTY
-  }
-
   const properties = Object
     .entries(schema)
-    .map(([key, config]) => [key, {
+    .map(([key, config]) => [
+      key,
+      {
         type: 'string',
         [config.type]: config.value,
       },
@@ -47,70 +43,96 @@ function buildFormatterSchema (schema) {
   }
 }
 
-export async function parseJson (req, res, next) {
-  const contentType = req.headers.get('content-type')
+function compileSchemas (schemas) {
+  return Object
+    .entries(schemas)
+    .reduce((accum, [key, schema]) => {
+      const formattedSchema = key !== 'body'
+        ? buildFormatterSchema(schema)
+        : schema
+
+      return [
+        ...accum,
+        [key, formattedSchema],
+      ]
+    }, [])
+    .map(([key, schema]) => {
+      const ajv = new Ajv({
+        allErrors: true,
+        removeAdditional: 'all',
+      })
+
+      addFormats(ajv)
+
+      Object
+        .entries(_customFormats ?? [])
+        .forEach(([k, v]) => ajv.addFormat(k, v))
+
+      const validator = ajv.compile(schema)
+
+      return [key, validator]
+    })
+}
 
-  if (!contentType) {
-    return next()
-  }
+export function parseJsonBody () {
+  return async (req, res, next) => {
+    const contentType = req.headers.get('content-type')
 
-  if (contentType !== 'application/json') {
-    throw new UnsupportedMediaTypeError('content-type')
-  }
+    if (!contentType) {
+      return next(res)
+    }
 
-  try {
-    res.body = await req.json()
-  } catch (err) {
-    console.error(err)
+    if (!contentType.startsWith('application/json')) {
+      throw new UnsupportedMediaTypeError('content-type')
+    }
 
-    throw new BadRequestError('Body is invalid JSON')
-  }
+    const body = await parseBody(req)
 
-  return next()
+    return next(body)
+  }
 }
 
 export function setValidationFormats (formats) {
+  if (_customFormats) {
+    console.warn('setValidationFormats() - already initialized')
+  }
+
+  if (_schemasCompiled) {
+    console.warn('setValidationFormats() - called after compilation')
+  }
+
   _customFormats = formats
 }
 
-export function validateSchema (schemas) {
-  return function (req, res, next) {
-    const formattedSchemas = {
-      headers: buildFormatterSchema(schemas.headers),
-      params: buildFormatterSchema(schemas.params),
-      query: buildFormatterSchema(schemas.query),
-      body: schemas.body || SCHEMA_EMPTY,
-    }
+/* only for testing purposes */
 
-    const ajv = new Ajv({
-      allErrors: true,
-      removeAdditional: 'all',
-    })
+export function resetValidationFormatsState () {
+  _customFormats = null
+  _schemasCompiled = false
+}
 
-    addFormats(ajv)
+export function validateSchemas (schemas) {
+  const entries = compileSchemas(schemas)
 
-    Object
-      .entries(_customFormats)
-      .forEach(([k, v]) => ajv.addFormat(k, v))
+  _schemasCompiled = true
 
-    const errors = Object
-      .entries(formattedSchemas)
-      .reduce((accum, [key, schema]) => {
-        const data = key === 'body' ? res[key] : req[key]
-        const valid = schema ? ajv.validate(schema, data) : true
+  return (req, res, next) => {
+    const errors = entries.reduce((accum, [key, validator]) => {
+      const data = key === 'body' ? res : req[key]
+      const valid = validator(data)
 
-        return !valid
-          ? [
-            ...accum,
-            ...ajv.errors.map(item => formatError(key, item)),
-          ]
-          : accum
-      }, [])
+      return !valid
+        ? [
+          ...accum,
+          ...validator.errors.map(item => formatError(key, item)),
+        ]
+        : accum
+    }, [])
 
     if (errors.length > 0) {
       throw new UnprocessableContentError(errors)
     }
 
-    return next()
+    return next(res)
   }
 }