@upendra19/swagger-ui-custom 1.0.0 → 1.0.1

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

@@ -1,286 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * @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

@@ -1,27 +0,0 @@
-/**
- * @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

@@ -1,19 +0,0 @@
-/**
- * @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

@@ -1,94 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 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 })
-}