make onRequest hook async

Author: StarpTech

README.md

@@ -66,7 +66,7 @@ const datasource = new (class MoviesAPI extends HTTPDataSource {
     // return different key based on request options
   }
 
-  onRequest(request: Request): void {
+  async onRequest(request: Request): Promise<void> {
     // manipulate request before it is send
     // for example assign a AbortController signal to all requests and abort
 

src/http-data-source.ts

@@ -138,7 +138,7 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
    *
    * @param request
    */
-  protected onRequest?(request: Request): void
+  protected async onRequest?(request: Request): Promise<void>
 
   /**
    * onResponse is executed when a response has been received.
@@ -229,19 +229,19 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
   }
 
   private async performRequest<TResult>(
-    options: Request,
+    request: Request,
     cacheKey: string,
   ): Promise<Response<TResult>> {
-    this.onRequest?.(options)
+    await this.onRequest?.(request)
 
     try {
       const responseData = await this.pool.request({
-        method: options.method,
-        origin: options.origin,
-        path: options.path,
-        body: options.body,
-        headers: options.headers,
-        signal: options.signal,
+        method: request.method,
+        origin: request.origin,
+        path: request.path,
+        body: request.body,
+        headers: request.headers,
+        signal: request.signal,
       })
 
       responseData.body.setEncoding('utf8')
@@ -262,29 +262,29 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
         body: json,
       }
 
-      this.onResponse<TResult>(options, response)
+      this.onResponse<TResult>(request, response)
 
       // let's see if we can fill the shared cache
-      if (options.requestCache && this.isResponseCacheable<TResult>(options, response)) {
-        response.maxTtl = Math.max(options.requestCache.maxTtl, options.requestCache.maxTtlIfError)
+      if (request.requestCache && this.isResponseCacheable<TResult>(request, response)) {
+        response.maxTtl = Math.max(request.requestCache.maxTtl, request.requestCache.maxTtlIfError)
         const cachedResponse = JSON.stringify(response)
         this.cache
           .set(cacheKey, cachedResponse, {
-            ttl: options.requestCache?.maxTtl,
+            ttl: request.requestCache?.maxTtl,
           })
           .catch((err) => this.logger?.error(err))
         this.cache
           .set(`staleIfError:${cacheKey}`, cachedResponse, {
-            ttl: options.requestCache?.maxTtlIfError,
+            ttl: request.requestCache?.maxTtlIfError,
           })
           .catch((err) => this.logger?.error(err))
       }
 
       return response
     } catch (error) {
-      this.onError?.(error, options)
+      this.onError?.(error, request)
 
-      if (options.requestCache) {
+      if (request.requestCache) {
         const cacheItem = await this.cache.get(`staleIfError:${cacheKey}`)
         if (cacheItem) {
           const response: Response<TResult> = sjson.parse(cacheItem)

test/http-data-source.test.ts

@@ -588,7 +588,7 @@ test('Should be able to modify request in willSendRequest', async (t) => {
     constructor() {
       super(baseURL)
     }
-    onRequest(request: Request) {
+    async onRequest(request: Request) {
       request.headers = {
         'X-Foo': 'bar',
       }