[FIX] - fix getErrorMessage naming, regex lint error, Test no options when registering

Author: KirillTregubov

index.js

@@ -1,17 +1,13 @@
 const fp = require('fastify-plugin')
 const {
- getErrrorMessage,
+ getErrorMessage,
  hasProperties,
  initialExcludes,
  isSchemaTypeExcluded,
  SCHEMA_TYPES
 } = require('./utils')
 
-function FastifyEnforceSchema (fastify, opts, done) {
- if (!opts) {
- opts = {}
- }
-
+function FastifyEnforceSchema (fastify, opts = {}, done) {
  if (!Object.prototype.hasOwnProperty.call(opts, 'required')) {
  opts.required = []
  }
@@ -59,7 +55,7 @@ function FastifyEnforceSchema (fastify, opts, done) {
  const schema = Object.keys(routeOptions?.schema?.response || [])
 
  if (!routeOptions?.schema?.response) {
- throw new Error(getErrrorMessage(SCHEMA_TYPES.response, routeOptions))
+ throw new Error(getErrorMessage(SCHEMA_TYPES.response, routeOptions))
  }
 
  if (
@@ -88,17 +84,17 @@ function FastifyEnforceSchema (fastify, opts, done) {
  required.indexOf(SCHEMA_TYPES.body) !== -1 &&
  !hasProperties(routeOptions, SCHEMA_TYPES.body)
  ) {
- throw new Error(getErrrorMessage(SCHEMA_TYPES.body, routeOptions))
+ throw new Error(getErrorMessage(SCHEMA_TYPES.body, routeOptions))
  }
 
  if (
  routeOptions?.schema?.params !== false &&
- new RegExp(/:\w+/).test(routeOptions.url) &&
+ /:\w+/.test(routeOptions.url) &&
  !isSchemaTypeExcluded(excludedEntity, SCHEMA_TYPES.params) &&
  required.indexOf(SCHEMA_TYPES.params) !== -1 &&
  !hasProperties(routeOptions, SCHEMA_TYPES.params)
  ) {
- throw new Error(getErrrorMessage(SCHEMA_TYPES.params, routeOptions))
+ throw new Error(getErrorMessage(SCHEMA_TYPES.params, routeOptions))
  }
  })
 

test/enforce-schema.test.js

@@ -4,11 +4,47 @@ const { test } = require('tap')
 const Fastify = require('fastify')
 const enforceSchema = require('../index.js')
 const {
- getErrrorMessage,
+ getErrorMessage,
  hasProperties,
  isSchemaTypeExcluded
 } = require('../utils.js')
 
+test('Should fail if no options passed: every endpoint should have a schema', async (t) => {
+ t.plan(1)
+
+ const fastify = Fastify()
+
+ await fastify.register(enforceSchema)
+
+ try {
+ fastify.post('/foo', {}, (req, reply) => {
+ reply.code(201).send('ok')
+ })
+ } catch (error) {
+ t.equal(error.message, 'schema missing at the path POST: "/foo"')
+ }
+})
+
+test('Should pass if no options passed and schema validation explicitly disabled', async (t) => {
+ t.plan(2)
+
+ const fastify = Fastify()
+
+ await fastify.register(enforceSchema)
+ 
+ fastify.post('/foo', { schema: false }, (req, reply) => {
+ reply.code(201).send('ok')
+ })
+
+ const res = await fastify.inject({
+ method: 'POST',
+ url: '/foo'
+ })
+
+ t.equal(res.statusCode, 201)
+ t.equal(res.payload, 'ok')
+})
+
 test('Should fail if schema is missing', async (t) => {
  t.plan(1)
 
@@ -132,7 +168,6 @@ test('Should NOT fail if params schema is missing', async (t) => {
 
  await fastify.register(enforceSchema, { required: ['params'] })
 
- 
  fastify.get('/foo', { schema: {} }, (req, reply) => {
  reply.code(200).send('ok')
  })
@@ -166,15 +201,15 @@ test('getErrorMessage should return a proper message', async (t) => {
  t.plan(3)
 
  t.equal(
- getErrrorMessage('body', { path: '/bar', method: 'PUT' }),
+ getErrorMessage('body', { path: '/bar', method: 'PUT' }),
  'PUT: /bar is missing a body schema'
  )
  t.equal(
- getErrrorMessage('response', { path: '/bar', method: 'PUT' }),
+ getErrorMessage('response', { path: '/bar', method: 'PUT' }),
  'PUT: /bar is missing a response schema'
  )
  t.equal(
- getErrrorMessage('params', { path: '/bar', method: 'PUT' }),
+ getErrorMessage('params', { path: '/bar', method: 'PUT' }),
  'PUT: /bar is missing a params schema'
  )
 })

utils.js

@@ -1,9 +1,9 @@
-const getErrrorMessage = (schemaType, routeOptions) => {
+const getErrorMessage = (schemaType, routeOptions) => {
  const { path, method } = routeOptions
  return `${method}: ${path} is missing a ${schemaType} schema`
 }
 
-exports.getErrrorMessage = getErrrorMessage
+exports.getErrorMessage = getErrorMessage
 
 exports.hasProperties = (routeOptions, name) => {
  return !!Object.keys(routeOptions?.schema?.[name]?.properties || []).length