feat(oas3): added support for global security requirement

Author: pksunkara

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

@@ -15,10 +15,11 @@ const parseOpenAPI = require('../openapi');
 const parseInfoObject = require('./parseInfoObject');
 const parsePathsObject = require('./parsePathsObject');
 const parseComponentsObject = require('./parseComponentsObject');
+const parseSecurityRequirementsArray = require('./parseSecurityRequirementsArray');
 
 const name = 'OpenAPI Object';
 const requiredKeys = ['openapi', 'info', 'paths'];
-const unsupportedKeys = ['servers', 'security', 'tags', 'externalDocs'];
+const unsupportedKeys = ['servers', 'tags', 'externalDocs'];
 
 /**
  * Returns whether the given member element is unsupported
@@ -111,6 +112,7 @@ function parseOASObject(context, object) {
     [hasKey('info'), R.compose(parseInfoObject(context), getValue)],
     [hasKey('paths'), R.compose(asArray, parsePathsObject(context), getValue)],
     [hasKey('components'), R.compose(parseComponentsObject(context), getValue)],
+    [hasKey('security'), R.compose(parseSecurityRequirementsArray(context), getValue)],
 
     // FIXME Support exposing extensions into parse result
     [isExtension, () => new namespace.elements.ParseResult()],
@@ -126,6 +128,7 @@ function parseOASObject(context, object) {
     (object) => {
       const api = object.get('info');
       const components = object.get('components');
+      const security = object.get('security');
 
       if (components) {
         const schemes = R.or(components.get('securitySchemes'), new namespace.elements.Array());
@@ -142,6 +145,20 @@ function parseOASObject(context, object) {
         api.content = api.content.concat(resources.content);
       }
 
+      api.resources.forEach((resource) => {
+        resource.transitions.forEach((transition) => {
+          transition.transactions.forEach((transaction) => {
+            if (!transaction.authSchemes && security && !security.isEmpty) {
+              transaction.attributes.set('authSchemes', security.clone());
+            }
+
+            if (transaction.authSchemes && transaction.authSchemes.isEmpty) {
+              transaction.attributes.remove('authSchemes');
+            }
+          });
+        });
+      });
+
       if (components) {
         const schemas = R.or(components.get('schemas'), new namespace.elements.Array())
           .content

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

@@ -1,9 +1,8 @@
 const R = require('ramda');
 const {
-  isArray, isMember, isExtension, hasKey, getValue,
+  isMember, isExtension, hasKey, getValue,
 } = require('../../predicates');
 const {
-  createWarning,
   createUnsupportedMemberWarning,
   createInvalidMemberWarning,
   createIdentifierNotUniqueWarning,
@@ -14,8 +13,8 @@ const parseObject = require('../parseObject');
 const parseString = require('../parseString');
 const parseResponsesObject = require('./parseResponsesObject');
 const parseParameterObjects = require('./parseParameterObjects');
-const parseSecurityRequirementObject = require('./parseSecurityRequirementObject');
 const parseRequestBodyObject = require('./parseRequestBodyObject');
+const parseSecurityRequirementsArray = require('./parseSecurityRequirementsArray');
 const parseReference = require('../parseReference');
 
 const parseRequestBodyObjectOrRef = parseReference('requestBodies', parseRequestBodyObject);
@@ -104,32 +103,14 @@ function parseOperationObject(context, path, member) {
     ),
   ]));
 
-  const parseSecurity = pipeParseResult(namespace,
-    R.unless(isArray, createWarning(namespace, `'${name}' 'security' is not an array`)),
-    R.compose(R.chain(parseSecurityRequirementObject(context)), R.constructN(1, namespace.elements.Array)),
-    requirements => requirements.map((requirement) => {
-      if (requirement.length === 1) {
-        return requirement.get(0);
-      }
-
-      const link = new namespace.elements.Link();
-      link.relation = 'profile';
-      link.href = 'https://github.com/refractproject/rfcs/issues/39';
-
-      const allOf = new namespace.elements.Extension(requirement.content);
-      allOf.meta.set('links', new namespace.elements.Array([link]));
-
-      return allOf;
-    }));
-
   const parseMember = R.cond([
     [hasKey('summary'), parseString(context, name, false)],
     [hasKey('description'), parseCopy(context, name, false)],
     [hasKey('operationId'), pipeParseResult(namespace, parseString(context, name, false), parseOperationId)],
     [hasKey('responses'), R.compose(parseResponsesObject(context), getValue)],
     [hasKey('requestBody'), R.compose(parseRequestBodyObjectOrRef(context), getValue)],
     [hasKey('parameters'), R.compose(parseParameterObjects(context, name), getValue)],
-    [hasKey('security'), R.compose(parseSecurity, getValue)],
+    [hasKey('security'), R.compose(parseSecurityRequirementsArray(context), getValue)],
 
     [isUnsupportedKey, createUnsupportedMemberWarning(namespace, name)],
 

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

@@ -0,0 +1,40 @@
+const R = require('ramda');
+const pipeParseResult = require('../../pipeParseResult');
+const parseArray = require('../parseArray');
+const parseSecurityRequirementObject = require('./parseSecurityRequirementObject');
+
+const name = 'Security Requirements Array';
+
+/**
+ * Parse Security Requirements Array
+ *
+ * @param namespace {Namespace}
+ * @param element {Element}
+ * @returns ParseResult
+ *
+ * @private
+ */
+function parseSecurityRequirementsArray(context, element) {
+  const { namespace } = context;
+
+  const parseSecurityRequirements = pipeParseResult(namespace,
+    parseArray(context, name, R.curry(parseSecurityRequirementObject)(context)),
+    requirements => requirements.map((requirement) => {
+      if (requirement.length === 1) {
+        return requirement.get(0);
+      }
+
+      const link = new namespace.elements.Link();
+      link.relation = 'profile';
+      link.href = 'https://github.com/refractproject/rfcs/issues/39';
+
+      const allOf = new namespace.elements.Extension(requirement.content);
+      allOf.meta.set('links', new namespace.elements.Array([link]));
+
+      return allOf;
+    }));
+
+  return parseSecurityRequirements(element);
+}
+
+module.exports = R.curry(parseSecurityRequirementsArray);