@api-client/core 0.18.12 → 0.18.13

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

@@ -0,0 +1,280 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,55 @@
+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/HttpRequestRunner.ts

@@ -1,3 +1,4 @@
+import { Logger, type ILogObj } from 'tslog'
 import { IRequest } from '../../models/Request.js'
 import { IHttpRequest } from '../../models/HttpRequest.js'
 import { IRequestConfig } from '../../models/RequestConfig.js'
@@ -6,9 +7,8 @@ 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 { HttpEngineOptions } from '../http-engine/HttpEngine.js'
+import type { HttpEngineOptions } from '../http-engine/CoreEngine.js'
 import { CoreEngine } from '../http-engine/CoreEngine.js'
-import { Logger } from '../../lib/logging/Logger.js'
 import { CookieJar } from '../../cookies/CookieJar.js'
 import { SecurityProcessor } from '../../authorization/lib/SecurityProcessor.js'
 import { RequestCookiesProcessor } from './RequestCookiesProcessor.js'
@@ -63,7 +63,7 @@ export class HttpRequestRunner {
    */
   variablesProcessor = new VariablesProcessor()
 
-  logger?: Logger
+  logger?: Logger<ILogObj>
 
   /**
    * The abort signal to set on this request.

package/src/runtime/node/InteropInterfaces.ts

@@ -1,7 +1,7 @@
 /* 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 { Logger } from '../../lib/logging/Logger.js'
 import { IRequestLog } from '../../models/RequestLog.js'
 import { CookieJar } from '../../cookies/CookieJar.js'
 
@@ -20,7 +20,7 @@ export interface IRequestRunnerOptions {
   /**
    * Overrides the default logger (console).
    */
-  logger?: Logger
+  logger?: Logger<ILogObj>
   /**
    * An instance of a cookie jar (store) to put/read cookies.
    */
@@ -121,7 +121,7 @@ export interface IProjectRunnerOptions {
    * The logger to use with the request factory.
    * When not set it uses the dummy logger (no output).
    */
-  logger?: Logger
+  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.

package/src/runtime/node/ProjectRequestRunner.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 import { EventEmitter } from 'events'
 import { Environment, Kind as EnvironmentKind } from '../../models/Environment.js'
-import { Logger } from '../../lib/logging/Logger.js'
+import { type Logger, type ILogObj } from '../../lib/logging/index.js'
 import { IRequestLog, RequestLog } from '../../models/RequestLog.js'
 import { Property } from '../../models/Property.js'
 import { ProjectFolder } from '../../models/ProjectFolder.js'
@@ -59,7 +59,7 @@ export interface ProjectRequestRunner {
  * Requests are executed in order defined in the folder.
  */
 export class ProjectRequestRunner extends EventEmitter {
-  logger?: Logger
+  logger?: Logger<ILogObj>
   project: HttpProject
   /**
    * An instance of a cookie jar (store) to put/read cookies.

package/src/runtime/node/ProjectRunner.ts

@@ -5,7 +5,6 @@ import { SerializableError } from '../../models/SerializableError.js'
 import { HttpProject } from '../../models/HttpProject.js'
 import { ProjectFolder } from '../../models/ProjectFolder.js'
 import { Environment, IEnvironment } from '../../models/Environment.js'
-import { DummyLogger } from '../../lib/logging/DummyLogger.js'
 import { IRequestLog } from '../../models/RequestLog.js'
 import { IHttpRequest } from '../../models/HttpRequest.js'
 import { ProjectRequestRunner } from './ProjectRequestRunner.js'
@@ -14,6 +13,7 @@ import { pathExists, readJson } from '../../lib/fs/Fs.js'
 import { BaseRunner } from './BaseRunner.js'
 import { IProjectRunnerOptions, IRequestRunnerOptions } from './InteropInterfaces.js'
 import { State } from './enums.js'
+import { createLogger } from '../../lib/logging/index.js'
 
 type ProjectParent = HttpProject | ProjectFolder
 
@@ -275,7 +275,7 @@ export abstract class ProjectRunner extends BaseRunner {
     if (options.logger) {
       result.logger = options.logger
     } else {
-      result.logger = new DummyLogger()
+      result.logger = createLogger()
     }
     if (options.cookies) {
       result.cookies = options.cookies