@upendra19/swagger-ui-custom 1.0.0 → 1.0.3

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

@@ -1,653 +0,0 @@
-import XML from "xml"
-import RandExp from "randexp"
-import isEmpty from "lodash/isEmpty"
-import { deeplyStripKey, isFunc, normalizeArray, objectify, immutableToJS } from "core/utils"
-import memoizeN from "core/utils/memoizeN"
-
-const generateStringFromRegex = (pattern) => {
-  try {
-    /**
-     * Applying maximum value (100) to numbers from regex patterns to avoid ReDoS:
-     * 1. {x}
-     * 2. {x,}
-     * 3. {,y}
-     * 4. {x,y}
-     */
-    const patternSanitizer =
-      /(?<=(?<!\\)\{)(\d{3,})(?=\})|(?<=(?<!\\)\{\d*,)(\d{3,})(?=\})|(?<=(?<!\\)\{)(\d{3,})(?=,\d*\})/g
-    const safePattern = pattern.replace(patternSanitizer, "100")
-    const randexpInstance = new RandExp(safePattern)
-    randexpInstance.max = 100
-    return randexpInstance.gen()
-  } catch (e) {
-    // Invalid regex should not cause a crash (regex syntax varies across languages)
-    return "string"
-  }
-}
-
-const primitives = {
-  "string": (schema) => schema.pattern ? generateStringFromRegex(schema.pattern) : "string",
-  "string_email": () => "user@example.com",
-  "string_date-time": () => new Date().toISOString(),
-  "string_date": () => new Date().toISOString().substring(0, 10),
-  "string_time": () => new Date().toISOString().substring(11),
-  "string_uuid": () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-  "string_hostname": () => "example.com",
-  "string_ipv4": () => "198.51.100.42",
-  "string_ipv6": () => "2001:0db8:5b96:0000:0000:426f:8e17:642a",
-  "number": () => 0,
-  "number_float": () => 0.0,
-  "integer": () => 0,
-  "boolean": (schema) => typeof schema.default === "boolean" ? schema.default : true
-}
-
-const primitive = (schema) => {
-  schema = objectify(schema)
-  let { type, format } = schema
-
-  let fn = primitives[`${type}_${format}`] || primitives[type]
-
-  if(isFunc(fn))
-    return fn(schema)
-
-  return "Unknown Type: " + schema.type
-}
-
-// do a couple of quick sanity tests to ensure the value
-// looks like a $$ref that swagger-client generates.
-const sanitizeRef = (value) => deeplyStripKey(value, "$$ref", (val) =>
-  typeof val === "string" && val.indexOf("#") > -1)
-
-const objectContracts = ["maxProperties", "minProperties"]
-const arrayContracts = ["minItems", "maxItems"]
-const numberContracts = [
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum"
-]
-const stringContracts = ["minLength", "maxLength"]
-
-export const mergeJsonSchema = (target, source, config = {}) => {
-  const merged = { ...target }
-
-  const setIfNotDefinedInTarget = (key) => {
-    if(merged[key] === undefined && source[key] !== undefined) {
-      merged[key] = source[key]
-    }
-  }
-
-  [
-    "example",
-    "default",
-    "enum",
-    "xml",
-    "type",
-    ...objectContracts,
-    ...arrayContracts,
-    ...numberContracts,
-    ...stringContracts,
-  ].forEach(key => setIfNotDefinedInTarget(key))
-
-  if(source.required !== undefined && Array.isArray(source.required)) {
-    if(merged.required === undefined || !merged.required.length) {
-      merged.required = []
-    }
-    source.required.forEach(key => {
-      if(merged.required.includes(key)) {
-        return
-      }
-      merged.required.push(key)
-    })
-  }
-  if(source.properties) {
-    if(!merged.properties) {
-      merged.properties = {}
-    }
-    let props = objectify(source.properties)
-    for (let propName in props) {
-      if (!Object.prototype.hasOwnProperty.call(props, propName)) {
-        continue
-      }
-      if ( props[propName] && props[propName].deprecated ) {
-        continue
-      }
-      if ( props[propName] && props[propName].readOnly && !config.includeReadOnly ) {
-        continue
-      }
-      if ( props[propName] && props[propName].writeOnly && !config.includeWriteOnly ) {
-        continue
-      }
-      if(!merged.properties[propName]) {
-        merged.properties[propName] = props[propName]
-        if(!source.required && Array.isArray(source.required) && source.required.indexOf(propName) !== -1) {
-          if(!merged.required) {
-            merged.required = [propName]
-          } else {
-            merged.required.push(propName)
-          }
-        }
-      }
-    }
-  }
-  if(source.items) {
-    if(!merged.items) {
-      merged.items = {}
-    }
-    merged.items = mergeJsonSchema(merged.items, source.items, config)
-  }
-
-  return merged
-}
-
-export const sampleFromSchemaGeneric = (schema, config={}, exampleOverride = undefined, respectXML = false) => {
-  if(schema && isFunc(schema.toJS))
-    schema = schema.toJS()
-  let usePlainValue = exampleOverride !== undefined || schema && schema.example !== undefined || schema && schema.default !== undefined
-  // first check if there is the need of combining this schema with others required by allOf
-  const hasOneOf = !usePlainValue && schema && schema.oneOf && schema.oneOf.length > 0
-  const hasAnyOf = !usePlainValue && schema && schema.anyOf && schema.anyOf.length > 0
-  if(!usePlainValue && (hasOneOf || hasAnyOf)) {
-    const schemaToAdd = objectify(hasOneOf
-      ? schema.oneOf[0]
-      : schema.anyOf[0]
-    )
-    schema = mergeJsonSchema(schema, schemaToAdd, config)
-    if(!schema.xml && schemaToAdd.xml) {
-      schema.xml = schemaToAdd.xml
-    }
-    if(schema.example !== undefined && schemaToAdd.example !== undefined) {
-      usePlainValue = true
-    } else if(schemaToAdd.properties) {
-      if(!schema.properties) {
-        schema.properties = {}
-      }
-      let props = objectify(schemaToAdd.properties)
-      for (let propName in props) {
-        if (!Object.prototype.hasOwnProperty.call(props, propName)) {
-          continue
-        }
-        if ( props[propName] && props[propName].deprecated ) {
-          continue
-        }
-        if ( props[propName] && props[propName].readOnly && !config.includeReadOnly ) {
-          continue
-        }
-        if ( props[propName] && props[propName].writeOnly && !config.includeWriteOnly ) {
-          continue
-        }
-        if(!schema.properties[propName]) {
-          schema.properties[propName] = props[propName]
-          if(!schemaToAdd.required && Array.isArray(schemaToAdd.required) && schemaToAdd.required.indexOf(propName) !== -1) {
-            if(!schema.required) {
-              schema.required = [propName]
-            } else {
-              schema.required.push(propName)
-            }
-          }
-        }
-      }
-    }
-  }
-  const _attr = {}
-  let { xml, type, example, properties, additionalProperties, items } = schema || {}
-  let { includeReadOnly, includeWriteOnly } = config
-  xml = xml || {}
-  let { name, prefix, namespace } = xml
-  let displayName
-  let res = {}
-
-  // set xml naming and attributes
-  if(respectXML) {
-    name = name || "notagname"
-    // add prefix to name if exists
-    displayName = (prefix ? prefix + ":" : "") + name
-    if ( namespace ) {
-      //add prefix to namespace if exists
-      let namespacePrefix = prefix ? ( "xmlns:" + prefix ) : "xmlns"
-      _attr[namespacePrefix] = namespace
-    }
-  }
-
-  // init xml default response sample obj
-  if(respectXML) {
-    res[displayName] = []
-  }
-
-  const schemaHasAny = (keys) => keys.some(key => Object.prototype.hasOwnProperty.call(schema, key))
-  // try recover missing type
-  if(schema && !type) {
-    if(properties || additionalProperties || schemaHasAny(objectContracts)) {
-      type = "object"
-    } else if(items || schemaHasAny(arrayContracts)) {
-      type = "array"
-    } else if(schemaHasAny(numberContracts)) {
-      type = "number"
-      schema.type = "number"
-    } else if(!usePlainValue && !schema.enum){
-      // implicit cover schemaHasAny(stringContracts) or A schema without a type matches any data type is:
-      // components:
-      //   schemas:
-      //     AnyValue:
-      //       anyOf:
-      //         - type: string
-      //         - type: number
-      //         - type: integer
-      //         - type: boolean
-      //         - type: array
-      //           items: {}
-      //         - type: object
-      //
-      // which would resolve to type: string
-      type = "string"
-      schema.type = "string"
-    }
-  }
-
-  const handleMinMaxItems = (sampleArray) => {
-    if (schema?.maxItems !== null && schema?.maxItems !== undefined) {
-      sampleArray = sampleArray.slice(0, schema?.maxItems)
-    }
-    if (schema?.minItems !== null && schema?.minItems !== undefined) {
-      let i = 0
-      while (sampleArray.length < schema?.minItems) {
-        sampleArray.push(sampleArray[i++ % sampleArray.length])
-      }
-    }
-    return sampleArray
-  }
-
-  // add to result helper init for xml or json
-  const props = objectify(properties)
-  let addPropertyToResult
-  let propertyAddedCounter = 0
-
-  const hasExceededMaxProperties = () => schema
-    && schema.maxProperties !== null && schema.maxProperties !== undefined
-    && propertyAddedCounter >= schema.maxProperties
-
-  const requiredPropertiesToAdd = () => {
-    if(!schema || !schema.required) {
-      return 0
-    }
-    let addedCount = 0
-    if(respectXML) {
-      schema.required.forEach(key => addedCount +=
-        res[key] === undefined
-          ? 0
-          : 1
-      )
-    } else {
-      schema.required.forEach(key => addedCount +=
-        res[displayName]?.find(x => x[key] !== undefined) === undefined
-          ? 0
-          : 1
-      )
-    }
-    return schema.required.length - addedCount
-  }
-
-  const isOptionalProperty = (propName) => {
-    if(!schema || !schema.required || !schema.required.length) {
-      return true
-    }
-    return !schema.required.includes(propName)
-  }
-
-  const canAddProperty = (propName) => {
-    if(!schema || schema.maxProperties === null || schema.maxProperties === undefined) {
-      return true
-    }
-    if(hasExceededMaxProperties()) {
-      return false
-    }
-    if(!isOptionalProperty(propName)) {
-      return true
-    }
-    return (schema.maxProperties - propertyAddedCounter - requiredPropertiesToAdd()) > 0
-  }
-
-  if(respectXML) {
-    addPropertyToResult = (propName, overrideE = undefined) => {
-      if(schema && props[propName]) {
-        // case it is an xml attribute
-        props[propName].xml = props[propName].xml || {}
-
-        if (props[propName].xml.attribute) {
-          const enumAttrVal = Array.isArray(props[propName].enum)
-            ? props[propName].enum[0]
-            : undefined
-          const attrExample = props[propName].example
-          const attrDefault = props[propName].default
-
-          if(attrExample !== undefined) {
-            _attr[props[propName].xml.name || propName] = attrExample
-          } else if(attrDefault !== undefined) {
-            _attr[props[propName].xml.name || propName] = attrDefault
-          } else if(enumAttrVal !== undefined) {
-            _attr[props[propName].xml.name || propName] = enumAttrVal
-          } else {
-            _attr[props[propName].xml.name || propName] = primitive(props[propName])
-          }
-
-          return
-        }
-        props[propName].xml.name = props[propName].xml.name || propName
-      } else if(!props[propName] && additionalProperties !== false) {
-        // case only additionalProperty that is not defined in schema
-        props[propName] = {
-          xml: {
-            name: propName
-          }
-        }
-      }
-
-      let t = sampleFromSchemaGeneric(schema && props[propName] || undefined, config, overrideE, respectXML)
-      if(!canAddProperty(propName)) {
-        return
-      }
-
-      propertyAddedCounter++
-      if (Array.isArray(t)) {
-        res[displayName] = res[displayName].concat(t)
-      } else {
-        res[displayName].push(t)
-      }
-    }
-  } else {
-    addPropertyToResult = (propName, overrideE) => {
-      if(!canAddProperty(propName)) {
-        return
-      }
-      if(Object.prototype.hasOwnProperty.call(schema, "discriminator") &&
-        schema.discriminator &&
-        Object.prototype.hasOwnProperty.call(schema.discriminator, "mapping") &&
-        schema.discriminator.mapping &&
-        Object.prototype.hasOwnProperty.call(schema, "$$ref") &&
-        schema.$$ref &&
-        schema.discriminator.propertyName === propName) {
-        for (let pair in schema.discriminator.mapping){
-          if (schema.$$ref.search(schema.discriminator.mapping[pair]) !== -1) {
-            res[propName] = pair
-            break
-          }
-        }
-      } else {
-        res[propName] = sampleFromSchemaGeneric(props[propName], config, overrideE, respectXML)
-      }
-      propertyAddedCounter++
-    }
-  }
-
-  // check for plain value and if found use it to generate sample from it
-  if(usePlainValue) {
-    let sample
-    if(exampleOverride !== undefined) {
-      sample = sanitizeRef(exampleOverride)
-    } else if(example !== undefined) {
-      sample = sanitizeRef(example)
-    } else {
-      sample = sanitizeRef(schema.default)
-    }
-
-    // if json just return
-    if(!respectXML) {
-      // special case yaml parser can not know about
-      if(typeof sample === "number" && type === "string") {
-        return `${sample}`
-      }
-      // return if sample does not need any parsing
-      if(typeof sample !== "string" || type === "string") {
-        return sample
-      }
-      // check if sample is parsable or just a plain string
-      try {
-        return JSON.parse(sample)
-      } catch(e) {
-        // sample is just plain string return it
-        return sample
-      }
-    }
-
-    // recover missing type
-    if(!schema) {
-      type = Array.isArray(sample) ? "array" : typeof sample
-    }
-
-    // generate xml sample recursively for array case
-    if(type === "array") {
-      if (!Array.isArray(sample)) {
-        if(typeof sample === "string") {
-          return sample
-        }
-        sample = [sample]
-      }
-      const itemSchema = schema
-        ? schema.items
-        : undefined
-      if(itemSchema) {
-        itemSchema.xml = itemSchema.xml || xml || {}
-        itemSchema.xml.name = itemSchema.xml.name || xml.name
-      }
-      let itemSamples = sample
-        .map(s => sampleFromSchemaGeneric(itemSchema, config, s, respectXML))
-      itemSamples = handleMinMaxItems(itemSamples)
-      if(xml.wrapped) {
-        res[displayName] = itemSamples
-        if (!isEmpty(_attr)) {
-          res[displayName].push({_attr: _attr})
-        }
-      }
-      else {
-        res = itemSamples
-      }
-      return res
-    }
-
-    // generate xml sample recursively for object case
-    if(type === "object") {
-      // case literal example
-      if(typeof sample === "string") {
-        return sample
-      }
-      for (let propName in sample) {
-        if (!Object.prototype.hasOwnProperty.call(sample, propName)) {
-          continue
-        }
-        if (schema && props[propName] && props[propName].readOnly && !includeReadOnly) {
-          continue
-        }
-        if (schema && props[propName] && props[propName].writeOnly && !includeWriteOnly) {
-          continue
-        }
-        if (schema && props[propName] && props[propName].xml && props[propName].xml.attribute) {
-          _attr[props[propName].xml.name || propName] = sample[propName]
-          continue
-        }
-        addPropertyToResult(propName, sample[propName])
-      }
-      if (!isEmpty(_attr)) {
-        res[displayName].push({_attr: _attr})
-      }
-
-      return res
-    }
-
-    res[displayName] = !isEmpty(_attr) ? [{_attr: _attr}, sample] : sample
-    return res
-  }
-
-  // use schema to generate sample
-
-  if(type === "object") {
-    for (let propName in props) {
-      if (!Object.prototype.hasOwnProperty.call(props, propName)) {
-        continue
-      }
-      if ( props[propName] && props[propName].deprecated ) {
-        continue
-      }
-      if ( props[propName] && props[propName].readOnly && !includeReadOnly ) {
-        continue
-      }
-      if ( props[propName] && props[propName].writeOnly && !includeWriteOnly ) {
-        continue
-      }
-      addPropertyToResult(propName)
-    }
-    if (respectXML && _attr) {
-      res[displayName].push({_attr: _attr})
-    }
-
-    if(hasExceededMaxProperties()) {
-      return res
-    }
-
-    if ( additionalProperties === true ) {
-      if(respectXML) {
-        res[displayName].push({additionalProp: "Anything can be here"})
-      } else {
-        res.additionalProp1 = {}
-      }
-      propertyAddedCounter++
-    } else if ( additionalProperties ) {
-      const additionalProps = objectify(additionalProperties)
-      const additionalPropSample = sampleFromSchemaGeneric(additionalProps, config, undefined, respectXML)
-
-      if(respectXML && additionalProps.xml && additionalProps.xml.name && additionalProps.xml.name !== "notagname")
-      {
-        res[displayName].push(additionalPropSample)
-      } else {
-        const keyName = additionalProps["x-additionalPropertiesName"] || "additionalProp"
-        const toGenerateCount = schema.minProperties !== null && schema.minProperties !== undefined && propertyAddedCounter < schema.minProperties
-          ? schema.minProperties - propertyAddedCounter
-          : 3
-        for (let i = 1; i <= toGenerateCount; i++) {
-          if(hasExceededMaxProperties()) {
-            return res
-          }
-          if(respectXML) {
-            const temp = {}
-            temp[keyName + i] = additionalPropSample["notagname"]
-            res[displayName].push(temp)
-          } else {
-            res[keyName + i] = additionalPropSample
-          }
-          propertyAddedCounter++
-        }
-      }
-    }
-    return res
-  }
-
-  if(type === "array") {
-    if (!items) {
-      return
-    }
-
-    let sampleArray
-    if(respectXML) {
-      items.xml = items.xml || schema?.xml || {}
-      items.xml.name = items.xml.name || xml.name
-    }
-
-    if(Array.isArray(items.anyOf)) {
-      sampleArray = items.anyOf.map(i => sampleFromSchemaGeneric(mergeJsonSchema(i, items, config), config, undefined, respectXML))
-    } else if(Array.isArray(items.oneOf)) {
-      sampleArray = items.oneOf.map(i => sampleFromSchemaGeneric(mergeJsonSchema(i, items, config), config, undefined, respectXML))
-    } else if(!respectXML || respectXML && xml.wrapped) {
-      sampleArray = [sampleFromSchemaGeneric(items, config, undefined, respectXML)]
-    } else {
-      return sampleFromSchemaGeneric(items, config, undefined, respectXML)
-    }
-    sampleArray = handleMinMaxItems(sampleArray)
-    if(respectXML && xml.wrapped) {
-      res[displayName] = sampleArray
-      if (!isEmpty(_attr)) {
-        res[displayName].push({_attr: _attr})
-      }
-      return res
-    }
-    return sampleArray
-  }
-
-  let value
-  if (schema && Array.isArray(schema.enum)) {
-    //display enum first value
-    value = normalizeArray(schema.enum)[0]
-  } else if(schema) {
-    // display schema default
-    value = primitive(schema)
-    if(typeof value === "number") {
-      let min = schema.minimum
-      if(min !== undefined && min !== null) {
-        if(schema.exclusiveMinimum) {
-          min++
-        }
-        value = min
-      }
-      let max = schema.maximum
-      if(max !== undefined && max !== null) {
-        if(schema.exclusiveMaximum) {
-          max--
-        }
-        value = max
-      }
-    }
-    if(typeof value === "string") {
-      if (schema.maxLength !== null && schema.maxLength !== undefined) {
-        value = value.slice(0, schema.maxLength)
-      }
-      if (schema.minLength !== null && schema.minLength !== undefined) {
-        let i = 0
-        while (value.length < schema.minLength) {
-          value += value[i++ % value.length]
-        }
-      }
-    }
-  } else {
-    return
-  }
-  if (type === "file") {
-    return
-  }
-
-  if(respectXML) {
-    res[displayName] = !isEmpty(_attr) ? [{_attr: _attr}, value] : value
-    return res
-  }
-
-  return value
-}
-
-export const inferSchema = (thing) => {
-  if(thing.schema)
-    thing = thing.schema
-
-  if(thing.properties) {
-    thing.type = "object"
-  }
-
-  return thing // Hopefully this will have something schema like in it... `type` for example
-}
-
-export const createXMLExample = (schema, config, o) => {
-  const json = sampleFromSchemaGeneric(schema, config, o, true)
-  if (!json) { return }
-  if(typeof json === "string") {
-    return json
-  }
-  return XML(json, { declaration: true, indent: "\t" })
-}
-
-
-export const sampleFromSchema = (schema, config, o) =>
-  sampleFromSchemaGeneric(schema, config, o, false)
-
-const resolver = (arg1, arg2, arg3) => [arg1, JSON.stringify(arg2), JSON.stringify(arg3)]
-
-export const memoizedCreateXMLExample = memoizeN(createXMLExample, resolver)
-
-export const memoizedSampleFromSchema = memoizeN(sampleFromSchema, resolver)
-
-export const getSchemaObjectType = (schema) => immutableToJS(schema)?.type ?? "string"

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

@@ -1,56 +0,0 @@
-/**
- * @prettier
- */
-import {
-  sampleFromSchema,
-  inferSchema,
-  sampleFromSchemaGeneric,
-  createXMLExample,
-  memoizedCreateXMLExample,
-  memoizedSampleFromSchema,
-  mergeJsonSchema,
-  getSchemaObjectType,
-} from "./fn/index"
-import makeGetJsonSampleSchema from "./fn/get-json-sample-schema"
-import makeGetYamlSampleSchema from "./fn/get-yaml-sample-schema"
-import makeGetXmlSampleSchema from "./fn/get-xml-sample-schema"
-import makeGetSampleSchema from "./fn/get-sample-schema"
-
-const JSONSchema5SamplesPlugin = ({ getSystem }) => {
-  const getJsonSampleSchema = makeGetJsonSampleSchema(getSystem)
-  const getYamlSampleSchema = makeGetYamlSampleSchema(getSystem)
-  const getXmlSampleSchema = makeGetXmlSampleSchema(getSystem)
-  const getSampleSchema = makeGetSampleSchema(getSystem)
-
-  return {
-    fn: {
-      jsonSchema5: {
-        inferSchema,
-        sampleFromSchema,
-        sampleFromSchemaGeneric,
-        createXMLExample,
-        memoizedSampleFromSchema,
-        memoizedCreateXMLExample,
-        getJsonSampleSchema,
-        getYamlSampleSchema,
-        getXmlSampleSchema,
-        getSampleSchema,
-        mergeJsonSchema,
-      },
-      inferSchema,
-      sampleFromSchema,
-      sampleFromSchemaGeneric,
-      createXMLExample,
-      memoizedSampleFromSchema,
-      memoizedCreateXMLExample,
-      getJsonSampleSchema,
-      getYamlSampleSchema,
-      getXmlSampleSchema,
-      getSampleSchema,
-      mergeJsonSchema,
-      getSchemaObjectType,
-    },
-  }
-}
-
-export default JSONSchema5SamplesPlugin