Merge pull request #8 from wework/json-schema-walker

Use JSON Schema Walker

Author: Phil Sturgeon

.circleci/config.yml

@@ -0,0 +1,52 @@
+version: 2
+shared: &shared
+    docker:
+        - image: circleci/node:latest
+    steps:
+        - checkout
+        - restore_cache:
+            key: dependency-cache-{{ checksum "package.json" }}
+        - run:
+            name: Update npm
+            command: 'sudo npm install -g npm@latest'
+        - run:
+            name: Install npm dependencies
+            command: npm install
+        - save_cache:
+            key: dependency-cache-{{ checksum "package.json" }}
+            paths:
+              - node_modules
+        - run:
+            name: Tests
+            command: npm test
+        # - run:
+        #    name: Report Coverage
+        #    command: npm run coverage
+
+jobs:
+    node-latest:
+        <<: *shared
+
+    node-10:
+        docker:
+            - image: circleci/node:10
+        <<: *shared
+
+    node-9:
+        docker:
+            - image: circleci/node:9
+        <<: *shared
+
+    node-8:
+        docker:
+            - image: circleci/node:8
+        <<: *shared
+
+workflows:
+    version: 2
+    commit:
+        jobs:
+            - node-latest
+            - node-10
+            - node-9
+            - node-8

README.md

@@ -1,4 +1,4 @@
-# JSON Schema to OpenAPI Schema 
+# JSON Schema to OpenAPI Schema
 
 A little NodeJS package to convert JSON Schema to [OpenAPI Schema Objects](https://swagger.io/specification/#schemaObject).
 
@@ -72,11 +72,11 @@ _† Draft v5 is also known as Draft Wright 00, as the drafts are often named af
 
 ## TODO
 
-- [ ] Support later JSON Schema drafts through a yet-to-be-released json-schema-migrator package
+- [ ] Support later JSON Schema drafts via [cloudflare/json-schema-transformer] when it adds that functionality
 
 ## Converting Back
 
-To convert the other way, check out [openapi-schema-to-json-schema](https://github.com/mikunn/openapi-schema-to-json-schema), which this package was based on.
+To convert the other way, check out [openapi-schema-to-json-schema], which this package was based on.
 
 **NOTE**: `$ref`s are not dereferenced. Use a dereferencer such as [json-schema-ref-parser](https://www.npmjs.com/package/json-schema-ref-parser) prior to using this package.
 
@@ -98,3 +98,5 @@ npm test
 [mikunn]: https://github.com/mikunn
 [Phil Sturgeon]: https://github.com/philsturgeon
 [openapi-schema-to-json-schema]: https://github.com/mikunn/openapi-schema-to-json-schema
+[link-contributors]: https://github.com/wework/json-schema-to-openapi-schema/graphs/contributors
+[cloudflare/json-schema-transformer]: https://github.com/cloudflare/json-schema-tools/blob/master/workspaces/json-schema-transform/README.md

index.js

@@ -1,4 +1,4 @@
-const structs = ['allOf', 'anyOf', 'oneOf', 'not', 'items', 'additionalProperties'];
+const schemaWalker = require('@cloudflare/json-schema-walker');
 
 function InvalidTypeError(message) {
 	this.name = 'InvalidTypeError';
@@ -7,61 +7,27 @@ function InvalidTypeError(message) {
 
 InvalidTypeError.prototype = new Error();
 
-function convert(schema, options) {
-	options = options || {};
-	options.cloneSchema = ! (options.cloneSchema === false);
+function convert(schema, options = {}) {
+	const { cloneSchema = true } = options;
 
-	if (options.cloneSchema) {
+	if (cloneSchema) {
 		schema = JSON.parse(JSON.stringify(schema));
 	}
 
-	schema = removeRootKeywords(schema);
-	schema = convertSchema(schema);
-
+	const vocab = schemaWalker.getVocabulary(schema, schemaWalker.vocabularies.DRAFT_04);
+	schemaWalker.schemaWalk(schema, convertSchema, null, vocab);
 	return schema;
 }
 
-function removeRootKeywords(schema) {
+function stripIllegalKeywords(schema) {
 	delete schema['$schema'];
+	delete schema['$id'];
 	delete schema['id'];
 	return schema;
 }
 
-function convertSchema(schema) {
-	let i = 0;
-	let j = 0;
-	let struct = null;
-
-	for (i; i < structs.length; i++) {
-		struct = structs[i];
-
-		if (Array.isArray(schema[struct])) {
-			for (j; j < schema[struct].length; j++) {
-				schema[struct][j] = convertSchema(schema[struct][j]);
-			}
-		} else if (typeof schema[struct] === 'object') {
-			schema[struct] = convertSchema(schema[struct]);
-		}
-	}
-
-	if (typeof schema.properties === 'object') {
-		schema.properties = convertProperties(schema.properties);
-
-		if (Array.isArray(schema.required)) {
-			schema.required = cleanRequired(schema.required, schema.properties);
-
-			if (schema.required.length === 0) {
-				delete schema.required;
-			}
-		}
-		if (Object.keys(schema.properties).length === 0) {
-			delete schema.properties;
-		}
-
-	}
-
-	validateType(schema.type);
-
+function convertSchema(schema, path, parent, parentPath) {
+	schema = stripIllegalKeywords(schema);
 	schema = convertTypes(schema);
 	schema = convertDependencies(schema);
 
@@ -81,19 +47,6 @@ function validateType(type) {
 	});
 }
 
-function convertProperties(properties) {
-	let key = {};
-	let property = {};
-	let props = {};
-
-	for (key in properties) {
-		property = properties[key];
-		props[key] = convertSchema(property);
-	}
-
-	return props;
-}
-
 function convertDependencies(schema) {
 	const deps = schema.dependencies;
 	if (typeof deps !== 'object') {
@@ -140,38 +93,40 @@ function convertDependencies(schema) {
 }
 
 function convertTypes(schema) {
-	var newType;
-
 	if (schema.type === undefined) {
 		return schema;
 	}
 
-	// type needs to be a string, not an array
-	if (schema.type instanceof Array && schema.type.includes('null')) {
-		var numTypes = schema.type.length;
+	validateType(schema.type);
 
-		schema.nullable = true;
+	if (Array.isArray(schema.type)) {
 
-		// if it was just type: ['null'] for some reason
-		switch (numTypes) {
-			case 1:
-				// Didn't know what else to do
-				newType = 'string';
+		if (schema.type.length > 2 || !schema.type.includes('null')) {
+			throw new Error('Type of ' + schema.type.join(',') + ' is too confusing for OpenAPI to understand. Found in ' + JSON.stringify(schema));
+		}
+
+		switch (schema.type.length) {
+			case 0:
+				delete schema.type;
 				break;
 
-			case 2:
-				newType = schema.type.find(function(element) {
-					return element !== 'null';
-				});
+			case 1:
+				if (schema.type === 'null') {
+					schema.nullable = true;
+				}
+				else {
+					schema.type = schema.type[0];
+				}
 				break;
 
 			default:
-				throw 'type cannot be an array, and you have ' + numTypes + ' types';
+				schema.type = schema.type.find(type => type !== 'null');
+				schema.nullable = true;
 		}
 	}
-
-	if (newType) {
-		schema.type = newType;
+	else if (schema.type === 'null') {
+		delete schema.type;
+		schema.nullable = true;
 	}
 
 	return schema;
@@ -185,19 +140,4 @@ function convertPatternProperties(schema) {
 	return schema;
 }
 
-function cleanRequired(required, properties) {
-	var i = 0;
-
-	required = required || [];
-	properties = properties || {};
-
-	for (i; i < required.length; i++) {
-		if (properties[required[i]] === undefined) {
-			required.splice(i, 1);
-		}
-	}
-
-	return required;
-}
-
 module.exports = convert;

package-lock.json

@@ -15,5 +15,8 @@
     "mocha": "^5.0.0",
     "nyc": "^11.6.0",
     "should": "^13.2.0"
+  },
+  "dependencies": {
+    "@cloudflare/json-schema-walker": "^0.1.1"
   }
 }

package.json

@@ -17,6 +17,26 @@ it('adds `nullable: true` for `type: [string, null]`', () => {
 	});
 });
 
+
+it('supports nullables inside sub-schemas', () => {
+	const schema = {
+		$schema: 'http://json-schema.org/draft-04/schema#',
+		oneOf: [
+			{ type: 'string' },
+			{ type: 'null' }
+		]
+	};
+
+	const result = convert(schema);
+
+	should(result).deepEqual({
+		oneOf: [
+			{ type: 'string' },
+			{ nullable: true }
+		]
+	});
+});
+
 it('does not add nullable for non null types', () => {
 	const schema = {
 		$schema: 'http://json-schema.org/draft-04/schema#',

test/nullable.test.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const convert = require('../');
+const should = require('should');
+
+it('strips $id from all subschemas not just root`', () => {
+	const schema = {
+    $id: "https://foo/bla",
+    $schema: "http://json-schema.org/draft-06/schema#",
+    type: "object",
+    properties: {
+      foo: {
+        $id: "/properties/foo",
+        type: "array",
+        items: {
+          $id: "/properties/foo/items",
+          type: "object",
+          properties: {
+            id: {
+              $id: "/properties/foo/items/properties/id",
+              type: "string",
+            }
+					}
+        }
+			}
+    }
+	};
+
+	const result = convert(schema);
+
+	should(result).deepEqual({
+    type: "object",
+    properties: {
+      foo: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+            }
+					}
+        }
+			}
+    }
+	});
+});