@api-client/ui 0.2.0 → 0.2.2

package/src/amf/lib/AmfSecurity.ts

@@ -1,45 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-
-import type { IApiSecurityRequirement } from '@api-client/core/amf/definitions/Api.js'
-import type { SecuritySelectorListItem } from '../types.js'
-
-export class AmfSecurity {
-  static readSecurityList(security: IApiSecurityRequirement[]): SecuritySelectorListItem[] {
-    const result: SecuritySelectorListItem[] = []
-    if (!Array.isArray(security) || !security.length) {
-      return result
-    }
-    security.forEach((item) => {
-      const { schemes } = item
-      if (!Array.isArray(schemes)) {
-        return
-      }
-      result.push(AmfSecurity.readSecurityListItem(item))
-    })
-    return result
-  }
-
-  static readSecurityListItem(item: IApiSecurityRequirement): SecuritySelectorListItem {
-    const { schemes } = item
-    const result: SecuritySelectorListItem = {
-      types: [],
-      labels: [],
-      security: item,
-    }
-    schemes.forEach((scheme) => {
-      const { name, scheme: settings } = scheme
-      if (name === 'null') {
-        // RAML allows to define a "null" scheme. This means that the authorization
-        // for this endpoint is optional.
-        result.types.push(undefined)
-        result.labels.push('No authorization')
-        return
-      }
-      const label = name || (settings && settings.name)
-      const type = settings && settings.type
-      result.types.push(type)
-      result.labels.push(label)
-    })
-    return result
-  }
-}

package/src/amf/lib/InputCache.ts

@@ -1,100 +0,0 @@
-/**
- * A cache of provided by the user values to the input fields.
- * This is used to restore data when the user switches between different operations.
- */
-export const globalValues = new Map<string, unknown>()
-/**
- * A cache for "local" values cached per instance of the component.
- */
-export const localValues = new WeakMap<HTMLElement, Map<string, unknown>>()
-
-/**
- * @param element
- * @param globalCache Whether to use the global cache.
- */
-export function getStore(element: HTMLElement, globalCache: boolean): Map<string, unknown> {
-  if (globalCache) {
-    return globalValues
-  }
-  return localValues.get(element) as Map<string, unknown>
-}
-
-/**
- * @param element
- * @param key The key to use
- * @param globalCache Whether to use the global cache.
- */
-export function get(element: HTMLElement, key: string, globalCache: boolean): unknown {
-  const store = getStore(element, globalCache)
-  if (store && store.has(key)) {
-    return store.get(key)
-  }
-  return undefined
-}
-
-/**
- * @param element
- * @param key The key to use
- * @param value The value to store
- * @param globalCache Whether to use the global cache.
- * @param isArray Whether the value is an array.
- * @param index The array index.
- */
-export function set(
-  element: HTMLElement,
-  key: string,
-  value: unknown,
-  globalCache: boolean,
-  isArray?: boolean,
-  index?: number
-): void {
-  const store = getStore(element, globalCache)
-  if (isArray) {
-    if (!store.has(key)) {
-      store.set(key, [])
-    }
-    if (typeof index === 'number' && !Number.isNaN(index)) {
-      ;(store.get(key) as unknown[])[index] = value
-    } else {
-      ;(store.get(key) as unknown[]).push(value)
-    }
-  } else {
-    store.set(key, value)
-  }
-}
-
-/**
- * @param element
- * @param key The key to use
- * @param globalCache Whether to use the global cache.
- */
-export function has(element: HTMLElement, key: string, globalCache: boolean): boolean {
-  const store = getStore(element, globalCache)
-  return store.has(key)
-}
-
-export function registerLocal(element: HTMLElement): void {
-  localValues.set(element, new Map())
-}
-
-export function unregisterLocal(element: HTMLElement): void {
-  localValues.delete(element)
-}
-
-/**
- * @param element
- * @param key The key to use
- * @param globalCache Whether to use the global cache.
- * @param index When set to a number it expects the value to be array and removes an item on the specified index.
- */
-export function remove(element: HTMLElement, key: string, globalCache: boolean, index?: number): void {
-  const store = getStore(element, globalCache)
-  if (typeof index === 'number' && !Number.isNaN(index)) {
-    const value = store.get(key)
-    if (Array.isArray(value)) {
-      value.splice(index, 1)
-    }
-  } else {
-    store.delete(key)
-  }
-}

package/src/amf/lib/Oauth2RamlCustomData.ts

@@ -1,265 +0,0 @@
-import { AmfNamespace } from '@api-client/core/amf/definitions/Namespace.js'
-import type { IApiParameter } from '@api-client/core/amf/definitions/Api.js'
-import type {
-  IApiArrayShape,
-  IApiDataNodeUnion,
-  IApiObjectNode,
-  IApiScalarNode,
-  IApiScalarShape,
-  IApiShape,
-  IShapeUnion,
-} from '@api-client/core/amf/definitions/Shapes.js'
-
-/**
- * Computes a data model for custom definition for the OAuth 2 scheme
- * According to the annotation published at
- * https://github.com/raml-org/raml-annotations/tree/master/annotations/security-schemes
- */
-export class Oauth2RamlCustomData {
-  readParams(properties: Record<string, IApiDataNodeUnion>): IApiParameter[] {
-    const result: IApiParameter[] = []
-    Object.keys(properties).forEach((key) => {
-      const definition = properties[key]
-      if (definition.types.includes(AmfNamespace.aml.vocabularies.data.Object)) {
-        const property = this.getProperty(definition as IApiObjectNode)
-        result.push(property)
-      } else if (definition.types.includes(AmfNamespace.aml.vocabularies.data.Scalar)) {
-        const property = this.getPropertyScalar(definition as IApiScalarNode)
-        result.push(property)
-      }
-    })
-    return result
-  }
-
-  /**
-   * Creates an IApiParameter for an annotation that has properties.
-   * This expects the properties to be defined like RAML's type definition.
-   */
-  getProperty(definition: IApiObjectNode): IApiParameter {
-    const { properties = {}, id, name } = definition
-    const result: IApiParameter = {
-      id,
-      name,
-      examples: [],
-      payloads: [],
-      types: [AmfNamespace.aml.vocabularies.apiContract.Parameter],
-      customDomainProperties: [],
-    }
-    const schema = this.readSchema(definition)
-    if (schema) {
-      result.schema = schema
-    }
-    if (properties.required) {
-      const req = properties.required as IApiScalarNode
-      result.required = req.value === 'true'
-    }
-    return result
-  }
-
-  /**
-   * Creates an IApiParameter for an annotation that has no properties but rather a simplified
-   * notation of `propertyName: dataType`.
-   */
-  getPropertyScalar(definition: IApiScalarNode): IApiParameter {
-    const { dataType = '', id, name } = definition
-    const result: IApiParameter = {
-      id,
-      name,
-      examples: [],
-      payloads: [],
-      types: [AmfNamespace.aml.vocabularies.apiContract.Parameter],
-      customDomainProperties: [],
-    }
-    const schema = this.createSchema() as IApiScalarShape
-    schema.types = [AmfNamespace.aml.vocabularies.shapes.ScalarShape]
-    schema.id = id
-    schema.name = name
-    schema.dataType = this.typeToSchemaType(dataType)
-    result.schema = schema
-    return result
-  }
-
-  readSchema(property: IApiObjectNode): IShapeUnion | undefined {
-    const { properties = {}, name, id } = property
-    // const { example, examples, } = properties;
-    const isArray = this.readIsSchemaArray(properties.type as IApiScalarNode, properties.items as IApiScalarNode)
-    const type = this.readSchemaType(properties.type as IApiScalarNode, properties.items as IApiScalarNode)
-    let schema: IShapeUnion | undefined
-    if (isArray) {
-      const s = this.createSchema() as IApiArrayShape
-      s.types = [AmfNamespace.aml.vocabularies.shapes.ArrayShape]
-      s.id = id
-      s.name = name
-      s.items = this.createTypedSchema(type, property)
-      schema = s
-    } else {
-      schema = this.createTypedSchema(type, property)
-    }
-    return schema
-  }
-
-  createTypedSchema(type: string, object: IApiObjectNode): IShapeUnion | undefined {
-    switch (type) {
-      case 'string':
-      case 'number':
-      case 'integer':
-      case 'float':
-      case 'double':
-      case 'long':
-      case 'date-only':
-      case 'date-time':
-      case 'time-only':
-      case 'nil':
-      case 'date':
-      case 'boolean':
-        return this.createScalarSchema(object, type)
-      default:
-        return undefined
-    }
-  }
-
-  createSchema(): IApiShape {
-    return {
-      id: '',
-      types: [],
-      and: [],
-      name: '',
-      inherits: [],
-      or: [],
-      values: [],
-      xone: [],
-      customDomainProperties: [],
-    }
-  }
-
-  createScalarSchema(object: IApiObjectNode, type: string): IApiScalarShape {
-    const { properties = {}, name, id } = object
-    const schema = this.createSchema() as IApiScalarShape
-    schema.types = [AmfNamespace.aml.vocabularies.shapes.ScalarShape]
-    schema.id = id
-    schema.name = name
-    schema.dataType = this.typeToSchemaType(type)
-    if (properties.format) {
-      const item = properties.format as IApiScalarNode
-      schema.format = item.value
-    }
-    if (properties.default) {
-      const item = properties.default as IApiScalarNode
-      schema.defaultValueStr = item.value
-      // schema.defaultValue = item.value;
-    }
-    if (properties.description) {
-      const item = properties.description as IApiScalarNode
-      schema.description = item.value
-    }
-    if (properties.displayName) {
-      const item = properties.displayName as IApiScalarNode
-      schema.displayName = item.value
-    }
-    if (properties.pattern) {
-      const item = properties.pattern as IApiScalarNode
-      schema.pattern = item.value
-    }
-    if (properties.maximum) {
-      const item = properties.maximum as IApiScalarNode
-      const value = Number(item.value)
-      if (!Number.isNaN(value)) {
-        schema.maximum = value
-      }
-    }
-    if (properties.minimum) {
-      const item = properties.minimum as IApiScalarNode
-      const value = Number(item.value)
-      if (!Number.isNaN(value)) {
-        schema.minimum = value
-      }
-    }
-    if (properties.multipleOf) {
-      const item = properties.multipleOf as IApiScalarNode
-      const value = Number(item.value)
-      if (!Number.isNaN(value)) {
-        schema.multipleOf = value
-      }
-    }
-    if (properties.maxLength) {
-      const item = properties.maxLength as IApiScalarNode
-      const value = Number(item.value)
-      if (!Number.isNaN(value)) {
-        schema.maxLength = value
-      }
-    }
-    if (properties.minLength) {
-      const item = properties.minLength as IApiScalarNode
-      const value = Number(item.value)
-      if (!Number.isNaN(value)) {
-        schema.minLength = value
-      }
-    }
-    return schema
-  }
-
-  /**
-   * @param object
-   * @param items The definition of the `items` property that corresponds to RAML's items property of an array
-   */
-  readSchemaType(object: IApiScalarNode, items?: IApiScalarNode): string {
-    if (object.dataType !== AmfNamespace.w3.xmlSchema.string) {
-      return AmfNamespace.w3.xmlSchema.string
-    }
-    let inputType = object.value || ''
-    if (inputType.endsWith('[]')) {
-      inputType = inputType.replace('[]', '')
-    }
-    if (inputType === 'array' && items) {
-      return this.readSchemaType(items)
-    }
-    return inputType || 'string'
-  }
-
-  typeToSchemaType(type: string): string {
-    switch (type) {
-      case 'boolean':
-        return AmfNamespace.w3.xmlSchema.boolean
-      case 'number':
-        return AmfNamespace.w3.xmlSchema.number
-      case 'integer':
-        return AmfNamespace.w3.xmlSchema.integer
-      case 'float':
-        return AmfNamespace.w3.xmlSchema.float
-      case 'double':
-        return AmfNamespace.w3.xmlSchema.double
-      case 'long':
-        return AmfNamespace.w3.xmlSchema.long
-      case 'date-only':
-        return AmfNamespace.w3.xmlSchema.date
-      case 'date-time':
-        return AmfNamespace.w3.xmlSchema.dateTime
-      case 'time-only':
-        return AmfNamespace.w3.xmlSchema.time
-      case 'nil':
-        return AmfNamespace.w3.xmlSchema.nil
-      default:
-        return AmfNamespace.w3.xmlSchema.string
-    }
-  }
-
-  /**
-   * Checks whether the custom property represents an array.
-   * @param type
-   * @param items The definition of the `items` property that corresponds to RAML's items property of an array
-   * @returns True when the schema is an array.
-   */
-  readIsSchemaArray(type: IApiScalarNode, items: IApiScalarNode): boolean {
-    if (!type && items) {
-      return true
-    }
-    if (!type) {
-      return false
-    }
-    const inputType = type.value || ''
-    if (inputType.endsWith('[]') || inputType === 'array') {
-      return true
-    }
-    return false
-  }
-}

package/src/amf/lib/PayloadUtils.ts

@@ -1,87 +0,0 @@
-import { ApiExampleGenerator } from '@api-client/core/amf/ApiExampleGenerator.js'
-import { ApiMonacoSchemaGenerator } from '@api-client/core/amf/ApiMonacoSchemaGenerator.js'
-import { ApiSchemaGenerator } from '@api-client/core/amf/ApiSchemaGenerator.js'
-import type { IApiPayload } from '@api-client/core/amf/definitions/Api.js'
-import type { IApiAnyShape } from '@api-client/core/amf/definitions/Shapes.js'
-import type { IProperty } from '@api-client/core/models/Property.js'
-
-export interface PayloadInfo {
-  value: string | FormData | Blob
-  model?: IProperty[]
-  schemas?: unknown
-}
-
-const cache = new Map<string, PayloadInfo>()
-
-export function getPayloadValue(payload: IApiPayload): PayloadInfo {
-  if (cache.has(payload.id)) {
-    return cache.get(payload.id) as PayloadInfo
-  }
-  const { id, mediaType = 'text/plain', schema } = payload
-
-  if (mediaType === 'multipart/form-data') {
-    // schema generators don't support this yet,
-    const info = { value: new FormData(), schemas: [] } as PayloadInfo
-    cache.set(id, info)
-    return info
-  }
-  if (!schema) {
-    const info = { value: '', schemas: [] }
-    cache.set(id, info)
-    return info
-  }
-
-  const schemaFactory = new ApiMonacoSchemaGenerator()
-  const monacoSchemes = schemaFactory.generate(schema, id)
-  let { examples } = payload
-  if (!Array.isArray(examples) || !examples.length) {
-    examples = (schema as IApiAnyShape).examples
-  }
-  if (Array.isArray(examples) && examples.length) {
-    const [example] = examples
-    const generator = new ApiExampleGenerator()
-    const value = generator.read(example, mediaType)
-    const info = { value, schemas: monacoSchemes } as PayloadInfo
-    cache.set(id, info)
-    return info
-  }
-  // generate values.
-  const result = ApiSchemaGenerator.asExample(schema, mediaType, {
-    selectedUnions: [],
-    renderExamples: true,
-    renderOptional: true,
-    renderMocked: true,
-  })
-  if (!result || !result.renderValue) {
-    const info = { value: '', schemas: monacoSchemes }
-    cache.set(id, info)
-    return info
-  }
-  const info = { value: result.renderValue, schemas: monacoSchemes } as PayloadInfo
-  cache.set(id, info)
-  return info
-}
-
-/**
- * @param id The ApiPayload id.
- * @param value The value to cache.
- * @param model Optional model to set.
- */
-export function cachePayloadValue(id: string, value: string, model?: IProperty[]): void {
-  if (cache.has(id)) {
-    const info = cache.get(id) as PayloadInfo
-    info.value = value
-    if (model) {
-      info.model = model
-    }
-    return
-  }
-  cache.set(id, { value, model })
-}
-
-/**
- * @param id Payload id to read the value.
- */
-export function readCachePayloadValue(id: string): PayloadInfo | undefined {
-  return cache.get(id)
-}

package/src/amf/lib/QueryParameterProcessor.ts

@@ -1,186 +0,0 @@
-import { AmfNamespace } from '@api-client/core/amf/definitions/Namespace.js'
-import type { IApiParameter } from '@api-client/core/amf/definitions/Api.js'
-import type {
-  IShapeUnion,
-  IApiScalarShape,
-  IApiNodeShape,
-  IApiArrayShape,
-  IApiUnionShape,
-  IApiPropertyShape,
-} from '@api-client/core/amf/definitions/Shapes.js'
-import type { OperationParameter } from '../types.js'
-
-/**
- * A library to create a list of ApiParameters from a query string value.
- */
-export class QueryParameterProcessor {
-  /**
-   * @param schema
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  collectOperationParameters(schema: IShapeUnion, binding: string, source?: string): OperationParameter[] {
-    let result: OperationParameter[] = []
-    if (!schema) {
-      return result
-    }
-    const { types } = schema
-    if (types.includes(AmfNamespace.aml.vocabularies.shapes.ScalarShape)) {
-      result.push(this.scalarShapeOperationParameter(schema as IApiScalarShape, binding, source))
-    } else if (types.includes(AmfNamespace.w3.shacl.NodeShape)) {
-      const params = this.nodeShapeOperationParameter(schema as IApiNodeShape, binding, source)
-      result = result.concat(params)
-    } else if (types.includes(AmfNamespace.aml.vocabularies.shapes.ArrayShape)) {
-      const arrResult = this.arrayShapeOperationParameter(schema as IApiArrayShape, binding, source)
-      if (Array.isArray(arrResult)) {
-        result = result.concat(arrResult)
-      } else if (arrResult) {
-        result.push(arrResult)
-      }
-    } else if (types.includes(AmfNamespace.aml.vocabularies.shapes.UnionShape)) {
-      const params = this.unionShapeOperationParameter(schema as IApiUnionShape, binding, source)
-      if (params) {
-        result = result.concat(params)
-      }
-    }
-    return result
-  }
-
-  /**
-   * @param shape
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  scalarShapeOperationParameter(shape: IApiScalarShape, binding: string, source?: string): OperationParameter {
-    const { id, name } = shape
-    const constructed: IApiParameter = {
-      id,
-      binding,
-      schema: shape,
-      name,
-      examples: [],
-      payloads: [],
-      types: [AmfNamespace.aml.vocabularies.apiContract.Parameter],
-      required: false,
-      customDomainProperties: [],
-    }
-    return {
-      binding,
-      paramId: id,
-      parameter: constructed,
-      source: source || '',
-      schemaId: id,
-      schema: shape,
-    }
-  }
-
-  /**
-   * @param shape
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  nodeShapeOperationParameter(shape: IApiNodeShape, binding: string, source?: string): OperationParameter[] {
-    const result: OperationParameter[] = []
-    const { properties = [] } = shape
-    if (!properties.length) {
-      return result
-    }
-    properties.forEach((prop) => {
-      result.push(this.parameterOperationParameter(prop, binding, source))
-    })
-    return result
-  }
-
-  /**
-   * @param property The property to build the parameter for.
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  parameterOperationParameter(property: IApiPropertyShape, binding: string, source?: string): OperationParameter {
-    const { id, range, name, minCount = 0 } = property
-    const constructed: IApiParameter = {
-      id,
-      binding,
-      schema: range,
-      name,
-      examples: [],
-      payloads: [],
-      types: [AmfNamespace.aml.vocabularies.apiContract.Parameter],
-      required: minCount > 0,
-      customDomainProperties: [],
-    }
-    return {
-      binding,
-      paramId: id,
-      parameter: constructed,
-      source: source || '',
-      schemaId: property.id,
-      schema: range,
-    }
-  }
-
-  /**
-   * @param shape
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  arrayShapeOperationParameter(
-    shape: IApiArrayShape,
-    binding: string,
-    source?: string
-  ): OperationParameter | OperationParameter[] {
-    const target = shape.items || shape
-    if (target.types.includes(AmfNamespace.w3.shacl.NodeShape)) {
-      const typed = shape.items as IApiNodeShape
-      return this.collectOperationParameters(typed, binding, source)
-    }
-    const { id, name } = target
-    const constructed: IApiParameter = {
-      id,
-      binding,
-      schema: shape,
-      name,
-      examples: [],
-      payloads: [],
-      types: [AmfNamespace.aml.vocabularies.apiContract.Parameter],
-      required: false,
-      customDomainProperties: [],
-    }
-    return {
-      binding,
-      paramId: id,
-      parameter: constructed,
-      source: source || '',
-      schemaId: id,
-      schema: shape,
-    }
-  }
-
-  /**
-   * @param shape
-   * @param binding The parameter binding.
-   * @param source Optional parameter source.
-   */
-  unionShapeOperationParameter(
-    shape: IApiUnionShape,
-    binding: string,
-    source?: string
-  ): OperationParameter[] | undefined {
-    const { anyOf = [], or = [], and = [], xone = [] } = shape
-    if (and.length) {
-      let result: OperationParameter[] = []
-      and.forEach((item) => {
-        const itemResult = this.collectOperationParameters(item, binding, source)
-        if (itemResult) {
-          result = result.concat(itemResult)
-        }
-      })
-      return result
-    }
-    const info = anyOf[0] || or[0] || xone[0]
-    if (!info) {
-      return undefined
-    }
-    return this.collectOperationParameters(info, binding, source)
-  }
-}