@api-client/core 0.20.10 → 0.21.1

package/src/runtime/http-runner/HttpRequestRunner.ts

@@ -1,427 +0,0 @@
-import { Logger, type ILogObj } from 'tslog'
-import { IRequest } from '../../models/Request.js'
-import { IHttpRequest } from '../../models/HttpRequest.js'
-import { IRequestConfig } from '../../models/RequestConfig.js'
-import { IRequestAuthorization } from '../../models/RequestAuthorization.js'
-import { IRequestLog } from '../../models/RequestLog.js'
-import { VariablesProcessor } from '../variables/VariablesProcessor.js'
-import { IHttpFlow } from '../../models/http-flows/HttpFlows.js'
-import { AssertionResult, IHttpAssertion } from '../../models/http-flows/HttpAssertion.js'
-import type { HttpEngineOptions } from '../http-engine/CoreEngine.js'
-import { CoreEngine } from '../http-engine/CoreEngine.js'
-import { CookieJar } from '../../cookies/CookieJar.js'
-import { SecurityProcessor } from '../../authorization/lib/SecurityProcessor.js'
-import { RequestCookiesProcessor } from './RequestCookiesProcessor.js'
-import { HttpFlowRunner } from './HttpFlowRunner.js'
-import { ISentRequest } from '../../models/SentRequest.js'
-import { IResponse } from '../../models/Response.js'
-import { IErrorResponse } from '../../models/ErrorResponse.js'
-import { HttpCertificate } from '../../models/ClientCertificate.js'
-import { HttpAssertionRunner } from './HttpAssertionRunner.js'
-
-/**
- * A class that takes a single HttpRequest definition and executes it.
- *
- * This class does the following (in order):
- *
- * - applies variables
- * - applies authorization configuration
- * - applies cookies
- * - runs request actions
- * - transports the request
- * - processes response and redirect cookies
- * - runs response actions
- * - reports the request log
- */
-export class HttpRequestRunner {
-  /**
-   * Request processing configuration.
-   */
-  config?: IRequestConfig
-
-  /**
-   * Request authorization configuration
-   */
-  authorization?: IRequestAuthorization[]
-
-  /**
-   * Actions to be performed when the request is executed.
-   */
-  flows?: IHttpFlow[]
-
-  /**
-   * The cumulative list of all variables to be applied to the request and other properties.
-   * The variables must be already processed for variables in values (evaluated).
-   *
-   * These variables are passed by reference. Changes made anywhere to the variables will result
-   * with updating this list.
-   */
-  variables?: Record<string, string>
-
-  /**
-   * The variables processor instance.
-   */
-  variablesProcessor = new VariablesProcessor()
-
-  logger?: Logger<ILogObj>
-
-  /**
-   * The abort signal to set on this request.
-   * Aborts the request when the signal fires.
-   * @type {(AbortSignal | undefined)}
-   */
-  signal?: AbortSignal
-
-  /**
-   * An instance of a cookie jar (store) to put/read cookies.
-   */
-  cookies?: CookieJar
-
-  /**
-   * Certificates to send with the request.
-   */
-  certificates?: HttpCertificate[]
-
-  assertions?: IHttpAssertion[]
-
-  /**
-   * Creates an instance from the IRequest object with setting the corresponding variables.
-   * @param request The request object to use.
-   */
-  static fromRequest(request: IRequest): HttpRequestRunner {
-    const instance = new HttpRequestRunner()
-    instance.flows = request.flows
-    instance.authorization = request.authorization
-    instance.config = request.config
-    instance.assertions = request.assertions
-    return instance
-  }
-
-  /**
-   * Runs the request and all tasks around the HTTp request execution like gathering
-   * environment information, running actions, and HTTP modules.
-   *
-   * @param request The request object to execute.
-   * @returns The execution log.
-   */
-  async run(request: IHttpRequest): Promise<IRequestLog> {
-    const requestCopy = await this.processRequest(request)
-    const result = await this.executeRequest(requestCopy)
-    await this.processResponse(result)
-    return result
-  }
-
-  /**
-   * @returns the configuration processed by the variables processor.
-   */
-  async readConfig(): Promise<IRequestConfig | undefined> {
-    const { config, variables, variablesProcessor } = this
-    if (!config) {
-      return undefined
-    }
-    if (!variables) {
-      return config
-    }
-    return variablesProcessor.evaluateVariablesWithContext(config, variables)
-  }
-
-  /**
-   * @returns the authorization data processed by the variables processor.
-   */
-  async readAuthorization(): Promise<IRequestAuthorization[] | undefined> {
-    const { variables, authorization, variablesProcessor } = this
-    if (!Array.isArray(authorization) || !authorization.length) {
-      return undefined
-    }
-    if (!variables) {
-      return authorization
-    }
-
-    const ps = authorization
-      .filter((i) => i.enabled !== false)
-      .map(async (item) => {
-        const copy = await variablesProcessor.evaluateVariablesWithContext(item, variables)
-        if (copy.config) {
-          copy.config = await variablesProcessor.evaluateVariablesWithContext(copy.config, variables)
-        }
-        return copy
-      })
-    const result = await Promise.all(ps)
-    return result
-  }
-
-  /**
-   * Prepares the request object before making the HTTP request
-   * and runs actions and modules.
-   *
-   * @param request The request to execute.
-   * @returns the copy of the request object.
-   */
-  async processRequest(request: IHttpRequest): Promise<IHttpRequest> {
-    let copy = await this.applyVariables(request)
-    copy = await this.applyAuthorization(copy)
-    copy = await this.applyCookies(copy)
-    await this.runRequestFlows(copy)
-    return copy
-  }
-
-  /**
-   * Runs the request through the variables processor.
-   * @returns A copy of the passed request with possibly changed values.
-   */
-  async applyVariables(request: IHttpRequest): Promise<IHttpRequest> {
-    const { variables, variablesProcessor } = this
-    let copy: IHttpRequest = { ...request }
-    if (variables) {
-      copy.url = this.prepareRequestUrl(copy.url, variables)
-      copy = await variablesProcessor.evaluateVariablesWithContext(copy, variables)
-    }
-    return copy
-  }
-
-  async applyAuthorization(request: IHttpRequest): Promise<IHttpRequest> {
-    const auth = await this.readAuthorization()
-    SecurityProcessor.applyAuthorization(request, auth)
-    return request
-  }
-
-  async applyCookies(request: IHttpRequest): Promise<IHttpRequest> {
-    const { cookies } = this
-    if (!cookies || !this.sessionCookies) {
-      return request
-    }
-    const list = await cookies.listCookies(request.url)
-    RequestCookiesProcessor.request(request, list)
-    return request
-  }
-
-  /**
-   * Executes the request actions and modules.
-   */
-  async runRequestFlows(request: IHttpRequest): Promise<void> {
-    const flows = await this.readFlows('request')
-    const runner = new HttpFlowRunner()
-    runner.cookies = this.cookies
-    runner.variables = this.variables
-    await runner.request(request, flows)
-  }
-
-  /**
-   * Executes the request actions and modules.
-   */
-  async runResponseFlows(request: ISentRequest, response: IResponse | IErrorResponse): Promise<void> {
-    const flows = await this.readFlows('response')
-    const runner = new HttpFlowRunner()
-    runner.cookies = this.cookies
-    runner.variables = this.variables
-    await runner.response(request, response, flows)
-  }
-
-  /**
-   * Reads and evaluates action flows.
-   *
-   * @param trigger The trigger name to read the flows for.
-   */
-  protected async readFlows(trigger: 'request' | 'response'): Promise<IHttpFlow[]> {
-    const result: IHttpFlow[] = []
-    const { flows, variables = {}, variablesProcessor } = this
-    if (!Array.isArray(flows) || !flows.length) {
-      return result
-    }
-    for (const flow of flows) {
-      if (flow.trigger !== trigger) {
-        continue
-      }
-      if (!Array.isArray(flow.actions) || !flow.actions.length) {
-        continue
-      }
-      const copy = { ...flow } as IHttpFlow
-      if (copy.condition) {
-        copy.condition = await variablesProcessor.evaluateVariablesWithContext(copy.condition, variables)
-      }
-      const actions = copy.actions.map(async (action) => {
-        const actionCopy = { ...action }
-        if (Array.isArray(actionCopy.steps) && actionCopy.steps.length) {
-          const stepsPromises = actionCopy.steps.map((step) =>
-            variablesProcessor.evaluateVariablesWithContext(step, variables)
-          )
-          actionCopy.steps = await Promise.all(stepsPromises)
-        }
-        return actionCopy
-      })
-      copy.actions = await Promise.all(actions)
-      result.push(copy)
-    }
-    return result
-  }
-
-  /**
-   * Prepares the HTTP engine configuration and executes the request,
-   * @param request The request to execute.
-   * @returns The execution log.
-   */
-  async executeRequest(request: IHttpRequest): Promise<IRequestLog> {
-    const opts = await this.prepareEngineConfig()
-    const engine = new CoreEngine(request, opts)
-    return engine.send()
-  }
-
-  /**
-   * Creates a configuration options for the HTTP engine.
-   */
-  async prepareEngineConfig(): Promise<HttpEngineOptions> {
-    const { logger, signal } = this
-    const auth = await this.readAuthorization()
-    const config = await this.readConfig()
-    const cert = SecurityProcessor.readCertificate(auth)
-    const opts: HttpEngineOptions = {}
-    if (cert) {
-      opts.certificates = [cert]
-    }
-    if (this.certificates) {
-      if (!opts.certificates) {
-        opts.certificates = []
-      }
-      opts.certificates = opts.certificates.concat(this.certificates)
-    }
-    if (Array.isArray(auth)) {
-      opts.authorization = auth
-    }
-    if (logger) {
-      opts.logger = logger
-    }
-    if (signal) {
-      opts.signal = signal
-    }
-    if (!config || config.enabled === false) {
-      return opts
-    }
-    if (typeof config.timeout === 'number') {
-      opts.timeout = config.timeout
-    }
-    if (typeof config.sentMessageLimit === 'number') {
-      opts.sentMessageLimit = config.sentMessageLimit
-    }
-    if (typeof config.followRedirects === 'boolean') {
-      opts.followRedirects = config.followRedirects
-    }
-    if (typeof config.defaultHeaders === 'boolean') {
-      opts.defaultHeaders = config.defaultHeaders
-    }
-    if (typeof config.validateCertificates === 'boolean') {
-      opts.validateCertificates = config.validateCertificates
-    }
-    if (config.defaultUserAgent) {
-      opts.defaultUserAgent = config.defaultUserAgent
-    }
-    if (config.defaultAccept) {
-      opts.defaultAccept = config.defaultAccept
-    }
-    if (config.proxy) {
-      opts.proxy = config.proxy
-    }
-    if (config.proxyUsername) {
-      opts.proxyUsername = config.proxyUsername
-    }
-    if (config.proxyPassword) {
-      opts.proxyPassword = config.proxyPassword
-    }
-    if (Array.isArray(config.hosts)) {
-      opts.hosts = config.hosts
-    }
-    return opts
-  }
-
-  async processResponse(log: IRequestLog): Promise<void> {
-    const { request, response } = log
-    if (!request || !response) {
-      return
-    }
-    if (this.cookies && this.sessionCookies) {
-      const cookies = RequestCookiesProcessor.response(log)
-      if (cookies) {
-        const ps = Object.keys(cookies).map((url) => {
-          const items = cookies[url]
-          this.cookies?.setCookies(url, items)
-        })
-        await Promise.allSettled(ps)
-      }
-    }
-    await this.runResponseFlows(request, response)
-    const assertions = await this.runAssertions(request, response)
-    if (assertions) {
-      log.assertions = assertions
-    }
-  }
-
-  get sessionCookies(): boolean {
-    const { config } = this
-    if (!config) {
-      return true
-    }
-    if (config.enabled === false) {
-      return true
-    }
-    return !config.ignoreSessionCookies
-  }
-
-  /**
-   * When defined it applies the serve's base URI to relative URLs.
-   * @param currentUrl The URL to process.
-   */
-  prepareRequestUrl(currentUrl: string, variables: Record<string, string>): string {
-    const { baseUri } = variables
-    if (!baseUri) {
-      return currentUrl
-    }
-    if (currentUrl.startsWith('http:') || currentUrl.startsWith('https:')) {
-      return currentUrl
-    }
-    if (currentUrl.startsWith('/')) {
-      return `${baseUri}${currentUrl}`
-    }
-    return `${baseUri}/${currentUrl}`
-  }
-
-  /**
-   * Prepares and runs assertions on the response.
-   * It changes the response object by setting the assertions result.
-   */
-  async runAssertions(
-    request: ISentRequest,
-    response: IResponse | IErrorResponse
-  ): Promise<AssertionResult[] | undefined> {
-    const assertions = await this.readAssertions()
-    if (!assertions.length) {
-      return
-    }
-    const factory = new HttpAssertionRunner()
-    return factory.run(request, response, assertions)
-  }
-
-  /**
-   * @returns Prepared (evaluated with variables) assertions. Only not disabled assertions are returned.
-   */
-  protected async readAssertions(): Promise<IHttpAssertion[]> {
-    const { assertions, variablesProcessor, variables = {} } = this
-    if (!Array.isArray(assertions) || !assertions.length) {
-      return []
-    }
-    const result: IHttpAssertion[] = []
-    for (const assertion of assertions) {
-      if (assertion.enabled === false) {
-        continue
-      }
-      if (!Array.isArray(assertion.steps) || !assertion.steps.length) {
-        continue
-      }
-      const copy = { ...assertion } as IHttpAssertion
-      const stepsPromises = copy.steps.map(async (step) => {
-        return variablesProcessor.evaluateVariablesWithContext(step, variables)
-      })
-      copy.steps = await Promise.all(stepsPromises)
-      result.push(copy)
-    }
-    return result
-  }
-}

package/src/runtime/http-runner/HttpRuntimeEnvironment.ts

@@ -1,27 +0,0 @@
-import { CookieJar } from '../../cookies/CookieJar.js'
-
-/**
- * The request(s) execution environment.
- * An environment is applied to each request in the iteration (if running a project request)
- * or to the HTTP request (when running a single request).
- *
- * In the iteration mode, the environment is shared across all requests in the iteration.
- * After that the environment is discarded and re-created for the next iteration.
- *
- * Cookies, depending on the implementation, most likely are shared across all iterations.
- * This is why the implementation must to make sure it is safe to run the cookie functions
- * in the parallel mode of a project runner.
- */
-export interface IHttpRuntimeEnvironment {
-  /**
-   * The computed environment variables to use with this request or iteration.
-   * Variables can be changed but this change is not persistent. After each iteration
-   * the environment is restored it its default values.
-   */
-  variables: Record<string, string>
-
-  /**
-   * An instance of a cookie jar (store) to put/read cookies.
-   */
-  cookies: CookieJar
-}

package/src/runtime/http-runner/RequestCookiesProcessor.ts

@@ -1,80 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import { IHttpCookie, HttpCookie } from '../../models/HttpCookie.js'
-import { IHttpRequest } from '../../models/HttpRequest.js'
-import { IRequestLog } from '../../models/RequestLog.js'
-import { IErrorResponse } from '../../models/ErrorResponse.js'
-import { IResponse } from '../../models/Response.js'
-import { IResponseRedirect } from '../../models/ResponseRedirect.js'
-import { Headers } from '../../lib/headers/Headers.js'
-import { CookieParser } from '../../cookies/CookieParser.js'
-
-export class RequestCookiesProcessor {
-  /**
-   * Applies cookies to the request object.
-   *
-   * Note, this mutates the request object.
-   *
-   * @param request The request to which apply the cookies.
-   * @param cookies The cookies to apply
-   */
-  static request(request: IHttpRequest, cookies?: (IHttpCookie | HttpCookie)[]): void {
-    if (!Array.isArray(cookies) || !cookies.length) {
-      return
-    }
-    const header = cookies.map((c) => `${c.name}=${c.value}`).join('; ')
-    const headers = new Headers(request.headers)
-    headers.append('cookie', header)
-    request.headers = headers.toString()
-  }
-
-  /**
-   * Computes a list of cookies in the response. This includes the redirect cookies and the final response.
-   *
-   * @param log The HTTP log.
-   * @returns A map where keys are the URL of the request and the values are cookies.
-   *          It may be empty map when no cookies.
-   */
-  static response(log: IRequestLog): Record<string, HttpCookie[]> | undefined {
-    if (!log.response || !log.request) {
-      return
-    }
-    const typedError = log.response as IErrorResponse
-    if (typedError.error) {
-      return
-    }
-    const typedResponse = log.response as IResponse
-    return this.extract(typedResponse, log.request.url, log.redirects)
-  }
-
-  protected static extract(
-    response: IResponse,
-    url: string,
-    redirects?: IResponseRedirect[]
-  ): Record<string, HttpCookie[]> {
-    const result: Record<string, HttpCookie[]> = {}
-    let redirectUrl = url
-    if (redirects && redirects.length) {
-      for (const redirect of redirects) {
-        const headers = new Headers(redirect.response.headers)
-        const sc = headers.get('set-cookie')
-        if (sc) {
-          const cookies = CookieParser.parse(redirectUrl, sc)
-          if (cookies.length) {
-            result[redirectUrl] = cookies
-          }
-        }
-        redirectUrl = redirect.url
-      }
-    }
-
-    const headers = new Headers(response.headers)
-    const sc = headers.get('set-cookie')
-    if (sc) {
-      const cookies = CookieParser.parse(redirectUrl, sc)
-      if (cookies.length) {
-        result[redirectUrl] = cookies
-      }
-    }
-    return result
-  }
-}

package/src/runtime/node/BaseRunner.ts

@@ -1,29 +0,0 @@
-import { EventEmitter } from 'events'
-import { IProjectExecutionIteration, IProjectExecutionLog } from '../../models/ProjectExecution.js'
-
-export abstract class BaseRunner extends EventEmitter {
-  /**
-   * Iteration start time.
-   */
-  protected startTime?: number
-  /**
-   * Iteration end time.
-   */
-  protected endTime?: number
-  /**
-   * A list of already executed iterations.
-   */
-  protected executed: IProjectExecutionIteration[] = []
-
-  /**
-   * Creates the report of the execution.
-   */
-  protected async createReport(): Promise<IProjectExecutionLog> {
-    const log: IProjectExecutionLog = {
-      started: this.startTime as number,
-      ended: this.endTime as number,
-      iterations: this.executed,
-    }
-    return log
-  }
-}

package/src/runtime/node/InteropInterfaces.ts

@@ -1,143 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import { IProjectRequestIterator, IHttpProject } from '../../models/HttpProject.js'
-import { type Logger, type ILogObj } from 'tslog'
-import { Environment } from '../../models/Environment.js'
-import { IRequestLog } from '../../models/RequestLog.js'
-import { CookieJar } from '../../cookies/CookieJar.js'
-
-export interface IRequestRunnerOptions {
-  /**
-   * When provided it overrides any project / folder defined environment.
-   */
-  environment?: Environment
-  /**
-   * Additional variables to pass to the selected environment.
-   * This can be use to pass system variables, when needed.
-   *
-   * To use system variables tou can use `init.variables = process.env`;
-   */
-  variables?: Record<string, string>
-  /**
-   * Overrides the default logger (console).
-   */
-  logger?: Logger<ILogObj>
-  /**
-   * An instance of a cookie jar (store) to put/read cookies.
-   */
-  cookies?: CookieJar
-}
-
-export interface IRequestRunnerRunOptions extends IProjectRequestIterator {}
-
-export interface IProjectExecutionResult {
-  /**
-   * The variables evaluated during the run.
-   * These variables have values set by requests' HTTP flows.
-   */
-  variables: Record<string, string>
-  /**
-   * The executed items.
-   */
-  items: IRunResult[]
-}
-
-export interface IRunResult {
-  /**
-   * The key of the request from the HttpProject that was executed.
-   */
-  key: string
-  /**
-   * The key of parent folder of the executed request.
-   */
-  parent?: string
-  /**
-   * Set when a fatal error occurred so the request couldn't be executed.
-   * This is not the same as error reported during a request. The log's response can still be IResponseError.
-   */
-  error?: boolean
-  /**
-   * The error message. Always set when the `error` is `true`.
-   */
-  errorMessage?: string
-  /**
-   * The request log.
-   * Always set when the `error` is `false`.
-   */
-  log?: IRequestLog
-}
-
-export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {}
-
-export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
-  project: IHttpProject
-}
-
-export interface IProjectRunnerOptions {
-  /**
-   * The environment to use.
-   * This can be a name or the key of the environment located under the parent or root.
-   * It can also be a path to the environment definition. If the file exists it is used. Otherwise it tried to
-   * find the environment in the project.
-   */
-  environment?: string
-  /**
-   * The parent folder to execute.
-   */
-  parent?: string
-  /**
-   * The names or the keys of requests to execute.
-   * This can be used to limit the number of requests.
-   */
-  request?: string[]
-  /**
-   * The number of times the execution should be repeated.
-   * Default to 1.
-   */
-  iterations?: number
-  /**
-   * The number of milliseconds to wait between each iteration.
-   * Default to the next frame (vary from 1 to tens of milliseconds).
-   */
-  iterationDelay?: number
-  /**
-   * When set it performs parallel execution for each iteration.
-   * The number of executions at the same time depends on the number of processor cores
-   * available on the current machine. The maximum of the parallel execution
-   * is the number of available cores. When the `iterations` number is higher
-   * then the "rest" is added to the iterations per each core.
-   */
-  parallel?: boolean
-  /**
-   * When set it includes requests in the current folder and sub-folder according to the order
-   * defined in the folder.
-   */
-  recursive?: boolean
-  /**
-   * The opposite of the `requests`. The list of names or keys of requests or folders to ignore.
-   * Note, ignore is tested before the `requests`.
-   */
-  ignore?: string[]
-  /**
-   * The logger to use with the request factory.
-   * When not set it uses the dummy logger (no output).
-   */
-  logger?: Logger<ILogObj>
-  /**
-   * When true it copies all system variables to the execution environment.
-   * When an array of strings, only takes system variables that are listed in the array.
-   * When a map, it uses this map as a list of variables.
-   * When not set it does not read system variables.
-   */
-  variables?: boolean | string[] | Record<string, string>
-
-  /**
-   * Optional signal from an `AbortController`.
-   * It aborts the execution when the ``abort` event is dispatched.
-   */
-  signal?: AbortSignal
-
-  /**
-   * An instance of a cookie jar (store) to put/read cookies.
-   */
-  cookies?: CookieJar
-}