support query params

Author: dustin deus

src/http-data-source.ts

@@ -10,6 +10,7 @@ import { ResponseData, RequestOptions as UndiciRequestOptions } from 'undici/typ
 import { ApolloError } from 'apollo-server-errors'
 import { EventEmitter, Readable } from 'stream'
 import { Logger } from 'apollo-server-types'
+import { URLSearchParams } from 'url'
 
 type AbortSignal = unknown
 
@@ -27,6 +28,7 @@ interface Dictionary<T> {
 }
 
 export type RequestOptions = {
+  query?: Dictionary<string | number>
   body?: string | Buffer | Uint8Array | Readable | null
   headers?: Dictionary<string>
   signal?: AbortSignal | EventEmitter | null
@@ -35,6 +37,7 @@ export type RequestOptions = {
 export type Request = UndiciRequestOptions &
   CacheTTLOptions & {
     headers: Dictionary<string>
+    query?: Dictionary<string | number>
   }
 
 export type Response<TResult> = {
@@ -103,6 +106,19 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     this.logger = options?.logger
   }
 
+  private buildQueryString(query: Dictionary<string | number>): string {
+    const params = new URLSearchParams()
+    for (const key in query) {
+      if (Object.prototype.hasOwnProperty.call(query, key)) {
+        const value = query[key]
+        if (value !== undefined) {
+          params.append(key, value.toString())
+        }
+      }
+    }
+    return params.toString()
+  }
+
   /**
    * Initialize the datasource with apollo internals (context, cache).
    *
@@ -275,6 +291,10 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
   }
 
   private async request<TResult = unknown>(request: Request): Promise<Response<TResult>> {
+    if (request?.query) {
+      request.path = request.path + '?' + this.buildQueryString(request.query)
+    }
+
     const cacheKey = this.onCacheKeyCalculation(request)
     const ttlCacheEnabled = request.requestCache
 

test/rest-data-source.test.ts

@@ -151,6 +151,46 @@ test('Should be able to make a simple PUT call', async (t) => {
   t.deepEqual(response.body, { name: 'foo' })
 })
 
+test('Should be able to pass query params', async (t) => {
+  t.plan(3)
+
+  const path = '/'
+
+  const wanted = { name: 'foo' }
+
+  const server = http.createServer((req, res) => {
+    t.is(req.method, 'GET')
+    t.is(req.url, '/?a=1&b=2')
+    res.write(JSON.stringify(wanted))
+    res.end()
+    res.socket?.unref()
+  })
+
+  t.teardown(server.close.bind(server))
+
+  server.listen()
+
+  const baseURL = `http://localhost:${(server.address() as AddressInfo)?.port}`
+
+  const dataSource = new (class extends HTTPDataSource {
+    constructor() {
+      super(baseURL)
+    }
+    getFoo() {
+      return this.get(path, {
+        query: {
+          a: 1,
+          b: '2'
+        }
+      })
+    }
+  })()
+
+  const response = await dataSource.getFoo()
+
+  t.deepEqual(response.body, { name: 'foo' })
+})
+
 test('Should error', async (t) => {
   t.plan(2)