@upendra19/swagger-ui-custom 1.0.0

package/src/core/plugins/oas31/json-schema-2020-12-extensions/components/keywords/Properties.jsx

@@ -0,0 +1,60 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import PropTypes from "prop-types"
+import classNames from "classnames"
+
+const Properties = ({ schema, getSystem }) => {
+  const { fn, getComponent } = getSystem()
+  const { useComponent, usePath } = fn.jsonSchema202012
+  const { getDependentRequired, getProperties } = fn.jsonSchema202012.useFn()
+  const config = fn.jsonSchema202012.useConfig()
+  const required = Array.isArray(schema?.required) ? schema.required : []
+  const { path } = usePath("properties")
+  const JSONSchema = useComponent("JSONSchema")
+  const JSONSchemaPathContext = getComponent("JSONSchema202012PathContext")()
+  const properties = getProperties(schema, config)
+
+  /**
+   * Rendering.
+   */
+  if (Object.keys(properties).length === 0) {
+    return null
+  }
+
+  return (
+    <JSONSchemaPathContext.Provider value={path}>
+      <div className="json-schema-2020-12-keyword json-schema-2020-12-keyword--properties">
+        <ul>
+          {Object.entries(properties).map(([propertyName, propertySchema]) => {
+            const isRequired = required.includes(propertyName)
+            const dependentRequired = getDependentRequired(propertyName, schema)
+
+            return (
+              <li
+                key={propertyName}
+                className={classNames("json-schema-2020-12-property", {
+                  "json-schema-2020-12-property--required": isRequired,
+                })}
+              >
+                <JSONSchema
+                  name={propertyName}
+                  schema={propertySchema}
+                  dependentRequired={dependentRequired}
+                />
+              </li>
+            )
+          })}
+        </ul>
+      </div>
+    </JSONSchemaPathContext.Provider>
+  )
+}
+
+Properties.propTypes = {
+  schema: PropTypes.oneOfType([PropTypes.object, PropTypes.bool]).isRequired,
+  getSystem: PropTypes.func.isRequired,
+}
+
+export default Properties

package/src/core/plugins/oas31/json-schema-2020-12-extensions/components/keywords/Xml.jsx

@@ -0,0 +1,162 @@
+/**
+ * @prettier
+ */
+import React, { useCallback } from "react"
+import PropTypes from "prop-types"
+import classNames from "classnames"
+import { getExtensions } from "../../../../../utils"
+
+const Xml = ({ schema, getSystem }) => {
+  const xml = schema?.xml || {}
+  const { fn, getComponent, getConfigs } = getSystem()
+  const { showExtensions } = getConfigs()
+  const { useComponent, useIsExpanded, usePath, useLevel } = fn.jsonSchema202012
+  const pathToken = "xml"
+  const { path } = usePath(pathToken)
+  const { isExpanded, setExpanded, setCollapsed } = useIsExpanded(pathToken)
+  const [level, nextLevel] = useLevel()
+  const extensions = showExtensions ? getExtensions(xml) : []
+  const isExpandable = !!(
+    xml.name ||
+    xml.namespace ||
+    xml.prefix ||
+    extensions.length > 0
+  )
+  const Accordion = useComponent("Accordion")
+  const ExpandDeepButton = useComponent("ExpandDeepButton")
+  const OpenAPI31Extensions = getComponent("OpenAPI31Extensions")
+  const JSONSchemaPathContext = getComponent("JSONSchema202012PathContext")()
+  const JSONSchemaLevelContext = getComponent("JSONSchema202012LevelContext")()
+
+  /**
+   * Event handlers.
+   */
+  const handleExpansion = useCallback(() => {
+    if (isExpanded) {
+      setCollapsed()
+    } else {
+      setExpanded()
+    }
+  }, [isExpanded, setExpanded, setCollapsed])
+  const handleExpansionDeep = useCallback(
+    (e, expandedDeepNew) => {
+      if (expandedDeepNew) {
+        setExpanded({ deep: true })
+      } else {
+        setCollapsed({ deep: true })
+      }
+    },
+    [setExpanded, setCollapsed]
+  )
+
+  /**
+   * Rendering.
+   */
+  if (Object.keys(xml).length === 0) {
+    return null
+  }
+
+  return (
+    <JSONSchemaPathContext.Provider value={path}>
+      <JSONSchemaLevelContext.Provider value={nextLevel}>
+        <div
+          className="json-schema-2020-12-keyword json-schema-2020-12-keyword--xml"
+          data-json-schema-level={level}
+        >
+          {isExpandable ? (
+            <>
+              <Accordion expanded={isExpanded} onChange={handleExpansion}>
+                <span className="json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary">
+                  XML
+                </span>
+              </Accordion>
+              <ExpandDeepButton
+                expanded={isExpanded}
+                onClick={handleExpansionDeep}
+              />
+            </>
+          ) : (
+            <span className="json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary">
+              XML
+            </span>
+          )}
+          {xml.attribute === true && (
+            <span className="json-schema-2020-12__attribute json-schema-2020-12__attribute--muted">
+              attribute
+            </span>
+          )}
+          {xml.wrapped === true && (
+            <span className="json-schema-2020-12__attribute json-schema-2020-12__attribute--muted">
+              wrapped
+            </span>
+          )}
+          <strong className="json-schema-2020-12__attribute json-schema-2020-12__attribute--primary">
+            object
+          </strong>
+          <ul
+            className={classNames("json-schema-2020-12-keyword__children", {
+              "json-schema-2020-12-keyword__children--collapsed": !isExpanded,
+            })}
+          >
+            {isExpanded && (
+              <>
+                {xml.name && (
+                  <li className="json-schema-2020-12-property">
+                    <div className="json-schema-2020-12-keyword json-schema-2020-12-keyword">
+                      <span className="json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary">
+                        name
+                      </span>
+                      <span className="json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary">
+                        {xml.name}
+                      </span>
+                    </div>
+                  </li>
+                )}
+
+                {xml.namespace && (
+                  <li className="json-schema-2020-12-property">
+                    <div className="json-schema-2020-12-keyword">
+                      <span className="json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary">
+                        namespace
+                      </span>
+                      <span className="json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary">
+                        {xml.namespace}
+                      </span>
+                    </div>
+                  </li>
+                )}
+
+                {xml.prefix && (
+                  <li className="json-schema-2020-12-property">
+                    <div className="json-schema-2020-12-keyword">
+                      <span className="json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary">
+                        prefix
+                      </span>
+                      <span className="json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary">
+                        {xml.prefix}
+                      </span>
+                    </div>
+                  </li>
+                )}
+              </>
+            )}
+            {extensions.length > 0 && (
+              <OpenAPI31Extensions
+                openAPISpecObj={xml}
+                openAPIExtensions={extensions}
+                getSystem={getSystem}
+              />
+            )}
+          </ul>
+        </div>
+      </JSONSchemaLevelContext.Provider>
+    </JSONSchemaPathContext.Provider>
+  )
+}
+
+Xml.propTypes = {
+  schema: PropTypes.oneOfType([PropTypes.object, PropTypes.bool]).isRequired,
+  getSystem: PropTypes.func.isRequired,
+}
+
+export default Xml

package/src/core/plugins/oas31/json-schema-2020-12-extensions/fn.js

@@ -0,0 +1,57 @@
+/**
+ * @prettier
+ */
+export const makeIsExpandable = (original, getSystem) => {
+  const { fn } = getSystem()
+
+  if (typeof original !== "function") {
+    return null
+  }
+
+  const { hasKeyword } = fn.jsonSchema202012
+
+  return (schema) =>
+    original(schema) ||
+    hasKeyword(schema, "example") ||
+    schema?.xml ||
+    schema?.discriminator ||
+    schema?.externalDocs
+}
+
+export const getProperties = (
+  schema,
+  { includeReadOnly, includeWriteOnly }
+) => {
+  // shortcut
+  if (!schema?.properties) return {}
+
+  const properties = Object.entries(schema.properties)
+  const filteredProperties = properties.filter(([, value]) => {
+    const isReadOnly = value?.readOnly === true
+    const isWriteOnly = value?.writeOnly === true
+
+    return (
+      (!isReadOnly || includeReadOnly) && (!isWriteOnly || includeWriteOnly)
+    )
+  })
+
+  return Object.fromEntries(filteredProperties)
+}
+
+export const makeGetSchemaKeywords = (original) => {
+  if (typeof original !== "function") {
+    return null
+  }
+
+  const jsonSchema202012Keywords = original()
+
+  return () => [
+    ...jsonSchema202012Keywords,
+    "discriminator",
+    "xml",
+    "externalDocs",
+    "example",
+    // $$ref is an internal keyword used for dereferencing
+    "$$ref",
+  ]
+}

package/src/core/plugins/oas31/json-schema-2020-12-extensions/wrap-components/keywords/Description.jsx

@@ -0,0 +1,9 @@
+/**
+ * @prettier
+ */
+import DescriptionKeyword from "../../components/keywords/Description"
+import { createOnlyOAS31ComponentWrapper } from "../../../fn"
+
+const DescriptionWrapper = createOnlyOAS31ComponentWrapper(DescriptionKeyword)
+
+export default DescriptionWrapper

package/src/core/plugins/oas31/json-schema-2020-12-extensions/wrap-components/keywords/Examples.jsx

@@ -0,0 +1,31 @@
+/**
+ * @prettier
+ */
+import React from "react"
+import { createOnlyOAS31ComponentWrapper } from "../../../fn"
+
+const ExamplesWrapper = createOnlyOAS31ComponentWrapper(
+  ({ schema, getSystem, originalComponent: KeywordExamples }) => {
+    const { getComponent } = getSystem()
+    const KeywordDiscriminator = getComponent(
+      "JSONSchema202012KeywordDiscriminator"
+    )
+    const KeywordXml = getComponent("JSONSchema202012KeywordXml")
+    const KeywordExample = getComponent("JSONSchema202012KeywordExample")
+    const KeywordExternalDocs = getComponent(
+      "JSONSchema202012KeywordExternalDocs"
+    )
+
+    return (
+      <>
+        <KeywordExamples schema={schema} />
+        <KeywordDiscriminator schema={schema} getSystem={getSystem} />
+        <KeywordXml schema={schema} getSystem={getSystem} />
+        <KeywordExternalDocs schema={schema} getSystem={getSystem} />
+        <KeywordExample schema={schema} getSystem={getSystem} />
+      </>
+    )
+  }
+)
+
+export default ExamplesWrapper

package/src/core/plugins/oas31/json-schema-2020-12-extensions/wrap-components/keywords/Properties.jsx

@@ -0,0 +1,9 @@
+/**
+ * @prettier
+ */
+import PropertiesKeyword from "../../components/keywords/Properties"
+import { createOnlyOAS31ComponentWrapper } from "../../../fn"
+
+const PropertiesWrapper = createOnlyOAS31ComponentWrapper(PropertiesKeyword)
+
+export default PropertiesWrapper

package/src/core/plugins/oas31/oas3-extensions/fn.js

@@ -0,0 +1,46 @@
+/**
+ * @prettier
+ */
+import { Map } from "immutable"
+import isPlainObject from "lodash/isPlainObject"
+
+export const makeIsFileUploadIntended = (getSystem) => {
+  const isFileUploadIntended = (schema, mediaType = null) => {
+    const { fn } = getSystem()
+
+    /**
+     *  Return `true` early if the media type indicates a file upload
+     *  or if a combination of type: `string` and format: `binary/byte` is detected.
+     *  This ensures support for empty Media Type Objects,
+     *  as the schema check is performed later.
+     */
+    const isFileUploadIntendedOAS30 = fn.isFileUploadIntendedOAS30(
+      schema,
+      mediaType
+    )
+
+    if (isFileUploadIntendedOAS30) {
+      return true
+    }
+
+    const isSchemaImmutable = Map.isMap(schema)
+
+    if (!isSchemaImmutable && !isPlainObject(schema)) {
+      return false
+    }
+
+    const contentMediaType = isSchemaImmutable
+      ? schema.get("contentMediaType")
+      : schema.contentMediaType
+    const contentEncoding = isSchemaImmutable
+      ? schema.get("contentEncoding")
+      : schema.contentEncoding
+
+    return (
+      (typeof contentMediaType === "string" && contentMediaType !== "") ||
+      (typeof contentEncoding === "string" && contentEncoding !== "")
+    )
+  }
+
+  return isFileUploadIntended
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @prettier
+ */
+import { createSelector } from "reselect"
+
+import { safeBuildUrl } from "core/utils/url"
+
+export const selectLicenseUrl = createSelector(
+  [
+    (state, system) => system.specSelectors.url(),
+    (state, system) => system.oas3Selectors.selectedServer(),
+    (state, system) => system.specSelectors.selectLicenseUrlField(),
+    (state, system) => system.specSelectors.selectLicenseIdentifierField(),
+  ],
+  (specUrl, selectedServer, url, identifier) => {
+    if (url) {
+      return safeBuildUrl(url, specUrl, { selectedServer })
+    }
+
+    if (identifier) {
+      return `https://spdx.org/licenses/${identifier}.html`
+    }
+
+    return undefined
+  }
+)

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

@@ -0,0 +1,198 @@
+/**
+ * @prettier
+ */
+import { List, Map } from "immutable"
+import { createSelector } from "reselect"
+
+import { safeBuildUrl } from "core/utils/url"
+import { isOAS31 as isOAS31Fn } from "../fn"
+
+const map = Map()
+
+export const isOAS31 = createSelector(
+  (state, system) => system.specSelectors.specJson(),
+  isOAS31Fn
+)
+
+export const webhooks = () => (system) => {
+  const webhooks = system.specSelectors.specJson().get("webhooks")
+  return Map.isMap(webhooks) ? webhooks : map
+}
+
+/**
+ * `specResolvedSubtree` selector is needed as input selector,
+ * so that we regenerate the selected result whenever the lazy
+ * resolution happens.
+ */
+export const selectWebhooksOperations = createSelector(
+  [
+    (state, system) => system.specSelectors.webhooks(),
+    (state, system) => system.specSelectors.validOperationMethods(),
+    (state, system) => system.specSelectors.specResolvedSubtree(["webhooks"]),
+  ],
+  (webhooks, validOperationMethods) =>
+    webhooks
+      .reduce((allOperations, pathItem, pathItemName) => {
+        if (!Map.isMap(pathItem)) return allOperations
+
+        const pathItemOperations = pathItem
+          .entrySeq()
+          .filter(([key]) => validOperationMethods.includes(key))
+          .map(([method, operation]) => ({
+            operation: Map({ operation }),
+            method,
+            path: pathItemName,
+            specPath: ["webhooks", pathItemName, method],
+          }))
+
+        return allOperations.concat(pathItemOperations)
+      }, List())
+      .groupBy((operationDTO) => operationDTO.path)
+      .map((operations) => operations.toArray())
+      .toObject()
+)
+
+export const license = () => (system) => {
+  const license = system.specSelectors.info().get("license")
+  return Map.isMap(license) ? license : map
+}
+
+export const selectLicenseNameField = () => (system) => {
+  return system.specSelectors.license().get("name", "License")
+}
+
+export const selectLicenseUrlField = () => (system) => {
+  return system.specSelectors.license().get("url")
+}
+
+export const selectLicenseUrl = createSelector(
+  [
+    (state, system) => system.specSelectors.url(),
+    (state, system) => system.oas3Selectors.selectedServer(),
+    (state, system) => system.specSelectors.selectLicenseUrlField(),
+  ],
+  (specUrl, selectedServer, url) => {
+    if (url) {
+      return safeBuildUrl(url, specUrl, { selectedServer })
+    }
+
+    return undefined
+  }
+)
+
+export const selectLicenseIdentifierField = () => (system) => {
+  return system.specSelectors.license().get("identifier")
+}
+
+export const contact = () => (system) => {
+  const contact = system.specSelectors.info().get("contact")
+  return Map.isMap(contact) ? contact : map
+}
+
+export const selectContactNameField = () => (system) => {
+  return system.specSelectors.contact().get("name", "the developer")
+}
+
+export const selectContactEmailField = () => (system) => {
+  return system.specSelectors.contact().get("email")
+}
+
+export const selectContactUrlField = () => (system) => {
+  return system.specSelectors.contact().get("url")
+}
+
+export const selectContactUrl = createSelector(
+  [
+    (state, system) => system.specSelectors.url(),
+    (state, system) => system.oas3Selectors.selectedServer(),
+    (state, system) => system.specSelectors.selectContactUrlField(),
+  ],
+  (specUrl, selectedServer, url) => {
+    if (url) {
+      return safeBuildUrl(url, specUrl, { selectedServer })
+    }
+
+    return undefined
+  }
+)
+
+export const selectInfoTitleField = () => (system) => {
+  return system.specSelectors.info().get("title")
+}
+
+export const selectInfoSummaryField = () => (system) => {
+  return system.specSelectors.info().get("summary")
+}
+
+export const selectInfoDescriptionField = () => (system) => {
+  return system.specSelectors.info().get("description")
+}
+
+export const selectInfoTermsOfServiceField = () => (system) => {
+  return system.specSelectors.info().get("termsOfService")
+}
+
+export const selectInfoTermsOfServiceUrl = createSelector(
+  [
+    (state, system) => system.specSelectors.url(),
+    (state, system) => system.oas3Selectors.selectedServer(),
+    (state, system) => system.specSelectors.selectInfoTermsOfServiceField(),
+  ],
+  (specUrl, selectedServer, termsOfService) => {
+    if (termsOfService) {
+      return safeBuildUrl(termsOfService, specUrl, { selectedServer })
+    }
+
+    return undefined
+  }
+)
+
+export const selectExternalDocsDescriptionField = () => (system) => {
+  return system.specSelectors.externalDocs().get("description")
+}
+
+export const selectExternalDocsUrlField = () => (system) => {
+  return system.specSelectors.externalDocs().get("url")
+}
+
+export const selectExternalDocsUrl = createSelector(
+  [
+    (state, system) => system.specSelectors.url(),
+    (state, system) => system.oas3Selectors.selectedServer(),
+    (state, system) => system.specSelectors.selectExternalDocsUrlField(),
+  ],
+  (specUrl, selectedServer, url) => {
+    if (url) {
+      return safeBuildUrl(url, specUrl, { selectedServer })
+    }
+
+    return undefined
+  }
+)
+
+export const selectJsonSchemaDialectField = () => (system) => {
+  return system.specSelectors.specJson().get("jsonSchemaDialect")
+}
+
+export const selectJsonSchemaDialectDefault = () =>
+  "https://spec.openapis.org/oas/3.1/dialect/base"
+
+export const selectSchemas = createSelector(
+  (state, system) => system.specSelectors.definitions(),
+  (state, system) =>
+    system.specSelectors.specResolvedSubtree(["components", "schemas"]),
+
+  (rawSchemas, resolvedSchemas) => {
+    if (!Map.isMap(rawSchemas)) return {}
+    if (!Map.isMap(resolvedSchemas)) return rawSchemas.toJS()
+
+    return Object.entries(rawSchemas.toJS()).reduce(
+      (acc, [schemaName, rawSchema]) => {
+        const resolvedSchema = resolvedSchemas.get(schemaName)
+        acc[schemaName] = resolvedSchema?.toJS() || rawSchema
+        return acc
+      },
+      {}
+    )
+  }
+)

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

@@ -0,0 +1,18 @@
+/**
+ * @prettier
+ */
+
+import { createOnlyOAS31SelectorWrapper } from "../fn"
+
+export const isOAS3 =
+  (oriSelector, system) =>
+  (state, ...args) => {
+    const isOAS31 = system.specSelectors.isOAS31()
+    return isOAS31 || oriSelector(...args)
+  }
+
+export const selectLicenseUrl = createOnlyOAS31SelectorWrapper(
+  () => (oriSelector, system) => {
+    return system.oas31Selectors.selectLicenseUrl()
+  }
+)

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

@@ -0,0 +1,22 @@
+/**
+ * @prettier
+ */
+import React from "react"
+
+import { createOnlyOAS31ComponentWrapper } from "../../fn"
+
+const AuthItem = createOnlyOAS31ComponentWrapper(
+  ({ originalComponent: Ori, ...props }) => {
+    const { getComponent, schema, name } = props
+    const MutualTLSAuth = getComponent("MutualTLSAuth", true)
+    const type = schema.get("type")
+
+    if (type === "mutualTLS") {
+      return <MutualTLSAuth schema={schema} name={name} />
+    }
+
+    return <Ori {...props} />
+  }
+)
+
+export default AuthItem

package/src/core/plugins/oas31/wrap-components/auths.jsx

@@ -0,0 +1,17 @@
+/**
+ * @prettier
+ */
+import React from "react"
+
+import { createOnlyOAS31ComponentWrapper } from "../fn"
+
+const AuthsWrapper = createOnlyOAS31ComponentWrapper(
+  ({ getSystem, ...props }) => {
+    const system = getSystem()
+    const OAS31Auths = system.getComponent("OAS31Auths", true)
+
+    return <OAS31Auths {...props} />
+  }
+)
+
+export default AuthsWrapper

package/src/core/plugins/oas31/wrap-components/contact.jsx

@@ -0,0 +1,15 @@
+/**
+ * @prettier
+ */
+import React from "react"
+
+import { createOnlyOAS31ComponentWrapper } from "../fn"
+
+const ContactWrapper = createOnlyOAS31ComponentWrapper(({ getSystem }) => {
+  const system = getSystem()
+  const OAS31Contact = system.getComponent("OAS31Contact", true)
+
+  return <OAS31Contact />
+})
+
+export default ContactWrapper