initial commit

Author: Mika Kunnas

.eslintrc.json

@@ -0,0 +1,25 @@
+{
+    "env": {
+        "node": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "indent": [
+            "error",
+            "tab",
+						{"SwitchCase": 1}
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+}

.gitignore

@@ -0,0 +1,2 @@
+*.swp
+node_modules

README.md

@@ -0,0 +1,89 @@
+# OpenAPI Schema to JSON Schema
+
+A little NodeJS package to convert OpenAPI Schema Object to JSON Schema. Currently converts from [OpenAPI 3.0](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md) to [JSON Schema Draft 4](http://json-schema.org/specification-links.html#draft-4).
+
+## Why?
+
+OpenAPI is a specification for describing RESTful APIs. OpenAPI 3.0 allows us to describe the structures of request and response payloads in a detailed manner. This would, theoretically, mean that we should be able to automatically validate request and response payloads. However, as of writing there aren't many validators around.
+
+The good news is that there are many validators for JSON Schema for different languages. The bad news is that OpenAPI 3.0 is not entirely compatible with JSON Schema. The Schema Object of OpenAPI 3.0 is an extended subset of JSON Schema Specification Wright Draft 00 with some differences.
+
+The purpose of this project is to fill the grap by doing the conversion between these two formats.
+
+## Features
+
+* converts OpenAPI 3.0 Schema Object to JSON Schema Draft 4
+* converts [common named data types](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#data-types) to `type` and `format`
+  * for example `type: "dateTime"` becomes `type: "string"` with `format: "date-time"`
+* deletes `nullable` and adds `"null"` to `type` array if `nullable` is `true`
+* supports deep structures with nested `allOf`s etc.
+* removes [OpenAPI specific properties](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#fixed-fields-20) such as `discriminator`, `deprecated` etc.
+
+**NOTE**: `$ref`s are not dereferenced. Use a dereferences such as [json-schema-ref-parser](https://www.npmjs.com/package/json-schema-ref-parser) prior to using this package.
+
+## Installation
+
+```
+npm install --save openapi-schema-to-json-schema
+```
+
+## Usage
+
+Here's a small example to get the idea:
+
+```js
+
+var toJsonSchema = require('openapi-schema-to-json-schema');
+
+var schema = {
+  type: 'dateTime',
+  nullable: true
+};
+
+var convertedSchema = toJsonSchema(schema);
+
+console.log(convertedSchema);
+```
+
+The example prints out
+
+```js
+{
+  type: ['string', 'null'],
+  format: 'date-time',
+  '$schema': 'http://json-schema.org/draft-04/schema#'
+}
+```
+
+Provide the function the schema object with possible options.
+
+### Options
+
+The function accepts `options` object as the second argument. Currently, the following options are supported:
+* `cloneSchema` (boolean)
+  * If set to `false`, converts the provided schema in place. If `true`, clones the schema by converting it to JSON and back. The overhead of the cloning is usually negligible. Defaults to `true`.
+* `dateToDateTime` (boolean)
+  * This is `false` by default and leaves `date` type/format as is. If set to `true`, sets `type: "string"` and `format: "date-time"` if
+    * `type: "string"` AND `format: "date"` OR
+	* `type: "date"`
+  * For example
+
+	```js
+	var schema = {
+	  type: 'date',
+	};
+
+	var convertedSchema = toJsonSchema(schema, {dateToDateTime: true});
+
+	console.log(convertedSchema);
+	```
+
+	prints 
+
+	```js
+	{
+	  type: 'string',
+	  format: 'date-time',
+	  '$schema': 'http://json-schema.org/draft-04/schema#'
+	}
+	```

index.js

@@ -0,0 +1,138 @@
+module.exports = convert;
+
+function convert(schema, options) {
+	options = options || {};
+	options.dateToDateTime = options.dateToDateTime || false;
+	options.cloneSchema = options.cloneSchema == false ? false : true;
+
+	options._structs = ['allOf', 'anyOf', 'oneOf', 'not', 'items', 'additionalProperties'];
+	options._notSupported = [
+		'nullable', 'discriminator', 'readOnly', 
+		'writeOnly', 'xml', 'externalDocs',
+		'example', 'deprecated'
+	];
+
+	if (options.cloneSchema) {
+		schema = JSON.parse(JSON.stringify(schema));
+	}
+
+	schema = convertSchema(schema, options);
+	schema['$schema'] = 'http://json-schema.org/draft-04/schema#';
+
+	return schema;
+}
+
+function convertSchema(schema, options) {
+	var arrays = options._structs
+		, notSupported = options._notSupported
+		, i = 0
+		, j = 0
+		, arr = null
+	;
+
+	for (i; i < arrays.length; i++) {
+		arr = arrays[i];
+
+		if (Array.isArray(schema[arr])) {
+			for (j; j < schema[arr].length; j++) {
+				schema[arr][j] = convertSchema(schema[arr][j], options);
+			}
+		} else if (typeof schema[arr] === 'object') {
+			schema[arr] = convertSchema(schema[arr], options);
+		}
+	}
+
+	if (typeof schema.properties === 'object') {
+		schema.properties = convertProperties(schema.properties, options);
+	}
+
+	schema = convertTypes(schema, options);
+
+	for (i=0; i < notSupported.length; i++) {
+		delete schema[notSupported[i]];
+	}
+
+	return schema;
+}
+
+function convertProperties(properties, options) {
+	var key;
+
+	for (key in properties) {
+		properties[key] = convertSchema(properties[key], options);
+	}
+
+	return properties;
+}
+
+function convertTypes(schema, options) {
+	var newType
+		, newFormat
+		, toDateTime = options.dateToDateTime
+	;
+
+	if (schema.type === undefined) {
+		return schema;
+	}
+
+	if (schema.type == 'string' && schema.format == 'date' && toDateTime === true) {
+		schema.format = 'date-time';
+	}
+
+	switch(schema.type) {
+		case 'integer':
+			newType = 'integer';
+			break;
+		case 'long':
+			newType = 'integer';
+			newFormat = 'int64';
+			break;
+		case 'float':
+			newType = 'number';
+			newFormat = 'float';
+			break;
+		case 'double':
+			newType = 'number';
+			newFormat = 'double';
+			break;
+		case 'byte':
+			newType = 'string';
+			newFormat = 'byte';
+			break;
+		case 'binary':
+			newType = 'string';
+			newFormat = 'binary';
+			break;
+		case 'date':
+			newType = 'string';
+			newFormat = 'date';
+			if (toDateTime === true) {
+				newFormat = 'date-time';
+			}
+			break;
+		case 'dateTime':
+			newType = 'string';
+			newFormat = 'date-time';
+			break;
+		case 'password':
+			newType = 'string';
+			newFormat = 'password';
+			break;
+		default:
+			newType = schema.type;
+	}
+
+	schema.type = newType;
+	schema.format = typeof newFormat === 'string' ? newFormat : schema.format;
+
+	if (! schema.format) {
+		delete schema.format;
+	}
+
+	if (schema.nullable === true) {
+		schema.type = [schema.type, 'null'];
+	}
+	
+	return schema;
+}
+