@upendra19/swagger-ui-custom 1.0.0

package/src/core/plugins/json-schema-5/components/primitive-model.jsx

@@ -0,0 +1,137 @@
+/**
+ * @prettier
+ */
+import React, { Component } from "react"
+import PropTypes from "prop-types"
+import { getExtensions } from "core/utils"
+import { sanitizeUrl } from "core/utils/url"
+
+const propClass = "property primitive"
+
+export default class Primitive extends Component {
+  static propTypes = {
+    schema: PropTypes.object.isRequired,
+    getComponent: PropTypes.func.isRequired,
+    getConfigs: PropTypes.func.isRequired,
+    name: PropTypes.string,
+    displayName: PropTypes.string,
+    depth: PropTypes.number,
+    expandDepth: PropTypes.number,
+  }
+
+  render() {
+    let {
+      schema,
+      getComponent,
+      getConfigs,
+      name,
+      displayName,
+      depth,
+      expandDepth,
+    } = this.props
+
+    const { showExtensions } = getConfigs()
+
+    if (!schema || !schema.get) {
+      // don't render if schema isn't correctly formed
+      return <div></div>
+    }
+
+    let type = schema.get("type")
+    let format = schema.get("format")
+    let xml = schema.get("xml")
+    let enumArray = schema.get("enum")
+    let title = schema.get("title") || displayName || name
+    let description = schema.get("description")
+    const extensions = getExtensions(schema)
+
+    let properties = schema
+      .filter(
+        (_, key) =>
+          [
+            "enum",
+            "type",
+            "format",
+            "description",
+            "$$ref",
+            "externalDocs",
+          ].indexOf(key) === -1
+      )
+      .filterNot((_, key) => extensions.has(key))
+    let externalDocsUrl = schema.getIn(["externalDocs", "url"])
+    let externalDocsDescription = schema.getIn(["externalDocs", "description"])
+
+    const Markdown = getComponent("Markdown", true)
+    const EnumModel = getComponent("EnumModel")
+    const Property = getComponent("Property")
+    const ModelCollapse = getComponent("ModelCollapse")
+    const Link = getComponent("Link")
+    const ModelExtensions = getComponent("ModelExtensions")
+
+    const titleEl = title && (
+      <span className="model-title">
+        <span className="model-title__text">{title}</span>
+      </span>
+    )
+
+    return (
+      <span className="model">
+        <ModelCollapse
+          title={titleEl}
+          expanded={depth <= expandDepth}
+          collapsedContent="[...]"
+        >
+          <span className="prop">
+            {name && depth > 1 && <span className="prop-name">{title}</span>}
+            <span className="prop-type">{type}</span>
+            {format && <span className="prop-format">(${format})</span>}
+            {properties.size
+              ? properties
+                  .entrySeq()
+                  .map(([key, v]) => (
+                    <Property
+                      key={`${key}-${v}`}
+                      propKey={key}
+                      propVal={v}
+                      propClass={propClass}
+                    />
+                  ))
+              : null}
+            {showExtensions && extensions.size > 0 ? (
+              <ModelExtensions
+                extensions={extensions}
+                propClass={`${propClass} extension`}
+              />
+            ) : null}
+            {!description ? null : <Markdown source={description} />}
+            {externalDocsUrl && (
+              <div className="external-docs">
+                <Link target="_blank" href={sanitizeUrl(externalDocsUrl)}>
+                  {externalDocsDescription || externalDocsUrl}
+                </Link>
+              </div>
+            )}
+            {xml && xml.size ? (
+              <span>
+                <br />
+                <span className={propClass}>xml:</span>
+                {xml
+                  .entrySeq()
+                  .map(([key, v]) => (
+                    <span key={`${key}-${v}`} className={propClass}>
+                      <br />
+                      &nbsp;&nbsp;&nbsp;{key}: {String(v)}
+                    </span>
+                  ))
+                  .toArray()}
+              </span>
+            ) : null}
+            {enumArray && (
+              <EnumModel value={enumArray} getComponent={getComponent} />
+            )}
+          </span>
+        </ModelCollapse>
+      </span>
+    )
+  }
+}

package/src/core/plugins/json-schema-5/components/schemes.jsx

@@ -0,0 +1,53 @@
+import React from "react"
+import PropTypes from "prop-types"
+
+export default class Schemes extends React.Component {
+
+  static propTypes = {
+    specActions: PropTypes.object.isRequired,
+    schemes: PropTypes.object.isRequired,
+    currentScheme: PropTypes.string.isRequired,
+    path: PropTypes.string,
+    method: PropTypes.string,
+  }
+
+  UNSAFE_componentWillMount() {
+    let { schemes } = this.props
+
+    //fire 'change' event to set default 'value' of select
+    this.setScheme(schemes.first())
+  }
+
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    if ( !this.props.currentScheme || !nextProps.schemes.includes(this.props.currentScheme) ) {
+      // if we don't have a selected currentScheme or if our selected scheme is no longer an option,
+      // then fire 'change' event and select the first scheme in the list of options
+      this.setScheme(nextProps.schemes.first())
+    }
+  }
+
+  onChange =( e ) => {
+    this.setScheme( e.target.value )
+  }
+
+  setScheme = ( value ) => {
+    let { path, method, specActions } = this.props
+
+    specActions.setScheme( value, path, method )
+  }
+
+  render() {
+    let { schemes, currentScheme } = this.props
+
+    return (
+      <label htmlFor="schemes">
+        <span className="schemes-title">Schemes</span>
+        <select onChange={ this.onChange } value={currentScheme} id="schemes">
+          { schemes.valueSeq().map(
+            ( scheme ) => <option value={ scheme } key={ scheme }>{ scheme }</option>
+          ).toArray()}
+        </select>
+      </label>
+    )
+  }
+}

package/src/core/plugins/json-schema-5/containers/schemes.jsx

@@ -0,0 +1,30 @@
+import React from "react"
+import PropTypes from "prop-types"
+
+export default class SchemesContainer extends React.Component {
+
+  static propTypes = {
+    specActions: PropTypes.object.isRequired,
+    specSelectors: PropTypes.object.isRequired,
+    getComponent: PropTypes.func.isRequired
+  }
+
+  render () {
+    const {specActions, specSelectors, getComponent} = this.props
+
+    const currentScheme = specSelectors.operationScheme()
+    const schemes = specSelectors.schemes()
+
+    const Schemes = getComponent("schemes")
+
+    const schemesArePresent = schemes && schemes.size
+
+    return schemesArePresent ? (
+        <Schemes
+          currentScheme={currentScheme}
+          schemes={schemes}
+          specActions={specActions}
+        />
+      ) : null
+  }
+}

package/src/core/plugins/json-schema-5/fn.js

@@ -0,0 +1,51 @@
+/**
+ * @prettier
+ */
+import { Map } from "immutable"
+import isPlainObject from "lodash/isPlainObject"
+import { immutableToJS } from "core/utils"
+
+export const hasSchemaType = (schema, type) => {
+  const isSchemaImmutable = Map.isMap(schema)
+
+  if (!isSchemaImmutable && !isPlainObject(schema)) {
+    return false
+  }
+
+  const schemaType = isSchemaImmutable ? schema.get("type") : schema.type
+
+  return (
+    type === schemaType || (Array.isArray(type) && type.includes(schemaType))
+  )
+}
+
+const getType = (schema, processedSchemas = new WeakSet()) => {
+  if (schema == null) {
+    return "any"
+  }
+
+  if (processedSchemas.has(schema)) {
+    return "any" // detect a cycle
+  }
+
+  processedSchemas.add(schema)
+
+  const { type, items } = schema
+
+  const getArrayType = () => {
+    if (items) {
+      const itemsType = getType(items, processedSchemas)
+      return `array<${itemsType}>`
+    } else {
+      return "array<any>"
+    }
+  }
+
+  if (Object.hasOwn(schema, "items")) {
+    return getArrayType()
+  }
+  return type
+}
+
+export const getSchemaObjectTypeLabel = (schema) =>
+  getType(immutableToJS(schema))

package/src/core/plugins/json-schema-5/index.js

@@ -0,0 +1,41 @@
+/**
+ * @prettier
+ */
+import ModelCollapse from "./components/model-collapse"
+import ModelExample from "./components/model-example"
+import ModelWrapper from "./components/model-wrapper"
+import Model from "./components/model"
+import Models from "./components/models"
+import EnumModel from "./components/enum-model"
+import ObjectModel from "./components/object-model"
+import ArrayModel from "./components/array-model"
+import PrimitiveModel from "./components/primitive-model"
+import Schemes from "./components/schemes"
+import SchemesContainer from "./containers/schemes"
+import * as JSONSchemaComponents from "./components/json-schema-components"
+import { ModelExtensions } from "./components/model-extensions"
+import { getSchemaObjectTypeLabel, hasSchemaType } from "./fn"
+
+const JSONSchema5Plugin = () => ({
+  components: {
+    modelExample: ModelExample,
+    ModelWrapper,
+    ModelCollapse,
+    Model,
+    Models,
+    EnumModel,
+    ObjectModel,
+    ArrayModel,
+    PrimitiveModel,
+    ModelExtensions,
+    schemes: Schemes,
+    SchemesContainer,
+    ...JSONSchemaComponents,
+  },
+  fn: {
+    hasSchemaType,
+    getSchemaObjectTypeLabel,
+  },
+})
+
+export default JSONSchema5Plugin

package/src/core/plugins/json-schema-5-samples/fn/get-json-sample-schema.js

@@ -0,0 +1,32 @@
+/**
+ * @prettier
+ */
+import some from "lodash/some"
+
+const shouldStringifyTypesConfig = [
+  {
+    when: /json/,
+    shouldStringifyTypes: ["string"],
+  },
+]
+const defaultStringifyTypes = ["object"]
+const makeGetJsonSampleSchema =
+  (getSystem) => (schema, config, contentType, exampleOverride) => {
+    const { fn } = getSystem()
+    const res = fn.memoizedSampleFromSchema(schema, config, exampleOverride)
+    const resType = typeof res
+
+    const typesToStringify = shouldStringifyTypesConfig.reduce(
+      (types, nextConfig) =>
+        nextConfig.when.test(contentType)
+          ? [...types, ...nextConfig.shouldStringifyTypes]
+          : types,
+      defaultStringifyTypes
+    )
+
+    return some(typesToStringify, (x) => x === resType)
+      ? JSON.stringify(res, null, 2)
+      : res
+  }
+
+export default makeGetJsonSampleSchema

package/src/core/plugins/json-schema-5-samples/fn/get-sample-schema.js

@@ -0,0 +1,30 @@
+/**
+ * @prettier
+ */
+const makeGetSampleSchema =
+  (getSystem) =>
+  (schema, contentType = "", config = {}, exampleOverride = undefined) => {
+    const { fn } = getSystem()
+
+    if (typeof schema?.toJS === "function") {
+      schema = schema.toJS()
+    }
+    if (typeof exampleOverride?.toJS === "function") {
+      exampleOverride = exampleOverride.toJS()
+    }
+
+    if (/xml/.test(contentType)) {
+      return fn.getXmlSampleSchema(schema, config, exampleOverride)
+    }
+    if (/(yaml|yml)/.test(contentType)) {
+      return fn.getYamlSampleSchema(
+        schema,
+        config,
+        contentType,
+        exampleOverride
+      )
+    }
+    return fn.getJsonSampleSchema(schema, config, contentType, exampleOverride)
+  }
+
+export default makeGetSampleSchema

package/src/core/plugins/json-schema-5-samples/fn/get-xml-sample-schema.js

@@ -0,0 +1,31 @@
+/**
+ * @prettier
+ */
+const makeGetXmlSampleSchema =
+  (getSystem) => (schema, config, exampleOverride) => {
+    const { fn } = getSystem()
+
+    if (schema && !schema.xml) {
+      schema.xml = {}
+    }
+    if (schema && !schema.xml.name) {
+      if (
+        !schema.$$ref &&
+        (schema.type ||
+          schema.items ||
+          schema.properties ||
+          schema.additionalProperties)
+      ) {
+        // eslint-disable-next-line quotes
+        return '<?xml version="1.0" encoding="UTF-8"?>\n<!-- XML example cannot be generated; root element name is undefined -->'
+      }
+      if (schema.$$ref) {
+        let match = schema.$$ref.match(/\S*\/(\S+)$/)
+        schema.xml.name = match[1]
+      }
+    }
+
+    return fn.memoizedCreateXMLExample(schema, config, exampleOverride)
+  }
+
+export default makeGetXmlSampleSchema

package/src/core/plugins/json-schema-5-samples/fn/get-yaml-sample-schema.js

@@ -0,0 +1,34 @@
+/**
+ * @prettier
+ */
+import YAML, { JSON_SCHEMA } from "js-yaml"
+
+const makeGetYamlSampleSchema =
+  (getSystem) => (schema, config, contentType, exampleOverride) => {
+    const { fn } = getSystem()
+    const jsonExample = fn.getJsonSampleSchema(
+      schema,
+      config,
+      contentType,
+      exampleOverride
+    )
+    let yamlString
+    try {
+      yamlString = YAML.dump(
+        YAML.load(jsonExample),
+        {
+          lineWidth: -1, // don't generate line folds
+        },
+        { schema: JSON_SCHEMA }
+      )
+      if (yamlString[yamlString.length - 1] === "\n") {
+        yamlString = yamlString.slice(0, yamlString.length - 1)
+      }
+    } catch (e) {
+      console.error(e)
+      return "error: could not generate yaml example"
+    }
+    return yamlString.replace(/\t/g, "  ")
+  }
+
+export default makeGetYamlSampleSchema