support for json as request payload

Author: StarpTech

src/http-data-source.ts

@@ -8,7 +8,7 @@ import sjson from 'secure-json-parse'
 import { KeyValueCache } from 'apollo-server-caching'
 import { ResponseData } from 'undici/types/dispatcher'
 import { toApolloError } from 'apollo-server-errors'
-import { EventEmitter, Readable } from 'stream'
+import { EventEmitter } from 'stream'
 import { Logger } from 'apollo-server-types'
 import { URLSearchParams } from 'url'
 
@@ -42,19 +42,14 @@ interface Dictionary<T> {
   [Key: string]: T | undefined
 }
 
-export type RequestOptions = {
-  context?: Dictionary<string>
-  query?: Dictionary<string | number>
-  body?: string | Buffer | Uint8Array | Readable | null
-  headers?: Dictionary<string>
-  signal?: AbortSignal
-} & CacheTTLOptions
+export type RequestOptions = Omit<Partial<Request>, 'origin' | 'path' | 'method'>
 
 export type Request = {
   context: Dictionary<string>
   query: Dictionary<string | number>
-  body: string | Buffer | Uint8Array | Readable | null
+  body: any
   signal?: AbortSignal | EventEmitter | null
+  json?: boolean
   origin: string
   path: string
   method: string
@@ -274,14 +269,23 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     await this.onRequest?.(request)
 
     try {
-      const responseData = await this.pool.request({
+      const requestOptions = {
         method: request.method,
         origin: request.origin,
         path: request.path,
         body: request.body,
         headers: request.headers,
         signal: request.signal,
-      })
+      }
+
+      if (request.json === true) {
+        if (requestOptions.headers['content-type'] === undefined) {
+          requestOptions.headers['content-type'] = 'application/json; charset=utf-8'
+        }
+        requestOptions.body = JSON.stringify(requestOptions.body)
+      }
+
+      const responseData = await this.pool.request(requestOptions)
       responseData.body.setEncoding('utf8')
 
       let data = ''

test/http-data-source.test.ts

@@ -99,6 +99,58 @@ test('Should be able to make a simple POST call', async (t) => {
   t.deepEqual(response.body, { name: 'foo' })
 })
 
+test('Should be able to make a simple POST with JSON body', async (t) => {
+  t.plan(4)
+
+  const path = '/'
+
+  const wanted = { name: 'foo' }
+
+  const server = http.createServer((req, res) => {
+    t.is(req.method, 'POST')
+    t.is(req.headers['content-type'], 'application/json; charset=utf-8')
+
+    let data = ''
+
+    req.on('data', (chunk) => {
+      data += chunk
+    })
+    req.on('end', () => {
+      t.deepEqual(data, '{"foo":"bar"}')
+      res.writeHead(200, {
+        'content-type': 'application/json',
+      })
+      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)
+    }
+    postFoo() {
+      return this.post(path, {
+        json: true,
+        body: {
+          foo: 'bar',
+        },
+      })
+    }
+  })()
+
+  const response = await dataSource.postFoo()
+
+  t.deepEqual(response.body, { name: 'foo' })
+})
+
 test('Should be able to make a simple DELETE call', async (t) => {
   t.plan(2)