oas-normalize

What is oas-normalize?

The oas-normalize npm package is designed to help developers work with OpenAPI Specification (OAS) documents. It provides functionalities to normalize, validate, and convert OAS documents, making it easier to handle different versions and formats of API specifications.

What are oas-normalize's main functionalities?

Normalization

This feature allows you to normalize an OpenAPI Specification document. The code sample demonstrates how to create an instance of OASNormalize with a path to an OAS file and validate it.

const OASNormalize = require('oas-normalize');
const oas = new OASNormalize('path/to/oas/file');
oas.validate().then(() => {
  console.log('OAS is valid');
}).catch(err => {
  console.error('OAS is invalid', err);
});

Conversion

This feature allows you to convert an OAS document to a different version or format. The code sample shows how to convert an OAS document and log the converted document.

const OASNormalize = require('oas-normalize');
const oas = new OASNormalize('path/to/oas/file');
oas.convert().then(convertedOAS => {
  console.log('Converted OAS:', convertedOAS);
}).catch(err => {
  console.error('Conversion failed', err);
});

Dereferencing

This feature allows you to dereference an OAS document, resolving all $ref pointers. The code sample demonstrates how to dereference an OAS document and log the dereferenced document.

const OASNormalize = require('oas-normalize');
const oas = new OASNormalize('path/to/oas/file');
oas.dereference().then(dereferencedOAS => {
  console.log('Dereferenced OAS:', dereferencedOAS);
}).catch(err => {
  console.error('Dereferencing failed', err);
});

Other packages similar to oas-normalize

swagger-parser

Swagger Parser is a powerful tool for parsing, validating, and dereferencing Swagger and OpenAPI documents. It offers similar functionalities to oas-normalize, such as validation and dereferencing, but also includes additional features like bundling multiple files into a single OAS document.

openapi-schema-validator

OpenAPI Schema Validator is a package focused on validating OpenAPI documents against the OpenAPI Specification. While it does not offer normalization or conversion features, it provides robust validation capabilities, making it a good choice for ensuring OAS compliance.

swagger-client

Swagger Client is a JavaScript client for Swagger and OpenAPI documents. It provides functionalities for parsing, validating, and interacting with OAS documents. Compared to oas-normalize, it offers more features for interacting with APIs defined by OAS documents, such as making HTTP requests.

README

Tooling for converting, valiating, and parsing OpenAPI, Swagger, and Postman API definitions

Installation

npm install oas-normalize

Usage

import OASNormalize from 'oas-normalize';
// const { default: OASNormalize } = require('oas-normalize'); // If you're using CJS.

const oas = new OASNormalize(
  'https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore-expanded.yaml'
  // ...or a string, path, JSON blob, whatever you've got.
);

oas
  .validate()
  .then(definition => {
    // Definition will always be JSON, and valid.
    console.log(definition);
  })
  .catch(err => {
    console.log(err);
  });

#bundle()

Note

Because Postman collections don't support $ref pointers, this method will automatically upconvert a Postman collection to OpenAPI if supplied one.

Bundle up the given API definition, resolving any external $ref pointers in the process.

await oas.bundle().then(definition => {
  console.log(definition);
});

#deref()

Note

Because Postman collections don't support $ref pointers, this method will automatically upconvert a Postman collection to OpenAPI if supplied one.

Dereference the given API definition, resolving all $ref pointers in the process.

await oas.deref().then(definition => {
  console.log(definition);
});

#validate({ convertToLatest?: boolean })

Validate and optionally convert to OpenAPI, a given API definition. This supports Swagger 2.0, OpenAPI 3.x API definitions as well as Postman 2.x collections.

Please note that if you've supplied a Postman collection to the library it will always be converted to OpenAPI, using postman-to-openapi, and we will only validate resulting OpenAPI definition.

await oas.validate().then(definition => {
  console.log(definition);
});

Options

Option	Type	Description
convertToLatest	Boolean	By default #validate will not upconvert Swagger API definitions to OpenAPI so if you wish for this to happen, supply true.

Error Handling

For validation errors, when available, you'll get back an object:

{
  "details": [
    // Ajv pathing errors. For example:
    /* {
      "instancePath": "/components/securitySchemes/tlsAuth",
      "schemaPath": "#/properties/securitySchemes/patternProperties/%5E%5Ba-zA-Z0-9%5C.%5C-_%5D%2B%24/oneOf",
      "keyword": "oneOf",
      "params": { "passingSchemas": null },
      "message": "must match exactly one schema in oneOf"
    }, */
  ]
}

message is almost always there, but path is less dependable.

#version()

Load and retrieve version information about a supplied API definition.

await oas.version().then(({ specification, version }) => {
  console.log(specification); // openapi
  console.log(version); // 3.1.0
});

Options

Enable local paths

For security reasons, you need to opt into allowing fetching by a local path. To enable it supply the enablePaths option to the class instance:

const oas = new OASNormalize('./petstore.json', { enablePaths: true });

Colorized errors

If you wish errors from .validate() to be styled and colorized, supply colorizeErrors: true to your instance of OASNormalize:

const oas = new OASNormalize('https://example.com/petstore.json', {
  colorizeErrors: true,
});

Error messages will look like such: