@upendra19/swagger-ui-custom 1.0.0

package/src/core/plugins/oas3/spec-extensions/selectors.js

@@ -0,0 +1,100 @@
+/**
+ * @prettier
+ */
+import { List, Map } from "immutable"
+
+import {
+  isSwagger2 as isSwagger2Helper,
+  isOAS30 as isOAS30Helper,
+} from "../helpers"
+
+/**
+ * Helpers
+ */
+
+const map = Map()
+
+export const isSwagger2 = () => (system) => {
+  const spec = system.getSystem().specSelectors.specJson()
+  return isSwagger2Helper(spec)
+}
+
+export const isOAS30 = () => (system) => {
+  const spec = system.getSystem().specSelectors.specJson()
+  return isOAS30Helper(spec)
+}
+
+export const isOAS3 = () => (system) => {
+  return system.getSystem().specSelectors.isOAS30()
+}
+
+function onlyOAS3(selector) {
+  return (state, ...args) =>
+    (system) => {
+      if (system.specSelectors.isOAS3()) {
+        const selectedValue = selector(state, ...args)
+        return typeof selectedValue === "function"
+          ? selectedValue(system)
+          : selectedValue
+      } else {
+        return null
+      }
+    }
+}
+
+export const servers = onlyOAS3(() => (system) => {
+  const spec = system.specSelectors.specJson()
+  return spec.get("servers", map)
+})
+
+export const findSchema = (state, schemaName) => {
+  const resolvedSchema = state.getIn(
+    ["resolvedSubtrees", "components", "schemas", schemaName],
+    null
+  )
+  const unresolvedSchema = state.getIn(
+    ["json", "components", "schemas", schemaName],
+    null
+  )
+
+  return resolvedSchema || unresolvedSchema || null
+}
+
+export const callbacksOperations = onlyOAS3(
+  (state, { callbacks, specPath }) =>
+    (system) => {
+      const validOperationMethods = system.specSelectors.validOperationMethods()
+
+      if (!Map.isMap(callbacks)) return {}
+
+      return callbacks
+        .reduce((allOperations, callback, callbackName) => {
+          if (!Map.isMap(callback)) return allOperations
+
+          const callbackOperations = callback.reduce(
+            (callbackOps, pathItem, expression) => {
+              if (!Map.isMap(pathItem)) return callbackOps
+
+              const pathItemOperations = pathItem
+                .entrySeq()
+                .filter(([key]) => validOperationMethods.includes(key))
+                .map(([method, operation]) => ({
+                  operation: Map({ operation }),
+                  method,
+                  path: expression,
+                  callbackName,
+                  specPath: specPath.concat([callbackName, expression, method]),
+                }))
+
+              return callbackOps.concat(pathItemOperations)
+            },
+            List()
+          )
+
+          return allOperations.concat(callbackOperations)
+        }, List())
+        .groupBy((operationDTO) => operationDTO.callbackName)
+        .map((operations) => operations.toArray())
+        .toObject()
+    }
+)

package/src/core/plugins/oas3/spec-extensions/wrap-selectors.js

@@ -0,0 +1,71 @@
+/**
+ * @prettier
+ */
+import { createSelector } from "reselect"
+import constant from "lodash/constant"
+import { specJsonWithResolvedSubtrees } from "../../spec/selectors"
+import { Map } from "immutable"
+
+/**
+ * Helpers
+ */
+
+const map = Map()
+
+function onlyOAS3(selector) {
+  return (ori, system) =>
+    (...args) => {
+      if (system.getSystem().specSelectors.isOAS3()) {
+        const result = selector(...args)
+        return typeof result === "function" ? result(system) : result
+      } else {
+        return ori(...args)
+      }
+    }
+}
+
+const nullSelector = constant(null)
+
+const OAS3NullSelector = onlyOAS3(nullSelector)
+
+/**
+ * Wrappers
+ */
+
+export const findDefinition = onlyOAS3((state, schemaName) => (system) => {
+  return system.getSystem().specSelectors.findSchema(schemaName)
+})
+
+export const definitions = onlyOAS3(() => (system) => {
+  const spec = system.getSystem().specSelectors.specJson()
+  const schemas = spec.getIn(["components", "schemas"])
+  return Map.isMap(schemas) ? schemas : map
+})
+
+export const hasHost = onlyOAS3(() => (system) => {
+  const spec = system.getSystem().specSelectors.specJson()
+  return spec.hasIn(["servers", 0])
+})
+
+export const securityDefinitions = onlyOAS3(
+  createSelector(
+    specJsonWithResolvedSubtrees,
+    (spec) => spec.getIn(["components", "securitySchemes"]) || null
+  )
+)
+
+export const validOperationMethods =
+  (oriSelector, system) =>
+  (state, ...args) => {
+    if (system.specSelectors.isOAS3()) {
+      return system.oas3Selectors.validOperationMethods()
+    }
+
+    return oriSelector(...args)
+  }
+
+export const host = OAS3NullSelector
+export const basePath = OAS3NullSelector
+export const consumes = OAS3NullSelector
+export const produces = OAS3NullSelector
+export const schemes = OAS3NullSelector

package/src/core/plugins/oas3/wrap-components/auth/auth-item.jsx

@@ -0,0 +1,25 @@
+import React from "react"
+import { OAS3ComponentWrapFactory } from "../../helpers"
+
+export default OAS3ComponentWrapFactory(({ Ori, ...props }) => {
+  const {
+    schema, getComponent, errSelectors, authorized, onAuthChange, name, authSelectors
+  } = props
+
+  const HttpAuth = getComponent("HttpAuth")
+  const type = schema.get("type")
+
+
+  if(type === "http") {
+    return <HttpAuth key={ name }
+              schema={ schema }
+              name={ name }
+              errSelectors={ errSelectors }
+              authorized={ authorized }
+              getComponent={ getComponent }
+              onChange={ onAuthChange }
+              authSelectors= { authSelectors }/>
+  } else {
+    return <Ori {...props} />
+  }
+})

package/src/core/plugins/oas3/wrap-components/index.js

@@ -0,0 +1,15 @@
+import Markdown from "./markdown"
+import AuthItem from "./auth/auth-item"
+import OnlineValidatorBadge from "./online-validator-badge"
+import Model from "./model"
+import JsonSchema_string from "./json-schema-string"
+import OpenAPIVersion from "./openapi-version"
+
+export default {
+  Markdown,
+  AuthItem,
+  OpenAPIVersion,
+  JsonSchema_string,
+  model: Model,
+  onlineValidatorBadge: OnlineValidatorBadge,
+}

package/src/core/plugins/oas3/wrap-components/json-schema-string.jsx

@@ -0,0 +1,27 @@
+import React from "react"
+import { OAS3ComponentWrapFactory } from "../helpers"
+
+export default OAS3ComponentWrapFactory(({ Ori, ...props }) => {
+  const {
+    schema,
+    getComponent,
+    errors,
+    onChange,
+    fn
+  } = props
+
+  const isFileUploadIntended = fn.isFileUploadIntended(schema)
+  const Input = getComponent("Input")
+
+  if (isFileUploadIntended) {
+    return <Input type="file"
+                   className={ errors.length ? "invalid" : ""}
+                   title={ errors.length ? errors : ""}
+                   onChange={(e) => {
+                     onChange(e.target.files[0])
+                   }}
+                   disabled={Ori.isDisabled}/>
+  } else {
+    return <Ori {...props} />
+  }
+})

package/src/core/plugins/oas3/wrap-components/markdown.jsx

@@ -0,0 +1,45 @@
+import React from "react"
+import PropTypes from "prop-types"
+import cx from "classnames"
+import { Remarkable } from "remarkable"
+import { OAS3ComponentWrapFactory } from "../helpers"
+import { sanitizer } from "core/components/providers/markdown"
+
+const parser = new Remarkable("commonmark")
+parser.block.ruler.enable(["table"])
+parser.set({ linkTarget: "_blank" })
+
+export const Markdown = ({ source, className = "", getConfigs = () => ({ useUnsafeMarkdown: false }) }) => {
+  if(typeof source !== "string") {
+    return null
+  }
+
+  if ( source ) {
+    const { useUnsafeMarkdown } = getConfigs()
+    const html = parser.render(source)
+    const sanitized = sanitizer(html, { useUnsafeMarkdown })
+
+    let trimmed
+
+    if(typeof sanitized === "string") {
+      trimmed = sanitized.trim()
+    }
+
+    return (
+      <div
+        dangerouslySetInnerHTML={{
+          __html: trimmed
+        }}
+        className={cx(className, "renderedMarkdown")}
+      />
+    )
+  }
+  return null
+}
+Markdown.propTypes = {
+  source: PropTypes.string,
+  className: PropTypes.string,
+  getConfigs: PropTypes.func,
+}
+
+export default OAS3ComponentWrapFactory(Markdown)

package/src/core/plugins/oas3/wrap-components/model.jsx

@@ -0,0 +1,40 @@
+import React, { Component } from "react"
+import PropTypes from "prop-types"
+import { OAS3ComponentWrapFactory } from "../helpers"
+
+class ModelComponent extends Component {
+  static propTypes = {
+    schema: PropTypes.object.isRequired,
+    name: PropTypes.string,
+    getComponent: PropTypes.func.isRequired,
+    getConfigs: PropTypes.func.isRequired,
+    specSelectors: PropTypes.object.isRequired,
+    expandDepth: PropTypes.number,
+    includeReadOnly: PropTypes.bool,
+    includeWriteOnly: PropTypes.bool,
+    Ori: PropTypes.func.isRequired,
+  }
+
+  render(){
+    let { getConfigs, schema, Ori: Model } = this.props
+    let classes = ["model-box"]
+    let isDeprecated = schema.get("deprecated") === true
+    let message = null
+
+    if(isDeprecated) {
+      classes.push("deprecated")
+      message = <span className="model-deprecated-warning">Deprecated:</span>
+    }
+
+    return <div className={classes.join(" ")}>
+      {message}
+      <Model { ...this.props }
+        getConfigs={ getConfigs }
+        depth={ 1 }
+        expandDepth={ this.props.expandDepth || 0 }
+        />
+    </div>
+  }
+}
+
+export default OAS3ComponentWrapFactory(ModelComponent)

package/src/core/plugins/oas3/wrap-components/online-validator-badge.js

@@ -0,0 +1,5 @@
+import { OAS3ComponentWrapFactory } from "../helpers"
+import OnlineValidatorBadge from "core/components/online-validator-badge"
+
+// OAS3 spec is now supported by the online validator.
+export default OAS3ComponentWrapFactory(OnlineValidatorBadge)

package/src/core/plugins/oas3/wrap-components/openapi-version.jsx

@@ -0,0 +1,7 @@
+import React from "react"
+import { OAS30ComponentWrapFactory } from "../helpers"
+
+export default OAS30ComponentWrapFactory((props) => {
+  const { Ori } = props
+  return <Ori oasVersion="3.0" />
+})

package/src/core/plugins/oas31/after-load.js

@@ -0,0 +1,72 @@
+/**
+ * @prettier
+ */
+import {
+  makeIsExpandable,
+  getProperties,
+} from "./json-schema-2020-12-extensions/fn"
+import { wrapOAS31Fn } from "./fn"
+import { makeIsFileUploadIntended } from "./oas3-extensions/fn"
+import { immutableToJS } from "core/utils"
+
+function afterLoad({ fn, getSystem }) {
+  // overrides for fn.jsonSchema202012
+  if (fn.jsonSchema202012) {
+    const isExpandable = makeIsExpandable(
+      fn.jsonSchema202012.isExpandable,
+      getSystem
+    )
+
+    Object.assign(this.fn.jsonSchema202012, { isExpandable, getProperties })
+  }
+
+  // wraps schema generators from samples plugin and make them specific to OpenAPI 3.1 version
+  if (typeof fn.sampleFromSchema === "function" && fn.jsonSchema202012) {
+    const wrappedFns = wrapOAS31Fn(
+      {
+        sampleFromSchema: fn.jsonSchema202012.sampleFromSchema,
+        sampleFromSchemaGeneric: fn.jsonSchema202012.sampleFromSchemaGeneric,
+        createXMLExample: fn.jsonSchema202012.createXMLExample,
+        memoizedSampleFromSchema: fn.jsonSchema202012.memoizedSampleFromSchema,
+        memoizedCreateXMLExample: fn.jsonSchema202012.memoizedCreateXMLExample,
+        getJsonSampleSchema: fn.jsonSchema202012.getJsonSampleSchema,
+        getYamlSampleSchema: fn.jsonSchema202012.getYamlSampleSchema,
+        getXmlSampleSchema: fn.jsonSchema202012.getXmlSampleSchema,
+        getSampleSchema: fn.jsonSchema202012.getSampleSchema,
+        mergeJsonSchema: fn.jsonSchema202012.mergeJsonSchema,
+        getSchemaObjectTypeLabel: (schema) =>
+          fn.jsonSchema202012.getType(immutableToJS(schema)),
+        getSchemaObjectType: (schema) =>
+          fn.jsonSchema202012.foldType(immutableToJS(schema)?.type),
+      },
+      getSystem()
+    )
+
+    Object.assign(this.fn, wrappedFns)
+  }
+
+  // overrides behavior in OpenAPI 3.1.x, recognizes more intentions
+  const isFileUploadIntended = makeIsFileUploadIntended(getSystem)
+  const { isFileUploadIntended: isFileUploadIntendedWrap } = wrapOAS31Fn(
+    {
+      isFileUploadIntended,
+    },
+    getSystem()
+  )
+
+  this.fn.isFileUploadIntended = isFileUploadIntendedWrap
+  this.fn.isFileUploadIntendedOAS31 = isFileUploadIntended
+
+  if (fn.jsonSchema202012) {
+    const { hasSchemaType } = wrapOAS31Fn(
+      {
+        hasSchemaType: fn.jsonSchema202012.hasSchemaType,
+      },
+      getSystem()
+    )
+
+    this.fn.hasSchemaType = hasSchemaType
+  }
+}
+
+export default afterLoad

package/src/core/plugins/oas31/auth-extensions/wrap-selectors.js

@@ -0,0 +1,28 @@
+/**
+ * @prettier
+ */
+import { Map } from "immutable"
+import { createOnlyOAS31SelectorWrapper } from "../fn"
+
+export const definitionsToAuthorize = createOnlyOAS31SelectorWrapper(
+  () => (oriSelector, system) => {
+    const definitions = system.specSelectors.securityDefinitions()
+    let list = oriSelector()
+
+    if (!definitions) return list
+
+    definitions.entrySeq().forEach(([defName, definition]) => {
+      const type = definition?.get("type")
+
+      if (type === "mutualTLS") {
+        list = list.push(
+          new Map({
+            [defName]: definition,
+          })
+        )
+      }
+    })
+
+    return list
+  }
+)

package/src/core/plugins/oas31/components/_all.scss

@@ -0,0 +1,2 @@
+@use "./model/model";
+@use "./models/models";

package/src/core/plugins/oas31/components/auth/auths.jsx

@@ -0,0 +1,186 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import PropTypes from "prop-types"
+import ImPropTypes from "react-immutable-proptypes"
+
+class Auths extends React.Component {
+  static propTypes = {
+    definitions: ImPropTypes.iterable.isRequired,
+    getComponent: PropTypes.func.isRequired,
+    authSelectors: PropTypes.object.isRequired,
+    authActions: PropTypes.object.isRequired,
+    errSelectors: PropTypes.object.isRequired,
+    specSelectors: PropTypes.object.isRequired,
+  }
+
+  constructor(props, context) {
+    super(props, context)
+
+    this.state = {}
+  }
+
+  onAuthChange = (auth) => {
+    let { name } = auth
+
+    this.setState({ [name]: auth })
+  }
+
+  submitAuth = (e) => {
+    e.preventDefault()
+
+    let { authActions } = this.props
+    authActions.authorizeWithPersistOption(this.state)
+  }
+
+  logoutClick = (e) => {
+    e.preventDefault()
+
+    let { authActions, definitions } = this.props
+    let auths = definitions
+      .map((val, key) => {
+        return key
+      })
+      .toArray()
+
+    this.setState(
+      auths.reduce((prev, auth) => {
+        prev[auth] = ""
+        return prev
+      }, {})
+    )
+
+    authActions.logoutWithPersistOption(auths)
+  }
+
+  close = (e) => {
+    e.preventDefault()
+    let { authActions } = this.props
+
+    authActions.showDefinitions(false)
+  }
+
+  render() {
+    let { definitions, getComponent, authSelectors, errSelectors } = this.props
+    const AuthItem = getComponent("AuthItem")
+    const Oauth2 = getComponent("oauth2", true)
+    const Button = getComponent("Button")
+
+    const authorized = authSelectors.authorized()
+    const authorizedAuth = definitions.filter((definition, key) => {
+      return !!authorized.get(key)
+    })
+    const nonOauthDefinitions = definitions.filter(
+      (schema) =>
+        schema.get("type") !== "oauth2" && schema.get("type") !== "mutualTLS"
+    )
+    const oauthDefinitions = definitions.filter(
+      (schema) => schema.get("type") === "oauth2"
+    )
+    const mutualTLSDefinitions = definitions.filter(
+      (schema) => schema.get("type") === "mutualTLS"
+    )
+    return (
+      <div className="auth-container">
+        {nonOauthDefinitions.size > 0 && (
+          <form onSubmit={this.submitAuth}>
+            {nonOauthDefinitions
+              .map((schema, name) => {
+                return (
+                  <AuthItem
+                    key={name}
+                    schema={schema}
+                    name={name}
+                    getComponent={getComponent}
+                    onAuthChange={this.onAuthChange}
+                    authorized={authorized}
+                    errSelectors={errSelectors}
+                    authSelectors={authSelectors}
+                  />
+                )
+              })
+              .toArray()}
+            <div className="auth-btn-wrapper">
+              {nonOauthDefinitions.size === authorizedAuth.size ? (
+                <Button
+                  className="btn modal-btn auth"
+                  onClick={this.logoutClick}
+                  aria-label="Remove authorization"
+                >
+                  Logout
+                </Button>
+              ) : (
+                <Button
+                  type="submit"
+                  className="btn modal-btn auth authorize"
+                  aria-label="Apply credentials"
+                >
+                  Authorize
+                </Button>
+              )}
+              <Button
+                className="btn modal-btn auth btn-done"
+                onClick={this.close}
+              >
+                Close
+              </Button>
+            </div>
+          </form>
+        )}
+
+        {oauthDefinitions.size > 0 ? (
+          <div>
+            <div className="scope-def">
+              <p>
+                Scopes are used to grant an application different levels of
+                access to data on behalf of the end user. Each API may declare
+                one or more scopes.
+              </p>
+              <p>
+                API requires the following scopes. Select which ones you want to
+                grant to Swagger UI.
+              </p>
+            </div>
+            {definitions
+              .filter((schema) => schema.get("type") === "oauth2")
+              .map((schema, name) => {
+                return (
+                  <div key={name}>
+                    <Oauth2
+                      authorized={authorized}
+                      schema={schema}
+                      name={name}
+                    />
+                  </div>
+                )
+              })
+              .toArray()}
+          </div>
+        ) : null}
+        {mutualTLSDefinitions.size > 0 && (
+          <div>
+            {mutualTLSDefinitions
+              .map((schema, name) => {
+                return (
+                  <AuthItem
+                    key={name}
+                    schema={schema}
+                    name={name}
+                    getComponent={getComponent}
+                    onAuthChange={this.onAuthChange}
+                    authorized={authorized}
+                    errSelectors={errSelectors}
+                    authSelectors={authSelectors}
+                  />
+                )
+              })
+              .toArray()}
+          </div>
+        )}
+      </div>
+    )
+  }
+}
+
+export default Auths

package/src/core/plugins/oas31/components/auth/mutual-tls-auth.jsx

@@ -0,0 +1,32 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import PropTypes from "prop-types"
+
+const MutualTLSAuth = ({ schema, getComponent, name, authSelectors }) => {
+  const JumpToPath = getComponent("JumpToPath", true)
+  const path = authSelectors.selectAuthPath(name)
+
+  return (
+    <div>
+      <h4>
+        {name} (mutualTLS) <JumpToPath path={path} />
+      </h4>
+      <p>
+        Mutual TLS is required by this API/Operation. Certificates are managed
+        via your Operating System and/or your browser.
+      </p>
+      <p>{schema.get("description")}</p>
+    </div>
+  )
+}
+
+MutualTLSAuth.propTypes = {
+  schema: PropTypes.object.isRequired,
+  getComponent: PropTypes.func.isRequired,
+  name: PropTypes.string.isRequired,
+  authSelectors: PropTypes.object.isRequired,
+}
+
+export default MutualTLSAuth