@api-client/core 0.20.10 → 0.21.0

package/src/runtime/http-engine/parsers/HttpResponseParser.ts

@@ -1,280 +0,0 @@
-import { EventEmitter } from 'events'
-import { Headers } from '../../../lib/headers/Headers.js'
-import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
-import type { HeadersReceivedDetail } from '../CoreEngine.js'
-import { StatusParser } from './StatusParser.js'
-import { HeadersParser } from './HeadersParser.js'
-import { BodyParser } from './BodyParser.js'
-
-export enum RequestState {
-  Status,
-  Headers,
-  Body,
-  Done,
-}
-
-export interface ResponseInfo {
-  status?: number
-  contentLength?: number
-  chunked: boolean
-  body?: Buffer
-  chunk?: Buffer
-  chunkSize?: number
-}
-
-export interface ParserCallbacks {
-  onStatusParsed: (status: number, statusText: string) => void
-  onHeadersParsed: (headers: Headers) => void
-  onBodyComplete: (body: Buffer) => void
-  onError: (error: Error) => void
-  onAbort: () => void
-  emit: (event: string, detail?: unknown) => void
-}
-
-/**
- * HTTP Response Parser
- * Handles parsing of HTTP response data including status, headers, and body
- */
-export class HttpResponseParser extends EventEmitter {
-  private state = RequestState.Status
-  private rawHeaders?: Buffer
-  private responseInfo: ResponseInfo
-  private logger: Logger<ILogObj>
-  private callbacks: ParserCallbacks
-  private aborted = false
-
-  private statusParser: StatusParser
-  private headersParser: HeadersParser
-  private bodyParser: BodyParser
-
-  constructor(logger: Logger<ILogObj>, callbacks: ParserCallbacks) {
-    super()
-    this.logger = logger
-    this.callbacks = callbacks
-    this.responseInfo = {
-      chunked: false,
-    }
-
-    this.statusParser = new StatusParser(logger)
-    this.headersParser = new HeadersParser(logger)
-    this.bodyParser = new BodyParser(logger, this.responseInfo)
-  }
-
-  /**
-   * Process incoming HTTP response data
-   * @param data Buffer containing HTTP response data
-   */
-  processData(data: Buffer): void {
-    if (this.aborted) {
-      return
-    }
-
-    let remaining: Buffer | undefined = data
-
-    if (this.state === RequestState.Status) {
-      remaining = this.processStatus(remaining)
-      if (!remaining) {
-        return
-      }
-    }
-
-    if (this.state === RequestState.Headers) {
-      remaining = this.processHeaders(remaining)
-      if (!remaining) {
-        return
-      }
-    }
-
-    if (this.state === RequestState.Body) {
-      this.processBody(remaining)
-    }
-  }
-
-  /**
-   * Process HTTP status line
-   * @param data Buffer containing status line data
-   * @returns Remaining data after status parsing
-   */
-  private processStatus(data?: Buffer): Buffer | undefined {
-    if (this.aborted) {
-      return
-    }
-
-    if (!data) {
-      return
-    }
-
-    try {
-      const result = this.statusParser.parse(data)
-      if (result) {
-        this.responseInfo.status = result.status
-        this.callbacks.onStatusParsed(result.status, result.statusText)
-        this.state = RequestState.Headers
-        return result.remaining
-      }
-    } catch (error) {
-      this.callbacks.onError(error as Error)
-    }
-
-    return data
-  }
-
-  /**
-   * Process HTTP headers
-   * @param data Buffer containing header data
-   * @returns Remaining data after header parsing
-   */
-  private processHeaders(data?: Buffer): Buffer | undefined {
-    if (this.aborted) {
-      return
-    }
-
-    if (!data) {
-      this.parseHeaders()
-      return
-    }
-
-    try {
-      const result = this.headersParser.parse(data, this.rawHeaders)
-      if (result.complete) {
-        this.rawHeaders = result.headers
-        this.parseHeaders(this.rawHeaders)
-        delete this.rawHeaders
-        this.state = RequestState.Body
-        return this.postHeaders(result.remaining)
-      } else {
-        this.rawHeaders = result.headers
-        return
-      }
-    } catch (error) {
-      this.callbacks.onError(error as Error)
-    }
-
-    return data
-  }
-
-  /**
-   * Parse headers and extract response information
-   * @param buffer Raw headers buffer
-   */
-  private parseHeaders(buffer?: Buffer): void {
-    let raw = ''
-    if (buffer) {
-      raw = buffer.toString()
-    }
-
-    this.logger.info('Received headers list', raw)
-    const headers = new Headers(raw)
-
-    // Extract response information
-    if (headers.has('Content-Length')) {
-      this.responseInfo.contentLength = Number(headers.get('Content-Length'))
-    }
-    if (headers.has('Transfer-Encoding')) {
-      const tr = headers.get('Transfer-Encoding')
-      if (tr === 'chunked') {
-        this.responseInfo.chunked = true
-      }
-    }
-
-    this.callbacks.onHeadersParsed(headers)
-
-    const rawHeaders = headers.toString()
-    const detail: HeadersReceivedDetail = {
-      returnValue: true,
-      value: rawHeaders,
-    }
-    this.callbacks.emit('headersreceived', detail)
-    if (!detail.returnValue) {
-      this.abort()
-    }
-  }
-
-  /**
-   * Check if response should end after headers
-   * @param data Remaining data after headers
-   * @returns Data to continue processing or undefined to end
-   */
-  private postHeaders(data?: Buffer): Buffer | undefined {
-    // Check if response status indicates no body should be present
-    const status = this.responseInfo.status
-    if (typeof status === 'number' && (status === 204 || status === 304 || (status >= 100 && status < 200))) {
-      // 204 No Content, 304 Not Modified, and informational responses do not have a body
-      this.state = RequestState.Done
-      this.callbacks.onBodyComplete(Buffer.alloc(0))
-      return
-    }
-
-    if (!data || data.length === 0) {
-      if (this.responseInfo.contentLength === 0) {
-        this.state = RequestState.Done
-        this.callbacks.onBodyComplete(Buffer.alloc(0))
-        return
-      }
-      return
-    }
-    return data
-  }
-
-  /**
-   * Process HTTP body data
-   * @param data Buffer containing body data
-   */
-  private processBody(data?: Buffer): void {
-    if (this.aborted || !data) {
-      return
-    }
-
-    try {
-      if (this.responseInfo.chunked) {
-        this.bodyParser.processChunked(data, (body) => {
-          this.state = RequestState.Done
-          this.callbacks.onBodyComplete(body)
-        })
-      } else {
-        this.bodyParser.processContentLength(data, (body) => {
-          this.state = RequestState.Done
-          this.callbacks.onBodyComplete(body)
-        })
-      }
-    } catch (error) {
-      this.callbacks.onError(error as Error)
-    }
-  }
-
-  /**
-   * Abort the parser
-   */
-  abort(): void {
-    this.aborted = true
-    this.state = RequestState.Done
-    this.callbacks.onAbort()
-  }
-
-  /**
-   * Reset parser state
-   */
-  reset(): void {
-    this.state = RequestState.Status
-    this.rawHeaders = undefined
-    this.responseInfo = {
-      chunked: false,
-    }
-    this.aborted = false
-    this.bodyParser = new BodyParser(this.logger, this.responseInfo)
-  }
-
-  /**
-   * Get current parser state
-   */
-  getState(): RequestState {
-    return this.state
-  }
-
-  /**
-   * Get response information
-   */
-  getResponseInfo(): ResponseInfo {
-    return this.responseInfo
-  }
-}

package/src/runtime/http-engine/parsers/StatusParser.ts

@@ -1,69 +0,0 @@
-import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
-
-const nlBuffer = Buffer.from([13, 10])
-
-export interface StatusParseResult {
-  status: number
-  statusText: string
-  remaining: Buffer
-}
-
-/**
- * Parser for HTTP status lines
- */
-export class StatusParser {
-  private logger: Logger<ILogObj>
-
-  constructor(logger: Logger<ILogObj>) {
-    this.logger = logger
-  }
-
-  /**
-   * Parse HTTP status line from buffer
-   * @param data Buffer containing status line data
-   * @returns Parsed status result or undefined if incomplete
-   */
-  parse(data: Buffer): StatusParseResult | undefined {
-    this.logger.info('Processing status')
-
-    const index = data.indexOf(nlBuffer)
-    if (index === -1) {
-      // Incomplete status line, need more data
-      return undefined
-    }
-
-    let statusLine = data.slice(0, index).toString()
-    const remaining = data.slice(index + 2)
-
-    // Remove HTTP version prefix
-    statusLine = statusLine.replace(/HTTP\/\d(\.\d)?\s/, '')
-
-    const delimiterPos = statusLine.indexOf(' ')
-    let status: string
-    let msg = ''
-
-    if (delimiterPos === -1) {
-      status = statusLine
-    } else {
-      status = statusLine.substr(0, delimiterPos)
-      msg = statusLine.substr(delimiterPos + 1)
-    }
-
-    let typedStatus = Number(status)
-    if (Number.isNaN(typedStatus)) {
-      typedStatus = 0
-    }
-
-    if (msg && msg.indexOf('\n') !== -1) {
-      msg = msg.split('\n')[0]
-    }
-
-    this.logger.info('Received status', typedStatus, msg)
-
-    return {
-      status: typedStatus,
-      statusText: msg,
-      remaining,
-    }
-  }
-}

package/src/runtime/http-engine/response/ResponseProcessor.ts

@@ -1,46 +0,0 @@
-import { Response } from '../../../models/Response.js'
-import { Headers } from '../../../lib/headers/Headers.js'
-import { isRedirect, STATUS_UNAUTHORIZED } from '../constants.js'
-
-export interface ResponseProcessingContext {
-  status: number
-  currentResponse?: Response
-  currentHeaders?: Headers
-  followRedirects: boolean
-  auth?: { method: string }
-  aborted: boolean
-}
-
-export interface ResponseProcessingResult {
-  shouldContinue: boolean
-  action: 'redirect' | 'auth' | 'publish' | 'abort'
-  data?: Record<string, unknown>
-}
-
-/**
- * Process the response and determine the next action
- */
-export function processResponse(context: ResponseProcessingContext): ResponseProcessingResult {
-  const { status, followRedirects, auth, aborted } = context
-
-  if (aborted) {
-    return { shouldContinue: false, action: 'abort' }
-  }
-
-  // Handle redirects
-  if (isRedirect(status)) {
-    if (followRedirects) {
-      return { shouldContinue: false, action: 'redirect', data: { status } }
-    }
-  }
-
-  // Handle authentication challenges
-  if (status === STATUS_UNAUTHORIZED && auth) {
-    if (auth.method === 'ntlm') {
-      return { shouldContinue: false, action: 'auth', data: { method: 'ntlm' } }
-    }
-  }
-
-  // Normal response - publish it
-  return { shouldContinue: false, action: 'publish' }
-}

package/src/runtime/http-engine/statistics/StatisticsProcessor.ts

@@ -1,52 +0,0 @@
-import { RequestTime } from '../../../models/RequestTime.js'
-import type { RequestStats } from '../CoreEngine.js'
-
-/**
- * Creates HAR 1.2 timings object from stats.
- */
-export function computeStats(stats: RequestStats): RequestTime {
-  const {
-    sentTime,
-    messageStart,
-    connectionTime = 0,
-    lookupTime = 0,
-    connectedTime,
-    secureStartTime,
-    secureConnectedTime,
-    lastReceivedTime,
-    firstReceiveTime,
-    receivingTime,
-  } = stats
-  // in case the `send` event was not handled we use the `messageStart` as this is set when the request is created.
-  const adjustedSentTime = sentTime || messageStart
-  // when there was no body we check when the end time.
-  const adjustedLastReceivedTime = lastReceivedTime || receivingTime
-  const adjustedLookupTime = lookupTime || messageStart
-  let send = adjustedSentTime && messageStart ? adjustedSentTime - messageStart : -1
-  if (send < 0) {
-    send = 0
-  }
-  const dns = lookupTime ? lookupTime - connectionTime : -1
-  const connect = connectedTime && adjustedLookupTime ? connectedTime - adjustedLookupTime : -1
-  let receive = adjustedLastReceivedTime && firstReceiveTime ? adjustedLastReceivedTime - firstReceiveTime : -1
-  if (receive < 0) {
-    receive = 0
-  }
-  let wait = firstReceiveTime && adjustedSentTime ? firstReceiveTime - adjustedSentTime : -1
-  if (wait < 0) {
-    wait = 0
-  }
-  let ssl = -1
-  if (typeof secureStartTime === 'number' && typeof secureConnectedTime === 'number') {
-    ssl = secureConnectedTime - secureStartTime
-  }
-  const result = new RequestTime()
-  result.blocked = 0
-  result.connect = connect
-  result.receive = receive
-  result.send = send
-  result.wait = wait
-  result.dns = dns
-  result.ssl = ssl
-  return result
-}

package/src/runtime/http-engine/url/UrlProcessor.ts

@@ -1,55 +0,0 @@
-import { URL } from 'url'
-import { HostRule } from '../../../models/HostRule.js'
-import { IRequestBaseConfig } from '../../../models/RequestConfig.js'
-
-export interface UrlProcessorOptions {
-  hosts?: IRequestBaseConfig['hosts']
-}
-
-/**
- * Updates the `uri` property from current request URL
- */
-export function readUrl(value: string, options: UrlProcessorOptions = {}): URL {
-  const { hosts = [] } = options
-  const instances = hosts.map((i) => new HostRule(i))
-  value = HostRule.applyHosts(value, instances)
-  try {
-    return new URL(value)
-  } catch {
-    throw new Error(`Unable to parse the URL: ${value}`)
-  }
-}
-
-/**
- * Get host header for the request
- */
-export function getHostHeader(url: string, options: UrlProcessorOptions = {}): string | undefined {
-  const { hosts = [] } = options
-  const instances = hosts.map((i) => new HostRule(i))
-  const processedUrl = HostRule.applyHosts(url, instances)
-  try {
-    const parsed = new URL(processedUrl)
-    return parsed.host
-  } catch {
-    return undefined
-  }
-}
-
-/**
- * Get redirect location
- */
-export function getRedirectLocation(location: string, currentUrl: string): string {
-  try {
-    const url = new URL(location, currentUrl)
-    return url.toString()
-  } catch {
-    return location
-  }
-}
-
-/**
- * Check if redirect is a loop
- */
-export function isRedirectLoop(location: string, redirects: { url: string }[]): boolean {
-  return redirects.some((redirect) => redirect.url === location)
-}

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

@@ -1,193 +0,0 @@
-import { AssertionEnum } from '../../models/http-flows/HttpAssertion.js'
-
-/**
- * Checks if values equal.
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if objects matches.
- */
-export function isEqual(value: unknown, condition: unknown): boolean {
-  if (value === condition || String(value) === String(condition)) {
-    return true
-  }
-  let valueTyped = value
-  let conditionTyped = condition
-  if (typeof value !== 'undefined') {
-    valueTyped = String(value)
-  }
-  if (typeof condition !== 'undefined') {
-    conditionTyped = String(condition)
-  }
-  const typedConditionNumber = Number(conditionTyped)
-  if (!Number.isNaN(typedConditionNumber)) {
-    conditionTyped = typedConditionNumber
-    valueTyped = Number(valueTyped)
-  }
-  return conditionTyped === valueTyped
-}
-
-/**
- * Opposite of `isEqual()`.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @return False if objects matches.
- */
-export function isNotEqual(value: unknown, condition: unknown): boolean {
-  return !isEqual(value, condition)
-}
-
-/**
- * Checks if value is less than comparator.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if value is less than condition.
- */
-export function isLessThan(value: unknown, condition: unknown): boolean {
-  const valueNumber = Number(value)
-  if (Number.isNaN(valueNumber)) {
-    return false
-  }
-  const conditionNumber = Number(condition)
-  if (Number.isNaN(conditionNumber)) {
-    return false
-  }
-  return valueNumber < conditionNumber
-}
-
-/**
- * Checks if value is less than or equal to comparator.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if value is less than or equal to `condition`.
- */
-export function isLessThanEqual(value: unknown, condition: unknown): boolean {
-  const valueNumber = Number(value)
-  if (Number.isNaN(valueNumber)) {
-    return false
-  }
-  const conditionNumber = Number(condition)
-  if (Number.isNaN(conditionNumber)) {
-    return false
-  }
-  return valueNumber <= conditionNumber
-}
-
-/**
- * Checks if value is greater than comparator.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if value is greater than `condition`.
- */
-export function isGreaterThan(value: unknown, condition: unknown): boolean {
-  const valueNumber = Number(value)
-  if (Number.isNaN(valueNumber)) {
-    return false
-  }
-  const conditionNumber = Number(condition)
-  if (Number.isNaN(conditionNumber)) {
-    return false
-  }
-  return valueNumber > conditionNumber
-}
-
-/**
- * Checks if value is greater than or equal to comparator.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if value is greater than or equal to `condition`.
- */
-export function isGreaterThanEqual(value: unknown, condition: unknown): boolean {
-  const valueNumber = Number(value)
-  if (Number.isNaN(valueNumber)) {
-    return false
-  }
-  const conditionNumber = Number(condition)
-  if (Number.isNaN(conditionNumber)) {
-    return false
-  }
-  return valueNumber >= conditionNumber
-}
-
-/**
- * Checks if value contains the `condition`.
- * It works on strings, arrays and objects.
- *
- * @param value Value to compare
- * @param condition Comparator value
- * @returns True if value contains the `condition`.
- */
-export function contains(value: unknown, condition: unknown): boolean {
-  if (!value) {
-    return false
-  }
-  if (typeof value === 'string') {
-    return value.indexOf(condition as string) !== -1
-  }
-  if (Array.isArray(value)) {
-    if (!Number.isNaN(condition) && typeof condition !== 'number') {
-      const result = value.indexOf(Number(condition))
-      if (result !== -1) {
-        return true
-      }
-    }
-    return value.indexOf(condition) !== -1
-  }
-  if (typeof value !== 'object') {
-    return false
-  }
-  return (condition as string) in value
-}
-
-/**
- * Checks if `value` can be tested against regular expression.
- *
- * @param value Value to compare
- * @param condition Comparator value - regex string.
- * @returns Value of calling `test()` function on string.
- */
-export function isRegex(value: unknown, condition: unknown): boolean {
-  let re
-  try {
-    re = new RegExp(condition as string, 'm')
-  } catch {
-    return false
-  }
-  const result = String(value)
-  return re.test(result)
-}
-
-/**
- * Checks if given condition is satisfied by both value and operator.
- *
- * @param value Value read from the response / request object
- * @param operator Comparison term.
- * @param condition Value to compare.
- * @returns True if the condition is satisfied and false otherwise.
- */
-export function checkCondition(value: unknown, operator: AssertionEnum, condition: string | undefined): boolean {
-  switch (operator) {
-    case 'equal':
-      return isEqual(value, condition)
-    case 'not-equal':
-      return isNotEqual(value, condition)
-    case 'greater-than':
-      return isGreaterThan(value, condition)
-    case 'greater-than-equal':
-      return isGreaterThanEqual(value, condition)
-    case 'less-than':
-      return isLessThan(value, condition)
-    case 'less-than-equal':
-      return isLessThanEqual(value, condition)
-    case 'contains':
-      return contains(value, condition)
-    case 'regex':
-      return isRegex(value, condition)
-    default:
-      return false
-  }
-}