@api-client/core 0.18.12 → 0.18.13

package/tests/servers/ProxyServer.ts

@@ -44,11 +44,13 @@ export class ProxyServer {
   }
 
   async start(httpPort: number, sslPort: number): Promise<void> {
+    this.log('Starting proxy server on ports', httpPort, sslPort)
     await this.startHttp(httpPort)
     await this.startHttps(sslPort)
   }
 
   async stop(): Promise<void> {
+    this.log('Stopping proxy server...')
     this.disconnectAll()
     await this.stopHttp()
     await this.stopHttps()
@@ -58,8 +60,8 @@ export class ProxyServer {
     const server = http.createServer()
     this.httpServer = server
     server.on('connection', this.connectionCallback)
-    server.on('connect', this.connectCallback) // -> this.#connectCallback
-    server.on('request', this.requestCallback) // -> this.#requestCallback
+    server.on('connect', this.connectCallback)
+    server.on('request', this.requestCallback)
     return new Promise((resolve) => {
       server.listen(port, () => resolve())
     })
@@ -119,20 +121,14 @@ export class ProxyServer {
    * @param res Node's response object
    */
   requestCallback(req: http.IncomingMessage, res: http.ServerResponse): void {
-    if (req.method === 'CONNECT') {
-      res.writeHead(500, {
-        'Content-Type': 'application/json',
-      })
-      res.write(JSON.stringify({ error: 'should not handle this path.' }))
-      res.end()
-    } else {
-      this.proxy(req, res)
-    }
+    this.log('Received request:', req.method, req.url)
+    this.proxy(req, res)
   }
 
   /**
    */
   connectCallback(request: http.IncomingMessage, clientSocket: net.Socket, head: Buffer): void {
+    this.log('Received CONNECT request:', request.method, request.url)
     if (!this.isAuthorizedProxy(request)) {
       const messages = [
         'HTTP/1.1 401 Unauthorized',
@@ -146,13 +142,13 @@ export class ProxyServer {
       messages.push('')
       const headersBuffer = Buffer.from(messages.join('\r\n'))
       const message = Buffer.concat([headersBuffer, bodyBuffer, Buffer.from('\r\n\r\n')])
-      // console.log(message.toString('utf8'));
+      // console.log(message.toString('utf8'))
       clientSocket.write(message)
       clientSocket.end()
       return
     }
 
-    this.log('Opening an SSL tunnel')
+    this.log('Opening SSL tunnel...')
     clientSocket.setKeepAlive(true)
     const { port, hostname } = new URL(`https://${request.url}`)
     const targetPort = Number(port || 443)
@@ -162,11 +158,9 @@ export class ProxyServer {
     const serverSocket = net.connect(targetPort, hostname)
     clientSocket.on('data', (data) => {
       this.log(`Tunneling Client -> Server: ${data.length} bytes`)
-      // data.toString().split('\n').forEach((line) => this.log(line));
     })
     serverSocket.on('data', (data) => {
       this.log(`Tunneling Client <- Server: ${data.length} bytes`)
-      // data.toString().split('\n').forEach((line) => this.log(line));
     })
     serverSocket.once('end', () => {
       this.log('Target socket ended.')
@@ -195,8 +189,9 @@ export class ProxyServer {
       clientSocket.destroy()
       serverSocket.destroy()
     })
-    clientSocket.on('end', () => {
-      this.log('Client socket ended.')
+    clientSocket.once('close', () => {
+      this.log('Client socket closed')
+      serverSocket.destroy()
     })
     serverSocket.setKeepAlive(true)
   }
@@ -205,9 +200,15 @@ export class ProxyServer {
    * Caches sockets after connection.
    */
   connectionCallback(socket: net.Socket): void {
+    this.log('Connection established, caching socket.')
     const socketKey = String(++this.lastSocketKey)
     this.socketMap[socketKey] = socket
-    socket.on('close', () => {
+    socket.once('close', () => {
+      this.log('Client socket closed, removing from cache:', socketKey)
+      const soc = this.socketMap[socketKey]
+      if (soc && !soc.destroyed) {
+        soc.destroy()
+      }
       // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete this.socketMap[socketKey]
     })
@@ -220,6 +221,7 @@ export class ProxyServer {
    * @param res Node's response object
    */
   proxy(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.log('Proxying request:', req.method, req.url)
     if (!req.url) {
       res.writeHead(400, {
         'Content-Type': 'application/json',
@@ -277,6 +279,7 @@ export class ProxyServer {
    * @param sourceResponse Node's response object
    */
   proxyHttp(sourceRequest: http.IncomingMessage, sourceResponse: http.ServerResponse): void {
+    this.log('Proxying HTTP request:', sourceRequest.method, sourceRequest.url)
     if (!this.isAuthorizedProxy(sourceRequest)) {
       sourceResponse.writeHead(401, {
         'Content-Type': 'application/json',
@@ -296,7 +299,13 @@ export class ProxyServer {
       protocol: urlInfo.protocol,
       headers,
     }
+
+    // Log the proxy request for debugging
+    this.log('Proxying request to:', urlInfo.href)
+    this.log('Target host:', urlInfo.host)
+    this.log('Target port:', urlInfo.port || 80)
     const proxy = http.request(options, (targetResponse) => {
+      this.log('Received response from target:', targetResponse.statusCode)
       if (targetResponse.statusCode) {
         sourceResponse.statusCode = targetResponse.statusCode
       }
@@ -326,6 +335,7 @@ export class ProxyServer {
       })
     }
     proxy.on('error', (err) => {
+      this.log('Proxy error:', err.message)
       if ((err as NodeJS.ErrnoException).code === 'ENOTFOUND') {
         sourceResponse.writeHead(404)
         sourceResponse.end()
@@ -348,13 +358,16 @@ export class ProxyServer {
     if (!info || !info.toLowerCase().startsWith('basic')) {
       return true
     }
+    this.log('Proxy authorization header found:', info)
     try {
       const buff = Buffer.from(info.substring(6), 'base64')
       const text = buff.toString('ascii')
       const parts = text.split(':')
       const [username, password] = parts
-      return username === 'proxy-name' && password === 'proxy-password'
+      return username === 'proxyuser' && password === 'proxypass'
     } catch {
+      // eslint-disable-next-line no-console
+      console.error('Invalid proxy authorization:', info)
       return false
     }
   }

package/tests/servers/express-routes/ApiEndpoint.ts

@@ -0,0 +1,24 @@
+import { Router, Request, Response } from 'express'
+import cors from 'cors'
+import { BaseApi } from './BaseApi.js'
+
+const router = Router()
+export default router
+
+class ApiEndpointRoute extends BaseApi {
+  async endpoint(req: Request, res: Response): Promise<void> {
+    res.setHeader('content-type', 'application/json')
+    res.json({
+      message: 'API endpoint reached',
+      method: req.method,
+      headers: req.headers,
+      url: req.url,
+    })
+  }
+}
+
+const api = new ApiEndpointRoute()
+api.setCors(router)
+const checkCorsFn = api._processCors
+router.get('/endpoint', cors(checkCorsFn), api.endpoint.bind(api))
+router.post('/endpoint', cors(checkCorsFn), api.endpoint.bind(api))

package/tests/servers/express-routes/BasicAuthRoute.ts

@@ -0,0 +1,36 @@
+import { Router, Request, Response } from 'express'
+import cors from 'cors'
+import { BaseApi } from './BaseApi.js'
+
+const router = Router()
+export default router
+
+class BasicAuthRoute extends BaseApi {
+  async resource(req: Request, res: Response): Promise<void> {
+    const authHeader = req.headers.authorization
+
+    if (!authHeader || !authHeader.startsWith('Basic ')) {
+      res.setHeader('WWW-Authenticate', 'Basic realm="Test Realm"')
+      res.status(401).json({ error: 'Authentication required' })
+      return
+    }
+
+    // Decode Basic auth credentials
+    const credentials = Buffer.from(authHeader.substring(6), 'base64').toString('utf8')
+    const [username, password] = credentials.split(':')
+
+    // Simple validation for test purposes
+    if (username === 'testuser' && password === 'testpass') {
+      res.setHeader('content-type', 'application/json')
+      res.json({ authenticated: true, username })
+    } else {
+      res.setHeader('WWW-Authenticate', 'Basic realm="Test Realm"')
+      res.status(401).json({ error: 'Invalid credentials' })
+    }
+  }
+}
+
+const api = new BasicAuthRoute()
+api.setCors(router)
+const checkCorsFn = api._processCors
+router.get('/resource', cors(checkCorsFn), api.resource.bind(api))

package/tests/servers/express-routes/BearerAuthRoute.ts

@@ -0,0 +1,35 @@
+import { Router, Request, Response } from 'express'
+import cors from 'cors'
+import { BaseApi } from './BaseApi.js'
+
+const router = Router()
+export default router
+
+class BearerAuthRoute extends BaseApi {
+  async resource(req: Request, res: Response): Promise<void> {
+    const authHeader = req.headers.authorization
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      res.setHeader('WWW-Authenticate', 'Bearer realm="Test Realm"')
+      res.status(401).json({ error: 'Authentication required' })
+      return
+    }
+
+    // Extract Bearer token
+    const token = authHeader.substring(7)
+
+    // Simple validation for test purposes
+    if (token === 'test-token-123') {
+      res.setHeader('content-type', 'application/json')
+      res.json({ authenticated: true, token })
+    } else {
+      res.setHeader('WWW-Authenticate', 'Bearer realm="Test Realm"')
+      res.status(401).json({ error: 'Invalid token' })
+    }
+  }
+}
+
+const api = new BearerAuthRoute()
+api.setCors(router)
+const checkCorsFn = api._processCors
+router.get('/resource', cors(checkCorsFn), api.resource.bind(api))

package/tests/servers/express-routes/NTLMRoute.ts

@@ -10,10 +10,9 @@ export default router
 router.use(
   ntlm({
     debug: function () {
-      // const args = Array.prototype.slice.apply(arguments);
-      // console.log.apply(null, args);
+      // console.log(...arguments)
     },
-    domain: 'TEST-DOMAIN',
+    domain: 'custom.com',
   })
 )
 

package/tests/servers/express-routes/PostApi.ts

@@ -7,9 +7,22 @@ export default router
 
 class PostApiRoute extends BaseApi {
   async echoProperties(req: Request, res: Response): Promise<void> {
-    const { headers, query } = req
+    const { headers, query, method } = req
     const body = await this.readRequestBuffer(req)
-    res.send({ headers, query, body: body.toString('utf8') })
+    const bodyStr = body.toString('utf8')
+
+    // Try to parse as JSON if content-type is application/json
+    let parsedBody = bodyStr
+    if (headers['content-type']?.includes('application/json')) {
+      try {
+        parsedBody = JSON.parse(bodyStr)
+      } catch {
+        // If parsing fails, keep as string
+        parsedBody = bodyStr
+      }
+    }
+
+    res.send({ headers, query, method, body: parsedBody })
   }
 }
 const api = new PostApiRoute()

package/tests/servers/express-routes/RedirectsApi.ts

@@ -110,7 +110,7 @@ class RedirectsApiRoute extends BaseApi {
     }
     res.setHeader('location', next)
     // Set-Cookie: UserID=JohnDoe; Max-Age=3600; Version=1
-    res.setHeader('set-cookie', `redirect-${size}=true; Path=/, unrelated=true; Domain=api.com`)
+    res.setHeader('set-cookie', `redirect-${size}=true; Path=/`)
     res.setHeader('connection', 'close')
     res.status(302)
     res.send({
@@ -118,6 +118,16 @@ class RedirectsApiRoute extends BaseApi {
       headers: req.headers,
     })
   }
+
+  async simpleRedirect(req: Request, res: Response): Promise<void> {
+    res.setHeader('location', '/v1/get')
+    res.setHeader('connection', 'close')
+    res.status(302)
+    res.send({
+      location: '/v1/get',
+      headers: req.headers,
+    })
+  }
 }
 const api = new RedirectsApiRoute()
 api.setCors(router)
@@ -126,3 +136,4 @@ router.get('/absolute/:n', cors(checkCorsFn), api.absolute.bind(api))
 router.get('/relative/:n', cors(checkCorsFn), api.relativePath.bind(api))
 router.get('/relative-root/:n', cors(checkCorsFn), api.relative.bind(api))
 router.get('/cookies/:n', cors(checkCorsFn), api.selfCookies.bind(api))
+router.get('/', cors(checkCorsFn), api.simpleRedirect.bind(api))

package/tests/servers/express-routes/ResponsesApi.ts

@@ -2,7 +2,7 @@ import { Router, Request, Response } from 'express'
 import cors from 'cors'
 import { readFile } from 'fs/promises'
 import path from 'path'
-import crypto from 'crypto'
+import crypto from 'node:crypto'
 import { BaseApi } from './BaseApi.js'
 
 const router = Router()

package/tests/servers/express-routes/StreamApi.ts

@@ -29,6 +29,24 @@ class StreamRoute extends BaseApi {
     }, time)
   }
 
+  async chunked(req: Request, res: Response): Promise<void> {
+    res.writeHead(200, {
+      'Content-Type': 'text/plain; charset=UTF-8',
+      'Transfer-Encoding': 'chunked',
+    })
+    this.#writeChunk(res)
+    let time = 0
+    for (let i = 0; i < 4; i++) {
+      const timeout = this.#types.number({ min: 1, max: 10 })
+      time += timeout
+      setTimeout(() => this.#writeChunk(res), timeout)
+    }
+    time += 5
+    setTimeout(() => {
+      res.end('END')
+    }, time)
+  }
+
   #writeChunk(res: Response): void {
     const word = this.#lorem.word({ length: 128 })
     res.write(`${word}\n`)
@@ -39,3 +57,4 @@ const api = new StreamRoute()
 api.setCors(router)
 const checkCorsFn = api._processCors
 router.get('/', cors(checkCorsFn), api.index.bind(api))
+router.get('/chunked', cors(checkCorsFn), api.chunked.bind(api))

package/tests/servers/oauth2mock/ServerMock.js

@@ -1,4 +1,4 @@
-import crypto from 'crypto'
+import crypto from 'node:crypto'
 import { URL, URLSearchParams } from 'url'
 import { Buffer } from 'buffer'