Swagger-Parser

Parses, validates, and dereferences JSON/YAML Swagger specs in Node and browsers

Live Demo!

Features

• Parses Swagger specs in JSON or YAML format
• Validates against the official Swagger 2.0 schema
• Dereferences all $ref pointers, including pointers to external files and URLs
• Asynchronously downloads and caches external files and URLs
• Tested in Node.js and all major web browsers on Windows, Mac, and Linux
• Tested on over 100 Google APIs
• Supports nested $ref pointers, even in external files and URLs
• Supports circular $ref pointers (see notes below)
• Multiple $ref pointers to the same object are resolved to the same object instance

Installation and Use

The syntax varies slightly depending on whether you're running it in Node.js or in a web browser. In all cases, you'll call the parse method, passing it the path/url of your Swagger spec and a callback function. The api parameter that's passed to the callback function is the parsed, validated, and dereferenced Swagger object.

Node

npm install swagger-parser

Then add this to your Node script:

var parser = require("swagger-parser");
parser.parse('swagger.yaml', function(err, api, metadata) {
  if (!err) {
    console.log("API name: %s, Version: %s", api.info.title, api.info.version);
  }
});

Bower

bower install swagger-parser

Then add this to your HTML page:

<script src="bower_components/swagger-parser/dist/swagger-parser.js"></script>
<script>
  swagger.parser.parse('http://mysite.com/swagger.yaml', function(err, api, metadata) {
    if (!err) {
      console.log("API name: " + api.info.title + ", Version: " + api.info.version);
    }
  });
</script>

AMD (Require.js)

Just add swagger-parser to your AMD module's dependencies, or require("swagger-parser") explicitly.

define("myModule", ["swagger-parser"], function(parser) {
  parser.parse('http://mysite.com/swagger.yaml', function(err, api, metadata) {
    if (!err) {
      console.log("API name: " + api.info.title + ", Version: " + api.info.version);
    }
  });
});

The API

Parser.parse(swaggerPath, [options], callback)

• swagger (required) - string or object
  The file path or URL of your Swagger file. Relative paths are allowed. In Node, the path is relative to process.cwd(). In the browser, it's relative to the URL of the page.
  
  If you pass an object instead of a string, then the parsing step will be skipped, but the object will still be validated, resolved, and dereferenced just like normal.

• options (optional) - object
  An object containing one or more parsing options. See options below.

• callback (required) - function(err, api, metadata)
  Called after the parsing is finished, or when an error occurs. See callback below for details.

Options

Property	Type	Default	Description
parseYaml	bool	true	Determines whether the parser will allow Swagger specs in YAML format. If set to false, then only JSON will be allowed.
dereference$Refs	bool	true	Determines whether $ref pointers in the Swagger API will be replaced with their resolved values. Different $ref pointers that resolve to the same object will be replaced with the same object instance. Setting this option to false will leave the $ref pointers in the Swagger API, but you can still access the resolved values using the metadata object.
resolve$Refs	bool	true	Determines whether $ref pointers will be resolved. Setting this option to false effectively disables dereference$Refs as well. The difference is that the metadata object won't be populated either.
resolveExternal$Refs	bool	true	Determines whether $ref pointers will be resolved if they point to external files or URLs. Internal $ref pointers will still be resolved and dereferenced.
validateSchema	bool	true	Determines whether your API will be validated against the official Swagger schema. If set to false, then the resulting Swagger object may be missing properties, have properties of the wrong data type, etc.
strictValidation	bool	true	Determines whether to perform strict validation, which enforces parts of the Swagger Spec that aren't enforced by the JSON schema. For example, duplicate parameters, invalid parameter types, etc.

Callback

Parameter	Type	Description
err	Error	null unless an error occurred.
api	Swagger object	The complete Swagger API object. Or null if an error occurred
metadata	object	This parameter provides extra information about the parsing operation. It is always provided, even if there's an error.

Metadata

The metadata parameter is an object with the following properties:

Property	Type	Description
baseDir	string	The base directory used to resolve any external $ref pointers. If you passed a file path/URL to the parse method, then the baseDir is the directory of that file. If you passed an object, then baseDir is set to process.cwd() in Node, or the URL of the current page in browsers.
files	array of strings	The full paths of all files that were parsed. This only includes local files, not URLs. If Parser.parse() was called with a local file path, then it will be the first item in this array.
urls	array of URL objects	The URLs that were parsed. If Parser.parse() was called with a URL, then it will be the first item in this array.
$refs	object	A map of all the $ref pointers that were resolved, and the objects they resolved to. If an error occurs while resolving a reference, then this object will still contain the $refs that were successfully parsed up to that point.

Circular $Refs

Swagger files can contain circular $ref pointers, and Swagger-Parser will correctly parse them, resolve their values, and validate them against the Swagger schema. However, Swagger-Parser does not dereference circular references because this can easily cause stack overflows when the Swagger object is serialized, as well as other, more subtle bugs.

If your Swagger API includes circular references, then the callback will receive a ReferenceError to alert you that the Swagger object was not fully dereferenced. However, you can choose to ignore this error and use the api parameter anyway. All non-circular $ref pointers in the Swagger object will still be resolved and dereferenced like always. Circular $ref pointers will not be dereferenced, but they will be resolved, so you can access their resolved values in metadata.$refs.

person:
  properties:
    name:
      type: string
    spouse:
      type:
        $ref: person   # circular reference

Command Line Interface (CLI)

Command line usage emulates the options in the API.

Installation

npm install swagger-parser -g

Usage

Usage: swagger-parser [options] <swaggerfile ...>

Options:

	-h, --help         output usage information
	-V, --version      output the version number
	-j, --json         Do not allow YAML, only JSON
	-m, --minify       Remove pretty formatting (ignores -s)
	-s, --spaces <n>   Number of spaces in prettification (default: 2)
	-nd, --noderef     Do not dereference $ref pointers
	-ne, --noexternal  Do not resolve external $ref pointers
	-nr, --noresolve   Do not resolve $ref pointers
	-ns, --nostrict    Do not do strict validation
	-nv, --novalidate  Do not validate schema

Contributing

I welcome any contributions, enhancements, and bug-fixes. File an issue on GitHub and submit a pull request. Just make sure you build the code and run the unit tests first.

Building/Testing

To build the project locally on your computer:

1. Clone this repo
   git clone https://github.com/BigstickCarpet/swagger-parser.git

2. Install dev dependencies
   npm install

3. Run the build script
   npm run build

4. Run unit tests
   npm test

License

Swagger-Parser is 100% free and open-source, under the MIT license. Use it however you want.