@api-client/core 0.20.10 → 0.21.0

package/src/data/RequestDataExtractor.ts

@@ -1,124 +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 { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from '../models/http-flows/HttpFlows.js'
-import { Headers } from '../lib/headers/Headers.js'
-import { DataExtractor } from './DataExtractor.js'
-
-/**
- * A class to extract data from the request or the response.
- */
-export class RequestDataExtractor {
-  /**
-   * The request that has been sent to the server.
-   */
-  request: HttpRequest | SentRequest
-
-  /**
-   * The response object
-   */
-  response?: HttpResponse | ErrorResponse
-
-  constructor(request: IHttpRequest | ISentRequest, response?: IHttpResponse | IErrorResponse) {
-    this.request = new HttpRequest(request)
-    if (response) {
-      if (ErrorResponse.isErrorResponse(response)) {
-        this.response = new ErrorResponse(response as IErrorResponse)
-      } else {
-        this.response = new HttpResponse(response)
-      }
-    }
-  }
-
-  /**
-   * Reads the data from the selected path.
-   *
-   * @param source The source of the data to read. Note, variables are not supported here.
-   * @param data The kind of data to read the value from
-   * @param path The path to the data.
-   * @return Data to be processed
-   */
-  async extract(
-    source: FlowSourceEnum,
-    data?: FlowRequestDataEnum | FlowResponseDataEnum,
-    path?: string
-  ): Promise<string | number | undefined> {
-    const args = path ? path.split('.') : []
-    switch (data) {
-      case 'url':
-        return DataExtractor.getDataUrl(this.getUrl(), args)
-      case 'headers':
-        return DataExtractor.getDataHeaders(this.getHeaders(source), args)
-      case 'status':
-        return this.response && this.response.status
-      case 'statusText':
-        return this.response && this.response.statusText
-      case 'method':
-        return this.request.method
-      case 'body':
-        return this.processBody(path, source)
-      case 'cookie':
-        return DataExtractor.readCookieValue(args[0], this.response)
-      default:
-        throw new Error(`Unknown data ${data} for ${source} data`)
-    }
-  }
-
-  /**
-   * @param source The source name
-   * @returns The URL of the request
-   */
-  getUrl(): string {
-    return this.request.url
-  }
-
-  /**
-   * @param source The source name
-   * @returns The headers from the request / response
-   */
-  getHeaders(source?: FlowSourceEnum): string {
-    return DataExtractor.readHeaders(source === 'request' ? this.request : this.response)
-  }
-
-  async processBody(path?: string, source?: FlowSourceEnum): Promise<string | undefined> {
-    const value = await this.getBody(source)
-    if (!value) {
-      return undefined
-    }
-    if (!path) {
-      return value
-    }
-    const headersValue = this.getHeaders(source)
-    if (!headersValue) {
-      return undefined
-    }
-    const headers = new Headers(headersValue)
-    const mime = headers.get('content-type')
-    if (!mime) {
-      return undefined
-    }
-    return DataExtractor.extractBody(value, mime, path)
-  }
-
-  /**
-   * @param source The source name
-   * @returns The headers from the request / response
-   */
-  async getBody(source?: FlowSourceEnum): Promise<string | undefined> {
-    if (source === 'request') {
-      return this.request.readPayloadAsString()
-    }
-    if (this.response) {
-      return this.response.readPayloadAsString()
-    }
-    return undefined
-  }
-
-  /**
-   * @deprecated Use `DataExtractor.extractBody()` instead.
-   */
-  async extractBody(value: string, mime: string, path: string): Promise<string | undefined> {
-    return DataExtractor.extractBody(value, mime, path)
-  }
-}

package/src/data/UrlEncodedReader.ts

@@ -1,21 +0,0 @@
-import { DataReader } from './DataReader.js'
-
-/**
- * Reads a value for a property in an `application/x-www-form-urlencoded` body.
- */
-export class UrlEncodedReader extends DataReader {
-  /**
-   * @param path Since the `application/x-www-form-urlencoded` is a key-value pair
-   *    this can be just a simple name of the property to read.
-   * @returns The value of the property or undefined.
-   */
-  async getValue(path: string): Promise<unknown> {
-    const body = await this.readPayloadAsString()
-    const parsed = new URLSearchParams(body)
-    const result = parsed.get(path)
-    if (result === null) {
-      return undefined
-    }
-    return result
-  }
-}

package/src/data/XmlReader.ts

@@ -1,128 +0,0 @@
-/* eslint-disable no-console */
-import { DataReader } from './DataReader.js'
-
-let xResult: typeof XPathResult | undefined = typeof XPathResult !== 'undefined' ? XPathResult : undefined
-
-/**
- * Reads the data from an XML using the xpath.
- * See https://www.w3schools.com/xml/xpath_syntax.asp.
- */
-export class XmlReader extends DataReader {
-  async getValue(path: string): Promise<unknown> {
-    const doc = await this.getDocument()
-    if (!doc) {
-      return undefined
-    }
-    return this.queryDocument(path, doc)
-  }
-
-  queryDocument(path: string, doc: Document): unknown {
-    try {
-      const result = doc.evaluate(path, doc)
-      switch (result.resultType) {
-        case (xResult as typeof XPathResult).NUMBER_TYPE:
-          return result.numberValue
-        case (xResult as typeof XPathResult).STRING_TYPE:
-          return result.stringValue
-        case (xResult as typeof XPathResult).BOOLEAN_TYPE:
-          return result.booleanValue
-        case (xResult as typeof XPathResult).UNORDERED_NODE_ITERATOR_TYPE:
-        case (xResult as typeof XPathResult).ORDERED_NODE_ITERATOR_TYPE:
-          return this.processNodeResult(result)
-        default:
-          console.error(`Unsupported xpath result type: [${result.resultType}]`)
-          return undefined
-      }
-    } catch (e) {
-      console.error(e)
-      return undefined
-    }
-  }
-
-  processNodeResult(result: XPathResult): unknown {
-    const results: unknown[] = []
-    let next = result.iterateNext()
-    while (next) {
-      const value = next.textContent
-      if (value) {
-        results.push(value.trim())
-      }
-      next = result.iterateNext()
-    }
-    if (!results.length) {
-      return undefined
-    }
-
-    const mapped = results.map((item) => {
-      if (item === 'true') {
-        return true
-      }
-      if (item === 'true') {
-        return false
-      }
-      const typedNumber = Number(item)
-      if (!Number.isNaN(typedNumber)) {
-        return typedNumber
-      }
-      return item
-    })
-    return mapped.length === 1 ? mapped[0] : mapped
-  }
-
-  async getDocument(): Promise<Document | undefined> {
-    const body = await this.readPayloadAsString()
-    if (!body) {
-      return undefined
-    }
-    return this.getDocumentWithBody(body)
-  }
-
-  async getDocumentWithBody(body: string): Promise<Document | undefined> {
-    if (typeof DOMParser === 'undefined') {
-      return this.getNodeDocument(body)
-    }
-    return this.getWebDocument(body)
-  }
-
-  async getWebDocument(data: string): Promise<Document | undefined> {
-    const parser = new DOMParser()
-    const dom = parser.parseFromString(data, 'text/xml')
-    if (dom.querySelector('parsererror')) {
-      return undefined
-    }
-    return dom
-  }
-
-  async getNodeDocument(data: string): Promise<Document | undefined> {
-    const { DOMParser } = await import('@xmldom/xmldom')
-    const xpath = await import('xpath')
-    // @ts-expect-error The xpath has invalid types defined.
-    xResult = xpath.default.XPathResult
-    let errored = false
-    const parser = new DOMParser({
-      onError: (level, msg): void => {
-        console.error(`[${level}] ${msg}`)
-        errored = true
-      },
-    })
-    let dom: Document | undefined
-    try {
-      dom = parser.parseFromString(data, 'text/xml') as unknown as Document
-    } catch (e) {
-      console.error(e)
-    }
-    if (!dom || errored) {
-      return undefined
-    }
-    Object.defineProperty(dom, 'evaluate', {
-      value: function (expression: string, contextNode: Node) {
-        // @ts-expect-error The xpath library has invalid types
-        return xpath.default.evaluate(expression, contextNode, null, 0, null)
-      },
-      enumerable: true, // Make the method visible in loops
-      configurable: true, // Allow the method to be deleted or redefined
-      writable: true, // Allow the method's value to be changed
-    })
-    return dom as unknown as Document
-  }
-}

package/src/events/authorization/AuthorizationEventTypes.ts

@@ -1,22 +0,0 @@
-export const AuthorizationEventTypes = Object.freeze({
-  OAuth2: Object.freeze({
-    /**
-     * Authorization with auth configuration on detail
-     */
-    authorize: 'oauth2authorize',
-    /**
-     * Removes cached token for the provider
-     */
-    removeToken: 'oauth2removetoken',
-  }),
-  Oidc: Object.freeze({
-    /**
-     * Authorization the user with the provided configuration.
-     */
-    authorize: 'oidcauthorize',
-    /**
-     * Removes cached tokens for the provider
-     */
-    removeTokens: 'oidcremovetokens',
-  }),
-})

package/src/events/authorization/AuthorizationEvents.ts

@@ -1,74 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import {
-  IOAuth2Authorization,
-  ITokenRemoveOptions,
-  IOidcTokenInfo,
-  IOidcTokenError,
-  ITokenInfo,
-} from '../../models/Authorization.js'
-import { AuthorizationEventTypes } from './AuthorizationEventTypes.js'
-import { ContextEvent } from '../BaseEvents.js'
-
-export class AuthorizationEvents {
-  static get OAuth2(): typeof OAuth2Events {
-    return OAuth2Events
-  }
-
-  static get Oidc(): typeof OidcEvents {
-    return OidcEvents
-  }
-}
-
-class OAuth2Events {
-  /**
-   * @param config Authorization options.
-   * @param target A node on which to dispatch the event.
-   * @returns Promise resolved with authorization result
-   */
-  static async authorize(config: IOAuth2Authorization, target: EventTarget = window): Promise<ITokenInfo | undefined> {
-    const e = new ContextEvent<IOAuth2Authorization, ITokenInfo>(AuthorizationEventTypes.OAuth2.authorize, config)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * @param config Authorization options.
-   * @param target A node on which to dispatch the event.
-   * @returns Promise resolved when the token is removed
-   */
-  static async removeToken(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
-    const e = new ContextEvent<ITokenRemoveOptions, void>(AuthorizationEventTypes.OAuth2.removeToken, config)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-}
-
-class OidcEvents {
-  /**
-   * @param config Authorization options.
-   * @param target A node on which to dispatch the event.
-   * @returns Promise resolved with authorization result
-   */
-  static async authorize(
-    config: IOAuth2Authorization,
-    target: EventTarget = window
-  ): Promise<(IOidcTokenInfo | IOidcTokenError)[] | undefined> {
-    const e = new ContextEvent<IOAuth2Authorization, (IOidcTokenInfo | IOidcTokenError)[]>(
-      AuthorizationEventTypes.Oidc.authorize,
-      config
-    )
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * @param config Authorization options.
-   * @param target A node on which to dispatch the event.
-   * @returns Promise resolved when the token is removed
-   */
-  static async removeTokens(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
-    const e = new ContextEvent<ITokenRemoveOptions, void>(AuthorizationEventTypes.Oidc.removeTokens, config)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-}

package/src/events/cookies/CookieEventTypes.ts

@@ -1,13 +0,0 @@
-export const CookieEventTypes = Object.freeze({
-  listAll: 'sessioncookielistall',
-  listDomain: 'sessioncookielistdomain',
-  listUrl: 'sessioncookielisturl',
-  delete: 'sessioncookiedelete',
-  deleteUrl: 'sessioncookiedeleteurl',
-  update: 'sessioncookieupdate',
-  updateBulk: 'sessioncookieupdatebulk',
-  State: Object.freeze({
-    delete: 'sessioncookiestatedelete',
-    update: 'sessioncookiestateupdate',
-  }),
-})

package/src/events/cookies/CookieEvents.ts

@@ -1,168 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import { CookieEventTypes } from './CookieEventTypes.js'
-import { IHttpCookie } from '../../models/HttpCookie.js'
-import {
-  ContextEventDetailWithResult,
-  ContextEvent,
-  ContextChangeRecord,
-  ContextUpdateEvent,
-  ContextStateUpdateEvent,
-} from '../BaseEvents.js'
-
-export interface ICookieDomainListDetail {
-  domain: string
-}
-
-export interface ICookieUrlListDetail {
-  url: string
-}
-
-export interface ICookieItemsDetail {
-  cookies: IHttpCookie[]
-}
-
-export interface ICookieDetail {
-  cookie: IHttpCookie
-}
-
-export interface ICookieDeleteUrlDetail {
-  url: string
-  name?: string
-}
-
-export class CookieEvents {
-  /**
-   * Lists all projects in the data store.
-   * This does not return the whole project record. Instead it only returns the index object of the project.
-   *
-   * @param target The target on which to dispatch the event
-   * @returns The list of project index objects.
-   */
-  static async listAll(target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
-    const detail: ContextEventDetailWithResult<IHttpCookie[]> = {}
-    const e = new CustomEvent(CookieEventTypes.listAll, {
-      bubbles: true,
-      composed: true,
-      cancelable: true,
-      detail,
-    })
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * @param target The target on which to dispatch the event
-   * @param domain The cookie domain
-   * @returns The list of project index objects.
-   */
-  static async listDomain(domain: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
-    const detail: ICookieDomainListDetail = { domain }
-    const e = new ContextEvent<ICookieDomainListDetail, IHttpCookie[]>(CookieEventTypes.listDomain, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * @param target The target on which to dispatch the event
-   * @param url The cookie URL
-   * @returns The list of project index objects.
-   */
-  static async listUrl(url: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
-    const detail: ICookieUrlListDetail = { url }
-    const e = new ContextEvent<ICookieUrlListDetail, IHttpCookie[]>(CookieEventTypes.listUrl, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * Deletes cookies from the store.
-   *
-   * @param target The target on which to dispatch the event
-   * @param cookies The list of cookies to remove
-   */
-  static async delete(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
-    const detail: ICookieItemsDetail = { cookies }
-    const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.delete, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * Deletes cookies from the store.
-   *
-   * @param target The target on which to dispatch the event
-   * @param url The url associated with the cookie. Depending on the session mechanism
-   *            the URL or the domain and the path is used.
-   * @param name The name of the cookie to remove. When not set all cookies are removed for the given URL.
-   */
-  static async deleteUrl(url: string, name?: string, target: EventTarget = window): Promise<void> {
-    const detail: ICookieDeleteUrlDetail = { url, name }
-    const e = new ContextEvent<ICookieDeleteUrlDetail, void>(CookieEventTypes.deleteUrl, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * Updates a cookie in the store.
-   *
-   * @param target The target on which to dispatch the event
-   * @param cookie A cookie to update
-   * @returns The change record of the updated cookie.
-   */
-  static async update(
-    cookie: IHttpCookie,
-    target: EventTarget = window
-  ): Promise<ContextChangeRecord<IHttpCookie> | undefined> {
-    const e = new ContextUpdateEvent(CookieEventTypes.update, { item: cookie })
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * Updates a cookie in the store in a bulk operation.
-   *
-   * @param target The target on which to dispatch the event
-   * @param cookies A list of cookies to update
-   * @returns The change record of the updated cookie.
-   */
-  static async updateBulk(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
-    const detail: ICookieItemsDetail = { cookies }
-    const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.updateBulk, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-
-  /**
-   * Events related to a state of a cookie store.
-   */
-  static get State(): typeof StateEvents {
-    return StateEvents
-  }
-}
-
-class StateEvents {
-  /**
-   * Event dispatched when a cookie was deleted from the context store
-   * @param target The target on which to dispatch the event
-   * @param cookie The schema of the removed cookie
-   */
-  static delete(cookie: IHttpCookie, target: EventTarget = window): void {
-    const e = new CustomEvent<ICookieDetail>(CookieEventTypes.State.delete, {
-      bubbles: true,
-      composed: true,
-      cancelable: false,
-      detail: { cookie },
-    })
-    target.dispatchEvent(e)
-  }
-
-  /**
-   * Event dispatched when a cookie was deleted from the context store
-   * @param target The target on which to dispatch the event
-   * @param record The change record.
-   */
-  static update(record: ContextChangeRecord<IHttpCookie>, target: EventTarget = window): void {
-    const e = new ContextStateUpdateEvent<IHttpCookie>(CookieEventTypes.State.update, record)
-    target.dispatchEvent(e)
-  }
-}

package/src/events/environment/EnvironmentEventTypes.ts

@@ -1,3 +0,0 @@
-export const EnvironmentEventTypes = Object.freeze({
-  set: 'environmentsetvariable',
-})

package/src/events/environment/EnvironmentEvents.ts

@@ -1,25 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import { EnvironmentEventTypes } from './EnvironmentEventTypes.js'
-import { ContextEvent } from '../BaseEvents.js'
-
-export interface ISetVariableDetail {
-  name: string
-  value: string
-}
-
-export class EnvironmentEvents {
-  /**
-   * An event dispatched to set a variable in the current environment.
-   *
-   * @param name Variable name
-   * @param value Variable value
-   * @param target A node on which to dispatch the event.
-   * @returns Nothing. The promise resolves when the variable is set.
-   */
-  static async set(name: string, value: string, target: EventTarget = window): Promise<void> {
-    const detail: ISetVariableDetail = { name, value }
-    const e = new ContextEvent<ISetVariableDetail, void>(EnvironmentEventTypes.set, detail)
-    target.dispatchEvent(e)
-    return e.detail.result
-  }
-}

package/src/events/transport/TransportEventTypes.ts

@@ -1,32 +0,0 @@
-export const TransportEventTypes = Object.freeze({
-  /**
-   * Transport via the CoreEngine.
-   */
-  Core: Object.freeze({
-    request: 'transportcorerequest',
-    httpProject: 'transportcorehttpproject',
-  }),
-
-  /**
-   * Transport via the native platform's bindings.
-   */
-  Http: Object.freeze({
-    send: 'httptransportsend',
-  }),
-
-  // web sockets.
-  Ws: Object.freeze({
-    /**
-     * Informs to make a connection. Used by web sockets.
-     */
-    connect: 'wstransportconnect',
-    /**
-     * Informs to close the current connection. Used by web sockets.
-     */
-    disconnect: 'wstransportdisconnect',
-    /**
-     * Informs to send a data on the current connection. Used by web sockets.
-     */
-    send: 'wstransportsend',
-  }),
-})