fix: update execution behavior of interceptor

This commit contains changes to the execution order of interceptors.
Now, the request interceptors registered from SkillBuilders will be executed
before request handler's canhandle is invoked. Response interceptors will be executed
immediately after request handler's handle returns.

ask-sdk-core/lib/dispatcher/DefaultRequestDispatcher.ts

@@ -20,6 +20,8 @@ import { ErrorMapper } from './error/ErrorMapper';
 import { HandlerAdapter } from './request/handler/HandlerAdapter';
 import { HandlerInput } from './request/handler/HandlerInput';
 import { RequestHandlerChain } from './request/handler/RequestHandlerChain';
+import { RequestInterceptor } from './request/interceptor/RequestInterceptor';
+import { ResponseInterceptor } from './request/interceptor/ResponseInterceptor';
 import { RequestMapper } from './request/mapper/RequestMapper';
 import { RequestDispatcher } from './RequestDispatcher';
 
@@ -30,15 +32,21 @@ export class DefaultRequestDispatcher implements RequestDispatcher {
     protected requestMappers : RequestMapper[];
     protected errorMapper : ErrorMapper;
     protected handlerAdapters : HandlerAdapter[];
+    protected requestInterceptors : RequestInterceptor[];
+    protected responseInterceptors : ResponseInterceptor[];
 
     constructor(options : {
         requestMappers : RequestMapper[],
         handlerAdapters : HandlerAdapter[],
         errorMapper? : ErrorMapper,
+        requestInterceptors? : RequestInterceptor[],
+        responseInterceptors? : ResponseInterceptor[],
     }) {
         this.requestMappers = options.requestMappers;
         this.handlerAdapters = options.handlerAdapters;
         this.errorMapper = options.errorMapper;
+        this.requestInterceptors = options.requestInterceptors;
+        this.responseInterceptors = options.responseInterceptors;
     }
 
     /**
@@ -50,7 +58,22 @@ export class DefaultRequestDispatcher implements RequestDispatcher {
     public async dispatch(handlerInput : HandlerInput) : Promise<Response> {
         let response : Response;
         try {
+            // Execute global request interceptors
+            if (this.requestInterceptors) {
+                for (const requestInterceptor of this.requestInterceptors) {
+                    await requestInterceptor.process(handlerInput);
+                }
+            }
+
+            // Dispatch request to handler chain
             response = await this.dispatchRequest(handlerInput);
+
+            // Execute global response interceptors
+            if (this.responseInterceptors) {
+                for (const responseInterceptor of this.responseInterceptors) {
+                    await responseInterceptor.process(handlerInput, response);
+                }
+            }
         } catch (err) {
             response = await this.dispatchError(handlerInput, err);
         }
@@ -64,49 +87,50 @@ export class DefaultRequestDispatcher implements RequestDispatcher {
      * @returns {Promise<Response>}
      */
     protected async dispatchRequest(handlerInput : HandlerInput) : Promise<Response> {
+        // Get the request handler chain that can handle the request
         let handlerChain : RequestHandlerChain;
-
         for (const requestMapper of this.requestMappers) {
             handlerChain = await requestMapper.getRequestHandlerChain(handlerInput);
             if (handlerChain) {
                 break;
             }
         }
-
         if (!handlerChain) {
             throw createAskSdkError(
                 this.constructor.name,
                 `Could not find handler that can handle the request: ${JSON.stringify(handlerInput.requestEnvelope.request, null, 2)}`);
         }
 
+        // Extract the handler and interceptors from the handler chain
         const handler = handlerChain.getRequestHandler();
         const requestInterceptors = handlerChain.getRequestInterceptors();
         const responseInterceptors = handlerChain.getResponseInterceptors();
 
+        // Get the handler adapter that supports the request handler
         let adapter : HandlerAdapter;
         for (const handlerAdapter of this.handlerAdapters) {
             if (handlerAdapter.supports(handler)) {
                 adapter = handlerAdapter;
                 break;
             }
         }
-
         if (!adapter) {
             throw createAskSdkError(
                 this.constructor.name,
-                'HandlerAdapter not found!');
+                `Could not find the handler adapter that supports the request handler.`);
         }
 
-        // Pre-processing logic. Going in order
+        // Execute request interceptors that are local to the handler chain
         if (requestInterceptors) {
             for (const requestInterceptor of requestInterceptors) {
                 await requestInterceptor.process(handlerInput);
             }
         }
 
+        // Invoke the request handler
         const response = await adapter.execute(handlerInput, handler);
 
-        // Post-processing logic. Going in order
+        // Execute response interceptors that are local to the handler chain
         if (responseInterceptors) {
             for (const responseInterceptor of responseInterceptors) {
                 await responseInterceptor.process(handlerInput, response);

ask-sdk-core/lib/skill/Skill.ts

@@ -52,6 +52,8 @@ export class Skill {
             requestMappers : skillConfiguration.requestMappers,
             handlerAdapters : skillConfiguration.handlerAdapters,
             errorMapper : skillConfiguration.errorMapper,
+            requestInterceptors : skillConfiguration.requestInterceptors,
+            responseInterceptors : skillConfiguration.responseInterceptors,
         });
     }
 

ask-sdk-core/lib/skill/SkillConfiguration.ts

@@ -17,6 +17,8 @@ import { services } from 'ask-sdk-model';
 import { PersistenceAdapter } from '../attributes/persistence/PersistenceAdapter';
 import { ErrorMapper } from '../dispatcher/error/ErrorMapper';
 import { HandlerAdapter } from '../dispatcher/request/handler/HandlerAdapter';
+import { RequestInterceptor } from '../dispatcher/request/interceptor/RequestInterceptor';
+import { ResponseInterceptor } from '../dispatcher/request/interceptor/ResponseInterceptor';
 import { RequestMapper } from '../dispatcher/request/mapper/RequestMapper';
 
 /**
@@ -26,6 +28,8 @@ export interface SkillConfiguration {
     requestMappers : RequestMapper[];
     handlerAdapters : HandlerAdapter[];
     errorMapper? : ErrorMapper;
+    requestInterceptors? : RequestInterceptor[];
+    responseInterceptors? : ResponseInterceptor[];
     persistenceAdapter? : PersistenceAdapter;
     apiClient? : services.ApiClient;
     customUserAgent? : string;

ask-sdk-core/lib/skill/factory/BaseSkillFactory.ts

@@ -43,7 +43,7 @@ export type LambdaHandler = (
 
 export class BaseSkillFactory {
     public static init() : BaseSkillBuilder {
-        const thisRequestHandlers : RequestHandler[] = [];
+        const thisRequestHandlerChains : DefaultRequestHandlerChain[] = [];
         const thisRequestInterceptors : RequestInterceptor[] = [];
         const thisResponseInterceptors : ResponseInterceptor[] = [];
         const thisErrorHandlers : ErrorHandler[] = [];
@@ -78,16 +78,21 @@ export class BaseSkillFactory {
                             `Matcher must be of type string or function, got: ${typeof matcher}!`);
                     }
                 }
-
-                thisRequestHandlers.push({
-                    canHandle,
-                    handle : executor,
-                });
+                thisRequestHandlerChains.push(new DefaultRequestHandlerChain({
+                    requestHandler : {
+                        canHandle,
+                        handle : executor,
+                    },
+                }));
 
                 return this;
             },
             addRequestHandlers(...requestHandlers : RequestHandler[]) : BaseSkillBuilder {
-                thisRequestHandlers.push(...requestHandlers);
+                for ( const requestHandler of requestHandlers ) {
+                    thisRequestHandlerChains.push(new DefaultRequestHandlerChain({
+                        requestHandler,
+                    }));
+                }
 
                 return this;
             },
@@ -165,18 +170,8 @@ export class BaseSkillFactory {
                 return this;
             },
             getSkillConfiguration() : SkillConfiguration {
-                const requestHandlerChains : DefaultRequestHandlerChain[] = [];
-
-                for ( const requestHandler of thisRequestHandlers ) {
-                    requestHandlerChains.push(new DefaultRequestHandlerChain({
-                        requestHandler,
-                        requestInterceptors : thisRequestInterceptors,
-                        responseInterceptors : thisResponseInterceptors,
-                    }));
-                }
-
                 const requestMapper = new DefaultRequestMapper({
-                    requestHandlerChains,
+                    requestHandlerChains : thisRequestHandlerChains,
                 });
 
                 const errorMapper = thisErrorHandlers.length
@@ -189,6 +184,8 @@ export class BaseSkillFactory {
                     requestMappers : [requestMapper],
                     handlerAdapters : [new DefaultHandlerAdapter()],
                     errorMapper,
+                    requestInterceptors : thisRequestInterceptors,
+                    responseInterceptors : thisResponseInterceptors,
                     customUserAgent : thisCustomUserAgent,
                     skillId : thisSkillId,
                 };