feature: lazy resolver (swagger-api#1681)

* Don't display file name in File menu
* Remove unused `fileName` variable
* v3.2.9
* fix dropzone sizing issue
* Rebuild dist
* Filter out non-semantic errors in resolver-vulnerable test
* Point validation to unresolved spec
* Elmiinate usage and references to resolved spec
* Migrate editor validation to resolvedless strategy
* Remove debugging console points
* Add async/await support to babel

.babelrc

@@ -5,6 +5,8 @@
     "stage-0"
   ],
   "plugins": [
+  "transform-runtime",
+  "transform-async-to-generator",
   [
     "module-alias",
     [

package.json

@@ -69,6 +69,8 @@
     "babel-eslint": "^6.1.2",
     "babel-loader": "^6.3.2",
     "babel-plugin-module-alias": "^1.6.0",
+    "babel-plugin-transform-async-to-generator": "^6.24.1",
+    "babel-plugin-transform-runtime": "^6.23.0",
     "babel-preset-es2015": "^6.22.0",
     "babel-preset-es2015-ie": "^6.6.2",
     "babel-preset-react": "^6.23.0",

src/plugins/validate-base/index.js

@@ -1,13 +1,13 @@
 // Base validate plugin that provides a placeholder `validateSpec` that fires
-// after `updateResolved` is dispatched.
+// after `updateJsonSpec` is dispatched.
 
-export const updateResolved = (ori, {specActions}) => (...args) => {
+export const updateJsonSpec = (ori, {specActions}) => (...args) => {
   ori(...args)
   /*
     To allow us to remove this, we should prefer the practice of
     only _composing_ inside of wrappedActions. It keeps us free to
     remove pieces added by plugins. In this case, I want to toggle validation.
-    But I can't look inside the updateResolved action,
+    But I can't look inside the updateJsonSpec action,
     I can only remove it ( which isn't desirable ). However I _can_ remove `validateSpec` action,
     making it a noop. That way, the only overhead I end up with is a bunch of noops inside wrappedActions.
     Which isn't bad.
@@ -17,7 +17,7 @@ export const updateResolved = (ori, {specActions}) => (...args) => {
 }
 
 //eslint-disable-next-line no-unused-vars
-export const validateSpec = (resolvedSpec) => ({ specSelectors, errActions }) => {
+export const validateSpec = (jsSpec) => ({ specSelectors, errActions }) => {
 
 }
 
@@ -29,7 +29,7 @@ export default function() {
           validateSpec,
         },
         wrapActions: {
-          updateResolved
+          updateJsonSpec
         }
       }
     }

src/plugins/validate-json-schema/apis/index.js

@@ -4,10 +4,10 @@ import { makeValidationWorker } from "../helpers"
 
 let debouncedValidation = makeValidationWorker()
 
-export const validateSpec = (resolvedSpec) => ({ specSelectors, errActions }) => {
+export const validateSpec = (jsSpec) => ({ specSelectors, errActions }) => {
   const isOAS3 = specSelectors.isOAS3 ? specSelectors.isOAS3() : false
   const ourMode = isOAS3 ? "oas3" : "swagger2"
-  debouncedValidation({ mode: ourMode, specSelectors, errActions, resolvedSpec })
+  debouncedValidation({ mode: ourMode, specSelectors, errActions, jsSpec })
 }
 
 export default function() {

src/plugins/validate-json-schema/helpers.js

@@ -9,7 +9,7 @@ export function makeValidationWorker() {
   var worker = new BareValidationWorker()
   var validationWorker = new PromiseWorker(worker)
 
-  function runValidation({ specSelectors, errActions, resolvedSpec, mode }) {
+  function runValidation({ specSelectors, errActions, mode }) {
     let specStr = specSelectors.specStr()
 
     if(specStr.trim().length === 0) {
@@ -20,7 +20,6 @@ export function makeValidationWorker() {
     return validationWorker.postMessage({
       mode,
       jsSpec: specSelectors.specJson().toJS(),
-      resolvedSpec,
       specStr
     }).then(function (validationErrors) {
       errActions.clear({

src/plugins/validate-json-schema/validation.worker.js

@@ -7,7 +7,7 @@ import getTimestamp from "./get-timestamp"
 import registerPromiseWorker from "promise-worker/register"
 import modes from "./modes"
 
-registerPromiseWorker(function ({ jsSpec, resolvedSpec, specStr, mode }) {
+registerPromiseWorker(function ({ jsSpec, specStr, mode }) {
   let boundGetLineNumber = getLineNumberForPath.bind(null, specStr)
 
   if(!modes[mode]) {
@@ -18,7 +18,6 @@ registerPromiseWorker(function ({ jsSpec, resolvedSpec, specStr, mode }) {
 
   let inputs = {
     jsSpec,
-    resolvedSpec,
     specStr,
     settings,
     getLineNumberForPath: boundGetLineNumber

src/plugins/validate-semantic/actions.js

@@ -17,6 +17,7 @@ const debNewSpecErrBatch = debounce(() => {
       obj.source = SOURCE
     })
     system.errActions.newSpecErrBatch(errorCollector)
+    delete errorCollector.system
     errorCollector = [] // Clear stack
   } catch(e) {
     console.error(e)

src/plugins/validate-semantic/index.js

@@ -3,6 +3,7 @@ import * as actions from "./actions"
 import traverse from "traverse"
 import {createSelector} from "reselect"
 import debounce from "lodash/debounce"
+import memoize from "lodash/memoize"
 
 import * as formDataValidateActions from "./validators/form-data"
 import * as schemaValidateActions from "./validators/schema"
@@ -21,12 +22,13 @@ export default function SemanticValidatorsPlugin({getSystem}) {
     fn: {
       traverse,
       traverseOnce,
+      memoizedResolveSubtree: makeMemoizedResolveSubtree(getSystem())
     },
     statePlugins: {
       spec: {
         selectors: {
           jsonAsJS: createSelector(
-            state => state.get("resolved"),
+            state => state.get("json"),
             (spec) => spec ? spec.toJS() : null
           )
         },
@@ -110,3 +112,13 @@ function makeTraverseOnce(getSystem) {
     return deferred.promise.then( a => a[name] )
   }
 }
+
+function makeMemoizedResolveSubtree(system) {
+  const cacheKeymaker = (obj, path) => {
+    return `${obj.toString()} ${path.join("<>")}`
+  }
+  return memoize(async (obj, path, opts) => {
+    const res = await system.fn.resolveSubtree(obj.toJS(), path, opts)
+    return res
+  }, cacheKeymaker)
+}

src/plugins/validate-semantic/validators/operations.js

@@ -6,9 +6,7 @@ export const validateOperationHasUniqueId = () => sys => {
       return nodes.reduce((acc, node) => {
         const value = node.node
 
-        // Swagger-Client messes with `value.operationId`, but puts the inital
-        // value in `__originalOperationId` when it resolves, so we use that.
-        const id = value.__originalOperationId
+        const id = value.operationId
 
         if(id) {
           if(seen.indexOf(id) > -1) {

src/plugins/validate-semantic/validators/paths.js

@@ -2,44 +2,42 @@ const operationKeys = ["get", "post", "put", "delete", "options", "head", "patch
 
 const PATH_TEMPLATES_REGEX = /\{(.*?)\}/g
 
-export const validatePathParameterDeclarationHasMatchingDefiniton = () => system => {
-  return system.validateSelectors
-    .allPathItems()
-    .then(nodes => {
-      return nodes.reduce((acc, node) => {
-        const pathItem = node.node
+export const validatePathParameterDeclarationHasMatchingDefiniton = () => async system => {
+  const nodes = await system.validateSelectors.allPathItems()
+
+  return nodes.reduce(async (prev, node) => {
+    const acc = await prev
+    const pathTemplates = (node.key.match(PATH_TEMPLATES_REGEX) || [])
+      .map(str => str.replace("{", "").replace("}", ""))
+    if(pathTemplates.length) {
+      for (let paramName of pathTemplates) {
+        if(paramName.length === 0) {
+          // don't validate empty param names... they're invalid anyway
+          continue
+        }
+        const resolverResult = await system.fn.memoizedResolveSubtree(system.specSelectors.specJson(), node.path)
+        const res = checkForDefinition(paramName, resolverResult.spec)
+        if(res.inOperation && res.missingFromOperations.length) {
+          const missingStr = res.missingFromOperations
+            .map(str => `"${str}"`)
+            .join(", ")
 
-        const pathTemplates = (node.key.match(PATH_TEMPLATES_REGEX) || [])
-          .map(str => str.replace("{", "").replace("}", ""))
-        if(pathTemplates.length) {
-          pathTemplates.forEach(paramName => {
-            if(paramName.length === 0) {
-              // don't validate empty param names... they're invalid anyway
-              return
-            }
-            const res = checkForDefinition(paramName, pathItem)
-            if(res.inOperation && res.missingFromOperations.length) {
-              const missingStr = res.missingFromOperations
-                .map(str => `"${str}"`)
-                .join(", ")
-
-              acc.push({
-                message: `Declared path parameter "${paramName}" needs to be defined within every operation in the path (missing in ${missingStr}), or moved to the path-level parameters object`,
-                path: [...node.path],
-                level: "error",
-              })
-            } else if(!res.found) {
-              acc.push({
-                message: `Declared path parameter "${paramName}" needs to be defined as a path parameter at either the path or operation level`,
-                path: [...node.path],
-                level: "error",
-              })
-            }
+          acc.push({
+            message: `Declared path parameter "${paramName}" needs to be defined within every operation in the path (missing in ${missingStr}), or moved to the path-level parameters object`,
+            path: [...node.path],
+            level: "error",
+          })
+        } else if(!res.found) {
+          acc.push({
+            message: `Declared path parameter "${paramName}" needs to be defined as a path parameter at either the path or operation level`,
+            path: [...node.path],
+            level: "error",
           })
         }
-        return acc
-      }, [])
-    })
+      }
+    }
+    return acc
+  }, Promise.resolve([]))
 }
 
 export const validatePathParameterDeclarationIsNotEmpty = () => system => {

src/plugins/validate-semantic/validators/refs.js

@@ -1,7 +1,7 @@
 import get from "lodash/get"
 
 export const validateRefHasNoSiblings = () => system => {
-  return system.validateSelectors.all$refArtifacts()
+  return system.validateSelectors.all$refs()
   .then((nodes) => {
       const immSpecJson = system.specSelectors.specJson()
       const specJson = immSpecJson.toJS ? immSpecJson.toJS() : {}
@@ -27,7 +27,7 @@ export const validateRefHasNoSiblings = () => system => {
 
 // Add warnings for unused definitions
 export const validateUnusedDefinitions = () => (system) => {
-  return system.validateSelectors.all$refArtifacts()
+  return system.validateSelectors.all$refs()
   .then((nodes) => {
     const references = nodes.map(node => node.node)
     const errors = []
@@ -49,7 +49,7 @@ export const validateUnusedDefinitions = () => (system) => {
 }
 
 export const validateRefPathFormatting = () => (system) => {
-  return system.validateSelectors.all$refArtifacts()
+  return system.validateSelectors.all$refs()
   .then((refArtifacts) => {
 
     const errors = []

test/plugins/selectors.js

@@ -9,15 +9,16 @@ function getSystem(spec) {
     const system = SwaggerUi({
       spec,
       domNode: null,
-      presets: [],
-      initialState: {
-        layout: undefined
-      },
-      plugins: [
+      presets: [
         SwaggerUi.plugins.SpecIndex,
         SwaggerUi.plugins.ErrIndex,
         SwaggerUi.plugins.DownloadUrl,
         SwaggerUi.plugins.SwaggerJsIndex,
+      ],
+      initialState: {
+        layout: undefined
+      },
+      plugins: [
         ASTPlugin,
         ValidateBasePlugin,
         ValidateSemanticPlugin,
@@ -27,7 +28,7 @@ function getSystem(spec) {
   })
 }
 
-describe("plugin - selectors", function() {
+describe("validation plugin - selectors", function() {
   this.timeout(10 * 1000)
 
   it("allSchemas should pick up parameter schemas", () => {
@@ -49,11 +50,9 @@ describe("plugin - selectors", function() {
     return getSystem(spec)
       .then(system => system.validateSelectors.allSchemas())
       .then(nodes => {
-        expect(nodes.length).toEqual(3) // the "common" parameter gets propagated to "get" method
+        expect(nodes.length).toEqual(2)
         expect(nodes[0].path).toEqual(["paths","test","parameters","0"])
         expect(nodes[1].path).toEqual(["paths","test","get","parameters","0"])
-        expect(nodes[2].path).toEqual(["paths","test","get","parameters","1"])
-        expect(nodes[2].node).toEqual({name: "common"})
       })
   })
 

test/plugins/validate-semantic/paths.js

@@ -312,22 +312,22 @@ describe("validation plugin - semantic - paths", function(){
     it("should return no problems for a templated and double-templated set of path strings", function(){
       const spec = {
         paths: {
-          "/CoolPath/{group_id}/all": {
+          "/CoolPath/{group_id1}/all": {
             parameters: [{
-              name: "group_id",
+              name: "group_id1",
               in: "path",
               required: true
             }]
           },
-          "/CoolPath/{group_id}/{user_id}": {
+          "/CoolPath/{group_id2}/{user_id2}": {
             parameters: [
               {
-                name: "group_id",
+                name: "group_id2",
                 in: "path",
                 required: true
               },
               {
-                name: "user_id",
+                name: "user_id2",
                 in: "path",
                 required: true
               },

test/plugins/validate-semantic/validate-helper.js

@@ -5,30 +5,33 @@ import ValidateBasePlugin from "plugins/validate-base"
 import ValidateSemanticPlugin from "plugins/validate-semantic"
 import ASTPlugin from "plugins/ast"
 
-const DELAY_MS = process.env.CI === "true" ? 110 : 60
+const DELAY_MS = 130
 
 export default function validateHelper(spec) {
   return new Promise((resolve) => {
     const system = SwaggerUi({
       spec,
       domNode: null,
-      presets: [],
-      initialState: {
-        layout: undefined
-      },
-      plugins: [
+      presets: [
         SwaggerUi.plugins.SpecIndex,
         SwaggerUi.plugins.ErrIndex,
         SwaggerUi.plugins.DownloadUrl,
         SwaggerUi.plugins.SwaggerJsIndex,
+      ],
+      initialState: {
+        layout: undefined
+      },
+      plugins: [
         ASTPlugin,
         ValidateBasePlugin,
         ValidateSemanticPlugin,
 
       ]
     })
     system.validateActions.all()
-    setTimeout(resolve.bind(null, system), DELAY_MS)
+    setTimeout(() => {
+      resolve(system)
+    }, DELAY_MS)
   })
 
 }