rename lifecycle hooks, pass request instead options

Author: StarpTech

README.md

@@ -51,7 +51,7 @@ const datasource = new (class MoviesAPI extends HTTPDataSource {
   constructor() {
     // global client options
     super({
-      request: {
+      requestOptions: {
         timeout: 2000,
         http2: true,
         headers: {
@@ -62,12 +62,12 @@ const datasource = new (class MoviesAPI extends HTTPDataSource {
     this.baseURL = "https://movies-api.example.com";
   })
 
-  cacheKey() {}
+  onCacheKeyCalculation() {}
 
   // lifecycle hooks for logging, tracing and request, response manipulation
-  didEncounterError() {}
-  async willSendRequest() {}
-  async didReceiveResponse() {}
+  async onRequestError() {}
+  async beforeRequest() {}
+  async onResponse() {}
 
   async getMovie(id) {
     return this.get(`/movies/${id}`, {

src/http-data-source.ts

@@ -1,5 +1,17 @@
 import { DataSource, DataSourceConfig } from 'apollo-datasource'
-import got, { Agents, HTTPError, NormalizedOptions, OptionsOfJSONResponseBody, Response } from 'got'
+import got, {
+  Agents,
+  HTTPError,
+  NormalizedOptions,
+  OptionsOfJSONResponseBody,
+  RequestError,
+  Response,
+  CacheError,
+  UploadError,
+  ReadError,
+  MaxRedirectsError,
+  GotReturn as Request,
+} from 'got'
 import QuickLRU from '@alloc/quick-lru'
 import AbortController from 'abort-controller'
 
@@ -11,14 +23,14 @@ import { KeyValueCache } from 'apollo-server-caching'
 
 const { HttpsAgent } = HttpAgent
 
-export type Request = OptionsOfJSONResponseBody | NormalizedOptions
+export type RequestOptions = OptionsOfJSONResponseBody | NormalizedOptions
 export interface LRUOptions {
   readonly maxAge?: number
   readonly maxSize: number
 }
 
 export interface HTTPDataSourceOptions {
-  request?: OptionsOfJSONResponseBody
+  requestOptions?: RequestOptions
   lru?: LRUOptions
 }
 
@@ -97,91 +109,92 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
   }
 
   /**
-   * DidReceiveResponse is executed after a response has been received.
+   * onResponse is executed after a response has been received.
    * You can manipulate the response by returning a different response.
    *
    * @param response
    * @param _request
    * @returns
    */
-  protected async didReceiveResponse<TResult = unknown>(
+  protected async onResponse<TResult = unknown>(
     response: Response<TResult>,
     _request: Request,
   ): Promise<Response<TResult>> {
     return response
   }
 
   /**
-   * CacheKey returns the key for the GET request.
+   * onCacheKeyCalculation returns the key for the GET request.
    * The key is used to memoize the request in the LRU cache.
    *
    * @param request
    * @returns
    */
-  protected cacheKey(request: Request): string {
-    if (request.url) return request.url.toString()
+  protected onCacheKeyCalculation(requestOptions: RequestOptions): string {
+    if (requestOptions.url) return requestOptions.url.toString()
     throw new Error('No Cache key provided')
   }
 
   /**
-   * WillSendRequest is executed before a request is made and isn't executed for memoized calls.
+   * beforeRequest is executed before a request is made and isn't executed for memoized calls.
    * You can manipulate the request e.g add/remove headers.
    *
    * @param request
    */
-  protected willSendRequest?(request?: Request): Promise<void>
+  protected beforeRequest?(requestOptions?: RequestOptions): Promise<void>
 
   /**
-   * DidEncounterError is executed for any request error.
+   * onRequestError is executed for any request error.
    * The raw error is passed. The thrown error might be different.
    *
    * @param _error
+   * @param _request
    */
-  protected didEncounterError(_error: Error) {}
+  protected onRequestError?(_error: Error, _request?: Request): Promise<void>
 
   protected async get<TResult = unknown>(
     url: string,
-    request?: Request,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request(url, {
       method: 'GET',
-      ...request,
+      ...requestOptions,
     })
   }
 
   protected async post<TResult = unknown>(
     url: string,
-    request?: Request,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request(url, {
       method: 'POST',
-      ...request,
+      ...requestOptions,
     })
   }
 
   protected async delete<TResult = unknown>(
     url: string,
-    request?: Request,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request(url, {
       method: 'DELETE',
-      ...request,
+      ...requestOptions,
     })
   }
 
   protected async put<TResult = unknown>(
     url: string,
-    request?: Request,
+    requestOptions?: RequestOptions,
   ): Promise<Response<TResult>> {
     return await this.request(url, {
       method: 'PUT',
-      ...request,
+      ...requestOptions,
     })
   }
 
   private async performRequest<TResult>(options: NormalizedOptions) {
-    if (this.willSendRequest != null) {
-      await this.willSendRequest(options)
+    if (this.beforeRequest != null) {
+      await this.beforeRequest(options)
     }
 
     const cancelableRequest = got<TResult>(options as OptionsOfJSONResponseBody)
@@ -194,12 +207,10 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
     try {
       const response = await cancelableRequest
-      return this.didReceiveResponse<TResult>(response, options)
+      return this.onResponse<TResult>(response, cancelableRequest)
     } catch (error) {
       let error_ = error
 
-      this.didEncounterError(error)
-
       if (error instanceof HTTPError) {
         if (error.response.statusCode === 401) {
           error_ = new AuthenticationError(error.message)
@@ -210,6 +221,18 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
         }
       }
 
+      if (
+        this.onRequestError &&
+        (error instanceof RequestError ||
+          error instanceof HTTPError ||
+          error instanceof CacheError ||
+          error instanceof UploadError ||
+          error instanceof ReadError ||
+          error instanceof MaxRedirectsError)
+      ) {
+        await this.onRequestError(error, error.request)
+      }
+
       throw error_
     } finally {
       this.abortController.signal.removeEventListener('abort', abort)
@@ -218,7 +241,7 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
 
   private async request<TResult = unknown>(
     path: string,
-    request: Request,
+    requestOptions: RequestOptions,
   ): Promise<Response<TResult>> {
     const options = got.mergeOptions(
       {
@@ -230,12 +253,12 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
         prefixUrl: this.baseURL,
       },
       {
-        ...this.options?.request,
+        ...this.options?.requestOptions,
       },
-      request,
+      requestOptions,
     )
 
-    const cacheKey = this.cacheKey(options)
+    const cacheKey = this.onCacheKeyCalculation(options)
 
     // Memoize get call for the same data source instance
     // data sources are scoped to the current request

src/index.ts

@@ -1,4 +1,4 @@
-export { HTTPDataSource, Request } from './http-data-source'
+export { HTTPDataSource, RequestOptions } from './http-data-source'
 export {
   Response,
   CacheError,
@@ -10,4 +10,5 @@ export {
   TimeoutError,
   RequestError,
   UnsupportedProtocolError,
+  GotReturn as Request
 } from 'got'

test/rest-data-source.test.ts

@@ -2,7 +2,7 @@ import { ApolloError, AuthenticationError, ForbiddenError } from 'apollo-server-
 import anyTest, { TestInterface } from 'ava'
 import { uid } from 'uid'
 import nock from 'nock'
-import { CancelError, Request, HTTPDataSource, TimeoutError } from '../src'
+import { CancelError, HTTPDataSource, TimeoutError, RequestOptions } from '../src'
 import { DataSourceConfig } from 'apollo-datasource'
 
 const test = anyTest as TestInterface<{ path: string }>
@@ -133,7 +133,7 @@ test('Should be able to define a custom cache key for request memoization', asyn
   const dataSource = new (class extends HTTPDataSource {
     baseURL = baseURL
 
-    cacheKey(_request: Request) {
+    onCacheKeyCalculation(_requestOptions: RequestOptions) {
       return 'foo'
     }
 
@@ -165,7 +165,7 @@ test('Should timeout', async (t) => {
 
     constructor() {
       super({
-        request: {
+        requestOptions: {
           timeout: 100,
         },
       })
@@ -200,7 +200,7 @@ test.cb('Should abort request', (t) => {
 
     constructor() {
       super({
-        request: {
+        requestOptions: {
           timeout: 1000,
         },
       })
@@ -245,8 +245,8 @@ test('Should be able to modify request in willSendRequest', async (t) => {
   const dataSource = new (class extends HTTPDataSource {
     baseURL = baseURL
 
-    async willSendRequest(request: Request) {
-      request.headers = {
+    async beforeRequest(requestOptions: RequestOptions) {
+      requestOptions.headers = {
         'X-Foo': 'bar',
       }
     }