fix(oas3): error out when parsing components using reserved elements

Author: kylef

packages/openapi3-parser/CHANGELOG.md

@@ -1,5 +1,15 @@
 # API Elements: OpenAPI 3 Parser Changelog
 
+## 0.14.2 (2020-07-20)
+
+### Bug Fixes
+
+- Prevents the parser from throwing an unhandled error while parsing components
+  which use keys which are the same as an [API Element type
+  identifier](https://apielements.org/en/latest/element-definitions.html). The
+  parser will now produce a handled error mentioning that these keys are
+  reserved and currently unsupported in the parser.
+
 ## 0.14.1 (2020-07-01)
 
 ### Enhancements

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

@@ -1,8 +1,9 @@
 const R = require('ramda');
 const {
-  isObject, isAnnotation, hasKey, isExtension, getValue,
+  isObject, isAnnotation, hasKey, isExtension, getKey, getValue,
 } = require('../../predicates');
 const {
+  createError,
   createWarning,
   createUnsupportedMemberWarning,
   createInvalidMemberWarning,
@@ -134,8 +135,21 @@ function parseComponentsObject(context, element) {
   const parseComponentObjectMember = R.curry((parser, member) => {
     const component = member.key.toValue();
 
+    const createKeyIsReservedError = key => createError(
+      namespace,
+      `'${name}' '${component}' contains a reserved key '${key.toValue()}' which is not currently supported by this parser`,
+      key
+    );
+    const isReservedKey = key => namespace.elementMap[key.toValue()] !== undefined;
+    const validateKeyIsNotReservedKey = R.when(
+      R.compose(isReservedKey, getKey),
+      R.compose(createKeyIsReservedError, getKey)
+    );
+
     const parseMember = parseComponentMember(context, parser);
-    const parseMemberOrRef = m => parseReference(component, () => parseMember(m), context, m.value, false, true);
+    const parseMemberOrRef = pipeParseResult(namespace,
+      validateKeyIsNotReservedKey,
+      m => parseReference(component, () => parseMember(m), context, m.value, false, true));
 
     return pipeParseResult(context.namespace,
       validateIsObject,

packages/openapi3-parser/lib/parser/parseObject.js

@@ -13,24 +13,29 @@ const pipeParseResult = require('../pipeParseResult');
  */
 const isAnnotationOrMember = R.anyPass([isAnnotation, isMember]);
 
+const parseResultHasErrors = parseResult => !parseResult.errors.isEmpty;
+
+
 /**
  * Transform every non-annotation element in the parse result and then flatten all of the results into a parse result
  * @param transform {function}
  * @param parseResult {ParseResult}
  * @private
  */
 const chainParseResult = R.curry((transform, parseResult) => {
+  if (parseResultHasErrors(parseResult)) {
+    return parseResult;
+  }
+
   const result = R.chain(transform, parseResult);
 
-  if (!result.errors.isEmpty) {
+  if (parseResultHasErrors(result)) {
     return new parseResult.constructor(result.errors);
   }
 
   return result;
 });
 
-const parseResultHasErrors = parseResult => !parseResult.errors.isEmpty;
-
 // FIXME Can be simplified once https://github.com/refractproject/minim/issues/201 is completed
 const hasMember = R.curry((object, key) => {
   const findKey = R.allPass([isMember, member => member.key.toValue() === key]);
@@ -145,13 +150,25 @@ function parseObject(context, name, parseMember, requiredKeys = [], orderedKeys
     wrapObjectInParseResult,
     (value) => {
       // pre-parse the ordered keys in order
+      let errors = null;
+
       orderedKeys.forEach((key) => {
         const isOrderedKey = R.allPass([isMember, m => m.key.equals(key)]);
         const member = R.filter(isOrderedKey, value).get(0);
         if (member) {
-          member.value = parseMember(member);
+          const parseResult = parseMember(member);
+          member.value = parseResult;
+
+          if (parseResultHasErrors(parseResult)) {
+            ({ errors } = parseResult);
+          }
         }
       });
+
+      if (errors) {
+        return new namespace.elements.ParseResult(errors.elements);
+      }
+
       return value;
     },
     chainParseResult(transformMember),

packages/openapi3-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apielements/openapi3-parser",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Open API Specification 3 API Elements Parser",
   "author": "Apiary.io <support@apiary.io>",
   "license": "MIT",

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

@@ -20,6 +20,20 @@ describe('Components Object', () => {
     expect(parseResult).to.contain.warning("'Components Object' is not an object");
   });
 
+  it('provides an error when a reusable component is named after an element', () => {
+    const components = new namespace.elements.Object({
+      schemas: {
+        member: {},
+      },
+    });
+
+    const parseResult = parse(context, components);
+
+    expect(parseResult).to.contain.error(
+      "'Components Object' 'schemas' contains a reserved key 'member' which is not currently supported by this parser"
+    );
+  });
+
   describe('#schemas', () => {
     it('provides a warning when schemas is non-object', () => {
       const components = new namespace.elements.Object({