[NEW] - Add option excludeOnFalseSchema + Test

Author: Sako K

index.d.ts

@@ -23,7 +23,7 @@ enum SchemaTypes {
   Params = "params",
 }
 
-declare namespace fasticyEnforceSchema {
+declare namespace fastifyEnforceSchema {
   export type OriginFunction = (
     origin: string,
     callback: OriginCallback
@@ -35,6 +35,22 @@ declare namespace fasticyEnforceSchema {
      * A list of endpoints to exclude by the route path
      */
     exclude: string[];
+    /**
+     * If true, the plugin will not throw an error if the schema or schema types is equal to false
+     * @default false
+     * @example
+     * fastify.register(fastifyEnforceSchema, { excludeOnFalseSchema: true })
+     *
+     * fastify.get('/', { schema: false }, (req, reply) => {
+     *  reply.send({ hello: 'world' })
+     * })
+     * // or
+     * fastify.get('/test', { schema: { body: false } }, (req, reply) => {
+     *  reply.send({ hello: 'world' })
+     * })
+     * // no error will be thrown
+     */
+    excludeOnFalseSchema: boolean;
   }
 
   export interface FastifyEnforceSchemaOptionsDelegateCallback {

index.js

@@ -21,14 +21,43 @@ function FastifyEnforceSchema(fastify, opts, done) {
     opts.exclude = [];
   }
 
-  const { required, exclude } = opts;
+  if (!Object.prototype.hasOwnProperty.call(opts, 'excludeOnFalseSchema')) {
+    opts.excludeOnFalseSchema = false;
+  }
+
+  const { required, exclude, excludeOnFalseSchema } = opts;
 
-  fastify.addHook("onRoute", routeOptions => {
-    if (routeOptions.path === "*" || !routeOptions.path) {
+  fastify.addHook("onRoute", (routeOptions) => {
+    if (
+      routeOptions.path === "*" ||
+      !routeOptions.path ||
+      (excludeOnFalseSchema && routeOptions.schema === false)
+    ) {
       done();
       return;
     }
 
+    if (excludeOnFalseSchema && typeof routeOptions.schema === "object") {
+      const excludedEntity = exclude.find(
+        ({ url }) => url === routeOptions.path
+      );
+      const excludedSchemas = [];
+
+      Object.entries(routeOptions.schema).forEach(([key, value]) => {
+        if (value === false) {
+          excludedSchemas.push(key);
+        }
+      });
+
+      if (excludedEntity) {
+        excludedEntity.excludedSchemas = [
+          ...new Set([...excludedEntity.excludedSchemas, ...excludedSchemas]),
+        ];
+      } else {
+        exclude.push({ url: routeOptions.path, excludedSchemas });
+      }
+    }
+
     const excludedEntity = [...initialExcludes, ...exclude].find(
       ({ url }) => url === routeOptions.path
     );

package.json

@@ -2,7 +2,7 @@
   "name": "fastify-enforce-schema",
   "url": "",
   "author": "Aleksandar Grbic - (https://programmer.network)",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Enforce AJV schemas across your endpoints.",
   "repository": {
     "type": "git",

test/enforce-schema.test.js

@@ -243,6 +243,52 @@ test("enforce should be disabled for excluded paths without excludedSchemas prop
   t.equal(res.payload, "exclude works");
 });
 
+test("enforce should be disabled for excluded paths via excludeOnFalseSchema option directly on schema", async (t) => {
+  t.plan(2);
+
+  const fastify = Fastify();
+
+  await fastify.register(enforceSchema, {
+    required: ["response"],
+    excludeOnFalseSchema: true,
+  });
+
+  fastify.get("/foo", { schema: false }, (req, reply) => {
+    reply.code(200).send("exclude works");
+  });
+
+  const res = await fastify.inject({
+    method: "GET",
+    url: "/foo",
+  });
+
+  t.equal(res.statusCode, 200);
+  t.equal(res.payload, "exclude works");
+});
+
+test("enforce should be disabled for excluded paths via excludeOnFalseSchema option directly on schema.response", async (t) => {
+  t.plan(2);
+
+  const fastify = Fastify();
+
+  await fastify.register(enforceSchema, {
+    required: ["response"],
+    excludeOnFalseSchema: true,
+  });
+
+  fastify.get("/foo", { schema: { response: false } }, (req, reply) => {
+    reply.code(200).send("exclude works");
+  });
+
+  const res = await fastify.inject({
+    method: "GET",
+    url: "/foo",
+  });
+
+  t.equal(res.statusCode, 200);
+  t.equal(res.payload, "exclude works");
+});
+
 test("enforce should be disabled at the body schema", async t => {
   t.plan(2);
 
@@ -273,3 +319,42 @@ test("enforce should be disabled at the body schema", async t => {
   t.equal(res.statusCode, 200);
   t.equal(res.payload, "body schema excluded for /foo");
 });
+
+test("No http status codes set in schema for required schema type", async (t) => {
+  t.plan(1);
+
+  const fastify = Fastify();
+
+  await fastify.register(enforceSchema, {
+    required: ["response"],
+  });
+
+  try {
+    fastify.get("/foo", { schema: { response: {} } }, (req, reply) => {
+      reply.code(200).send("exclude works");
+    });
+  } catch (err) {
+    t.equal(
+      err.message,
+      "No HTTP status codes provided in the response schema"
+    );
+  }
+});
+
+test("Http status code outside support set in schema for required schema type", async (t) => {
+  t.plan(1);
+
+  const fastify = Fastify();
+
+  await fastify.register(enforceSchema, {
+    required: ["response"],
+  });
+
+  try {
+    fastify.get("/foo", { schema: { response: { 600: {} } } }, (req, reply) => {
+      reply.code(200).send("exclude works");
+    });
+  } catch (err) {
+    t.equal(err.message, "HTTP status codes from 100 - 599 supported");
+  }
+});