@api-client/core 0.20.10 → 0.21.0

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

@@ -1,106 +0,0 @@
-import cors, { CorsOptions } from 'cors'
-import { Request, Response, Router } from 'express'
-import path from 'path'
-
-/**
- * A base class for API routes
- */
-export class BaseApi {
-  constructor() {
-    this._processCors = this._processCors.bind(this)
-  }
-
-  getResourcePath(name: string): string {
-    return path.join('tests', 'resources', 'http', name)
-  }
-
-  /**
-   * Sets CORS on all routes for `OPTIONS` HTTP method.
-   * @param router Express app.
-   */
-  setCors(router: Router): void {
-    router.options('*splat', cors(this._processCors))
-  }
-
-  /**
-   * Shorthand function to register a route on this class.
-   * @param router Express app.
-   * @param routes List of routes. Each route is an array
-   * where:
-   * - index `0` is the API route, eg, `/api/models/:modelId`
-   * - index `1` is the function name to call
-   * - index `2` is optional and describes HTTP method. Defaults to 'get'.
-   * It must be lowercase.
-   */
-  wrapApi(router: Router, routes: string[][]): void {
-    for (let i = 0, len = routes.length; i < len; i++) {
-      const route = routes[i]
-      const method = route[2] || 'get'
-      const fnName = route[1]
-      // @ts-expect-error Used in testing
-      const clb = this[fnName].bind(this)
-      // @ts-expect-error Used in testing
-      router[method](route[0], cors(this._processCors), clb)
-    }
-  }
-
-  /**
-   * Sends error to the client in a standardized way.
-   * @param res HTTP response object
-   * @param message Error message to send.
-   * @param status HTTP status code, default to 400.
-   */
-  sendError(res: Response, message: string, status = 400): void {
-    res.status(status).send({
-      error: true,
-      message,
-    })
-  }
-
-  /**
-   * Processes CORS request.
-   */
-  _processCors(req: Request, callback: (error: Error | null, opts?: CorsOptions) => void): void {
-    const whitelist = ['https://ci.advancedrestclient.com']
-    const origin = req.header('Origin')
-    let corsOptions: CorsOptions | undefined
-    if (!origin) {
-      corsOptions = { origin: false }
-    } else if (origin.indexOf('http://localhost:') === 0 || origin.indexOf('http://127.0.0.1:') === 0) {
-      corsOptions = { origin: true }
-    } else if (whitelist.indexOf(origin) !== -1) {
-      corsOptions = { origin: true }
-    }
-    if (corsOptions) {
-      corsOptions.credentials = true
-      corsOptions.allowedHeaders = ['Content-Type', 'Authorization']
-      corsOptions.origin = origin
-    }
-    callback(null, corsOptions)
-  }
-
-  /**
-   * Awaits a timeout.
-   */
-  async aTimeout(timeout = 0): Promise<void> {
-    return new Promise((resolve) => {
-      setTimeout(() => resolve(), timeout)
-    })
-  }
-
-  async readRequestBuffer(request: Request): Promise<Buffer> {
-    return new Promise((resolve) => {
-      const parts: Buffer[] = []
-      request.on('data', (chunk) => {
-        if (typeof chunk === 'string') {
-          parts.push(Buffer.from(chunk))
-        } else {
-          parts.push(chunk)
-        }
-      })
-      request.on('end', () => {
-        resolve(Buffer.concat(parts))
-      })
-    })
-  }
-}

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

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

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

@@ -1,46 +0,0 @@
-import { Router, Request, Response } from 'express'
-import tls from 'tls'
-import { BaseApi } from './BaseApi.js'
-import cors from 'cors'
-
-const router = Router()
-export default router
-
-class CertificatesRoute extends BaseApi {
-  async index(req: Request, res: Response): Promise<void> {
-    const socket = req.socket as tls.TLSSocket
-    const cert = socket.getPeerCertificate()
-
-    let status: number
-    let message: unknown
-    if (socket.authorized) {
-      status = 200
-      message = {
-        authenticated: true,
-        name: cert.subject.CN,
-        issuer: cert.issuer.CN,
-      }
-    } else if (cert.subject) {
-      status = 403
-      message = {
-        authenticated: false,
-        name: cert.subject.CN,
-        issuer: cert.issuer.CN,
-      }
-    } else {
-      status = 401
-      message = {
-        authenticated: false,
-      }
-    }
-    res.writeHead(status, {
-      'Content-Type': 'application/json; charset=UTF-8',
-    })
-    res.end(JSON.stringify(message))
-  }
-}
-
-const api = new CertificatesRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/', cors(checkCorsFn), api.index.bind(api))

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

@@ -1,71 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { createReadStream } from 'fs'
-import { pipeline } from 'stream'
-import zlib from 'zlib'
-import { BaseApi } from './BaseApi.js'
-import { OutgoingMessage } from 'http'
-
-const router = Router()
-export default router
-
-// router.use(shrinkRay());
-
-class CompressApiRoute extends BaseApi {
-  async brotli(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('json.json')
-    const onError = (err: Error | null): void => {
-      if (err) {
-        // If an error occurs, there's not much we can do because
-        // the server has already sent the 200 response code and
-        // some amount of data has already been sent to the client.
-        // The best we can do is terminate the response immediately
-        // and log the error.
-        res.end()
-        // eslint-disable-next-line no-console
-        console.error('An error occurred:', err)
-      }
-    }
-    res.writeHead(200, { 'Content-Encoding': 'br', 'content-type': 'application/json' })
-    pipeline(createReadStream(resource), zlib.createBrotliCompress(), res as OutgoingMessage, onError)
-  }
-
-  async deflate(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('json.json')
-    // const buff = await readFile(resource);
-    // res.setHeader('content-type', 'application/json');
-    // res.send(buff);
-    const onError = (err: Error | null): void => {
-      if (err) {
-        res.end()
-        // eslint-disable-next-line no-console
-        console.error('An error occurred:', err)
-      }
-    }
-    res.writeHead(200, { 'Content-Encoding': 'deflate', 'content-type': 'application/json' })
-    pipeline(createReadStream(resource), zlib.createDeflate(), res as OutgoingMessage, onError)
-  }
-
-  async gzip(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('json.json')
-    // const buff = await readFile(resource);
-    // res.setHeader('content-type', 'application/json');
-    // res.send(buff);
-
-    const onError = (err: Error | null): void => {
-      if (err) {
-        res.end()
-        // eslint-disable-next-line no-console
-        console.error('An error occurred:', err)
-      }
-    }
-    res.writeHead(200, { 'Content-Encoding': 'gzip', 'content-type': 'application/json' })
-    pipeline(createReadStream(resource), zlib.createGzip(), res as OutgoingMessage, onError)
-  }
-}
-const api = new CompressApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/brotli', cors(checkCorsFn), api.brotli.bind(api))
-router.get('/deflate', cors(checkCorsFn), api.deflate.bind(api))
-router.get('/gzip', cors(checkCorsFn), api.gzip.bind(api))

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

@@ -1,20 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class CookieApiRoute extends BaseApi {
-  async randomCookies(req: Request, res: Response): Promise<void> {
-    res.cookie('c1', 'v1', { expires: new Date(Date.now() + 900000), httpOnly: true })
-    res.cookie('c2', 'v2')
-    res.cookie('c3', 'v3', { sameSite: 'strict', secure: true })
-    res.send({ ok: true })
-  }
-}
-
-const api = new CookieApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/', cors(checkCorsFn), api.randomCookies.bind(api))

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

@@ -1,28 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-/**
- * Some tests API route
- */
-class DelayRoute extends BaseApi {
-  /**
-   * List tests
-   */
-  async delay(req: Request, res: Response): Promise<void> {
-    const { params } = req
-    let duration = Number(params.ms)
-    if (Number.isNaN(duration)) {
-      duration = 10
-    }
-    await this.aTimeout(duration)
-    res.send({ body: `Delayed for ${duration}ms.` })
-  }
-}
-const api = new DelayRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/:ms', cors(checkCorsFn), api.delay.bind(api))

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

@@ -1,58 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class GetApiRoute extends BaseApi {
-  async echoGet(req: Request, res: Response): Promise<void> {
-    const { headers, query, originalUrl, baseUrl, cookies, hostname, method, params, path, ip, protocol, url } = req
-    const start = Date.now()
-    await this.aTimeout(120)
-    res.send({
-      headers,
-      query,
-      originalUrl,
-      baseUrl,
-      cookies,
-      hostname,
-      method,
-      params,
-      path,
-      ip,
-      protocol,
-      url,
-      delay: Date.now() - start,
-    })
-  }
-
-  async echoPost(req: Request, res: Response): Promise<void> {
-    req.setEncoding('utf8')
-    const { headers, query, originalUrl, baseUrl, cookies, hostname, method, params, path, ip, protocol, url } = req
-    const data = await this.readRequestBuffer(req)
-    const start = Date.now()
-    await this.aTimeout(120)
-    res.send({
-      headers,
-      query,
-      originalUrl,
-      baseUrl,
-      cookies,
-      hostname,
-      method,
-      params,
-      path,
-      ip,
-      protocol,
-      url,
-      delay: Date.now() - start,
-      body: data.toString('utf8'),
-    })
-  }
-}
-const api = new GetApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/', cors(checkCorsFn), api.echoGet.bind(api))
-router.post('/', cors(checkCorsFn), api.echoPost.bind(api))

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

@@ -1,17 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class HeadersApiRoute extends BaseApi {
-  async listHeaders(req: Request, res: Response): Promise<void> {
-    const { headers } = req
-    res.send({ headers })
-  }
-}
-const api = new HeadersApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/', cors(checkCorsFn), api.listHeaders.bind(api))

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

@@ -1,44 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { readFile } from 'fs/promises'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class ImagesApiRoute extends BaseApi {
-  async jpeg(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('jpeg.jpg')
-    const buff = await readFile(resource)
-    res.setHeader('content-type', 'image/jpeg')
-    res.send(buff)
-  }
-
-  async png(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('png.png')
-    const buff = await readFile(resource)
-    res.setHeader('content-type', 'image/png')
-    res.send(buff)
-  }
-
-  async svg(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('svg.svg')
-    const buff = await readFile(resource)
-    res.setHeader('content-type', 'image/svg+xml')
-    res.send(buff)
-  }
-
-  async webp(req: Request, res: Response): Promise<void> {
-    const resource = this.getResourcePath('webp.webp')
-    const buff = await readFile(resource)
-    res.setHeader('content-type', 'image/webp')
-    res.send(buff)
-  }
-}
-const api = new ImagesApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/jpeg', cors(checkCorsFn), api.jpeg.bind(api))
-router.get('/png', cors(checkCorsFn), api.png.bind(api))
-router.get('/svg', cors(checkCorsFn), api.svg.bind(api))
-router.get('/webp', cors(checkCorsFn), api.webp.bind(api))

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

@@ -1,29 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import ntlm from 'express-ntlm'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-// https://github.com/einfallstoll/express-ntlm
-router.use(
-  ntlm({
-    debug: function () {
-      // console.log(...arguments)
-    },
-    domain: 'custom.com',
-  })
-)
-
-class NTLMRoute extends BaseApi {
-  async resource(req: Request, res: Response): Promise<void> {
-    // console.log('[SERVER] Handling the NTLM request');
-    res.setHeader('content-type', 'application/json')
-    res.send({ authenticated: true })
-  }
-}
-const api = new NTLMRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/resource', cors(checkCorsFn), api.resource.bind(api))

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

@@ -1,31 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class PostApiRoute extends BaseApi {
-  async echoProperties(req: Request, res: Response): Promise<void> {
-    const { headers, query, method } = req
-    const body = await this.readRequestBuffer(req)
-    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()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.post('/', cors(checkCorsFn), api.echoProperties.bind(api))

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

@@ -1,17 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class QueryParamsApiRoute extends BaseApi {
-  async listParams(req: Request, res: Response): Promise<void> {
-    const { query } = req
-    res.send({ params: { query } })
-  }
-}
-const api = new QueryParamsApiRoute()
-api.setCors(router)
-const checkCorsFn = api._processCors
-router.get('/', cors(checkCorsFn), api.listParams.bind(api))

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

@@ -1,139 +0,0 @@
-import { Router, Request, Response } from 'express'
-import cors from 'cors'
-import { URLSearchParams } from 'url'
-import { BaseApi } from './BaseApi.js'
-
-const router = Router()
-export default router
-
-class RedirectsApiRoute extends BaseApi {
-  /**
-   * Reads query params from the request and returns them as a string.
-   */
-  readQueryParams(req: Request): string {
-    const { query } = req
-    const params = new URLSearchParams()
-    Object.keys(query).forEach((key) => {
-      const value = query[key]
-      params.append(key, value as string)
-    })
-    return params.toString()
-  }
-
-  /**
-   * Redirects absolute URLs
-   */
-  async absolute(req: Request, res: Response): Promise<void> {
-    const { params } = req
-    const size = Number(params.n) - 1
-    let next: string
-    if (Number.isNaN(size) || size === 0) {
-      next = `${req.protocol}://${req.headers.host}/v1/get`
-    } else {
-      next = `${req.protocol}://${req.headers.host}/v1/redirect/absolute/${size}`
-    }
-    const qp = this.readQueryParams(req)
-    if (qp) {
-      next += `?${qp}`
-    }
-    res.setHeader('location', next)
-    res.setHeader('connection', 'close')
-    res.status(302)
-    res.send({
-      location: next,
-      headers: req.headers,
-    })
-  }
-
-  /**
-   * Redirects relative URLs
-   */
-  async relative(req: Request, res: Response): Promise<void> {
-    const { params } = req
-    const size = Number(params.n) - 1
-    let next: string
-    if (Number.isNaN(size) || size === 0) {
-      next = `/v1/get`
-    } else {
-      next = `/v1/redirect/relative/${size}`
-    }
-    const qp = this.readQueryParams(req)
-    if (qp) {
-      next += `?${qp}`
-    }
-    res.setHeader('location', next)
-    res.setHeader('connection', 'close')
-    res.status(302)
-    res.send({
-      location: next,
-      headers: req.headers,
-    })
-  }
-
-  /**
-   * Redirects relative URLs
-   */
-  async relativePath(req: Request, res: Response): Promise<void> {
-    const { params } = req
-    const size = Number(params.n) - 1
-    let next: string
-    if (Number.isNaN(size) || size === 0) {
-      next = `/v1/get`
-    } else {
-      next = `../relative/${size}`
-    }
-    const qp = this.readQueryParams(req)
-    if (qp) {
-      next += `?${qp}`
-    }
-    res.setHeader('location', next)
-    res.setHeader('connection', 'close')
-    res.status(302)
-    res.send({
-      location: next,
-      headers: req.headers,
-    })
-  }
-
-  async selfCookies(req: Request, res: Response): Promise<void> {
-    const { params } = req
-    const size = Number(params.n) - 1
-    let next: string
-    if (Number.isNaN(size) || size === 0) {
-      next = `/v1/get`
-    } else {
-      next = `/v1/redirect/relative/${size}`
-    }
-    const qp = this.readQueryParams(req)
-    if (qp) {
-      next += `?${qp}`
-    }
-    res.setHeader('location', next)
-    // Set-Cookie: UserID=JohnDoe; Max-Age=3600; Version=1
-    res.setHeader('set-cookie', `redirect-${size}=true; Path=/`)
-    res.setHeader('connection', 'close')
-    res.status(302)
-    res.send({
-      location: next,
-      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)
-const checkCorsFn = api._processCors
-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))