Handle pre-parsing object members in parseObject

packages/fury-adapter-oas3-parser/lib/parser/oas/parseComponentsObject.js

@@ -109,15 +109,19 @@ function parseComponentsObject(context, element) {
    * @param parser {function}
    * @param member {Member}
    *
-   * @returns ParseResult
+   * @returns ParseResult<ObjectElement>
    * @private
    */
   const parseComponentObjectMember = (parser) => {
     const parseMember = parseComponentMember(context, parser);
 
-    return pipeParseResult(context.namespace,
+    return member => pipeParseResult(context.namespace,
       validateIsObject,
-      R.compose(parseObject(context, name, parseMember), getValue));
+      R.compose(parseObject(context, name, parseMember), getValue),
+      (object) => {
+        context.state.components.push(new namespace.elements.Member(member.key, object));
+        return object;
+      })(member);
   };
 
   const setDataStructureId = (dataStructure, key) => {

packages/fury-adapter-oas3-parser/lib/parser/oas/parseOpenAPIObject.js

@@ -106,22 +106,11 @@ function parseOASObject(context, object) {
     return new namespace.elements.ParseResult([array].concat(parseResult.annotations.elements));
   };
 
-  // Pre-parse 'components', this needs to be done first since other
-  // structures can reference it.
-  let components = object.get('components');
-  if (components) {
-    components = parseComponentsObject(context, components);
-    object.set('components', components);
-
-    // eslint-disable-next-line no-param-reassign
-    context.state.components = components.reject(isAnnotation).get(0);
-  }
-
   const parseMember = R.cond([
     [hasKey('openapi'), parseOpenAPI(context)],
     [hasKey('info'), R.compose(parseInfoObject(context), getValue)],
     [hasKey('paths'), R.compose(asArray, parsePathsObject(context), getValue)],
-    [hasKey('components'), getValue],
+    [hasKey('components'), R.compose(parseComponentsObject(context), getValue)],
 
     // FIXME Support exposing extensions into parse result
     [isExtension, () => new namespace.elements.ParseResult()],
@@ -133,7 +122,7 @@ function parseOASObject(context, object) {
   ]);
 
   const parseOASObject = pipeParseResult(namespace,
-    parseObject(context, name, parseMember, requiredKeys),
+    parseObject(context, name, parseMember, requiredKeys, ['components']),
     (object) => {
       const api = object.get('info');
 

packages/fury-adapter-oas3-parser/lib/parser/oas/parseSecuritySchemeObject.js

@@ -60,7 +60,7 @@ function validateApiKeyScheme(context, securityScheme) {
     [R.T, e => e],
   ]);
 
-  return parseObject(context, name, parseMember, ['name', 'in'], true)(securityScheme);
+  return parseObject(context, name, parseMember, ['name', 'in'], [], true)(securityScheme);
 }
 
 function validateHttpScheme(context, securityScheme) {
@@ -70,7 +70,7 @@ function validateHttpScheme(context, securityScheme) {
     [R.T, e => e],
   ]);
 
-  return parseObject(context, name, parseMember, ['scheme'], true)(securityScheme);
+  return parseObject(context, name, parseMember, ['scheme'], [], true)(securityScheme);
 }
 
 /**
@@ -116,7 +116,7 @@ function parseSecuritySchemeObject(context, object) {
   ]);
 
   const parseSecurityScheme = pipeParseResult(namespace,
-    parseObject(context, name, parseMember, requiredKeys, true),
+    parseObject(context, name, parseMember, requiredKeys, [], true),
     R.when(isApiKeyScheme, R.curry(validateApiKeyScheme)(context)),
     R.when(isHttpScheme, R.curry(validateHttpScheme)(context)),
     (securityScheme) => {

packages/fury-adapter-oas3-parser/lib/parser/parseObject.js

@@ -1,6 +1,6 @@
 const R = require('ramda');
 const {
-  isAnnotation, isMember, isParseResult, isObject,
+  isAnnotation, isMember, isParseResult, isObject, getValue,
 } = require('../predicates');
 const { createError, createWarning } = require('./annotations');
 const pipeParseResult = require('../pipeParseResult');
@@ -97,13 +97,13 @@ const validateObjectContainsRequiredKeysNoError = R.curry((namespace, requiredKe
  * @param name {string} - The human readable name of the element. Used for annotation messages.
  * @param transform {transformMember} - The callback to transform a member
  * @param requiredKeys {string[]} - The callback to transform a member
+ * @param orderedKeys {string[]} - An ordered list of keys which should be parsed first - This is useful when some keys depend on others. All non-ordered keys past last in user-defined order.
  * @param sendWarning {boolean}
  * @param object {ObjectElement} - The object containing members to transform
- *
  * @returns {ParseResult<ObjectElement>}
  * @private
  */
-function parseObject(context, name, parseMember, requiredKeys = [], sendWarning = false) {
+function parseObject(context, name, parseMember, requiredKeys = [], orderedKeys = [], sendWarning = false) {
   const { namespace } = context;
 
   // Create a member from a key and value
@@ -120,8 +120,9 @@ function parseObject(context, name, parseMember, requiredKeys = [], sendWarning
   // values in the parse result that are not annotations or a member
   // into a member using the same key as provided
   const transformMember = (member) => {
+    const transformUnlessParseResult = R.ifElse(R.compose(isParseResult, getValue), getValue, transform);
     const coerceMember = (R.unless(isAnnotationOrMember, createMember(member.key)));
-    return R.map(coerceMember, transform(member));
+    return R.map(coerceMember, transformUnlessParseResult(member));
   };
 
   /**
@@ -140,11 +141,22 @@ function parseObject(context, name, parseMember, requiredKeys = [], sendWarning
   // Create a parse result from an object using all of the members
   const wrapObjectInParseResult = object => new namespace.elements.ParseResult(object.content);
 
-  const validateMembers = R.pipe(
+  const validateMembers = object => R.pipe(
     wrapObjectInParseResult,
+    (value) => {
+      // pre-parse the ordered keys in order
+      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);
+        }
+      });
+      return value;
+    },
     chainParseResult(transformMember),
     R.unless(parseResultHasErrors, convertParseResultMembersToObject)
-  );
+  )(object);
 
   return pipeParseResult(namespace,
     R.unless(isObject, createWarning(namespace, `'${name}' is not an object`)),