@upendra19/swagger-ui-custom 1.0.0

package/src/core/plugins/auth/actions.js

@@ -0,0 +1,286 @@
+import parseUrl from "url-parse"
+import win from "core/window"
+import { btoa, buildFormData } from "core/utils"
+
+export const SHOW_AUTH_POPUP = "show_popup"
+export const AUTHORIZE = "authorize"
+export const LOGOUT = "logout"
+export const AUTHORIZE_OAUTH2 = "authorize_oauth2"
+export const CONFIGURE_AUTH = "configure_auth"
+export const RESTORE_AUTHORIZATION = "restore_authorization"
+
+const scopeSeparator = " "
+
+export function showDefinitions(payload) {
+  return {
+    type: SHOW_AUTH_POPUP,
+    payload: payload
+  }
+}
+
+export function authorize(payload) {
+  return {
+    type: AUTHORIZE,
+    payload: payload
+  }
+}
+
+export const authorizeWithPersistOption = (payload) => ( { authActions } ) => {
+  authActions.authorize(payload)
+  authActions.persistAuthorizationIfNeeded()
+}
+
+export function logout(payload) {
+  return {
+    type: LOGOUT,
+    payload: payload
+  }
+}
+
+export const logoutWithPersistOption = (payload) => ( { authActions } ) => {
+  authActions.logout(payload)
+  authActions.persistAuthorizationIfNeeded()
+}
+
+export const preAuthorizeImplicit = (payload) => ( { authActions, errActions } ) => {
+  let { auth , token, isValid } = payload
+  let { schema, name } = auth
+  let flow = schema.get("flow")
+
+  // remove oauth2 property from window after redirect from authentication
+  delete win.swaggerUIRedirectOauth2
+
+  if ( flow !== "accessCode" && !isValid ) {
+    errActions.newAuthErr( {
+      authId: name,
+      source: "auth",
+      level: "warning",
+      message: "Authorization may be unsafe, passed state was changed in server Passed state wasn't returned from auth server"
+    })
+  }
+
+  if ( token.error ) {
+    errActions.newAuthErr({
+      authId: name,
+      source: "auth",
+      level: "error",
+      message: JSON.stringify(token)
+    })
+    return
+  }
+
+  authActions.authorizeOauth2WithPersistOption({ auth, token })
+}
+
+
+export function authorizeOauth2(payload) {
+  return {
+    type: AUTHORIZE_OAUTH2,
+    payload: payload
+  }
+}
+
+
+export const authorizeOauth2WithPersistOption = (payload) => ( { authActions } ) => {
+  authActions.authorizeOauth2(payload)
+  authActions.persistAuthorizationIfNeeded()
+}
+
+export const authorizePassword = ( auth ) => ( { authActions } ) => {
+  let { schema, name, username, password, passwordType, clientId, clientSecret } = auth
+  let form = {
+    grant_type: "password",
+    scope: auth.scopes.join(scopeSeparator),
+    username,
+    password
+  }
+  let query = {}
+  let headers = {}
+
+  switch (passwordType) {
+    case "request-body":
+      setClientIdAndSecret(form, clientId, clientSecret)
+      break
+
+    case "basic":
+      headers.Authorization = "Basic " + btoa(clientId + ":" + clientSecret)
+      break
+    default:
+      console.warn(`Warning: invalid passwordType ${passwordType} was passed, not including client id and secret`)
+  }
+
+  return authActions.authorizeRequest({ body: buildFormData(form), url: schema.get("tokenUrl"), name, headers, query, auth})
+}
+
+function setClientIdAndSecret(target, clientId, clientSecret) {
+  if ( clientId ) {
+    Object.assign(target, {client_id: clientId})
+  }
+
+  if ( clientSecret ) {
+    Object.assign(target, {client_secret: clientSecret})
+  }
+}
+
+export const authorizeApplication = ( auth ) => ( { authActions } ) => {
+  let { schema, scopes, name, clientId, clientSecret } = auth
+  let headers = {
+    Authorization: "Basic " + btoa(clientId + ":" + clientSecret)
+  }
+  let form = {
+    grant_type: "client_credentials",
+    scope: scopes.join(scopeSeparator)
+  }
+
+  return authActions.authorizeRequest({body: buildFormData(form), name, url: schema.get("tokenUrl"), auth, headers })
+}
+
+export const authorizeAccessCodeWithFormParams = ( { auth, redirectUrl } ) => ( { authActions } ) => {
+  let { schema, name, clientId, clientSecret, codeVerifier } = auth
+  let form = {
+    grant_type: "authorization_code",
+    code: auth.code,
+    client_id: clientId,
+    client_secret: clientSecret,
+    redirect_uri: redirectUrl,
+    code_verifier: codeVerifier
+  }
+
+  return authActions.authorizeRequest({body: buildFormData(form), name, url: schema.get("tokenUrl"), auth})
+}
+
+export const authorizeAccessCodeWithBasicAuthentication = ( { auth, redirectUrl } ) => ( { authActions } ) => {
+  let { schema, name, clientId, clientSecret, codeVerifier } = auth
+  let headers = {
+    Authorization: "Basic " + btoa(clientId + ":" + clientSecret)
+  }
+  let form = {
+    grant_type: "authorization_code",
+    code: auth.code,
+    client_id: clientId,
+    redirect_uri: redirectUrl,
+    code_verifier: codeVerifier
+  }
+
+  return authActions.authorizeRequest({body: buildFormData(form), name, url: schema.get("tokenUrl"), auth, headers})
+}
+
+export const authorizeRequest = ( data ) => ( { fn, getConfigs, authActions, errActions, oas3Selectors, specSelectors, authSelectors } ) => {
+  let { body, query={}, headers={}, name, url, auth } = data
+
+  let { additionalQueryStringParams } = authSelectors.getConfigs() || {}
+
+  let parsedUrl
+
+  if (specSelectors.isOAS3()) {
+    let finalServerUrl = oas3Selectors.serverEffectiveValue(oas3Selectors.selectedServer())
+    parsedUrl = parseUrl(url, finalServerUrl, true)
+  } else {
+    parsedUrl = parseUrl(url, specSelectors.url(), true)
+  }
+
+  if(typeof additionalQueryStringParams === "object") {
+    parsedUrl.query = Object.assign({}, parsedUrl.query, additionalQueryStringParams)
+  }
+
+  const fetchUrl = parsedUrl.toString()
+
+  let _headers = Object.assign({
+    "Accept":"application/json, text/plain, */*",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "X-Requested-With": "XMLHttpRequest"
+  }, headers)
+
+  fn.fetch({
+    url: fetchUrl,
+    method: "post",
+    headers: _headers,
+    query: query,
+    body: body,
+    requestInterceptor: getConfigs().requestInterceptor,
+    responseInterceptor: getConfigs().responseInterceptor
+  })
+  .then(function (response) {
+    let token = JSON.parse(response.data)
+    let error = token && ( token.error || "" )
+    let parseError = token && ( token.parseError || "" )
+
+    if ( !response.ok ) {
+      errActions.newAuthErr( {
+        authId: name,
+        level: "error",
+        source: "auth",
+        message: response.statusText
+      } )
+      return
+    }
+
+    if ( error || parseError ) {
+      errActions.newAuthErr({
+        authId: name,
+        level: "error",
+        source: "auth",
+        message: JSON.stringify(token)
+      })
+      return
+    }
+
+    authActions.authorizeOauth2WithPersistOption({ auth, token})
+  })
+  .catch(e => {
+    let err = new Error(e)
+    let message = err.message
+    // swagger-js wraps the response (if available) into the e.response property;
+    // investigate to check whether there are more details on why the authorization
+    // request failed (according to RFC 6479).
+    // See also https://github.com/swagger-api/swagger-ui/issues/4048
+    if (e.response && e.response.data) {
+      const errData = e.response.data
+      try {
+        const jsonResponse = typeof errData === "string" ? JSON.parse(errData) : errData
+        if (jsonResponse.error)
+          message += `, error: ${jsonResponse.error}`
+        if (jsonResponse.error_description)
+          message += `, description: ${jsonResponse.error_description}`
+      } catch (jsonError) {
+        // Ignore
+      }
+    }
+    errActions.newAuthErr( {
+      authId: name,
+      level: "error",
+      source: "auth",
+      message: message
+    } )
+  })
+}
+
+export function configureAuth(payload) {
+  return {
+    type: CONFIGURE_AUTH,
+    payload: payload
+  }
+}
+
+export function restoreAuthorization(payload) {
+  return {
+    type: RESTORE_AUTHORIZATION,
+    payload: payload
+  }
+}
+
+export const persistAuthorizationIfNeeded = () => ( { authSelectors, getConfigs } ) => {
+  const configs = getConfigs()
+
+  if (!configs.persistAuthorization) return
+
+  // persist authorization to local storage
+  const authorized = authSelectors.authorized().toJS()
+  localStorage.setItem("authorized", JSON.stringify(authorized))
+}
+
+export const authPopup = (url, swaggerUIRedirectOauth2) => ( ) => {
+  win.swaggerUIRedirectOauth2 = swaggerUIRedirectOauth2
+
+  win.open(url)
+}

package/src/core/plugins/auth/components/lock-auth-icon.jsx

@@ -0,0 +1,27 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import PropTypes from "prop-types"
+import omit from "lodash/omit"
+
+class LockAuthIcon extends React.Component {
+  mapStateToProps(state, props) {
+    const ownProps = omit(props, Object.keys(props.getSystem()))
+    return { state, ownProps }
+  }
+
+  render() {
+    const { getComponent, ownProps } = this.props
+    const LockIcon = getComponent("LockIcon")
+
+    return <LockIcon {...ownProps} />
+  }
+}
+
+LockAuthIcon.propTypes = {
+  getComponent: PropTypes.func.isRequired,
+  ownProps: PropTypes.shape({}).isRequired,
+}
+
+export default LockAuthIcon

package/src/core/plugins/auth/components/unlock-auth-icon.jsx

@@ -0,0 +1,27 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import PropTypes from "prop-types"
+import omit from "lodash/omit"
+
+class UnlockAuthIcon extends React.Component {
+  mapStateToProps(state, props) {
+    const ownProps = omit(props, Object.keys(props.getSystem()))
+    return { state, ownProps }
+  }
+
+  render() {
+    const { getComponent, ownProps } = this.props
+    const UnlockIcon = getComponent("UnlockIcon")
+
+    return <UnlockIcon {...ownProps} />
+  }
+}
+
+UnlockAuthIcon.propTypes = {
+  getComponent: PropTypes.func.isRequired,
+  ownProps: PropTypes.shape({}).isRequired,
+}
+
+export default UnlockAuthIcon

package/src/core/plugins/auth/configs-extensions/wrap-actions.js

@@ -0,0 +1,19 @@
+/**
+ * @prettier
+ */
+export const loaded = (oriAction, system) => (payload) => {
+  const { getConfigs, authActions } = system
+  const configs = getConfigs()
+
+  oriAction(payload)
+
+  // check if we should restore authorization data from localStorage
+  if (configs.persistAuthorization) {
+    const authorized = localStorage.getItem("authorized")
+    if (authorized) {
+      authActions.restoreAuthorization({
+        authorized: JSON.parse(authorized),
+      })
+    }
+  }
+}

package/src/core/plugins/auth/index.js

@@ -0,0 +1,94 @@
+import reducers from "./reducers"
+import * as actions from "./actions"
+import * as selectors from "./selectors"
+import { execute as wrappedExecuteAction } from "./spec-extensions/wrap-actions"
+import { loaded as wrappedLoadedAction } from "./configs-extensions/wrap-actions"
+import { authorize as wrappedAuthorizeAction, logout as wrappedLogoutAction } from "./wrap-actions"
+
+import LockAuthIcon from "./components/lock-auth-icon"
+import UnlockAuthIcon from "./components/unlock-auth-icon"
+
+export default function() {
+  return {
+    afterLoad(system) {
+      this.rootInjects = this.rootInjects || {}
+      this.rootInjects.initOAuth = system.authActions.configureAuth
+      this.rootInjects.preauthorizeApiKey = preauthorizeApiKey.bind(null, system)
+      this.rootInjects.preauthorizeBasic = preauthorizeBasic.bind(null, system)
+    },
+    components: {
+      LockAuthIcon: LockAuthIcon,
+      UnlockAuthIcon: UnlockAuthIcon,
+      LockAuthOperationIcon: LockAuthIcon,
+      UnlockAuthOperationIcon: UnlockAuthIcon,
+    },
+    statePlugins: {
+      auth: {
+        reducers,
+        actions,
+        selectors,
+        wrapActions: {
+          authorize: wrappedAuthorizeAction,
+          logout: wrappedLogoutAction,
+        }
+      },
+      configs: {
+        wrapActions: {
+          loaded: wrappedLoadedAction,
+        },
+      },
+      spec: {
+        wrapActions: {
+          execute: wrappedExecuteAction,
+        },
+      },
+    }
+  }
+}
+
+export function preauthorizeBasic(system, key, username, password) {
+  const {
+    authActions: { authorize },
+    specSelectors: { specJson, isOAS3 }
+  } = system
+
+  const definitionBase = isOAS3() ? ["components", "securitySchemes"] : ["securityDefinitions"]
+
+  const schema = specJson().getIn([...definitionBase, key])
+
+  if(!schema) {
+    return null
+  }
+
+  return authorize({
+    [key]: {
+      value: {
+        username,
+        password,
+      },
+      schema: schema.toJS()
+    }
+  })
+}
+
+export function preauthorizeApiKey(system, key, value) {
+  const {
+    authActions: { authorize },
+    specSelectors: { specJson, isOAS3 }
+  } = system
+
+  const definitionBase = isOAS3() ? ["components", "securitySchemes"] : ["securityDefinitions"]
+
+  const schema = specJson().getIn([...definitionBase, key])
+
+  if(!schema) {
+    return null
+  }
+
+  return authorize({
+    [key]: {
+      value,
+      schema: schema.toJS()
+    }
+  })
+}

package/src/core/plugins/auth/reducers.js

@@ -0,0 +1,77 @@
+import { fromJS, Map } from "immutable"
+import { btoa, isFunc } from "core/utils"
+
+import {
+  SHOW_AUTH_POPUP,
+  AUTHORIZE,
+  AUTHORIZE_OAUTH2,
+  LOGOUT,
+  CONFIGURE_AUTH,
+  RESTORE_AUTHORIZATION
+} from "./actions"
+
+export default {
+  [SHOW_AUTH_POPUP]: (state, { payload } ) =>{
+    return state.set( "showDefinitions", payload )
+  },
+
+  [AUTHORIZE]: (state, { payload } ) =>{
+    let securities = fromJS(payload)
+    let map = state.get("authorized") || Map()
+
+    // refactor withMutations
+    securities.entrySeq().forEach( ([ key, security ]) => {
+      if (!isFunc(security.getIn)) {
+        return state.set("authorized", map)
+      }
+      let type = security.getIn(["schema", "type"])
+
+      if ( type === "apiKey" || type === "http" ) {
+        map = map.set(key, security)
+      } else if ( type === "basic" ) {
+        let username = security.getIn(["value", "username"])
+        let password = security.getIn(["value", "password"])
+
+        map = map.setIn([key, "value"], {
+          username: username,
+          header: "Basic " + btoa(username + ":" + password)
+        })
+
+        map = map.setIn([key, "schema"], security.get("schema"))
+      }
+    })
+
+    return state.set( "authorized", map )
+  },
+
+  [AUTHORIZE_OAUTH2]: (state, { payload } ) =>{
+    let { auth, token } = payload
+    let parsedAuth
+
+    auth.token = Object.assign({}, token)
+    parsedAuth = fromJS(auth)
+
+    let map = state.get("authorized") || Map()
+    map = map.set(parsedAuth.get("name"), parsedAuth)
+    
+    return state.set( "authorized", map )
+  },
+
+  [LOGOUT]: (state, { payload } ) =>{
+    let result = state.get("authorized").withMutations((authorized) => {
+        payload.forEach((auth) => {
+          authorized.delete(auth)
+        })
+      })
+
+    return state.set("authorized", result)
+  },
+
+  [CONFIGURE_AUTH]: (state, { payload } ) =>{
+    return state.set("configs", payload)
+  },
+
+  [RESTORE_AUTHORIZATION]: (state, { payload } ) =>{    
+    return state.set("authorized", fromJS(payload.authorized))
+  },
+}

package/src/core/plugins/auth/selectors.js

@@ -0,0 +1,121 @@
+import { createSelector } from "reselect"
+import { List, Map } from "immutable"
+
+const state = state => state
+
+export const shownDefinitions = createSelector(
+    state,
+    auth => auth.get( "showDefinitions" )
+)
+
+export const definitionsToAuthorize = createSelector(
+    state,
+    () => ( { specSelectors } ) => {
+      let definitions = specSelectors.securityDefinitions() || Map({})
+      let list = List()
+
+      //todo refactor
+      definitions.entrySeq().forEach( ([ key, val ]) => {
+        let map = Map()
+
+        map = map.set(key, val)
+        list = list.push(map)
+      })
+
+      return list
+    }
+)
+
+export const selectAuthPath =
+  (state, name) =>
+  ({ specSelectors }) =>
+    List(
+      specSelectors.isOAS3()
+        ? ["components", "securitySchemes", name]
+        : ["securityDefinitions", name]
+    )
+    
+export const getDefinitionsByNames = ( state, securities ) => ( { specSelectors } ) => {
+  console.warn("WARNING: getDefinitionsByNames is deprecated and will be removed in the next major version.")
+  let securityDefinitions = specSelectors.securityDefinitions()
+  let result = List()
+
+  securities.valueSeq().forEach( (names) => {
+    let map = Map()
+    names.entrySeq().forEach( ([name, scopes]) => {
+      let definition = securityDefinitions.get(name)
+      let allowedScopes
+
+      if ( definition.get("type") === "oauth2" && scopes.size ) {
+        allowedScopes = definition.get("scopes")
+
+        allowedScopes.keySeq().forEach( (key) => {
+          if ( !scopes.contains(key) ) {
+            allowedScopes = allowedScopes.delete(key)
+          }
+        })
+
+        definition = definition.set("allowedScopes", allowedScopes)
+      }
+
+      map = map.set(name, definition)
+    })
+
+    result = result.push(map)
+  })
+
+  return result
+}
+
+export const definitionsForRequirements = (state, securities = List()) => ({ authSelectors }) => {
+  const allDefinitions = authSelectors.definitionsToAuthorize() || List()
+  let result = List()
+  allDefinitions.forEach( (definition) => {
+    let security = securities.find(sec => sec.get(definition.keySeq().first()))
+    if ( security ) {
+      definition.forEach( (props, name) => {
+        if ( props.get("type") === "oauth2" ) {
+          const securityScopes = security.get(name)
+          let definitionScopes = props.get("scopes")
+          if( List.isList(securityScopes) && Map.isMap(definitionScopes) ) {
+            definitionScopes.keySeq().forEach( (key) => {
+              if ( !securityScopes.contains(key) ) {
+                definitionScopes = definitionScopes.delete(key)
+              }
+            })
+            definition = definition.set(name, props.set("scopes", definitionScopes))
+          }
+        }
+      })
+      result = result.push(definition)
+    }
+  })
+  return result
+}
+
+export const authorized = createSelector(
+    state,
+    auth => auth.get("authorized") || Map()
+)
+
+
+export const isAuthorized = ( state, securities ) => ( { authSelectors } ) => {
+  let authorized = authSelectors.authorized()
+
+  if(!List.isList(securities)) {
+    return null
+  }
+
+  return !!securities.toJS().filter( ( security ) => {
+      let isAuthorized = true
+
+      return Object.keys(security).map((key) => {
+        return !isAuthorized || !!authorized.get(key)
+      }).indexOf(false) === -1
+    }).length
+}
+
+export const getConfigs = createSelector(
+    state,
+    auth => auth.get( "configs" )
+)

package/src/core/plugins/auth/spec-extensions/wrap-actions.js

@@ -0,0 +1,10 @@
+// Add security to the final `execute` call ( via `extras` )
+export const execute = ( oriAction, { authSelectors, specSelectors }) => ({ path, method, operation, extras }) => {
+  let securities = {
+    authorized: authSelectors.authorized() && authSelectors.authorized().toJS(),
+    definitions: specSelectors.securityDefinitions() && specSelectors.securityDefinitions().toJS(),
+    specSecurity:  specSelectors.security() && specSelectors.security().toJS()
+  }
+
+  return oriAction({ path, method, operation, securities, ...extras })
+}