@upendra19/swagger-ui-custom 1.0.0

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

@@ -0,0 +1,66 @@
+/**
+ * @prettier
+ */
+import { fromJS } from "immutable"
+
+/**
+ * `authorize` and `logout` wrapped actions provide capacity
+ * to persist cookie based apiKey in document.cookie.
+ *
+ * `persistAuthorization` SwaggerUI options needs to set to `true`
+ * for document.cookie persistence to work.
+ */
+export const authorize = (oriAction, system) => (payload) => {
+  oriAction(payload)
+
+  const configs = system.getConfigs()
+
+  if (!configs.persistAuthorization) return
+
+  // create cookie
+  try {
+    const [{ schema: payloadSchema, value }] = Object.values(payload)
+    const schema = fromJS(payloadSchema)
+    const isApiKeyAuth = schema.get("type") === "apiKey"
+    const isInCookie = schema.get("in") === "cookie"
+    const isApiKeyInCookie = isApiKeyAuth && isInCookie
+
+    if (isApiKeyInCookie) {
+      document.cookie = `${schema.get("name")}=${value}; SameSite=None; Secure`
+    }
+  } catch (error) {
+    console.error(
+      "Error persisting cookie based apiKey in document.cookie.",
+      error
+    )
+  }
+}
+
+export const logout = (oriAction, system) => (payload) => {
+  const configs = system.getConfigs()
+  const authorized = system.authSelectors.authorized()
+
+  // deleting cookie
+  try {
+    if (configs.persistAuthorization && Array.isArray(payload)) {
+      payload.forEach((authorizedName) => {
+        const auth = authorized.get(authorizedName, {})
+        const isApiKeyAuth = auth.getIn(["schema", "type"]) === "apiKey"
+        const isInCookie = auth.getIn(["schema", "in"]) === "cookie"
+        const isApiKeyInCookie = isApiKeyAuth && isInCookie
+
+        if (isApiKeyInCookie) {
+          const cookieName = auth.getIn(["schema", "name"])
+          document.cookie = `${cookieName}=; Max-Age=-99999999`
+        }
+      })
+    }
+  } catch (error) {
+    console.error(
+      "Error deleting cookie based apiKey from document.cookie.",
+      error
+    )
+  }
+
+  oriAction(payload)
+}

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

@@ -0,0 +1,58 @@
+/**
+ * @prettier
+ */
+import { parseConfig } from "./fn"
+
+export const UPDATE_CONFIGS = "configs_update"
+export const TOGGLE_CONFIGS = "configs_toggle"
+
+// Update the configs, with a merge ( not deep )
+export function update(configName, configValue) {
+  return {
+    type: UPDATE_CONFIGS,
+    payload: {
+      [configName]: configValue,
+    },
+  }
+}
+
+// Toggle's the config, by name
+export function toggle(configName) {
+  return {
+    type: TOGGLE_CONFIGS,
+    payload: configName,
+  }
+}
+
+// Hook
+export const loaded = () => () => {
+  // noop
+}
+
+export const downloadConfig = (req) => (system) => {
+  const {
+    fn: { fetch },
+  } = system
+
+  return fetch(req)
+}
+
+export const getConfigByUrl = (req, cb) => (system) => {
+  const { specActions, configsActions } = system
+
+  if (req) {
+    return configsActions.downloadConfig(req).then(next, next)
+  }
+
+  function next(res) {
+    if (res instanceof Error || res.status >= 400) {
+      specActions.updateLoadingStatus("failedConfig")
+      specActions.updateLoadingStatus("failedConfig")
+      specActions.updateUrl("")
+      console.error(res.statusText + " " + req.url)
+      cb(null)
+    } else {
+      cb(parseConfig(res.text, system))
+    }
+  }
+}

package/src/core/plugins/configs/fn.js

@@ -0,0 +1,12 @@
+import YAML from "js-yaml"
+
+export const parseConfig = (yaml, system) => {
+  try {
+    return YAML.load(yaml)
+  } catch(e) {
+    if (system) {
+      system.errActions.newThrownErr( new Error(e) )
+    }
+    return {}
+  }
+}

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

@@ -0,0 +1,16 @@
+import * as actions from "./actions"
+import * as selectors from "./selectors"
+import reducers from "./reducers"
+
+export default function configsPlugin() {
+
+  return {
+    statePlugins: {
+      configs: {
+        reducers,
+        actions,
+        selectors,
+      }
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+import { fromJS } from "immutable"
+
+import {
+	UPDATE_CONFIGS,
+	TOGGLE_CONFIGS,
+} from "./actions"
+
+export default {
+
+  [UPDATE_CONFIGS]: (state, action) => {
+    return state.merge(fromJS(action.payload))
+  },
+
+  [TOGGLE_CONFIGS]: (state, action) => {
+    const configName = action.payload
+    const oriVal = state.get(configName)
+    return state.set(configName, !oriVal)
+  },
+
+}

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

@@ -0,0 +1,4 @@
+// Just get the config value ( it can possibly be an immutable object)
+export const get = (state, path) => {
+  return state.getIn(Array.isArray(path) ? path : [path])
+}

package/src/core/plugins/deep-linking/README.md

@@ -0,0 +1 @@
+See `docs/deep-linking.md`.

package/src/core/plugins/deep-linking/helpers.js

@@ -0,0 +1,7 @@
+export const setHash = (value) => {
+  if(value) {
+    return history.pushState(null, null, `#${value}`)
+  } else {
+    return window.location.hash = ""
+  }
+}

package/src/core/plugins/deep-linking/index.js

@@ -0,0 +1,24 @@
+import layout from "./layout"
+import OperationWrapper from "./operation-wrapper"
+import OperationTagWrapper from "./operation-tag-wrapper"
+
+export default function() {
+  return [layout, {
+    statePlugins: {
+      configs: {
+        wrapActions: {
+          loaded: (ori, system) => (...args) => {
+            ori(...args)
+            // location.hash was an UTF-16 String, here is required UTF-8
+            const hash = decodeURIComponent(window.location.hash)
+            system.layoutActions.parseDeepLinkHash(hash)
+          }
+        }
+      }
+    },
+    wrapComponents: {
+      operation: OperationWrapper,
+      OperationTag: OperationTagWrapper,
+    },
+  }]
+}

package/src/core/plugins/deep-linking/layout.js

@@ -0,0 +1,209 @@
+import { setHash } from "./helpers"
+import zenscroll from "zenscroll"
+import { createDeepLinkPath } from "core/utils"
+import Im, { fromJS } from "immutable"
+
+const SCROLL_TO = "layout_scroll_to"
+const CLEAR_SCROLL_TO = "layout_clear_scroll"
+
+export const show = (ori, { getConfigs, layoutSelectors }) => (...args) => {
+  ori(...args)
+
+  if(!getConfigs().deepLinking) {
+    return
+  }
+
+  try {
+    let [tokenArray, shown] = args
+    //Coerce in to array
+    tokenArray = Array.isArray(tokenArray) ? tokenArray : [tokenArray]
+    // Convert into something we can put in the URL hash
+    // Or return empty, if we cannot
+    const urlHashArray = layoutSelectors.urlHashArrayFromIsShownKey(tokenArray) // Will convert
+
+    // No hash friendly list?
+    if(!urlHashArray.length)
+      return
+
+    const [type, assetName] = urlHashArray
+
+    if (!shown) {
+      return setHash("/")
+    }
+
+    if (urlHashArray.length === 2) {
+      setHash(createDeepLinkPath(`/${encodeURIComponent(type)}/${encodeURIComponent(assetName)}`))
+    } else if (urlHashArray.length === 1) {
+      setHash(createDeepLinkPath(`/${encodeURIComponent(type)}`))
+    }
+
+  } catch (e) {
+    // This functionality is not mission critical, so if something goes wrong
+    // we'll just move on
+    console.error(e) // eslint-disable-line no-console
+  }
+}
+
+export const scrollTo = (path) => {
+  return {
+    type: SCROLL_TO,
+    payload: Array.isArray(path) ? path : [path]
+  }
+}
+
+export const parseDeepLinkHash = (rawHash) => ({ layoutActions, layoutSelectors, getConfigs }) => {
+
+  if(!getConfigs().deepLinking) {
+    return
+  }
+
+  if(rawHash) {
+    let hash = rawHash.slice(1) // # is first character
+
+
+    if(hash[0] === "!") {
+      // Parse UI 2.x shebangs
+      hash = hash.slice(1)
+    }
+
+    if(hash[0] === "/") {
+      // "/pet/addPet" => "pet/addPet"
+      // makes the split result cleaner
+      // also handles forgotten leading slash
+      hash = hash.slice(1)
+    }
+
+    const hashArray = hash.split("/").map(val => (val || ""))
+
+    const isShownKey = layoutSelectors.isShownKeyFromUrlHashArray(hashArray)
+
+    const [type, tagId = "", maybeOperationId = ""] = isShownKey
+
+    if(type === "operations") {
+      // we're going to show an operation, so we need to expand the tag as well
+      const tagIsShownKey = layoutSelectors.isShownKeyFromUrlHashArray([tagId])
+
+      // If an `_` is present, trigger the legacy escaping behavior to be safe
+      // TODO: remove this in v4.0, it is deprecated
+      if(tagId.indexOf("_") > -1) {
+        console.warn("Warning: escaping deep link whitespace with `_` will be unsupported in v4.0, use `%20` instead.")
+        layoutActions.show(tagIsShownKey.map(val => val.replace(/_/g, " ")), true)
+      }
+
+      layoutActions.show(tagIsShownKey, true)
+    }
+
+    // If an `_` is present, trigger the legacy escaping behavior to be safe
+    // TODO: remove this in v4.0, it is deprecated
+    if (tagId.indexOf("_") > -1 || maybeOperationId.indexOf("_") > -1) {
+      console.warn("Warning: escaping deep link whitespace with `_` will be unsupported in v4.0, use `%20` instead.")
+      layoutActions.show(isShownKey.map(val => val.replace(/_/g, " ")), true)
+    }
+
+    layoutActions.show(isShownKey, true)
+
+    // Scroll to the newly expanded entity
+    layoutActions.scrollTo(isShownKey)
+  }
+}
+
+export const readyToScroll = (isShownKey, ref) => (system) => {
+  const scrollToKey = system.layoutSelectors.getScrollToKey()
+
+  if(Im.is(scrollToKey, fromJS(isShownKey))) {
+    system.layoutActions.scrollToElement(ref)
+    system.layoutActions.clearScrollTo()
+  }
+}
+
+// Scroll to "ref" (dom node) with the scrollbar on "container" or the nearest parent
+export const scrollToElement = (ref, container) => (system) => {
+  try {
+    container = container || system.fn.getScrollParent(ref)
+    let myScroller = zenscroll.createScroller(container)
+    myScroller.to(ref)
+  } catch(e) {
+    console.error(e) // eslint-disable-line no-console
+  }
+}
+
+export const clearScrollTo = () => {
+  return {
+    type: CLEAR_SCROLL_TO,
+  }
+}
+
+// From: https://stackoverflow.com/a/42543908/3933724
+// Modified to return html instead of body element as last resort
+function getScrollParent(element, includeHidden) {
+  const LAST_RESORT = document.documentElement
+  let style = getComputedStyle(element)
+  const excludeStaticParent = style.position === "absolute"
+  const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/
+
+  if (style.position === "fixed")
+    return LAST_RESORT
+  for (let parent = element; (parent = parent.parentElement);) {
+    style = getComputedStyle(parent)
+    if (excludeStaticParent && style.position === "static") {
+      continue
+    }
+    if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX))
+      return parent
+  }
+
+  return LAST_RESORT
+}
+
+export default {
+  fn: {
+    getScrollParent,
+  },
+  statePlugins: {
+    layout: {
+      actions: {
+        scrollToElement,
+        scrollTo,
+        clearScrollTo,
+        readyToScroll,
+        parseDeepLinkHash
+      },
+      selectors: {
+        getScrollToKey(state) {
+          return state.get("scrollToKey")
+        },
+        isShownKeyFromUrlHashArray(state, urlHashArray) {
+          const [tag, operationId] = urlHashArray
+          // We only put operations in the URL
+          if(operationId) {
+            return ["operations", tag, operationId]
+          } else if (tag) {
+            return ["operations-tag", tag]
+          }
+          return []
+        },
+        urlHashArrayFromIsShownKey(state, isShownKey) {
+          let [type, tag, operationId] = isShownKey
+          // We only put operations in the URL
+          if(type == "operations") {
+            return [tag, operationId]
+          } else if (type == "operations-tag") {
+            return [tag]
+          }
+          return []
+        },
+      },
+      reducers: {
+        [SCROLL_TO](state, action) {
+          return state.set("scrollToKey", Im.fromJS(action.payload))
+        },
+        [CLEAR_SCROLL_TO](state) {
+          return state.delete("scrollToKey")
+        }
+      },
+      wrapActions: {
+        show
+      }
+    }
+  }
+}

package/src/core/plugins/deep-linking/operation-tag-wrapper.jsx

@@ -0,0 +1,25 @@
+import React from "react"
+import { PropTypes } from "prop-types"
+
+const Wrapper = (Ori, system) => class OperationTagWrapper extends React.Component {
+
+  static propTypes = {
+    tag: PropTypes.object.isRequired,
+  }
+
+  onLoad = (ref) => {
+    const { tag } = this.props
+    const isShownKey = ["operations-tag", tag]
+    system.layoutActions.readyToScroll(isShownKey, ref)
+  }
+
+  render() {
+    return (
+      <span ref={this.onLoad}>
+        <Ori {...this.props} />
+      </span>
+    )
+  }
+}
+
+export default Wrapper

package/src/core/plugins/deep-linking/operation-wrapper.jsx

@@ -0,0 +1,27 @@
+import React from "react"
+import ImPropTypes from "react-immutable-proptypes"
+
+const Wrapper = (Ori, system) => class OperationWrapper extends React.Component {
+
+  static propTypes = {
+    operation: ImPropTypes.map.isRequired,
+  }
+
+  onLoad = (ref) => {
+    const { operation } = this.props
+    const { tag, operationId } = operation.toObject()
+    let { isShownKey } = operation.toObject()
+    isShownKey = isShownKey || ["operations", tag, operationId]
+    system.layoutActions.readyToScroll(isShownKey, ref)
+  }
+
+  render() {
+    return (
+      <span ref={this.onLoad}>
+        <Ori {...this.props} />
+      </span>
+    )
+  }
+}
+
+export default Wrapper

package/src/core/plugins/download-url/index.js

@@ -0,0 +1,126 @@
+/**
+ * @prettier
+ */
+import { createSelector } from "reselect"
+import { Map } from "immutable"
+import win from "core/window"
+
+export default function downloadUrlPlugin(toolbox) {
+  let { fn } = toolbox
+
+  const actions = {
+    download:
+      (url) =>
+      ({ errActions, specSelectors, specActions, getConfigs }) => {
+        let { fetch } = fn
+        const config = getConfigs()
+        url = url || specSelectors.url()
+        specActions.updateLoadingStatus("loading")
+        errActions.clear({ source: "fetch" })
+        fetch({
+          url,
+          loadSpec: true,
+          requestInterceptor: config.requestInterceptor || ((a) => a),
+          responseInterceptor: config.responseInterceptor || ((a) => a),
+          credentials: "same-origin",
+          headers: {
+            Accept: "application/json,*/*",
+          },
+        }).then(next, next)
+
+        function next(res) {
+          if (res instanceof Error || res.status >= 400) {
+            specActions.updateLoadingStatus("failed")
+            errActions.newThrownErr(
+              Object.assign(
+                new Error((res.message || res.statusText) + " " + url),
+                { source: "fetch" }
+              )
+            )
+            // Check if the failure was possibly due to CORS or mixed content
+            if (!res.status && res instanceof Error) checkPossibleFailReasons()
+            return
+          }
+          specActions.updateLoadingStatus("success")
+          specActions.updateSpec(res.text)
+          if (specSelectors.url() !== url) {
+            specActions.updateUrl(url)
+          }
+        }
+
+        function checkPossibleFailReasons() {
+          try {
+            let specUrl
+
+            if ("URL" in win) {
+              specUrl = new URL(url)
+            } else {
+              // legacy browser, use <a href> to parse the URL
+              specUrl = document.createElement("a")
+              specUrl.href = url
+            }
+
+            if (
+              specUrl.protocol !== "https:" &&
+              win.location.protocol === "https:"
+            ) {
+              const error = Object.assign(
+                new Error(
+                  `Possible mixed-content issue? The page was loaded over https:// but a ${specUrl.protocol}// URL was specified. Check that you are not attempting to load mixed content.`
+                ),
+                { source: "fetch" }
+              )
+              errActions.newThrownErr(error)
+              return
+            }
+            if (specUrl.origin !== win.location.origin) {
+              const error = Object.assign(
+                new Error(
+                  `Possible cross-origin (CORS) issue? The URL origin (${specUrl.origin}) does not match the page (${win.location.origin}). Check the server returns the correct 'Access-Control-Allow-*' headers.`
+                ),
+                { source: "fetch" }
+              )
+              errActions.newThrownErr(error)
+            }
+          } catch (e) {
+            return
+          }
+        }
+      },
+
+    updateLoadingStatus: (status) => {
+      let enums = [null, "loading", "failed", "success", "failedConfig"]
+      if (enums.indexOf(status) === -1) {
+        console.error(`Error: ${status} is not one of ${JSON.stringify(enums)}`)
+      }
+
+      return {
+        type: "spec_update_loading_status",
+        payload: status,
+      }
+    },
+  }
+
+  let reducers = {
+    spec_update_loading_status: (state, action) => {
+      return typeof action.payload === "string"
+        ? state.set("loadingStatus", action.payload)
+        : state
+    },
+  }
+
+  let selectors = {
+    loadingStatus: createSelector(
+      (state) => {
+        return state || Map()
+      },
+      (spec) => spec.get("loadingStatus") || null
+    ),
+  }
+
+  return {
+    statePlugins: {
+      spec: { actions, reducers, selectors },
+    },
+  }
+}

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

@@ -0,0 +1,60 @@
+import { serializeError } from "serialize-error"
+
+export const NEW_THROWN_ERR = "err_new_thrown_err"
+export const NEW_THROWN_ERR_BATCH = "err_new_thrown_err_batch"
+export const NEW_SPEC_ERR = "err_new_spec_err"
+export const NEW_SPEC_ERR_BATCH = "err_new_spec_err_batch"
+export const NEW_AUTH_ERR = "err_new_auth_err"
+export const CLEAR = "err_clear"
+export const CLEAR_BY = "err_clear_by"
+
+export function newThrownErr(err) {
+  return {
+      type: NEW_THROWN_ERR,
+      payload: serializeError(err)
+  }
+}
+
+export function newThrownErrBatch(errors) {
+  return {
+      type: NEW_THROWN_ERR_BATCH,
+      payload: errors
+  }
+}
+
+export function newSpecErr(err) {
+  return {
+      type: NEW_SPEC_ERR,
+      payload: err
+  }
+}
+
+export function newSpecErrBatch(errArray) {
+  return {
+      type: NEW_SPEC_ERR_BATCH,
+      payload: errArray
+  }
+}
+
+export function newAuthErr(err) {
+  return {
+    type: NEW_AUTH_ERR,
+    payload: err
+  }
+}
+
+export function clear(filter = {}) {
+  // filter looks like: {type: 'spec'}, {source: 'parser'}
+  return {
+    type: CLEAR,
+    payload: filter
+  }
+}
+
+export function clearBy(filter = () => true) {
+  // filter is a function
+  return {
+    type: CLEAR_BY,
+    payload: filter
+  }
+}

package/src/core/plugins/err/error-transformers/README.md

@@ -0,0 +1,31 @@
+# Error transformers
+
+Error transformers provide a standard interface for making generated error messages more useful to end users.
+
+### Inputs & outputs
+
+Each transformer's `transform` function is given an Immutable List of Immutable Maps as its first argument.
+
+It is expected that each `transform` function returns a List of similarly-formed Maps.
+
+These errors originate from the Redux error actions that add errors to state. Errors are transformed before being passed into the reducer.
+
+It's important that all the keys present in each error (specifically, `line`, `level`, `message`, `source`, and `type`) are present when the transformer is finished.
+
+##### Deleting an error
+
+If you want to delete an error completely, you can overwrite it with `null`. The null value will be filtered out of the transformed error array before the errors are returned.
+å
+
+### Example transformer
+
+This transformer will increase all your line numbers by 10.
+
+```
+export function transform(errors) {
+  return errors.map(err => {
+    err.line += 10
+    return err
+  })
+}
+```