feat(oas3): support boolean additionalProperties

Author: kylef

packages/openapi3-parser/CHANGELOG.md

@@ -1,5 +1,11 @@
 # API Elements: OpenAPI 3 Parser Changelog
 
+## TBD
+
+### Enhancements
+
+- Support for 'Schema Object' `additionalProperties` when the value is boolean.
+
 ## 0.16.0 (2021-02-23)
 
 ### Enhancements

packages/openapi3-parser/lib/parser/oas/parseSchemaObject.js

@@ -6,7 +6,7 @@ const {
 } = require('../annotations');
 const pipeParseResult = require('../../pipeParseResult');
 const {
-  isArray, isString, hasKey, getValue,
+  isArray, isBoolean, isString, isObject, hasKey, getValue,
 } = require('../../predicates');
 const parseObject = require('../parseObject');
 const parseArray = require('../parseArray');
@@ -43,7 +43,7 @@ const unsupportedJSONSchemaDraft202012 = [
   'prefixItems', 'unevaluatedItems', 'contains', 'minContains', 'maxContains',
 
   // Object
-  'propertiesNames', 'unevaluatedProperties', 'dependentRequired',
+  'propertyNames', 'unevaluatedProperties', 'dependentRequired',
 ];
 const isUnsupportedKey = R.anyPass(R.map(hasKey, unsupportedKeys));
 const isUnsupportedKeyJSONSchemaDraft202012 = R.anyPass(
@@ -71,6 +71,11 @@ function constructObjectStructure(namespace, schema) {
       .forEach(member => member.attributes.set('typeAttributes', ['required']));
   }
 
+  const additionalProperties = schema.get('additionalProperties');
+  if (additionalProperties && additionalProperties.toValue() === false) {
+    element.attributes.set('typeAttributes', ['fixedType']);
+  }
+
   return element;
 }
 
@@ -305,6 +310,11 @@ function parseSchema(context) {
 
   const parseSubSchema = element => parseReference('schemas', R.uncurryN(2, parseSchema), context, element, true);
   const parseProperties = parseObject(context, `${name}' 'properties`, R.compose(parseSubSchema, getValue));
+  const parseAdditionalProperties = R.cond([
+    [isBoolean, R.identity],
+    [isObject, createWarning(namespace, `'${name}' 'additionalProperties' containing a Schema Object is currently unsupported`)],
+    [R.T, createWarning(namespace, `'${name}' 'additionalProperties' must be a boolean value, or a Schema Object`)],
+  ]);
 
   const parseRequiredString = R.unless(isString,
     createWarning(namespace, `'${name}' 'required' array value is not a string`));
@@ -334,6 +344,7 @@ function parseSchema(context) {
     [hasKey('type'), R.compose(parseType(context), getValue)],
     [hasKey('enum'), R.compose(parseEnum(context, name), getValue)],
     [hasKey('properties'), R.compose(parseProperties, getValue)],
+    [hasKey('additionalProperties'), R.compose(parseAdditionalProperties, getValue)],
     [hasKey('items'), R.compose(parseSubSchema, getValue)],
     [hasKey('required'), R.compose(parseRequired, getValue)],
     [hasKey('nullable'), parseNullable],

packages/openapi3-parser/test/unit/parser/oas/parseSchemaObject-test.js

@@ -665,6 +665,75 @@ describe('Schema Object', () => {
     });
   });
 
+  describe('#additionalProperties', () => {
+    it('warns when additionalProperties is not boolean or object', () => {
+      const schema = new namespace.elements.Object({
+        type: 'object',
+        additionalProperties: 5,
+      });
+      const parseResult = parse(context, schema);
+
+      expect(parseResult.length).to.equal(2);
+      expect(parseResult).to.contain.warning(
+        "'Schema Object' 'additionalProperties' must be a boolean value, or a Schema Object"
+      );
+    });
+
+    it('warns when additionalProperties is an object', () => {
+      const schema = new namespace.elements.Object({
+        type: 'object',
+        additionalProperties: {},
+      });
+      const parseResult = parse(context, schema);
+
+      expect(parseResult.length).to.equal(2);
+      expect(parseResult).to.contain.warning(
+        "'Schema Object' 'additionalProperties' containing a Schema Object is currently unsupported"
+      );
+    });
+
+    it('defaults additionalProperties to true', () => {
+      const schema = new namespace.elements.Object({
+        type: 'object',
+      });
+      const parseResult = parse(context, schema);
+
+      expect(parseResult.length).to.equal(1);
+      const object = parseResult.get(0).content;
+      expect(object).to.be.instanceof(namespace.elements.Object);
+      expect(object.length).to.equal(0);
+      expect(object.attributes.getValue('typeAttributes')).to.be.undefined;
+    });
+
+    it('supports additionalProperties as true', () => {
+      const schema = new namespace.elements.Object({
+        type: 'object',
+        additionalProperties: true,
+      });
+      const parseResult = parse(context, schema);
+
+      expect(parseResult.length).to.equal(1);
+      const object = parseResult.get(0).content;
+      expect(object).to.be.instanceof(namespace.elements.Object);
+      expect(object.length).to.equal(0);
+      expect(object.attributes.getValue('typeAttributes')).to.be.undefined;
+    });
+
+    it('supports additionalProperties as false', () => {
+      const schema = new namespace.elements.Object({
+        type: 'object',
+        additionalProperties: false,
+      });
+      const parseResult = parse(context, schema);
+
+      expect(parseResult.length).to.equal(1);
+      const object = parseResult.get(0).content;
+      expect(object).to.be.instanceof(namespace.elements.Object);
+      expect(object.length).to.equal(0);
+      expect(object.attributes.getValue('typeAttributes')).to.deep.equal(['fixedType']);
+    });
+  });
+
   describe('#items', () => {
     it('warns when items is not an object', () => {
       const schema = new namespace.elements.Object({