npm

Need private packages and team management tools?Check out npm Orgs. »

express-openapi-validate

0.4.4 • Public • Published

express-openapi-validate

Build Status Coverage Status npm version Try on RunKit

Express middleware to validate requests based on an OpenAPI 3.0 document. OpenAPI specification was called the Swagger specification before version 3.

Usage

Install this package with npm or yarn:

npm install --save express-openapi-validate
# or 
yarn add express-openapi-validate

Then use the validator like this:

index.js

const fs = require("fs");
const express = require("express");
const { OpenApiValidator } = require("express-openapi-validate");
const jsYaml = require("js-yaml");
 
const app = express();
app.use(express.json());
 
const openApiDocument = jsYaml.safeLoad(
  fs.readFileSync("openapi.yaml", "utf-8")
);
const validator = new OpenApiValidator(openApiDocument);
 
app.post("/echo", validator.validate("post", "/echo"), (req, res, next) => {
  res.json({ output: req.body.input });
});
 
app.use((err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    error: {
      name: err.name,
      message: err.message,
      data: err.data,
    },
  });
});
 
const server = app.listen(3000, () => {
  console.log("Listening on", server.address());
});

openapi.yaml

openapi: 3.0.1
info:
  title: Example API with a single echo endpoint
  version: 1.0.0
components:
  schemas:
    Error:
      type: object
      properties:
        error:
          type: object
          properties:
            name:
              type: string
            message:
              type: string
            data:
              type: array
              items:
                type: object
          required:
            - name
            - message
      required:
        - error
  responses:
    error:
      description: Default error response with error object
      content:
        application/json:
          schema:
            $ref: "#/components/schemas/Error"
paths:
  /echo:
    post:
      description: Echo input back
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                input:
                  type: string
              required:
                - input
      responses:
        "200":
          description: Echoed input
          content:
            application/json:
              schema:
                type: object
                properties:
                  output:
                    type: string
        default:
          $ref: "#/components/responses/error"

Supported features

Currently unsupported features

Public API

class OpenApiValidator

const { OpenApiValidator } = require("express-openapi-validate");

The main class of this package. Creates JSON schema validators for the given operations defined in the OpenAPI document. In the background Ajv is used to validate the request.

constructor(openApiDocument: OpenApiDocument, options: ValidatorConfig = {}))

Creates a new validator for the given OpenAPI document.

options parameter is optional. It has the following optional fields:

{
  ajvOptions: Ajv.Options;
}

You can find the list of options accepted by Ajv from its documentation. The formats object passed to Ajv will be merged with additional OpenAPI formats supported by this library.

validate(method: Operation, path: string): RequestHandler

Returns an express middleware function for the given operation. The operation matching the given method and path has to be defined in the OpenAPI document or this method throws.

The middleware validates the incoming request according to the parameters and requestBody fields defined in the Operation Object. If the validation fails the next express function is called with an ValidationError.

See the Parameter Object and Request Body Object sections of the OpenAPI specification for details how to define schemas for operations.

method must be one of the valid operations of an OpenAPI Path Item Object: "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace".

RequestHandler is an express middleware function with the signature (req: Request, res: Response, next: NextFunction): any;.

validateResponse(method: Operation, path: string): (res: any) => void

Creates a function for the given operation that can be used to validate responses. Response validation is meant to be used in tests and not in production code. See below for example usage.

For documentation of the method and path parameters see validate.

res is expected to have the shape { statusCode: number, body: {}, headers: {}}. The statusCode field can also be called status and the body field can be called data. This means that response objects from most request libraries should work out of the box.

If validation fails the validation function throws a ValidationError. Otherwise it returns undefined.

Example usage when using Jest and SuperTest:

import { OpenApiValidator } from "express-openapi-validate";
import fs from "fs";
import jsYaml from "js-yaml";
import request from "supertest";
import app from "./app";
 
const openApiDocument = jsYaml.safeLoad(
  fs.readFileSync("openapi.yaml", "utf-8")
);
const validator = new OpenApiValidator(openApiDocument);
 
test("/echo responses", async () => {
  const validateResponse = validator.validateResponse("post", "/echo");
  let res = await request(app)
    .post("/echo")
    .send({});
  expect(validateResponse(res)).toBeUndefined();
 
  res = await request(app)
    .post("/echo")
    .send({ input: "Hello!" });
  expect(validateResponse(res)).toBeUndefined();
});

class ValidationError extends Error

const { ValidationError } = require("express-openapi-validate");

This error is thrown by OpenApiValidator#validate when the request validation fails. It contains useful information about why the validation failed in human-readable format in the .message field and in machine-readable format in the .data array.

You can catch this error in your express error handler and handle it specially. You probably want to log the validation error and pass the errors to the client.

message: string

Human-readable error message about why the validation failed.

statusCode: number = 400

This field is always set to 400. You can check this field in your express error handler to decide what status code to send to the client when errors happen.

data: ErrorObject[]

Machine-readable array of validation errors. Ajv Error Objects documentation contains a list of the fields in ErrorObject.

install

npm i express-openapi-validate

Downloadsweekly downloads

5,680

version

0.4.4

license

Apache-2.0

homepage

github.com

repository

Gitgithub

last publish

collaborators

  • avatar
Report a vulnerability