feat: Query string params

docs/api/Dispatcher.md

@@ -194,6 +194,7 @@ Returns: `Boolean` - `false` if dispatcher is busy and further dispatch calls wo
 * **method** `string`
 * **body** `string | Buffer | Uint8Array | stream.Readable | Iterable | AsyncIterable | null` (optional) - Default: `null`
 * **headers** `UndiciHeaders | string[]` (optional) - Default: `null`.
+* **query** `Record<string, any> | null` (optional) - Default: `null` - Query string params to be embedded in the request URL.
 * **idempotent** `boolean` (optional) - Default: `true` if `method` is `'HEAD'` or `'GET'` - Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline has completed.
 * **blocking** `boolean` (optional) - Default: `false` - Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received.
 * **upgrade** `string | null` (optional) - Default: `null` - Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`.

lib/core/request.js

@@ -4,8 +4,8 @@ const {
   InvalidArgumentError,
   NotSupportedError
 } = require('./errors')
-const util = require('./util')
 const assert = require('assert')
+const util = require('./util')
 
 const kHandler = Symbol('handler')
 
@@ -38,6 +38,7 @@ class Request {
     method,
     body,
     headers,
+    query,
     idempotent,
     blocking,
     upgrade,
@@ -97,7 +98,7 @@ class Request {
 
     this.upgrade = upgrade || null
 
-    this.path = path
+    this.path = query ? util.buildURL(path, query) : path
 
     this.origin = origin
 

lib/core/util.js

@@ -26,6 +26,59 @@ function isBlobLike (object) {
   )
 }
 
+function isDate (val) {
+  return toString.call(val) === '[object Date]'
+}
+
+function isObject (val) {
+  return val !== null && typeof val === 'object'
+}
+
+// this escapes all non-uri friendly characters, but restores : which is commonly used for date formatting
+function encode (val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ':')
+}
+
+// based on https://github.com/axios/axios/blob/63e559fa609c40a0a460ae5d5a18c3470ffc6c9e/lib/helpers/buildURL.js (MIT license)
+function buildURL (url, queryParams) {
+  if (url.includes('?')) {
+    throw new Error('Query params cannot be passed when url contains "?" already.')
+  }
+
+  const parts = []
+  for (let [key, val] of Object.entries(queryParams)) {
+    if (val === null || typeof val === 'undefined') {
+      continue
+    }
+
+    if (!Array.isArray(val)) {
+      val = [val]
+    }
+
+    for (let v of val) {
+      if (isDate(v)) {
+        v = v.toISOString()
+      } else if (isObject(v)) {
+        throw new Error('Passing object as a query param is not supported, please serialize to string up-front')
+      }
+      parts.push(encode(key) + '=' + encode(v))
+    }
+  }
+
+  const serializedParams = parts.join('&')
+
+  if (serializedParams) {
+    const hashmarkIndex = url.indexOf('#')
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex)
+    }
+
+    url += '&' + serializedParams
+  }
+
+  return url
+}
+
 function parseURL (url) {
   if (typeof url === 'string') {
     url = new URL(url)
@@ -357,5 +410,6 @@ module.exports = {
   isBuffer,
   validateHandler,
   getSocketInfo,
-  isFormDataLike
+  isFormDataLike,
+  buildURL
 }

test/client.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { test } = require('tap')
-const { Client, errors } = require('..')
-const { createServer } = require('http')
 const { readFileSync, createReadStream } = require('fs')
+const { createServer } = require('http')
 const { Readable } = require('stream')
+const { test } = require('tap')
+const { Client, errors } = require('..')
 const { kSocket } = require('../lib/core/symbols')
 const { wrapWithAsyncIterable } = require('./utils/async-iterators')
 const EE = require('events')
@@ -80,6 +80,196 @@ test('basic get', (t) => {
   })
 })
 
+test('basic get with query params', (t) => {
+  t.plan(4)
+
+  const date = new Date(1995, 11, 17)
+  const server = createServer((req, res) => {
+    const searchParamsObject = buildParams(req.url)
+    t.strictSame(searchParamsObject, {
+      date: date.toISOString(),
+      bool: 'true',
+      foo: '1',
+      bar: 'bar',
+      ':%24%2C%2B%5B%5D%40%5E*()-': ':%24%2C%2B%5B%5D%40%5E*()-',
+      multi: ['1', '2']
+    })
+
+    res.statusCode = 200
+    res.end('hello')
+  })
+  t.teardown(server.close.bind(server))
+
+  const query = {
+    date,
+    bool: true,
+    foo: 1,
+    bar: 'bar',
+    nullVal: null,
+    undefinedVal: undefined,
+    ':$,+[]@^*()-': ':$,+[]@^*()-',
+    multi: [1, 2]
+  }
+
+  server.listen(0, () => {
+    const client = new Client(`http://localhost:${server.address().port}`, {
+      keepAliveTimeout: 300e3
+    })
+    t.teardown(client.close.bind(client))
+
+    const signal = new EE()
+    client.request({
+      signal,
+      path: '/',
+      method: 'GET',
+      query
+    }, (err, data) => {
+      t.error(err)
+      const { statusCode } = data
+      t.equal(statusCode, 200)
+    })
+    t.equal(signal.listenerCount('abort'), 1)
+  })
+})
+
+test('basic get with query params with object throws an error', (t) => {
+  t.plan(1)
+
+  const server = createServer((req, res) => {
+    t.fail()
+  })
+  t.teardown(server.close.bind(server))
+
+  const query = {
+    obj: { id: 1 }
+  }
+
+  server.listen(0, () => {
+    const client = new Client(`http://localhost:${server.address().port}`, {
+      keepAliveTimeout: 300e3
+    })
+    t.teardown(client.close.bind(client))
+
+    const signal = new EE()
+    client.request({
+      signal,
+      path: '/',
+      method: 'GET',
+      query
+    }, (err, data) => {
+      t.equal(err.message, 'Passing object as a query param is not supported, please serialize to string up-front')
+    })
+  })
+})
+
+test('basic get with query params ignores hashmark', (t) => {
+  t.plan(4)
+
+  const server = createServer((req, res) => {
+    const searchParamsObject = buildParams(req.url)
+    t.strictSame(searchParamsObject, {
+      foo: '1',
+      bar: 'bar',
+      multi: ['1', '2']
+    })
+
+    res.statusCode = 200
+    res.end('hello')
+  })
+  t.teardown(server.close.bind(server))
+
+  const query = {
+    foo: 1,
+    bar: 'bar',
+    multi: [1, 2]
+  }
+
+  server.listen(0, () => {
+    const client = new Client(`http://localhost:${server.address().port}`, {
+      keepAliveTimeout: 300e3
+    })
+    t.teardown(client.close.bind(client))
+
+    const signal = new EE()
+    client.request({
+      signal,
+      path: '/#',
+      method: 'GET',
+      query
+    }, (err, data) => {
+      t.error(err)
+      const { statusCode } = data
+      t.equal(statusCode, 200)
+    })
+    t.equal(signal.listenerCount('abort'), 1)
+  })
+})
+
+test('basic get with empty query params', (t) => {
+  t.plan(4)
+
+  const server = createServer((req, res) => {
+    const searchParamsObject = buildParams(req.url)
+    t.strictSame(searchParamsObject, {})
+
+    res.statusCode = 200
+    res.end('hello')
+  })
+  t.teardown(server.close.bind(server))
+
+  const query = {}
+
+  server.listen(0, () => {
+    const client = new Client(`http://localhost:${server.address().port}`, {
+      keepAliveTimeout: 300e3
+    })
+    t.teardown(client.close.bind(client))
+
+    const signal = new EE()
+    client.request({
+      signal,
+      path: '/',
+      method: 'GET',
+      query
+    }, (err, data) => {
+      t.error(err)
+      const { statusCode } = data
+      t.equal(statusCode, 200)
+    })
+    t.equal(signal.listenerCount('abort'), 1)
+  })
+})
+
+test('basic get with query params partially in path', (t) => {
+  t.plan(1)
+
+  const server = createServer((req, res) => {
+    t.fail()
+  })
+  t.teardown(server.close.bind(server))
+
+  const query = {
+    foo: 1
+  }
+
+  server.listen(0, () => {
+    const client = new Client(`http://localhost:${server.address().port}`, {
+      keepAliveTimeout: 300e3
+    })
+    t.teardown(client.close.bind(client))
+
+    const signal = new EE()
+    client.request({
+      signal,
+      path: '/?bar=2',
+      method: 'GET',
+      query
+    }, (err, data) => {
+      t.equal(err.message, 'Query params cannot be passed when url contains "?" already.')
+    })
+  })
+})
+
 test('basic head', (t) => {
   t.plan(14)
 
@@ -1589,3 +1779,26 @@ test('async iterator yield object error', (t) => {
     })
   })
 })
+
+function buildParams (path) {
+  const cleanPath = path.replace('/?', '').replace('/', '').split('&')
+  const builtParams = cleanPath.reduce((acc, entry) => {
+    const [key, value] = entry.split('=')
+    if (key.length === 0) {
+      return acc
+    }
+
+    if (acc[key]) {
+      if (Array.isArray(acc[key])) {
+        acc[key].push(value)
+      } else {
+        acc[key] = [acc[key], value]
+      }
+    } else {
+      acc[key] = value
+    }
+    return acc
+  }, {})
+
+  return builtParams
+}

types/dispatcher.d.ts

@@ -47,6 +47,8 @@ declare namespace Dispatcher {
     body?: string | Buffer | Uint8Array | Readable | null | FormData;
     /** Default: `null` */
     headers?: IncomingHttpHeaders | string[] | null;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
     /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
     idempotent?: boolean;
     /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */