@api-client/core 0.18.12 → 0.18.13

package/src/runtime/http-engine/message/MessageBuilder.ts

@@ -0,0 +1,201 @@
+import { Headers } from '../../../lib/headers/Headers.js'
+import { IHttpRequest } from '../../../models/HttpRequest.js'
+import * as PayloadSupport from '../PayloadSupport.js'
+import { HTTP_VERSION, CRLF_BUFFER } from '../constants.js'
+import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
+
+export interface MessageBuilderOptions {
+  logger: Logger<ILogObj>
+  request: IHttpRequest
+  hasProxy: boolean
+  isProxyTunnel: boolean
+  hostHeader?: string
+}
+
+export interface MessageBuilderContext {
+  headers: Headers
+  buffer?: Buffer
+  statusLine: string
+  hostHeader?: string
+}
+
+/**
+ * Builds HTTP messages for requests
+ */
+export class MessageBuilder {
+  private logger: Logger<ILogObj>
+  private request: IHttpRequest
+  private hasProxy: boolean
+  private isProxyTunnel: boolean
+  private hostHeader?: string
+  private hostTestReg = /^\s*host\s*:/im
+
+  constructor(options: MessageBuilderOptions) {
+    this.logger = options.logger
+    this.request = options.request
+    this.hasProxy = options.hasProxy
+    this.isProxyTunnel = options.isProxyTunnel
+    this.hostHeader = options.hostHeader
+  }
+
+  /**
+   * Builds a complete HTTP message
+   */
+  buildMessage(headers: Headers, buffer?: Buffer): Buffer {
+    this.logger.debug('Preparing HTTP message...')
+
+    const context = this.createMessageContext(headers, buffer)
+    const messageBuffer = this.assembleMessage(context)
+
+    this.logger.debug('The message is ready.')
+    return messageBuffer
+  }
+
+  /**
+   * Creates the message context with all components
+   */
+  private createMessageContext(headers: Headers, buffer?: Buffer): MessageBuilderContext {
+    const statusLine = this.createStatusLine()
+    this.logger.debug(`Created message status: ${statusLine}`)
+
+    const hostHeader = this.getHostHeader()
+    if (hostHeader) {
+      this.logger.debug(`Adding the "host" header: ${hostHeader}`)
+    }
+
+    return {
+      headers,
+      buffer,
+      statusLine,
+      hostHeader,
+    }
+  }
+
+  /**
+   * Assembles the complete HTTP message from components
+   */
+  private assembleMessage(context: MessageBuilderContext): Buffer {
+    const { headers, buffer, statusLine, hostHeader } = context
+
+    // Build the header lines
+    const headerLines = [statusLine]
+
+    if (hostHeader) {
+      headerLines.push(`Host: ${hostHeader}`)
+    }
+
+    // Add custom headers
+    const customHeaders = headers.toString()
+    if (customHeaders) {
+      this.logger.debug('Adding headers to the request...')
+      this.logger.silly('Headers:', [...headers.keys()])
+      headerLines.push(PayloadSupport.normalizeString(customHeaders))
+    }
+
+    // Join all header lines
+    const headerString = headerLines.join('\r\n')
+
+    // Create buffers
+    const startBuffer = Buffer.from(headerString, 'utf8')
+    const endBuffer = CRLF_BUFFER
+
+    // Calculate total size
+    let totalSize = startBuffer.length + endBuffer.length
+    if (buffer) {
+      totalSize += buffer.length
+    }
+
+    // Assemble the final message
+    if (buffer) {
+      return Buffer.concat([startBuffer, endBuffer, buffer], totalSize)
+    } else {
+      return Buffer.concat([startBuffer, endBuffer], totalSize)
+    }
+  }
+
+  /**
+   * Creates the HTTP status line
+   */
+  private createStatusLine(): string {
+    const { request, hasProxy, isProxyTunnel } = this
+    const parts = [request.method]
+
+    if (hasProxy && !isProxyTunnel) {
+      // For proxy requests, use the full URL
+      parts.push(request.url)
+    } else {
+      // For direct requests, use the path
+      const uri = new URL(request.url)
+      let path = uri.pathname
+      if (uri.search) {
+        path += uri.search
+      }
+      parts.push(path)
+    }
+
+    parts.push(HTTP_VERSION)
+    return parts.join(' ')
+  }
+
+  /**
+   * Determines if a host header is required and returns it
+   */
+  private getHostHeader(): string | undefined {
+    if (!this.hostRequired()) {
+      return undefined
+    }
+    return this.hostHeader
+  }
+
+  /**
+   * Tests if current connection is required to add `host` header.
+   * It returns `false` only if `host` header has been already provided.
+   */
+  private hostRequired(): boolean {
+    const headers = this.request.headers
+    if (typeof headers !== 'string') {
+      return true
+    }
+    return !this.hostTestReg.test(headers)
+  }
+
+  /**
+   * Updates the host header for the message builder
+   */
+  updateHostHeader(hostHeader: string): void {
+    this.hostHeader = hostHeader
+  }
+
+  /**
+   * Creates a status line for a specific request
+   */
+  createStatusLineForRequest(request: IHttpRequest, hasProxy: boolean, isProxyTunnel: boolean): string {
+    const parts = [request.method]
+
+    if (hasProxy && !isProxyTunnel) {
+      parts.push(request.url)
+    } else {
+      const uri = new URL(request.url)
+      let path = uri.pathname
+      if (uri.search) {
+        path += uri.search
+      }
+      parts.push(path)
+    }
+
+    parts.push(HTTP_VERSION)
+    return parts.join(' ')
+  }
+
+  /**
+   * Validates if a request needs a host header
+   */
+  static hostRequiredForRequest(request: IHttpRequest): boolean {
+    const hostTestReg = /^\s*host\s*:/im
+    const headers = request.headers
+    if (typeof headers !== 'string') {
+      return true
+    }
+    return !hostTestReg.test(headers)
+  }
+}

package/src/runtime/http-engine/message/MessageProcessor.ts

@@ -0,0 +1,73 @@
+import { Headers } from '../../../lib/headers/Headers.js'
+import { HttpRequest } from '../../../models/HttpRequest.js'
+import { IRequestAuthorization } from '../../../models/RequestAuthorization.js'
+
+export interface MessagePreparationContext {
+  request: HttpRequest
+  hasProxy: boolean
+  isProxyTunnel: boolean
+  hostHeader?: string
+  defaultHeaders?: boolean
+  defaultUserAgent?: string
+  defaultAccept?: string
+  proxyUsername?: string
+  proxyPassword?: string
+  proxyAuthorization?: string
+  authorization?: IRequestAuthorization[]
+}
+
+/**
+ * Prepares headers list to be sent to the remote machine.
+ * If `defaultHeaders` option is set then it adds `user-agent` and `accept`
+ * headers.
+ */
+export function prepareHeaders(headers: Headers, context: MessagePreparationContext, withPayload = false): void {
+  const { defaultHeaders, defaultUserAgent, defaultAccept, request } = context
+
+  if (defaultHeaders) {
+    if (!headers.has('user-agent')) {
+      if (defaultUserAgent) {
+        headers.set('user-agent', defaultUserAgent)
+      } else {
+        headers.set('user-agent', 'api client')
+      }
+    }
+    if (!headers.has('accept')) {
+      if (defaultAccept) {
+        headers.set('accept', defaultAccept)
+      } else {
+        headers.set('accept', '*/*')
+      }
+    }
+  }
+
+  if (withPayload) {
+    if (!headers.has('content-type') && request.payloadOptions) {
+      if (request.payloadOptions.mime) {
+        headers.set('content-type', request.payloadOptions.mime)
+      }
+    }
+  }
+}
+
+/**
+ * Generate proxy authorization header
+ */
+export function generateProxyAuthHeader(context: MessagePreparationContext): string | undefined {
+  const { hasProxy, isProxyTunnel, proxyUsername, proxyPassword, proxyAuthorization } = context
+
+  if (!hasProxy || isProxyTunnel) {
+    return undefined
+  }
+
+  if (proxyAuthorization) {
+    return proxyAuthorization
+  }
+
+  if (proxyUsername && proxyPassword) {
+    const auth = `${proxyUsername}:${proxyPassword}`
+    return `Basic ${Buffer.from(auth).toString('base64')}`
+  }
+
+  return undefined
+}

package/src/runtime/http-engine/ntlm/NtlmAuth.ts

@@ -1,13 +1,7 @@
 import { Des } from './Des.js'
 import { MD4 } from './MD4.js'
 import { NtlmMessage } from './NtlmMessage.js'
-
-export interface INtlmAuthConfig {
-  domain?: string
-  username: string
-  password: string
-  url: string
-}
+import type { INtlmAuthorization } from '../../../models/Authorization.js'
 
 /**
  * A base class for auth methods used in the library.
@@ -17,15 +11,13 @@ export class NtlmAuth {
   domain: string
   uid: string
   passwd: string
-  url: string
   lmHashedPassword?: string
   ntHashedPassword?: string
 
-  constructor(opts: INtlmAuthConfig) {
+  constructor(opts: INtlmAuthorization) {
     this.domain = opts.domain || ''
-    this.uid = opts.username
-    this.passwd = opts.password
-    this.url = opts.url
+    this.uid = opts.username || ''
+    this.passwd = opts.password || ''
 
     this.setCredentials()
   }
@@ -51,7 +43,18 @@ export class NtlmAuth {
   }
 
   getChallenge(data: string): string {
-    const msg2 = new NtlmMessage(data)
+    if (!data || typeof data !== 'string') {
+      throw new Error('Invalid NTLM challenge data: data is required and must be a string.')
+    }
+
+    // Remove "NTLM " prefix if present (for robustness)
+    const cleanData = data.replace(/^NTLM\s+/i, '')
+
+    if (!cleanData) {
+      throw new Error('Invalid NTLM challenge data: empty or invalid format.')
+    }
+
+    const msg2 = new NtlmMessage(cleanData)
     if (msg2.getString(0, 8) !== 'NTLMSSP\0') {
       throw new Error('Invalid NTLM response header.')
     }

package/src/runtime/http-engine/ntlm/NtlmMessage.ts

@@ -6,13 +6,13 @@ export class NtlmMessage {
       return
     }
     if (data.indexOf('NTLM ') === 0) {
-      data = data.substr(5)
+      data = data.substring(5)
+    }
+    // Use Buffer instead of atob for Node.js compatibility
+    const buffer = Buffer.from(data, 'base64')
+    for (const byte of buffer) {
+      this.data.push(byte)
     }
-    atob(data)
-      .split('')
-      .map((c) => {
-        this.data.push(c.charCodeAt(0))
-      })
   }
 
   addByte(b: number): void {

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

@@ -0,0 +1,171 @@
+import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
+import { ResponseInfo } from './HttpResponseParser.js'
+
+const nlNlBuffer = Buffer.from([13, 10, 13, 10])
+const nlBuffer = Buffer.from([13, 10])
+
+export type BodyCompleteCallback = (body: Buffer) => void
+
+/**
+ * Parser for HTTP body data
+ */
+export class BodyParser {
+  private logger: Logger<ILogObj>
+  private responseInfo: ResponseInfo
+  private rawBody?: Buffer
+
+  constructor(logger: Logger<ILogObj>, responseInfo: ResponseInfo) {
+    this.logger = logger
+    this.responseInfo = responseInfo
+  }
+
+  /**
+   * Process body with content-length encoding
+   * @param data Buffer containing body data
+   * @param onComplete Callback when body is complete
+   */
+  processContentLength(data: Buffer, onComplete: BodyCompleteCallback): void {
+    if (typeof this.responseInfo.contentLength === 'undefined') {
+      throw new Error('The content-length header of the response is missing.')
+    }
+
+    if (!this.responseInfo.body) {
+      this.responseInfo.body = data
+      if (data.length >= this.responseInfo.contentLength) {
+        const body = this.responseInfo.body.slice(0, this.responseInfo.contentLength)
+        this.rawBody = body
+        onComplete(body)
+        return
+      }
+      return
+    }
+
+    const sum = this.responseInfo.body.length + data.length
+    this.responseInfo.body = Buffer.concat([this.responseInfo.body, data], sum)
+
+    if (this.responseInfo.body.length >= this.responseInfo.contentLength) {
+      const body = this.responseInfo.body.slice(0, this.responseInfo.contentLength)
+      this.rawBody = body
+      onComplete(body)
+      return
+    }
+  }
+
+  /**
+   * Process body with chunked transfer encoding
+   * @param data Buffer containing chunked body data
+   * @param onComplete Callback when body is complete
+   */
+  processChunked(data: Buffer, onComplete: BodyCompleteCallback): void {
+    if (!data) {
+      return
+    }
+
+    if (this.responseInfo.chunk) {
+      data = Buffer.concat([this.responseInfo.chunk, data], this.responseInfo.chunk.length + data.length)
+      this.responseInfo.chunk = undefined
+    }
+
+    while (true) {
+      if (this.responseInfo.chunkSize === 0 && data.indexOf(nlNlBuffer) === 0) {
+        onComplete(this.rawBody || Buffer.alloc(0))
+        return
+      }
+
+      if (!this.responseInfo.chunkSize) {
+        const tmp = this.readChunkSize(data)
+        if (!tmp) {
+          return
+        }
+        data = tmp
+        if (!this.responseInfo.chunkSize && this.responseInfo.chunkSize !== 0) {
+          // It may happen that node's buffer cuts the data
+          // just before the chunk size.
+          // It should proceed it in next portion of the data.
+          this.responseInfo.chunk = data
+          return
+        }
+        if (!this.responseInfo.chunkSize) {
+          onComplete(this.rawBody || Buffer.alloc(0))
+          return
+        }
+      }
+
+      const size = Math.min(this.responseInfo.chunkSize, data.length)
+      const sliced = data.slice(0, size)
+
+      if (!this.rawBody) {
+        this.rawBody = sliced
+      } else {
+        const sum = size + this.rawBody.length
+        this.rawBody = Buffer.concat([this.rawBody, sliced], sum)
+      }
+
+      this.responseInfo.chunkSize -= size
+
+      if (data.length === 0) {
+        return
+      }
+
+      data = data.slice(size + 2) // + CR
+
+      if (data.length === 0) {
+        return
+      }
+    }
+  }
+
+  /**
+   * Read chunk size from chunked transfer encoding
+   * @param array Buffer containing chunk data
+   * @returns Remaining data after reading chunk size
+   */
+  readChunkSize(array: Buffer): Buffer | undefined {
+    let index = array.indexOf(nlBuffer)
+
+    if (index === -1) {
+      // not found in this portion of data.
+      return array
+    }
+
+    if (index === 0) {
+      // Node's buffer cuts CRLF after the end of chunk data, without last CLCR,
+      // here's to fix it.
+      // It can be either new line from the last chunk or end of
+      // the message where
+      // the rest of the array is [13, 10, 48, 13, 10, 13, 10]
+      if (array.indexOf(nlNlBuffer) === 0) {
+        this.responseInfo.chunkSize = 0
+        return Buffer.alloc(0)
+      }
+      array = array.subarray(index + 2)
+      index = array.indexOf(nlBuffer)
+    }
+
+    const chunkSize = parseInt(array.slice(0, index).toString(), 16)
+    if (Number.isNaN(chunkSize)) {
+      this.responseInfo.chunkSize = undefined
+      return array.slice(index + 2)
+    }
+
+    this.responseInfo.chunkSize = chunkSize
+    return array.slice(index + 2)
+  }
+
+  /**
+   * Get the raw body buffer
+   */
+  getRawBody(): Buffer | undefined {
+    return this.rawBody
+  }
+
+  /**
+   * Reset the parser state
+   */
+  reset(): void {
+    this.rawBody = undefined
+    this.responseInfo.body = undefined
+    this.responseInfo.chunk = undefined
+    this.responseInfo.chunkSize = undefined
+  }
+}

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

@@ -0,0 +1,103 @@
+import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
+
+const nlNlBuffer = Buffer.from([13, 10, 13, 10])
+const nlBuffer = Buffer.from([13, 10])
+
+export interface HeadersParseResult {
+  complete: boolean
+  headers?: Buffer
+  remaining?: Buffer
+}
+
+/**
+ * Parser for HTTP headers
+ */
+export class HeadersParser {
+  private logger: Logger<ILogObj>
+
+  constructor(logger: Logger<ILogObj>) {
+    this.logger = logger
+  }
+
+  /**
+   * Parse HTTP headers from buffer
+   * @param data Buffer containing header data
+   * @param existingHeaders Previously accumulated headers
+   * @returns Headers parse result
+   */
+  parse(data: Buffer, existingHeaders?: Buffer): HeadersParseResult {
+    this.logger.info('Processing headers')
+
+    // Looking for end of headers section
+    let index = data.indexOf(nlNlBuffer)
+    let padding = 4
+
+    if (index === -1) {
+      // It can also be 2x ASCII 10
+      const _index = data.indexOf(Buffer.from([10, 10]))
+      if (_index !== -1) {
+        index = _index
+        padding = 2
+      }
+    }
+
+    // https://github.com/jarrodek/socket-fetch/issues/3
+    const enterIndex = data.indexOf(nlBuffer)
+
+    if (index === -1 && enterIndex !== 0) {
+      // end in next chunk
+      if (!existingHeaders) {
+        return {
+          complete: false,
+          headers: data,
+        }
+      } else {
+        const sum = existingHeaders.length + data.length
+        const combined = Buffer.concat([existingHeaders, data], sum)
+        return {
+          complete: false,
+          headers: combined,
+        }
+      }
+    }
+
+    if (enterIndex !== 0) {
+      const headersArray = data.slice(0, index)
+      if (!existingHeaders) {
+        return {
+          complete: true,
+          headers: headersArray,
+          remaining: this.extractRemaining(data, index, padding),
+        }
+      } else {
+        const sum = existingHeaders.length + headersArray.length
+        const combined = Buffer.concat([existingHeaders, headersArray], sum)
+        return {
+          complete: true,
+          headers: combined,
+          remaining: this.extractRemaining(data, index, padding),
+        }
+      }
+    }
+
+    return {
+      complete: true,
+      headers: existingHeaders,
+      remaining: this.extractRemaining(data, index, padding),
+    }
+  }
+
+  /**
+   * Extract remaining data after headers
+   * @param data Original data buffer
+   * @param index Index where headers end
+   * @param padding Padding to skip
+   * @returns Remaining data
+   */
+  private extractRemaining(data: Buffer, index: number, padding: number): Buffer {
+    const start = index === -1 ? 0 : index
+    const enterIndex = data.indexOf(nlBuffer)
+    const move = enterIndex === 0 ? 2 : padding
+    return data.slice(start + move)
+  }
+}