@api-client/core 0.20.10 → 0.21.0

package/src/cookies/Punycode.ts

@@ -1,134 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g // RFC 3490 separators
-const regexNonASCII = /[^\0-\x7E]/ // non-ASCII chars
-const maxInt = 2147483647
-const base = 36
-const tMin = 1
-const tMax = 26
-const damp = 700
-const skew = 38
-const baseMinusTMin = base - tMin
-const overflowError = 'Overflow: input needs wider integers to process'
-
-/**
- * This is a short copy of https://github.com/mathiasbynens/punycode.js/blob/master/punycode.js
- * but written for ESM and browsers.
- * All credits to the original author: Mathias Bynens
- */
-export class Punycode {
-  static toASCII(input: string): string {
-    let result = ''
-    const parts = input.split('@')
-    if (parts.length > 1) {
-      result = parts[0] + '@'
-      input = parts[1]
-    }
-    input = input.replace(regexSeparators, '\x2E')
-    const labels = input.split('.')
-    const encoded = labels
-      .map((part) => {
-        return regexNonASCII.test(part) ? 'xn--' + this.encode(part) : part
-      })
-      .join('.')
-    return result + encoded
-  }
-
-  protected static encode(value: string): string {
-    const output = []
-    const input = this.ucs2decode(value)
-    const inputLength = input.length
-    let n = 128
-    let delta = 0
-    let bias = 72
-    for (const currentValue of input) {
-      if (currentValue < 0x80) {
-        output.push(String.fromCharCode(currentValue))
-      }
-    }
-    const basicLength = output.length
-    let handledCPCount = basicLength
-    if (basicLength) {
-      output.push('-')
-    }
-    while (handledCPCount < inputLength) {
-      let m = maxInt
-      for (const currentValue of input) {
-        if (currentValue >= n && currentValue < m) {
-          m = currentValue
-        }
-      }
-
-      const handledCPCountPlusOne = handledCPCount + 1
-      if (m - n > Math.floor((maxInt - delta) / handledCPCountPlusOne)) {
-        throw new RangeError(overflowError)
-      }
-
-      delta += (m - n) * handledCPCountPlusOne
-      n = m
-
-      for (const currentValue of input) {
-        if (currentValue < n && ++delta > maxInt) {
-          throw new RangeError(overflowError)
-        }
-        if (currentValue == n) {
-          // Represent delta as a generalized variable-length integer.
-          let q = delta
-          for (let k = base /* no condition */; ; k += base) {
-            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias
-            if (q < t) {
-              break
-            }
-            const qMinusT = q - t
-            const baseMinusT = base - t
-            output.push(String.fromCharCode(this.digitToBasic(t + (qMinusT % baseMinusT), 0)))
-            q = Math.floor(qMinusT / baseMinusT)
-          }
-
-          output.push(String.fromCharCode(this.digitToBasic(q, 0)))
-          bias = this.adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength)
-          delta = 0
-          ++handledCPCount
-        }
-      }
-      ++delta
-      ++n
-    }
-    return output.join('')
-  }
-
-  protected static digitToBasic(digit: number, flag: number): number {
-    return digit + 22 + 75 * (digit < 26 ? 1 : 0) - ((flag !== 0 ? 1 : 0) << 5)
-  }
-
-  protected static adapt(delta: number, numPoints: number, firstTime: boolean): number {
-    let k = 0
-    delta = firstTime ? Math.floor(delta / damp) : delta >> 1
-    delta += Math.floor(delta / numPoints)
-    for (; /* no initialization */ delta > (baseMinusTMin * tMax) >> 1; k += base) {
-      delta = Math.floor(delta / baseMinusTMin)
-    }
-    return Math.floor(k + ((baseMinusTMin + 1) * delta) / (delta + skew))
-  }
-
-  protected static ucs2decode(input: string): number[] {
-    const result: number[] = []
-    let i = 0
-    const len = input.length
-
-    while (i < len) {
-      const value = input.charCodeAt(i++)
-      if (value >= 0xd800 && value <= 0xdbff && i < len) {
-        const extra = input.charCodeAt(i++)
-        if ((extra & 0xfc00) == 0xdc00) {
-          result.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000)
-        } else {
-          result.push(value)
-          i--
-        }
-      } else {
-        result.push(value)
-      }
-    }
-    return result
-  }
-}

package/src/data/DataExtractor.ts

@@ -1,200 +0,0 @@
-import { IHttpRequest, HttpRequest } from '../models/HttpRequest.js'
-import { ISentRequest, SentRequest } from '../models/SentRequest.js'
-import { IHttpResponse, HttpResponse } from '../models/HttpResponse.js'
-import { IErrorResponse, ErrorResponse } from '../models/ErrorResponse.js'
-import { Headers } from '../lib/headers/Headers.js'
-import { DataReader } from './DataReader.js'
-import { JmespathReader } from './JmespathReader.js'
-import { XmlReader } from './XmlReader.js'
-import { UrlEncodedReader } from './UrlEncodedReader.js'
-import { CookieParser } from '../cookies/CookieParser.js'
-
-export type DataInput =
-  | HttpRequest
-  | SentRequest
-  | IHttpRequest
-  | ISentRequest
-  | IHttpResponse
-  | HttpResponse
-  | IErrorResponse
-  | ErrorResponse
-  | undefined
-
-/**
- * This is a factory class for the `RequestDataExtractor`.
- */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class DataExtractor {
-  /**
-   * Reads the value of a cookie.
-   * @param name The name of the cookie to read.
-   * @param input The response object.
-   */
-  static readCookieValue(
-    name: string,
-    input: IHttpResponse | HttpResponse | IErrorResponse | ErrorResponse | undefined
-  ): string | undefined {
-    const headers = this.readHeaders(input)
-    if (!headers) {
-      return undefined
-    }
-    const parsed = new Headers(headers)
-    const header = parsed.get('set-cookie')
-    if (!header) {
-      return undefined
-    }
-    const cookies = CookieParser.parseRelaxed(header)
-    const cookie = cookies.find((i) => i.name === name)
-    if (cookie) {
-      return cookie.value
-    }
-    return undefined
-  }
-
-  static readHeaders(obj: DataInput): string {
-    if (!obj) {
-      return ''
-    }
-    const typedInstance = obj as HttpRequest | SentRequest
-    if (typedInstance.headersModel && typeof typedInstance.headersModel.toRawString === 'function') {
-      return typedInstance.headersModel.toString()
-    }
-    const typedSchema = obj as IHttpRequest | ISentRequest
-    if (Array.isArray(typedSchema.headersModel)) {
-      const headers = Headers.fromPropertyArray(typedSchema.headersModel)
-      return headers.toString()
-    }
-    return obj.headers || ''
-  }
-
-  /**
-   * Reads value from the body.
-   * @param value The read body value as string
-   * @param mime The body mime
-   * @param path THe path to read.
-   * @returns The extracted value.
-   */
-  static async extractBody(value: string, mime: string, path: string): Promise<string | undefined> {
-    let reader: DataReader | undefined
-    if (mime.includes('json')) {
-      // reader = new JsonReader();
-      reader = new JmespathReader()
-    } else if (mime.includes('xml')) {
-      reader = new XmlReader()
-    } else if (mime.includes('x-www-form-urlencoded')) {
-      reader = new UrlEncodedReader()
-    }
-    if (!reader) {
-      return undefined
-    }
-    await reader.writePayload(value)
-    return reader.getValue(path) as Promise<string>
-  }
-
-  /**
-   * Returns the value for path for given source object
-   *
-   * @param url An url to parse.
-   * @param path Path to the data
-   * @return Value for the path.
-   */
-  static getDataUrl(url: string, path: string[]): string | number | undefined {
-    if (!path || path.length === 0 || !url) {
-      return url
-    }
-    let value: URL | undefined
-    try {
-      value = new URL(url)
-    } catch {
-      //
-    }
-    if (!value) {
-      return undefined
-    }
-    switch (path[0]) {
-      case 'host':
-        return value.host
-      case 'protocol':
-        return value.protocol
-      case 'path':
-        return value.pathname
-      case 'query':
-        return DataExtractor.readUrlQueryValue(value, path[1]) || undefined
-      case 'hash':
-        return DataExtractor.readUrlHashValue(value, path[1]) || undefined
-      default:
-        throw new Error(`Unknown path in the URL: ${path}`)
-    }
-  }
-
-  /**
-   * Reads value of the URL query parameters.
-   *
-   * The `?` at the beginning of the query string is removed.
-   *
-   * @param url The URL object instance
-   * @param param Param name to return. If not set then it returns  whole query string value.
-   * @return Full query string value if `param` is not set or parameter
-   * value. This function does not returns `null` values.
-   */
-  static readUrlQueryValue(url: URL, param?: string): string | null {
-    if (!param) {
-      let v = url.search || ''
-      if (v[0] === '?') {
-        v = v.substring(1)
-      }
-      return v
-    }
-    let value = url.searchParams.get(param)
-    if (!value && value !== '') {
-      value = null
-    }
-    return value
-  }
-
-  /**
-   * Reads value of the URL hash.
-   *
-   * The `#` at the beginning of the hash string is removed.
-   *
-   * If the `param` argument is set then it treats hahs value as a query
-   * parameters string and parses it to get the value.
-   *
-   * @param url The URL object instance
-   * @param param Param name to return. If not set then it returns whole hash string value.
-   * @return Hash parameter or whole hash value.
-   */
-  static readUrlHashValue(url: URL, param?: string): string | undefined {
-    let value: string | undefined = (url.hash || '').substring(1)
-    if (!param) {
-      return value
-    }
-    const obj = new URLSearchParams(value)
-    value = obj.get(param) || undefined
-    if (!value && value !== '') {
-      value = undefined
-    }
-    return value
-  }
-
-  /**
-   * Returns a value for the headers.
-   *
-   * @param source HTTP headers string
-   * @param path The path to the object
-   * @returns The value for the path.
-   */
-  static getDataHeaders(source: string, path: string[]): string | undefined {
-    if (!path || !path.length || !path[0]) {
-      return source
-    }
-    const headers = new Headers(source)
-    const lowerName = path[0].toLowerCase()
-    for (const [name, value] of headers) {
-      if (name.toLowerCase() === lowerName) {
-        return value
-      }
-    }
-    return undefined
-  }
-}

package/src/data/DataReader.ts

@@ -1,11 +0,0 @@
-import { SerializablePayload } from '../models/SerializablePayload.js'
-
-export abstract class DataReader extends SerializablePayload {
-  /**
-   * Reads the value for the given path.
-   *
-   * @param path The path to the data.
-   * @returns the data under the path.
-   */
-  abstract getValue(path: string): Promise<unknown>
-}

package/src/data/JmespathReader.ts

@@ -1,26 +0,0 @@
-import { search } from '@metrichor/jmespath'
-import { DataReader } from './DataReader.js'
-
-/**
- * Reads the value from a JSON document using the the JmesPath notation.
- * See https://jmespath.org/
- *
- * Note, after consideration this implementation is not used with API Client projects to extract
- * request data. Instead, we use `JsonReader` that converts the JSON to XML so the same
- * XPath can be used for both JSON and XML.
- */
-export class JmespathReader extends DataReader {
-  async getValue(path: string): Promise<unknown> {
-    const body = await this.readPayloadAsString()
-    if (!body) {
-      return undefined
-    }
-    let obj
-    try {
-      obj = JSON.parse(body)
-    } catch {
-      return undefined
-    }
-    return search(obj, path)
-  }
-}

package/src/data/Json2Xml.ts

@@ -1,192 +0,0 @@
-/**
- * Normalizes given name to a value that can be accepted by `createElement`
- * function on a document object.
- * @param name A name to process
- * @returns Normalized name
- */
-export const normalizeXmlTagName = (name: string): string => name.replace(/[^a-zA-Z0-9-_.]/g, '')
-
-/**
- * Converts a JSON value to an XML.
- *
- * To convert a JSON to XML call the `convert()` function. This creates the `doc` property with the XML document.
- * To transform the document into an XML string, use the `serialize()` function.
- *
- * This library work in both browser and NodeJS (via the `@xmldom/xmldom` library.)
- */
-export class Json2Xml {
-  /**
-   * Whether it uses native or synthetic API.
-   * Note, this will only happen in NodeJS.
-   */
-  syntheticApi: boolean
-  /**
-   * Created document
-   */
-  doc?: XMLDocument
-  /**
-   * The current node that is being processed.
-   */
-  currentNode?: Element
-
-  constructor() {
-    this.syntheticApi = typeof DOMParser === 'undefined'
-  }
-
-  /**
-   * Converts a JavaScript object to an XML document.
-   * This creates the `doc` property with the JSON translated to the XML document.
-   * Use the `serialize()` to convert it to string.
-   *
-   * @param data A JavaScript object to convert
-   * @param root The name of the root node. Defaults to "root"
-   */
-  async convert(data: unknown, root = 'root'): Promise<void> {
-    const doc = await this.getDocument()
-    this.doc = doc
-    const rootNode = doc.createElement(root)
-    doc.appendChild(rootNode)
-    this.currentNode = rootNode
-
-    if (Array.isArray(data)) {
-      this.processArray(data)
-    } else if (typeof data === 'object') {
-      this.processObject(data as Record<string, unknown>)
-    } else {
-      throw new Error('Invalid object. Unable to process non-object property.')
-    }
-  }
-
-  /**
-   * Converts the current document to a string.
-   * @returns The converted document.
-   */
-  async serialize(): Promise<string> {
-    const { doc } = this
-    if (!doc) {
-      throw new Error(`No document created.`)
-    }
-    const serializer = await this.getSerializer()
-    return serializer.serializeToString(doc)
-  }
-
-  /**
-   * A helper function to convert and serialize a JSON to XML.
-   *
-   * @param data The JSON data to serialize
-   * @param root The name of the root node. Defaults to "root"
-   * @returns The serialized to XML value.
-   */
-  async serializeJson(data: unknown, root = 'root'): Promise<string> {
-    await this.convert(data, root)
-    return this.serialize()
-  }
-
-  /**
-   * Depending on the environment it creates the XML document implementation.
-   *
-   * @returns The XML document to use
-   */
-  async getDocument(): Promise<XMLDocument> {
-    let doc: XMLDocument
-    if (this.syntheticApi) {
-      // This will only happen in NodeJS so it is safe to load it via the `import()`
-      const { DOMImplementation } = await import('@xmldom/xmldom')
-      doc = new DOMImplementation().createDocument(null, '', null) as unknown as XMLDocument
-    } else {
-      doc = document.implementation.createDocument(null, null, null)
-    }
-    return doc
-  }
-
-  /**
-   * Depending on the environment it creates the XML serializer implementation.
-   *
-   * @returns The XML serializer to use
-   */
-  async getSerializer(): Promise<XMLSerializer> {
-    if (this.syntheticApi) {
-      const { XMLSerializer } = await import('@xmldom/xmldom')
-      return new XMLSerializer() as unknown as XMLSerializer
-    }
-    return new XMLSerializer()
-  }
-
-  /**
-   * Processes a property which type is not yet detected
-   * @param input The input to process.
-   */
-  processAny(input: unknown): void {
-    const type = typeof input
-    if (Array.isArray(input)) {
-      this.processArray(input)
-    } else if (type === 'object' && input !== null) {
-      this.processObject(input as Record<string, unknown>)
-    } else {
-      this.processScalar(input as string | number | boolean | null)
-    }
-  }
-
-  /**
-   * Processes an array.
-   * @param input The array to process.
-   */
-  processArray(input: unknown[]): void {
-    if (!Array.isArray(input)) {
-      throw new Error(`Expected array. ${typeof input} given.`)
-    }
-    input.forEach((item) => this.processAny(item))
-  }
-
-  /**
-   * Appends object properties to the current node.
-   * @param input The object to process.
-   */
-  processObject(input: Record<string, unknown>): void {
-    const { currentNode, doc } = this
-    if (!currentNode || !doc) {
-      throw new Error(`Library not initialized. Call the convert() function.`)
-    }
-    Object.keys(input).forEach((key) => {
-      const val = input[key]
-      const elementName = normalizeXmlTagName(key)
-      const element = doc.createElement(elementName)
-      currentNode.appendChild(element)
-      this.currentNode = element
-      this.processAny(val)
-    })
-    this.currentNode = currentNode
-  }
-
-  /**
-   * Adds the value to the current node.
-   * @param input the scalar to add
-   */
-  processScalar(input: string | number | boolean | null): void {
-    const { currentNode, doc } = this
-    if (!currentNode || !doc) {
-      throw new Error(`Library not initialized. Call the convert() function.`)
-    }
-    if (input === undefined || input === null) {
-      // nothing to add. silently quit.
-      return
-    }
-    let value: string | number | boolean = ''
-    let valid = false
-    if (!valid && ['boolean', 'string', 'number', 'bigint'].includes(typeof input)) {
-      valid = true
-      value = input
-    }
-    if (!valid) {
-      throw new Error(`Invalid scalar type: ${typeof input}.`)
-    }
-    const typedValue = String(value)
-    if (typedValue.includes('<') || typedValue.includes('>')) {
-      const cdata = doc.createCDATASection(typedValue)
-      currentNode.appendChild(cdata)
-    } else {
-      const node = doc.createTextNode(typedValue)
-      currentNode.appendChild(node)
-    }
-  }
-}

package/src/data/JsonReader.ts

@@ -1,41 +0,0 @@
-import { Json2Xml } from './Json2Xml.js'
-import { XmlReader } from './XmlReader.js'
-
-/**
- * A class that converts the passed JSON value to XML and then it performs
- * search through the XPath implementation.
- */
-export class JsonReader extends XmlReader {
-  override async getValue(path: string): Promise<unknown> {
-    const body = await this.readPayloadAsString()
-    if (!body) {
-      return undefined
-    }
-    let obj: unknown
-    try {
-      obj = JSON.parse(body)
-    } catch {
-      return undefined
-    }
-    const factory = new Json2Xml()
-    const str = await factory.serializeJson(obj)
-    const doc = await this.getDocumentWithBody(str)
-    if (!doc) {
-      return undefined
-    }
-
-    // the below works well in a browser but in Node it won't process the document created from
-    // a synthetic API.
-    // await factory.convert(obj);
-    // const doc = factory.doc as XMLDocument;
-
-    let finalPath = path
-    if (finalPath.startsWith('/') && !finalPath.startsWith('//')) {
-      finalPath = `/root${finalPath}`
-    } else if (!finalPath.startsWith('/')) {
-      finalPath = `/root/${finalPath}`
-    }
-
-    return this.queryDocument(finalPath, doc)
-  }
-}

package/src/data/PayloadPointer.ts

@@ -1,50 +0,0 @@
-import { Payload } from '../lib/transformers/PayloadSerializer.js'
-import { JsonReader } from './JsonReader.js'
-import { XmlReader } from './XmlReader.js'
-import { UrlEncodedReader } from './UrlEncodedReader.js'
-import { DataReader } from './DataReader.js'
-
-/**
- * A class that creates a pointer to a value in a Payload.
- */
-export class PayloadPointer {
-  payload?: Payload
-  mime?: string
-  path: string
-
-  /**
-   * @param path The path to the data.
-   * @param payload The Payload value. Note, without the payload the `getValue()`
-   *    always returns `undefined`. This is optional for convenience.
-   * @param mime The content type of the body message. Note, without the payload's mime
-   *  the `getValue()` always returns `undefined`. This is optional for convenience.
-   */
-  constructor(path: string, payload?: Payload, mime?: string) {
-    this.path = path
-    this.payload = payload
-    this.mime = mime
-  }
-
-  /**
-   * @returns the value for the `path`.
-   */
-  async getValue(): Promise<unknown> {
-    const { path, payload, mime } = this
-    if (!mime || !path || !payload) {
-      return undefined
-    }
-    let reader: DataReader | undefined
-    if (mime.includes('json')) {
-      reader = new JsonReader()
-    } else if (mime.includes('xml')) {
-      reader = new XmlReader()
-    } else if (mime.includes('x-www-form-urlencoded')) {
-      reader = new UrlEncodedReader()
-    }
-    if (!reader) {
-      return undefined
-    }
-    reader.payload = payload
-    return reader.getValue(path)
-  }
-}