@upendra19/swagger-ui-custom 1.0.0 → 1.0.1

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

@@ -1,575 +0,0 @@
-import { createSelector } from "reselect"
-import constant from "lodash/constant"
-import { sorters, paramToIdentifier } from "core/utils"
-import { fromJS, Set, Map, OrderedMap, List } from "immutable"
-
-const DEFAULT_TAG = "default"
-
-const OPERATION_METHODS = [
-  "get", "put", "post", "delete", "options", "head", "patch", "trace"
-]
-
-const state = state => {
-  return state || Map()
-}
-
-export const lastError = createSelector(
-  state,
-  spec => spec.get("lastError")
-)
-
-export const url = createSelector(
-  state,
-  spec => spec.get("url")
-)
-
-export const specStr = createSelector(
-  state,
-  spec => spec.get("spec") || ""
-)
-
-export const specSource = createSelector(
-  state,
-  spec => spec.get("specSource") || "not-editor"
-)
-
-export const specJson = createSelector(
-  state,
-  spec => spec.get("json", Map())
-)
-
-export const specJS = createSelector(
-  specJson,
-  (spec) => spec.toJS()
-)
-
-export const specResolved = createSelector(
-  state,
-  spec => spec.get("resolved", Map())
-)
-
-export const specResolvedSubtree = (state, path) => {
-  return state.getIn(["resolvedSubtrees", ...path], undefined)
-}
-
-const mergerFn = (oldVal, newVal) => {
-  if(Map.isMap(oldVal) && Map.isMap(newVal)) {
-    if(newVal.get("$$ref")) {
-      // resolver artifacts indicated that this key was directly resolved
-      // so we should drop the old value entirely
-      return newVal
-    }
-
-    return OrderedMap().mergeWith(
-      mergerFn,
-      oldVal,
-      newVal
-    )
-  }
-
-  return newVal
-}
-
-export const specJsonWithResolvedSubtrees = createSelector(
-  state,
-  spec => OrderedMap().mergeWith(
-    mergerFn,
-    spec.get("json"),
-    spec.get("resolvedSubtrees")
-  )
-)
-
-// Default Spec ( as an object )
-export const spec = state => {
-  let res = specJson(state)
-  return res
-}
-
-export const isOAS3 = createSelector(
-  // isOAS3 is stubbed out here to work around an issue with injecting more selectors
-  // in the OAS3 plugin, and to ensure that the function is always available.
-  // It's not perfect, but our hybrid (core+plugin code) implementation for OAS3
-  // needs this. //KS
-  spec,
-	() => false
-)
-
-export const info = createSelector(
-  spec,
-	spec => returnSelfOrNewMap(spec && spec.get("info"))
-)
-
-export const externalDocs = createSelector(
-  spec,
-	spec => returnSelfOrNewMap(spec && spec.get("externalDocs"))
-)
-
-export const version = createSelector(
-	info,
-	info => info && info.get("version")
-)
-
-export const semver = createSelector(
-	version,
-	version => /v?([0-9]*)\.([0-9]*)\.([0-9]*)/i.exec(version).slice(1)
-)
-
-export const paths = createSelector(
-	specJsonWithResolvedSubtrees,
-	spec => spec.get("paths")
-)
-
-export const validOperationMethods = constant(["get", "put", "post", "delete", "options", "head", "patch"])
-
-export const operations = createSelector(
-  paths,
-  paths => {
-    let list = List()
-
-    if (!Map.isMap(paths) || paths.isEmpty()) {
-      return list
-    }
-
-    paths.forEach((path, pathName) => {
-      if(!path || !path.forEach) {
-        return {}
-      }
-      path.forEach((operation, method) => {
-        if(OPERATION_METHODS.indexOf(method) < 0) {
-          return
-        }
-        list = list.push(fromJS({
-          path: pathName,
-          method,
-          operation,
-          id: `${method}-${pathName}`
-        }))
-      })
-    })
-
-    return list
-  }
-)
-
-export const consumes = createSelector(
-  spec,
-  spec => Set(spec.get("consumes"))
-)
-
-export const produces = createSelector(
-  spec,
-  spec => Set(spec.get("produces"))
-)
-
-export const security = createSelector(
-    spec,
-    spec => spec.get("security", List())
-)
-
-export const securityDefinitions = createSelector(
-    spec,
-    spec => spec.get("securityDefinitions")
-)
-
-
-export const findDefinition = ( state, name ) => {
-  const resolvedRes = state.getIn(["resolvedSubtrees", "definitions", name], null)
-  const unresolvedRes = state.getIn(["json", "definitions", name], null)
-  return resolvedRes || unresolvedRes || null
-}
-
-export const definitions = createSelector(
-  spec,
-  spec => {
-    const res = spec.get("definitions")
-    return Map.isMap(res) ? res : Map()
-  }
-)
-
-export const basePath = createSelector(
-    spec,
-    spec => spec.get("basePath")
-)
-
-export const host = createSelector(
-    spec,
-    spec => spec.get("host")
-)
-
-export const schemes = createSelector(
-    spec,
-    spec => spec.get("schemes", Map())
-)
-
-export const operationsWithRootInherited = createSelector(
-  [
-    operations,
-    consumes,
-    produces
-  ],
-  (operations, consumes, produces) => {
-    return operations.map( ops => ops.update("operation", op => {
-      if (Map.isMap(op)) {
-        return op.withMutations( op => {
-          if ( !op.get("consumes") ) {
-            op.update("consumes", a => Set(a).merge(consumes))
-          }
-          if ( !op.get("produces") ) {
-            op.update("produces", a => Set(a).merge(produces))
-          }
-          return op
-        })
-      } else {
-        // return something with Immutable methods
-        return Map()
-      }
-
-    }))
-  }
-)
-
-export const tags = createSelector(
-  spec,
-  json => {
-    const tags = json.get("tags", List())
-    return List.isList(tags) ? tags.filter(tag => Map.isMap(tag)) : List()
-  }
-)
-
-export const tagDetails = (state, tag) => {
-  let currentTags = tags(state) || List()
-  return currentTags.filter(Map.isMap).find(t => t.get("name") === tag, Map())
-}
-
-export const operationsWithTags = createSelector(
-  operationsWithRootInherited,
-  tags,
-  (operations, tags) => {
-    return operations.reduce( (taggedMap, op) => {
-      let tags = Set(op.getIn(["operation","tags"]))
-      if(tags.count() < 1)
-        return taggedMap.update(DEFAULT_TAG, List(), ar => ar.push(op))
-      return tags.reduce( (res, tag) => res.update(tag, List(), (ar) => ar.push(op)), taggedMap )
-    }, tags.reduce( (taggedMap, tag) => {
-      return taggedMap.set(tag.get("name"), List())
-    } , OrderedMap()))
-  }
-)
-
-export const taggedOperations = (state) => ({ getConfigs }) => {
-  let { tagsSorter, operationsSorter } = getConfigs()
-  return operationsWithTags(state)
-    .sortBy(
-      (val, key) => key, // get the name of the tag to be passed to the sorter
-      (tagA, tagB) => {
-        let sortFn = (typeof tagsSorter === "function" ? tagsSorter : sorters.tagsSorter[ tagsSorter ])
-        return (!sortFn ? null : sortFn(tagA, tagB))
-      }
-    )
-    .map((ops, tag) => {
-      let sortFn = (typeof operationsSorter === "function" ? operationsSorter : sorters.operationsSorter[ operationsSorter ])
-      let operations = (!sortFn ? ops : ops.sort(sortFn))
-
-      return Map({ tagDetails: tagDetails(state, tag), operations: operations })
-    })
-}
-
-export const responses = createSelector(
-  state,
-  state => state.get( "responses", Map() )
-)
-
-export const requests = createSelector(
-    state,
-    state => state.get( "requests", Map() )
-)
-
-export const mutatedRequests = createSelector(
-    state,
-    state => state.get( "mutatedRequests", Map() )
-)
-
-export const responseFor = (state, path, method) => {
-  return responses(state).getIn([path, method], null)
-}
-
-export const requestFor = (state, path, method) => {
-  return requests(state).getIn([path, method], null)
-}
-
-export const mutatedRequestFor = (state, path, method) => {
-  return mutatedRequests(state).getIn([path, method], null)
-}
-
-export const allowTryItOutFor = () => {
-  // This is just a hook for now.
-  return true
-}
-
-export const parameterWithMetaByIdentity = (state, pathMethod, param) => {
-  const opParams = specJsonWithResolvedSubtrees(state).getIn(["paths", ...pathMethod, "parameters"], OrderedMap())
-  const metaParams = state.getIn(["meta", "paths", ...pathMethod, "parameters"], OrderedMap())
-
-  const mergedParams = opParams.map((currentParam) => {
-    const inNameKeyedMeta = metaParams.get(`${param.get("in")}.${param.get("name")}`)
-    const hashKeyedMeta = metaParams.get(`${param.get("in")}.${param.get("name")}.hash-${param.hashCode()}`)
-    return OrderedMap().merge(
-      currentParam,
-      inNameKeyedMeta,
-      hashKeyedMeta
-    )
-  })
-  return mergedParams.find(curr => curr.get("in") === param.get("in") && curr.get("name") === param.get("name"), OrderedMap())
-}
-
-export const parameterInclusionSettingFor = (state, pathMethod, paramName, paramIn) => {
-  const paramKey = `${paramIn}.${paramName}`
-  return state.getIn(["meta", "paths", ...pathMethod, "parameter_inclusions", paramKey], false)
-}
-
-
-export const parameterWithMeta = (state, pathMethod, paramName, paramIn) => {
-  const opParams = specJsonWithResolvedSubtrees(state).getIn(["paths", ...pathMethod, "parameters"], OrderedMap())
-  const currentParam = opParams.find(param => param.get("in") === paramIn && param.get("name") === paramName, OrderedMap())
-  return parameterWithMetaByIdentity(state, pathMethod, currentParam)
-}
-
-export const operationWithMeta = (state, path, method) => {
-  const op = specJsonWithResolvedSubtrees(state).getIn(["paths", path, method], OrderedMap())
-  const meta = state.getIn(["meta", "paths", path, method], OrderedMap())
-
-  const mergedParams = op.get("parameters", List()).map((param) => {
-    return parameterWithMetaByIdentity(state, [path, method], param)
-  })
-
-  return OrderedMap()
-    .merge(op, meta)
-    .set("parameters", mergedParams)
-}
-
-// Get the parameter value by parameter name
-export function getParameter(state, pathMethod, name, inType) {
-  pathMethod = pathMethod || []
-  let params = state.getIn(["meta", "paths", ...pathMethod, "parameters"], fromJS([]))
-  return params.find( (p) => {
-    return Map.isMap(p) && p.get("name") === name && p.get("in") === inType
-  }) || Map() // Always return a map
-}
-
-export const hasHost = createSelector(
-  spec,
-  spec => {
-    const host = spec.get("host")
-    return typeof host === "string" && host.length > 0 && host[0] !== "/"
-  }
-)
-
-// Get the parameter values, that the user filled out
-export function parameterValues(state, pathMethod, isXml) {
-  pathMethod = pathMethod || []
-  let paramValues = operationWithMeta(state, ...pathMethod).get("parameters", List())
-  return paramValues.reduce( (hash, p) => {
-    let value = isXml && p.get("in") === "body" ? p.get("value_xml") : p.get("value")
-    if (List.isList(value)) {
-      value = value.filter(v => v !== "")
-    }
-    return hash.set(paramToIdentifier(p, { allowHashes: false }), value)
-  }, fromJS({}))
-}
-
-// True if any parameter includes `in: ?`
-export function parametersIncludeIn(parameters, inValue="") {
-  if(List.isList(parameters)) {
-    return parameters.some( p => Map.isMap(p) && p.get("in") === inValue )
-  }
-}
-
-// True if any parameter includes `type: ?`
-export function parametersIncludeType(parameters, typeValue="") {
-  if(List.isList(parameters)) {
-    return parameters.some( p => Map.isMap(p) && p.get("type") === typeValue )
-  }
-}
-
-// Get the consumes/produces value that the user selected
-export function contentTypeValues(state, pathMethod) {
-  pathMethod = pathMethod || []
-  let op = specJsonWithResolvedSubtrees(state).getIn(["paths", ...pathMethod], fromJS({}))
-  let meta = state.getIn(["meta", "paths", ...pathMethod], fromJS({}))
-  let producesValue = currentProducesFor(state, pathMethod)
-
-  const parameters = op.get("parameters") || new List()
-
-  const requestContentType = (
-    meta.get("consumes_value") ? meta.get("consumes_value")
-      : parametersIncludeType(parameters, "file") ? "multipart/form-data"
-      : parametersIncludeType(parameters, "formData") ? "application/x-www-form-urlencoded"
-      : undefined
-  )
-
-  return fromJS({
-    requestContentType,
-    responseContentType: producesValue
-  })
-}
-
-// Get the currently selected produces value for an operation
-export function currentProducesFor(state, pathMethod) {
-  pathMethod = pathMethod || []
-
-  const operation = specJsonWithResolvedSubtrees(state).getIn([ "paths", ...pathMethod], null)
-
-  if(operation === null) {
-    // return nothing if the operation does not exist
-    return
-  }
-
-  const currentProducesValue = state.getIn(["meta", "paths", ...pathMethod, "produces_value"], null)
-  const firstProducesArrayItem = operation.getIn(["produces", 0], null)
-
-  return currentProducesValue || firstProducesArrayItem || "application/json"
-
-}
-
-// Get the produces options for an operation
-export function producesOptionsFor(state, pathMethod) {
-  pathMethod = pathMethod || []
-
-  const spec = specJsonWithResolvedSubtrees(state)
-  const operation = spec.getIn([ "paths", ...pathMethod], null)
-
-  if(operation === null) {
-    // return nothing if the operation does not exist
-    return
-  }
-
-  const [path] = pathMethod
-
-  const operationProduces = operation.get("produces", null)
-  const pathItemProduces = spec.getIn(["paths", path, "produces"], null)
-  const globalProduces = spec.getIn(["produces"], null)
-
-  return operationProduces || pathItemProduces || globalProduces
-}
-
-// Get the consumes options for an operation
-export function consumesOptionsFor(state, pathMethod) {
-  pathMethod = pathMethod || []
-
-  const spec = specJsonWithResolvedSubtrees(state)
-  const operation = spec.getIn(["paths", ...pathMethod], null)
-
-  if (operation === null) {
-    // return nothing if the operation does not exist
-    return
-  }
-
-  const [path] = pathMethod
-
-  const operationConsumes = operation.get("consumes", null)
-  const pathItemConsumes = spec.getIn(["paths", path, "consumes"], null)
-  const globalConsumes = spec.getIn(["consumes"], null)
-
-  return operationConsumes || pathItemConsumes || globalConsumes
-}
-
-export const operationScheme = ( state, path, method ) => {
-  let url = state.get("url")
-  let matchResult = url.match(/^([a-z][a-z0-9+\-.]*):/)
-  let urlScheme = Array.isArray(matchResult) ? matchResult[1] : null
-
-  return state.getIn(["scheme", path, method]) || state.getIn(["scheme", "_defaultScheme"]) || urlScheme || ""
-}
-
-export const canExecuteScheme = ( state, path, method ) => {
-  return ["http", "https"].indexOf(operationScheme(state, path, method)) > -1
-}
-
-export const validationErrors = (state, pathMethod) => {
-  pathMethod = pathMethod || []
-  const paramValues = state.getIn(["meta", "paths", ...pathMethod, "parameters"], fromJS([]))
-  const result = []
-
-  if (paramValues.length === 0) return result
-
-  const getErrorsWithPaths = (errors, path = []) => {
-    const getNestedErrorsWithPaths = (e, path) => {
-      const currPath = [...path, e.get("propKey") || e.get("index")]
-      return Map.isMap(e.get("error"))
-        ? getErrorsWithPaths(e.get("error"), currPath)
-        : { error: e.get("error"), path: currPath }
-    }
-
-    return List.isList(errors)
-     ? errors.map((e) => (Map.isMap(e) ? getNestedErrorsWithPaths(e, path) : { error: e, path }))
-     : getNestedErrorsWithPaths(errors, path)
-  }
-
-  const formatError = (error, path, paramName) => {
-    path = path.reduce((acc, curr) => {
-      return typeof curr === "number"
-        ? `${acc}[${curr}]`
-        : acc
-        ? `${acc}.${curr}`
-        : curr
-    }, "")
-    return `For '${paramName}'${path ? ` at path '${path}'` : ""}: ${error}.`
-  }
-
-  paramValues.forEach( (p, key) => {
-    const paramName = key.split(".").slice(1, -1).join(".")
-    const errors = p.get("errors")
-    if (errors && errors.count()) {
-      const errorsWithPaths = getErrorsWithPaths(errors)
-      errorsWithPaths.forEach(({error, path}) => {
-        result.push(formatError(error, path, paramName))
-      })
-    }
-  })
-  return result
-}
-
-export const validateBeforeExecute = (state, pathMethod) => {
-  return validationErrors(state, pathMethod).length === 0
-}
-
-export const getOAS3RequiredRequestBodyContentType = (state, pathMethod) => {
-  let requiredObj = {
-    requestBody: false,
-    requestContentType: {}
-  }
-  let requestBody = state.getIn(["resolvedSubtrees", "paths", ...pathMethod, "requestBody"], fromJS([]))
-  if (requestBody.size < 1) {
-    return requiredObj
-  }
-  if (requestBody.getIn(["required"])) {
-    requiredObj.requestBody = requestBody.getIn(["required"])
-  }
-  requestBody.getIn(["content"]).entrySeq().forEach((contentType) => { // e.g application/json
-    const key = contentType[0]
-    if (contentType[1].getIn(["schema", "required"])) {
-      const val = contentType[1].getIn(["schema", "required"]).toJS()
-      requiredObj.requestContentType[key] = val
-    }
-  })
-  return requiredObj
-}
-
-export const isMediaTypeSchemaPropertiesEqual = ( state, pathMethod, currentMediaType, targetMediaType) => {
-  if((currentMediaType || targetMediaType) && currentMediaType === targetMediaType ) {
-    return true
-  }
-  let requestBodyContent = state.getIn(["resolvedSubtrees", "paths", ...pathMethod, "requestBody", "content"], fromJS([]))
-  if (requestBodyContent.size < 2 || !currentMediaType || !targetMediaType) {
-    // nothing to compare
-    return false
-  }
-  let currentMediaTypeSchemaProperties = requestBodyContent.getIn([currentMediaType, "schema", "properties"], fromJS([]))
-  let targetMediaTypeSchemaProperties = requestBodyContent.getIn([targetMediaType, "schema", "properties"], fromJS([]))
-  return !!currentMediaTypeSchemaProperties.equals(targetMediaTypeSchemaProperties)
-}
-
-function returnSelfOrNewMap(obj) {
-  // returns obj if obj is an Immutable map, else returns a new Map
-  return Map.isMap(obj) ? obj : new Map()
-}

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

@@ -1,39 +0,0 @@
-import get from "lodash/get"
-import isPlainObject from "lodash/isPlainObject"
-
-export const updateSpec = (ori, {specActions}) => (...args) => {
-  ori(...args)
-  specActions.parseToJson(...args)
-}
-
-export const updateJsonSpec = (ori, {specActions}) => (...args) => {
-  ori(...args)
-
-  specActions.invalidateResolvedSubtreeCache()
-
-  // Trigger resolution of any path-level $refs.
-  const [json] = args
-  const pathItems = get(json, ["paths"]) || {}
-  const pathItemKeys = Object.keys(pathItems)
-
-  pathItemKeys.forEach(k => {
-    const val = get(pathItems, [k])
-
-    if (isPlainObject(val) && val.$ref) {
-      specActions.requestResolvedSubtree(["paths", k])
-    }
-  })
-
-  // Trigger resolution of any securitySchemes-level $refs.
-  specActions.requestResolvedSubtree(["components", "securitySchemes"])
-}
-
-// Log the request ( just for debugging, shouldn't affect prod )
-export const executeRequest = (ori, { specActions }) => (req) => {
-  specActions.logRequest(req)
-  return ori(req)
-}
-
-export const validateParams = (ori, { specSelectors }) => (req) => {
-  return ori(req, specSelectors.isOAS3())
-}

package/src/core/plugins/swagger-client/configs-wrap-actions.js

@@ -1,6 +0,0 @@
-export const loaded = (ori, system) => (...args) => {
-  ori(...args)
-  const value = system.getConfigs().withCredentials
-  
-  system.fn.fetch.withCredentials = value
-}

package/src/core/plugins/swagger-client/index.js

@@ -1,54 +0,0 @@
-import genericResolveStrategy from "swagger-client/es/resolver/strategies/generic"
-import openApi2ResolveStrategy from "swagger-client/es/resolver/strategies/openapi-2"
-import openApi30ResolveStrategy from "swagger-client/es/resolver/strategies/openapi-3-0"
-import openApi31ApiDOMResolveStrategy from "swagger-client/es/resolver/strategies/openapi-3-1-apidom"
-import { makeResolve } from "swagger-client/es/resolver"
-import { execute, buildRequest } from "swagger-client/es/execute"
-import Http, { makeHttp, serializeRes } from "swagger-client/es/http"
-import { makeResolveSubtree } from "swagger-client/es/subtree-resolver"
-import { opId } from "swagger-client/es/helpers"
-import { loaded } from "./configs-wrap-actions"
-
-export default function({ configs, getConfigs }) {
-  return {
-    fn: {
-      fetch: makeHttp(Http, configs.preFetch, configs.postFetch),
-      buildRequest,
-      execute,
-      resolve: makeResolve({
-        strategies: [
-          openApi31ApiDOMResolveStrategy,
-          openApi30ResolveStrategy,
-          openApi2ResolveStrategy,
-          genericResolveStrategy,
-        ],
-      }),
-      resolveSubtree: async (obj, path, options = {}) => {
-        const freshConfigs = getConfigs()
-        const defaultOptions = {
-          modelPropertyMacro: freshConfigs.modelPropertyMacro,
-          parameterMacro: freshConfigs.parameterMacro,
-          requestInterceptor: freshConfigs.requestInterceptor,
-          responseInterceptor: freshConfigs.responseInterceptor,
-          strategies: [
-            openApi31ApiDOMResolveStrategy,
-            openApi30ResolveStrategy,
-            openApi2ResolveStrategy,
-            genericResolveStrategy,
-          ],
-        }
-
-        return makeResolveSubtree(defaultOptions)(obj, path, options)
-      },
-      serializeRes,
-      opId
-    },
-    statePlugins: {
-      configs: {
-        wrapActions: {
-          loaded,
-        }
-      }
-    },
-  }
-}

package/src/core/plugins/syntax-highlighting/after-load.js

@@ -1,25 +0,0 @@
-/**
- * @prettier
- */
-import SyntaxHighlighter from "react-syntax-highlighter/dist/esm/light"
-import js from "react-syntax-highlighter/dist/esm/languages/hljs/javascript"
-import json from "react-syntax-highlighter/dist/esm/languages/hljs/json"
-import xml from "react-syntax-highlighter/dist/esm/languages/hljs/xml"
-import bash from "react-syntax-highlighter/dist/esm/languages/hljs/bash"
-import yaml from "react-syntax-highlighter/dist/esm/languages/hljs/yaml"
-import http from "react-syntax-highlighter/dist/esm/languages/hljs/http"
-import powershell from "react-syntax-highlighter/dist/esm/languages/hljs/powershell"
-import javascript from "react-syntax-highlighter/dist/esm/languages/hljs/javascript"
-
-const afterLoad = () => {
-  SyntaxHighlighter.registerLanguage("json", json)
-  SyntaxHighlighter.registerLanguage("js", js)
-  SyntaxHighlighter.registerLanguage("xml", xml)
-  SyntaxHighlighter.registerLanguage("yaml", yaml)
-  SyntaxHighlighter.registerLanguage("http", http)
-  SyntaxHighlighter.registerLanguage("bash", bash)
-  SyntaxHighlighter.registerLanguage("powershell", powershell)
-  SyntaxHighlighter.registerLanguage("javascript", javascript)
-}
-
-export default afterLoad