improve interface

Author: dustin deus

README.md

@@ -62,20 +62,20 @@ const datasource = new (class MoviesAPI extends HTTPDataSource {
     })
   }
 
-  onCacheKeyCalculation(requestOptions: RequestOptions): string {
+  onCacheKeyCalculation(request: Request): string {
     // return different key based on request options
   }
 
-  onRequest(requestOptions: RequestOptions): void {
+  onRequest(request: Request): void {
     // manipulate request before it is send
   }
 
-  onResponse<TResult = unknown>(request: RequestOptions, response: Response<TResult>): void {
+  onResponse<TResult = unknown>(request: Request, response: Response<TResult>): void {
     // manipulate response or handle unsuccessful response in a different way
     return super.onResponse(request, response)
   }
 
-  onError(error: RequestError, request: RequestOptions): void {
+  onError(error: RequestError, request: Request): void {
     // log errors
   }
 

package-lock.json

@@ -50,7 +50,6 @@
   },
   "dependencies": {
     "@alloc/quick-lru": "^5.2.0",
-    "abort-controller": "^3.0.0",
     "apollo-datasource": "^0.9.0",
     "apollo-server-caching": "^0.7.0",
     "apollo-server-errors": "^2.5.0",
@@ -62,6 +61,7 @@
   "devDependencies": {
     "@types/node": "^14.17.3",
     "apollo-datasource-rest": "^0.14.0",
+    "abort-controller": "^3.0.0",
     "ava": "^3.15.0",
     "h2url": "^0.2.0",
     "nock": "^13.1.0",

package.json

@@ -1,14 +1,16 @@
 import { DataSource, DataSourceConfig } from 'apollo-datasource'
-import { Client, Pool } from 'undici'
+import { Pool } from 'undici'
 import { STATUS_CODES } from 'http'
 import QuickLRU from '@alloc/quick-lru'
 import sjson from 'secure-json-parse'
-import AbortController from 'abort-controller'
 
 import Keyv, { Store } from 'keyv'
 import { KeyValueCache } from 'apollo-server-caching'
-import { DispatchOptions, ResponseData } from 'undici/types/dispatcher'
+import { ResponseData, RequestOptions as UndiciRequestOptions } from 'undici/types/dispatcher'
 import { ApolloError } from 'apollo-server-errors'
+import { EventEmitter, Readable } from 'stream'
+
+type AbortSignal = unknown
 
 export type CacheTTLOptions = {
   requestCache?: {
@@ -19,9 +21,19 @@ export type CacheTTLOptions = {
   }
 }
 
-export type ClientRequestOptions = Omit<DispatchOptions, 'origin' | 'path' | 'method'> & CacheTTLOptions
+interface Dictionary<T> {
+  [Key: string]: T
+}
 
-export type RequestOptions = DispatchOptions & CacheTTLOptions
+export type RequestOptions = {
+  body?: string | Buffer | Uint8Array | Readable | null
+  headers?: Dictionary<string>
+  signal?: AbortSignal | EventEmitter | null
+} & CacheTTLOptions
+
+export type Request = UndiciRequestOptions & CacheTTLOptions & {
+  headers: Dictionary<string>
+}
 
 export type Response<TResult> = {
   body: TResult
@@ -34,8 +46,8 @@ export interface LRUOptions {
 
 export interface HTTPDataSourceOptions {
   pool?: Pool
-  requestOptions?: ClientRequestOptions
-  clientOptions?: Client.Options
+  requestOptions?: RequestOptions
+  clientOptions?: Pool.Options
   lru?: Partial<LRUOptions>
 }
 
@@ -73,9 +85,8 @@ const cacheableStatusCodes = [200, 201, 202, 203, 206]
 export abstract class HTTPDataSource<TContext = any> extends DataSource {
   public context!: TContext
   private storageAdapter!: Keyv
-  private readonly pool: Pool
-  private readonly globalRequestOptions?: ClientRequestOptions
-  private readonly abortController: AbortController
+  private pool: Pool
+  private globalRequestOptions?: RequestOptions
   private readonly memoizedResults: QuickLRU<string, Response<any>>
 
   constructor(public readonly baseURL: string, private readonly options?: HTTPDataSourceOptions) {
@@ -85,7 +96,6 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     })
     this.pool = options?.pool ?? new Pool(this.baseURL, options?.clientOptions)
     this.globalRequestOptions = options?.requestOptions
-    this.abortController = new AbortController()
   }
 
   /**
@@ -100,22 +110,15 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     })
   }
 
-  /**
-   * Abort and signal to any request that the associated activity is to be aborted.
-   */
-  abort() {
-    this.abortController.abort()
-  }
-
   protected isResponseOk(statusCode: number): boolean {
     return (statusCode >= 200 && statusCode <= 399) || statusCode === 304
   }
 
   protected isResponseCacheable<TResult = unknown>(
-    requestOptions: RequestOptions,
+    request: Request,
     response: Response<TResult>,
   ): boolean {
-    return cacheableStatusCodes.indexOf(response.statusCode) > -1 && requestOptions.method === 'GET'
+    return cacheableStatusCodes.indexOf(response.statusCode) > -1 && request.method === 'GET'
   }
 
   /**
@@ -125,8 +128,8 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
    * @param request
    * @returns
    */
-  protected onCacheKeyCalculation(requestOptions: RequestOptions): string {
-    return requestOptions.origin + requestOptions.path
+  protected onCacheKeyCalculation(request: Request): string {
+    return request.origin + request.path
   }
 
   /**
@@ -135,17 +138,17 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
    *
    * @param request
    */
-  protected onRequest?(requestOptions: RequestOptions): void
+  protected onRequest?(request: Request): void
 
   /**
    * onResponse is executed when a response has been received.
    * By default the implementation will throw for for unsuccessful responses.
    *
-   * @param _requestOptions
+   * @param _request
    * @param response
    */
   protected onResponse<TResult = unknown>(
-    _requestOptions: RequestOptions,
+    _request: Request,
     response: Response<TResult>,
   ): Response<TResult> {
     if (this.isResponseOk(response.statusCode)) {
@@ -158,13 +161,14 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     )
   }
 
-  protected onError?(_error: Error, requestOptions: RequestOptions): void
+  protected onError?(_error: Error, requestOptions: Request): void
 
   protected async get<TResult = unknown>(
     path: string,
-    requestOptions?: ClientRequestOptions,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request<TResult>({
+      headers: {},
       ...requestOptions,
       method: 'GET',
       path,
@@ -174,9 +178,10 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
   protected async post<TResult = unknown>(
     path: string,
-    requestOptions?: ClientRequestOptions,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request<TResult>({
+      headers: {},
       ...requestOptions,
       method: 'POST',
       path,
@@ -186,9 +191,10 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
   protected async delete<TResult = unknown>(
     path: string,
-    requestOptions?: ClientRequestOptions,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request<TResult>({
+      headers: {},
       ...requestOptions,
       method: 'DELETE',
       path,
@@ -198,9 +204,10 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
   protected async put<TResult = unknown>(
     path: string,
-    requestOptions?: ClientRequestOptions,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request<TResult>({
+      headers: {},
       ...requestOptions,
       method: 'PUT',
       path,
@@ -209,7 +216,7 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
   }
 
   private async performRequest<TResult>(
-    options: RequestOptions,
+    options: Request,
     cacheKey: string,
   ): Promise<Response<TResult>> {
     this.onRequest?.(options)
@@ -261,14 +268,12 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     }
   }
 
-  private async request<TResult = unknown>(
-    requestOptions: RequestOptions,
-  ): Promise<Response<TResult>> {
-    const cacheKey = this.onCacheKeyCalculation(requestOptions)
-    const ttlCacheEnabled = requestOptions.requestCache
+  private async request<TResult = unknown>(request: Request): Promise<Response<TResult>> {
+    const cacheKey = this.onCacheKeyCalculation(request)
+    const ttlCacheEnabled = request.requestCache
 
     // check if we have any GET call in the cache and respond immediatly
-    if (requestOptions.method === 'GET' && ttlCacheEnabled) {
+    if (request.method === 'GET' && ttlCacheEnabled) {
       const cachedResponse = await this.storageAdapter.get(cacheKey)
       if (cachedResponse) {
         return cachedResponse
@@ -277,8 +282,7 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
     const options = {
       ...this.globalRequestOptions,
-      ...requestOptions,
-      signal: this.abortController.signal,
+      ...request,
     }
 
     // Memoize GET calls for the same data source instance

src/http-data-source.ts

@@ -2,8 +2,8 @@ export {
   HTTPDataSource,
   HTTPDataSourceOptions,
   LRUOptions,
-  ClientRequestOptions,
-  Response,
   RequestOptions,
+  Response,
+  Request,
   CacheTTLOptions,
 } from './http-data-source'

src/index.ts

@@ -1,7 +1,8 @@
 import anyTest, { TestInterface } from 'ava'
 import http from 'http'
 import { setGlobalDispatcher, Agent, Pool } from 'undici'
-import { HTTPDataSource, RequestOptions, Response } from '../src'
+import AbortController from 'abort-controller'
+import { HTTPDataSource, Request, Response } from '../src'
 import { AddressInfo } from 'net'
 import { KeyValueCacheSetOptions } from 'apollo-server-caching'
 
@@ -253,9 +254,9 @@ test('Should be able to define a custom cache key for request memoization', asyn
     constructor() {
       super(baseURL)
     }
-    onCacheKeyCalculation(requestOptions: RequestOptions) {
+    onCacheKeyCalculation(request: Request) {
       t.pass('onCacheKeyCalculation')
-      t.truthy(requestOptions)
+      t.truthy(request)
       return 'foo'
     }
     getFoo() {
@@ -293,7 +294,7 @@ test('Should call onError on request error', async (t) => {
       super(baseURL)
     }
 
-    onResponse<TResult = any>(requestOptions: RequestOptions, response: Response<TResult>) {
+    onResponse<TResult = any>(requestOptions: Request, response: Response<TResult>) {
       t.truthy(requestOptions)
       t.truthy(response)
       t.pass('onResponse')
@@ -342,13 +343,17 @@ test.cb('Should abort request', (t) => {
 
   const baseURL = `http://localhost:${(server.address() as AddressInfo)?.port}`
 
+  const abortController = new AbortController()
+
   const dataSource = new (class extends HTTPDataSource {
     constructor() {
       super(baseURL)
     }
 
     async getFoo() {
-      return await this.get(path)
+      return await this.get(path, {
+        signal: abortController.signal,
+      })
     }
   })()
 
@@ -369,7 +374,7 @@ test.cb('Should abort request', (t) => {
     'Timeout',
   ).finally(t.end)
 
-  dataSource.abort()
+  abortController.abort()
 })
 
 test.cb('Should timeout', (t) => {
@@ -452,8 +457,8 @@ test('Should be able to modify request in willSendRequest', async (t) => {
     constructor() {
       super(baseURL)
     }
-    onRequest(requestOptions: RequestOptions) {
-      requestOptions.headers = {
+    onRequest(request: Request) {
+      request.headers = {
         'X-Foo': 'bar',
       }
     }