@pristine-ts/core 0.0.174 → 0.0.178

package/dist/lib/esm/models/event.response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.response.js","sourceRoot":"","sources":["../../../../src/models/event.response.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,aAAa;IACtB,YAA4B,KAA0B,EAAkB,QAA8B;QAA1E,UAAK,GAAL,KAAK,CAAqB;QAAkB,aAAQ,GAAR,QAAQ,CAAsB;IACtG,CAAC;CACJ"}

package/dist/lib/esm/models/models.js

@@ -0,0 +1,3 @@
+export * from "./event";
+export * from "./event.response";
+//# sourceMappingURL=models.js.map

package/dist/lib/esm/models/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../src/models/models.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/dist/lib/esm/pipelines/event.pipeline.js

@@ -0,0 +1,279 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { injectable, injectAll, inject } from "tsyringe";
+import { Event } from "../models/event";
+import { ServiceDefinitionTagEnum } from "@pristine-ts/common";
+import { EventMappingError } from "../errors/event-mapping.error";
+import { EventPreMappingInterceptionError } from "../errors/event-pre-mapping-interception.error";
+import { EventPostMappingInterceptionError } from "../errors/event-post-mapping-interception.error";
+import { EventDispatchingError } from "../errors/event-dispatching.error";
+import { EventPreResponseMappingInterceptionError } from "../errors/event-pre-response-mapping-interception.error";
+import { EventPostResponseMappingInterceptionError } from "../errors/event-post-response-mapping-interception.error";
+import { SpanKeynameEnum } from "@pristine-ts/telemetry";
+let EventPipeline = class EventPipeline {
+    constructor(eventInterceptors, eventMappers, logHandler, tracingManager) {
+        this.eventInterceptors = eventInterceptors;
+        this.eventMappers = eventMappers;
+        this.logHandler = logHandler;
+        this.tracingManager = tracingManager;
+    }
+    /**
+     * This method calls the interceptors that are to be executed just before the EventMappers are executed. It allows
+     * for changing the raw event coming directly into the kernel.
+     *
+     * @param event
+     * @param executionContext
+     * @private
+     */
+    preMappingIntercept(event, executionContext) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let interceptedEvent = event;
+            const span = this.tracingManager.startSpan(SpanKeynameEnum.EventPreMappingInterception);
+            for (const eventInterceptor of this.eventInterceptors) {
+                try {
+                    interceptedEvent = (_b = yield ((_a = eventInterceptor.preMappingIntercept) === null || _a === void 0 ? void 0 : _a.call(eventInterceptor, interceptedEvent, executionContext))) !== null && _b !== void 0 ? _b : interceptedEvent;
+                }
+                catch (error) {
+                    throw new EventPreMappingInterceptionError("There was an error while executing the PreMapping Event interceptors", error, eventInterceptor.constructor.name, event, executionContext);
+                }
+            }
+            span.end();
+            return interceptedEvent;
+        });
+    }
+    /**
+     * This method calls the interceptors that are executed just after the EventMappers have mapped the raw event into
+     * an Event object.
+     *
+     * @param event
+     * @private
+     */
+    postMappingIntercept(event) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let interceptedEvent = event;
+            const span = this.tracingManager.startSpan(SpanKeynameEnum.EventPostMappingInterception);
+            for (const eventInterceptor of this.eventInterceptors) {
+                try {
+                    interceptedEvent = (_b = yield ((_a = eventInterceptor.postMappingIntercept) === null || _a === void 0 ? void 0 : _a.call(eventInterceptor, interceptedEvent))) !== null && _b !== void 0 ? _b : interceptedEvent;
+                }
+                catch (error) {
+                    throw new EventPostMappingInterceptionError("There was an error while executing the PostMapping Event interceptors", error, eventInterceptor.constructor.name, event);
+                }
+            }
+            span.end();
+            return interceptedEvent;
+        });
+    }
+    /**
+     * This method calls the interceptors that are to be executed just after the EventResponse has been returned from
+     * the EventDispatcher but before it is reverse mapped by the EventMappers.
+     *
+     * @param eventResponse
+     * @private
+     */
+    preResponseMappingIntercept(eventResponse) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let interceptedEventResponse = eventResponse;
+            const span = this.tracingManager.startSpan(SpanKeynameEnum.EventPreResponseMappingInterception);
+            for (const eventInterceptor of this.eventInterceptors) {
+                try {
+                    interceptedEventResponse = (_b = yield ((_a = eventInterceptor.preResponseMappingIntercept) === null || _a === void 0 ? void 0 : _a.call(eventInterceptor, interceptedEventResponse))) !== null && _b !== void 0 ? _b : interceptedEventResponse;
+                }
+                catch (error) {
+                    throw new EventPreResponseMappingInterceptionError("There was an error while executing the PreResponseMapping Event interceptors", error, eventInterceptor.constructor.name, eventResponse);
+                }
+            }
+            span.end();
+            return interceptedEventResponse;
+        });
+    }
+    /**
+     * This method calls the interceptors that are executed after the EventResponse object has been mapped into a simple
+     * object.
+     *
+     * @param eventResponse The event response object to be returned from the handle method in the kernel.
+     * @private
+     */
+    postResponseMappingIntercept(eventResponse) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let interceptedEventResponse = eventResponse;
+            const span = this.tracingManager.startSpan(SpanKeynameEnum.EventPostResponseMappingInterception);
+            for (const eventInterceptor of this.eventInterceptors) {
+                try {
+                    interceptedEventResponse = (_b = yield ((_a = eventInterceptor.postResponseMappingIntercept) === null || _a === void 0 ? void 0 : _a.call(eventInterceptor, interceptedEventResponse))) !== null && _b !== void 0 ? _b : interceptedEventResponse;
+                }
+                catch (error) {
+                    throw new EventPostResponseMappingInterceptionError("There was an error while executing the PostResponseMapping Event interceptors", error, eventInterceptor.constructor.name, eventResponse);
+                }
+            }
+            span.end();
+            return interceptedEventResponse;
+        });
+    }
+    /**
+     * This method executes the postMappingInterceptors and then dispatches the Event by using the EventDispatcher.
+     *
+     * @param event This is the event that must be dispatched.
+     * @param eventDispatcher This is the eventDispatcher instance that will dispatch the Event.
+     * @private
+     */
+    executeEvent(event, eventDispatcher) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1 - Run the post mapped interceptors on every single event before they get executed.
+            let interceptedEvent = yield this.postMappingIntercept(event);
+            try {
+                const eventExecutionSpan = this.tracingManager.startSpan(SpanKeynameEnum.EventExecution);
+                // 2 - Call the EventDispatcher and retrieve the Event Response
+                const response = yield eventDispatcher.dispatch(interceptedEvent);
+                eventExecutionSpan.end();
+                return response;
+            }
+            catch (error) {
+                this.logHandler.error("There was an error while dispatching the event", {
+                    error,
+                    interceptedEvent,
+                });
+                throw new EventDispatchingError("There was an error while dispatching the event", error, interceptedEvent);
+            }
+        });
+    }
+    /**
+     *
+     * @param event
+     * @param executionContext
+     * @param container
+     */
+    execute(event, executionContext, container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eventExecutions = [];
+            // If the event passed is already properly typed, we simply execute it, without mapping and without calling the pre-mapping interceptors
+            if (event instanceof Event) {
+                eventExecutions.push({
+                    events: [event],
+                    executionOrder: "sequential",
+                });
+            }
+            else {
+                // 1- We have the raw event, we start by executing the PreMapping Interceptors
+                const interceptedEvent = yield this.preMappingIntercept(event, executionContext);
+                // 2- With the intercepted raw event, run the Events Mapping to get all the Events and the EventsExecutionOptions.
+                // For each event mapper that supports the event, we batch the executions for each mapper. So it's possible to execute the same
+                // event twice. This is up to the EventMappers to properly identify when they map or don't map an event. Pristine
+                // isn't responsible to determine if two events are executed twice, so be careful.
+                let numberOfEventMappers = 0;
+                try {
+                    const span = this.tracingManager.startSpan(SpanKeynameEnum.EventMapping);
+                    this.eventMappers.forEach(eventMapper => {
+                        if (eventMapper.supportsMapping(interceptedEvent, executionContext)) {
+                            eventExecutions.push(eventMapper.map(interceptedEvent, executionContext));
+                            numberOfEventMappers++;
+                        }
+                    });
+                    span.end();
+                }
+                catch (error) {
+                    throw new EventMappingError("There was an error mapping the event into an Event object", event, interceptedEvent, executionContext, error);
+                }
+                if (numberOfEventMappers === 0) {
+                    throw new EventMappingError("There are no Event Mappers that support the event", event, interceptedEvent, executionContext);
+                }
+                if (eventExecutions.length === 0 || eventExecutions.reduce((agg, eventExecution) => {
+                    return agg + eventExecution.events.length;
+                }, 0) === 0) {
+                    throw new EventMappingError("There are no events to execute.", event, interceptedEvent, executionContext);
+                }
+            }
+            const eventsExecutionPromises = [];
+            // 3- Loop over the EventExecutionOptions array and start executing the events
+            eventExecutions.forEach(eventExecutionOptions => {
+                switch (eventExecutionOptions.executionOrder) {
+                    case 'sequential':
+                        eventsExecutionPromises.push(new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                            // await all events and then resolve.
+                            const eventResponses = [];
+                            for (const event of eventExecutionOptions.events) {
+                                const childContainer = container.createChildContainer();
+                                // It's important to register the CurrentChildContainer since even though it's not 100% recommended,
+                                // some handlers might want to retrieve the container. For example, the RequestHandler needs this mechanism
+                                // to dynamically load the controllers and not load all the containers all the time.
+                                childContainer.register(ServiceDefinitionTagEnum.CurrentChildContainer, {
+                                    useValue: childContainer,
+                                });
+                                const eventDispatcher = childContainer.resolve("EventDispatcherInterface");
+                                try {
+                                    eventResponses.push(yield this.executeEvent(event, eventDispatcher));
+                                }
+                                catch (error) {
+                                    return reject(error);
+                                }
+                            }
+                            return resolve(eventResponses);
+                        })));
+                        break;
+                    case 'parallel':
+                        for (const event of eventExecutionOptions.events) {
+                            eventsExecutionPromises.push(new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                                const childContainer = container.createChildContainer();
+                                // It's important to register the CurrentChildContainer since even though it's not 100% recommended,
+                                // some handlers might want to retrieve the container. For example, the RequestHandler needs this mechanism
+                                // to dynamically load the controllers and not load all the containers all the time.
+                                childContainer.register(ServiceDefinitionTagEnum.CurrentChildContainer, {
+                                    useValue: childContainer,
+                                });
+                                const eventDispatcher = childContainer.resolve("EventDispatcherInterface");
+                                this.executeEvent(event, eventDispatcher).then(eventResponse => resolve(eventResponse)).catch(error => reject(error));
+                            })));
+                        }
+                        break;
+                }
+            });
+            // 4- For each event, call the PreResponseMapping Interceptors
+            const eventResponses = yield Promise.all((yield Promise.all(eventsExecutionPromises)).flat().map((eventResponse) => __awaiter(this, void 0, void 0, function* () { return yield this.preResponseMappingIntercept(eventResponse); })));
+            let finalResponse = {};
+            // 5 - Construct the final response by calling the events mapper (reverse map method) for each eventResponse;
+            // This method updates the response object that will be returned from the kernel.
+            eventResponses.forEach(eventResponse => {
+                this.eventMappers.forEach(eventMapper => {
+                    if (eventMapper.supportsReverseMapping(eventResponse, finalResponse, executionContext)) {
+                        finalResponse = eventMapper.reverseMap(eventResponse, finalResponse, executionContext);
+                    }
+                });
+            });
+            // 6 - Call the PostResponseMapping interceptors and return the final intercepted response.
+            return this.postResponseMappingIntercept(finalResponse);
+        });
+    }
+};
+EventPipeline = __decorate([
+    injectable(),
+    __param(0, injectAll(ServiceDefinitionTagEnum.EventInterceptor)),
+    __param(1, injectAll(ServiceDefinitionTagEnum.EventMapper)),
+    __param(2, inject('LogHandlerInterface')),
+    __param(3, inject("TracingManagerInterface")),
+    __metadata("design:paramtypes", [Array, Array, Object, Object])
+], EventPipeline);
+export { EventPipeline };
+//# sourceMappingURL=event.pipeline.js.map

package/dist/lib/esm/pipelines/event.pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.pipeline.js","sourceRoot":"","sources":["../../../../src/pipelines/event.pipeline.ts"],"names":[],"mappings":"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"}

package/dist/lib/esm/pipelines/pipelines.js

@@ -0,0 +1,2 @@
+export * from "./event.pipeline";
+//# sourceMappingURL=pipelines.js.map

package/dist/lib/esm/pipelines/pipelines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelines.js","sourceRoot":"","sources":["../../../../src/pipelines/pipelines.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/types/core.module.d.ts

@@ -1,7 +1,14 @@
 import { ModuleInterface } from "@pristine-ts/common";
 export * from "./kernel";
+export * from "./dispatchers/dispatchers";
+export * from "./enums/enums";
 export * from "./errors/errors";
+export * from "./handlers/handlers";
 export * from "./interceptors/interceptors";
 export * from "./interfaces/interfaces";
+export * from "./listeners/listeners";
+export * from "./mappers/mappers";
+export * from "./models/models";
+export * from "./pipelines/pipelines";
 export * from "./core.module.keyname";
 export declare const CoreModule: ModuleInterface;

package/dist/types/dispatchers/dispatchers.d.ts

@@ -0,0 +1 @@
+export * from "./event.dispatcher";

package/dist/types/dispatchers/event.dispatcher.d.ts

@@ -0,0 +1,29 @@
+import { Event } from "../models/event";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { EventHandlerInterface } from "../interfaces/event-handler.interface";
+import { EventResponse } from "../models/event.response";
+import { EventDispatcherInterface } from "../interfaces/event-dispatcher.interface";
+import { EventListenerInterface } from "../interfaces/event-listener.interface";
+/**
+ * This class receives all the event handlers and listeners that were registered and calls them if they support the event.
+ */
+export declare class EventDispatcher implements EventDispatcherInterface {
+    private readonly eventHandlers;
+    private readonly eventListeners;
+    private readonly logHandler;
+    /**
+     * Dispatcher to dispatch the events to the event handlers that support them.
+     * @param eventHandlers All the event handlers that are tagged with ServiceDefinitionTagEnum.EventHandler
+     * @param eventListeners
+     * @param logHandler
+     */
+    constructor(eventHandlers: EventHandlerInterface<any, any>[], eventListeners: EventListenerInterface[], logHandler: LogHandlerInterface);
+    /**
+     * This method receives an event, loops through its event handlers and listeners and if they support the event,
+     * will call their handle method.
+     * Resolves once all the event handlers and listeners have settled, but does not return a response.
+     *
+     * @param event
+     */
+    dispatch(event: Event<any>): Promise<EventResponse<any, any>>;
+}

package/dist/types/enums/enums.d.ts

@@ -0,0 +1 @@
+export * from "./execution-context-keyname.enum";

package/dist/types/enums/execution-context-keyname.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum ExecutionContextKeynameEnum {
+    AwsLambda = "AWS_LAMBDA",
+    Cloudflare = "CLOUDFLARE",
+    Express = "EXPRESS",
+    Jest = "JEST"
+}

package/dist/types/errors/error-response-interception-execution.error.d.ts

@@ -1,7 +1,8 @@
-import { LoggableError, RequestInterface } from "@pristine-ts/common";
+import { LoggableError } from "@pristine-ts/common";
+import { Request } from "@pristine-ts/common";
 /**
  * This Error is thrown when an error happens in the execution of an error response interceptor.
  */
 export declare class ErrorResponseInterceptionExecutionError extends LoggableError {
-    constructor(message: string, error: Error, request: RequestInterface, interceptor: any, previousError?: Error);
+    constructor(message: string, error: Error, request: Request, interceptor: any, previousError?: Error);
 }

package/dist/types/errors/errors.d.ts

@@ -1,8 +1,10 @@
 export * from "./error-response-interception-execution.error";
-export * from "./provider-registration.error";
+export * from "./event-dispatcher-no-event-handlers.error";
+export * from "./event-dispatching.error";
 export * from "./event-interception-execution.error";
+export * from "./event-mapping.error";
+export * from "./event-post-mapping-interception.error";
+export * from "./event-pre-mapping-interception.error";
 export * from "./kernel-initialization.error";
-export * from "./request-handling.error";
-export * from "./request-interception-execution.error";
-export * from "./response-interception-execution.error";
+export * from "./provider-registration.error";
 export * from "./runtime.error";

package/dist/types/errors/event-dispatcher-no-event-handlers.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { Event } from "../models/event";
+/**
+ * This Error is thrown when there are not event handlers that support this event.
+ */
+export declare class EventDispatcherNoEventHandlersError extends LoggableError {
+    constructor(message: string, event: Event<any>);
+}

package/dist/types/errors/event-dispatching.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { Event } from "../models/event";
+/**
+ * This Error is thrown when there's an error when dispatching an event.
+ */
+export declare class EventDispatchingError extends LoggableError {
+    constructor(message: string, originalError: Error, event: Event<any>);
+}

package/dist/types/errors/event-mapping.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { ExecutionContextInterface } from "../interfaces/execution-context.interface";
+/**
+ * This Error is thrown when there's an error while Mapping an Event in the EventPipeline
+ */
+export declare class EventMappingError extends LoggableError {
+    constructor(message: string, event: object, interceptedEvent: object, executionContext: ExecutionContextInterface<any>, originalError?: Error);
+}

package/dist/types/errors/event-post-mapping-interception.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { Event } from "../models/event";
+/**
+ * This Error is thrown when there's an error when executing any event post mapping interceptors.
+ */
+export declare class EventPostMappingInterceptionError extends LoggableError {
+    constructor(message: string, originalError: Error, interceptorName: string, event: Event<any>);
+}

package/dist/types/errors/event-post-response-mapping-interception.error.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "@pristine-ts/common";
+/**
+ * This Error is thrown when there's an error when executing any event pre mapping interceptors.
+ */
+export declare class EventPostResponseMappingInterceptionError extends LoggableError {
+    constructor(message: string, originalError: Error, interceptorName: string, eventResponse: object);
+}

package/dist/types/errors/event-pre-mapping-interception.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { ExecutionContextInterface } from "../interfaces/execution-context.interface";
+/**
+ * This Error is thrown when there's an error when executing any event pre mapping interceptors.
+ */
+export declare class EventPreMappingInterceptionError extends LoggableError {
+    constructor(message: string, originalError: Error, interceptorName: string, event: object, executionContext: ExecutionContextInterface<any>);
+}

package/dist/types/errors/event-pre-response-mapping-interception.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { EventResponse } from "../models/event.response";
+/**
+ * This Error is thrown when there's an error when executing any event pre mapping interceptors.
+ */
+export declare class EventPreResponseMappingInterceptionError extends LoggableError {
+    constructor(message: string, originalError: Error, interceptorName: string, eventResponse: EventResponse<any, any>);
+}

package/dist/types/handlers/default-event.handler.d.ts

@@ -0,0 +1,7 @@
+import { EventHandlerInterface } from "../interfaces/event-handler.interface";
+import { Event } from "../models/event";
+import { EventResponse } from "../models/event.response";
+export declare class DefaultEventHandler implements EventHandlerInterface<any, any> {
+    handle(event: Event<any>): Promise<EventResponse<any, any>>;
+    supports<T>(event: Event<T>): boolean;
+}

package/dist/types/handlers/handlers.d.ts

@@ -0,0 +1 @@
+export * from "./default-event.handler";

package/dist/types/interceptors/event-logging.interceptor.d.ts

@@ -1,6 +1,8 @@
 import { EventInterceptorInterface } from "../interfaces/event-interceptor.interface";
-import { Event } from "@pristine-ts/event";
 import { LogHandlerInterface } from "@pristine-ts/logging";
+import { Event } from "../models/event";
+import { ExecutionContextInterface } from "../interfaces/execution-context.interface";
+import { EventResponse } from "../models/event.response";
 /**
  * This class is an interceptor to log the events. It is module scoped to Core module.
  * It is tagged as an EventInterceptor so it can be automatically injected with the all the other EventInterceptors.
@@ -8,14 +10,8 @@ import { LogHandlerInterface } from "@pristine-ts/logging";
 export declare class EventLoggingInterceptor implements EventInterceptorInterface {
     private readonly logHandler;
     constructor(logHandler: LogHandlerInterface);
-    /**
-     * This method intercepts an event and logs it.
-     * @param event
-     */
-    interceptEvent(event: Event<any>): Promise<Event<any>>;
-    /**
-     * This method intercepts a raw event and logs it.
-     * @param event
-     */
-    interceptRawEvent(event: any): Promise<any>;
+    preMappingIntercept(event: object, executionContextInterface: ExecutionContextInterface<any>): Promise<object>;
+    postMappingIntercept(event: Event<any>): Promise<Event<any>>;
+    preResponseMappingIntercept(eventResponse: EventResponse<any, any>): Promise<EventResponse<any, any>>;
+    postResponseMappingIntercept(eventResponse: object): Promise<object>;
 }

package/dist/types/interceptors/interceptors.d.ts

@@ -1,3 +1 @@
 export * from "./event-logging.interceptor";
-export * from "./request-body-converter.interceptor";
-export * from "./request-logging.interceptor";

package/dist/types/interfaces/event-dispatcher.interface.d.ts

@@ -0,0 +1,5 @@
+import { Event } from "../models/event";
+import { EventResponse } from "../models/event.response";
+export interface EventDispatcherInterface {
+    dispatch(event: Event<any>): Promise<EventResponse<any, any>>;
+}

package/dist/types/interfaces/event-handler.interface.d.ts

@@ -0,0 +1,23 @@
+import { Event } from "../models/event";
+import { EventResponse } from "../models/event.response";
+/**
+ * The Event Listener Interface defines the methods that an Event Listener must implement.
+ */
+export interface EventHandlerInterface<EventPayload, EventResponsePayload> {
+    /**
+     * This property represents the priority (highest number has the highest priority). Use this to specify
+     * which listener will be called the first one.
+     */
+    priority?: number;
+    /**
+     * This method receives an event and returns whether or not the event listener supports that type of event.
+     * This should always be called before calling handle.
+     * @param event
+     */
+    supports<T>(event: Event<T>): boolean;
+    /**
+     * This method receives an event and handles it and returns an EventResponse.
+     * @param event
+     */
+    handle(event: Event<EventPayload>): Promise<EventResponse<EventPayload, EventResponsePayload>>;
+}

package/dist/types/interfaces/event-interceptor.interface.d.ts

@@ -1,4 +1,6 @@
-import { Event } from "@pristine-ts/event";
+import { ExecutionContextInterface } from "./execution-context.interface";
+import { EventResponse } from "../models/event.response";
+import { Event } from "../models/event";
 /**
  * The Event Interceptor Interface defines the methods that an Event Interceptor must implement. This
  * interceptor is called before the event is being dispatched to the event listeners.
@@ -11,8 +13,9 @@ export interface EventInterceptorInterface {
      * If you force to never resolve the promise, the execution will stall. Be careful.
      *
      * @param event
+     * @param executionContextInterface
      */
-    interceptRawEvent(event: any): Promise<any>;
+    preMappingIntercept?(event: object, executionContextInterface: ExecutionContextInterface<any>): Promise<object>;
     /**
      * This method receives an event object and must return a transformed event object. If you don't want to
      * manipulate the event object (when logging for example), juste resolve a promise with the event passed to this method.
@@ -21,5 +24,21 @@ export interface EventInterceptorInterface {
      *
      * @param event
      */
-    interceptEvent(event: Event<any>): Promise<Event<any>>;
+    postMappingIntercept?(event: Event<any>): Promise<Event<any>>;
+    /**
+     * This method receives the EventResponse returned by the EventDispatcher before it is being reverse mapped by the EventMappers.
+     *
+     * If you force to never resolve the promise, the execution will stall. Be careful.
+     *
+     * @param eventResponse
+     */
+    preResponseMappingIntercept?(eventResponse: EventResponse<any, any>): Promise<EventResponse<any, any>>;
+    /**
+     * This method receives the reverse mapped EventResponse returned by the EventMappers, but before they are leaving Pristine entirely.
+     *
+     * If you force to never resolve the promise, the execution will stall. Be careful.
+     *
+     * @param eventResponse
+     */
+    postResponseMappingIntercept?(eventResponse: object): Promise<object>;
 }

package/dist/types/interfaces/event-listener.interface.d.ts

@@ -0,0 +1,17 @@
+import { Event } from "../models/event";
+/**
+ * The Event Listener Interface defines the methods that an Event Listener must implement.
+ */
+export interface EventListenerInterface {
+    /**
+     * This method receives an event and returns whether or not the event listener supports that type of event.
+     * This should always be called before calling handle.
+     * @param event
+     */
+    supports<T>(event: Event<T>): boolean;
+    /**
+     * This method receives an event and does something with it.
+     * @param event
+     */
+    execute<EventPayload>(event: Event<EventPayload>): Promise<void>;
+}

package/dist/types/interfaces/event-mapper.interface.d.ts

@@ -0,0 +1,9 @@
+import { ExecutionContextInterface } from "./execution-context.interface";
+import { EventResponse } from "../models/event.response";
+import { EventsExecutionOptionsInterface } from "./events-execution-options.interface";
+export interface EventMapperInterface<EventPayload, EventResponsePayload> {
+    supportsMapping(rawEvent: any, executionContext: ExecutionContextInterface<any>): boolean;
+    map(rawEvent: any, executionContext: ExecutionContextInterface<any>): EventsExecutionOptionsInterface<EventPayload>;
+    supportsReverseMapping(eventResponse: EventResponse<EventPayload, EventResponsePayload>, response: any, executionContext: ExecutionContextInterface<any>): boolean;
+    reverseMap(eventResponse: EventResponse<EventPayload, EventResponsePayload>, response: any, executionContext: ExecutionContextInterface<any>): any;
+}

package/dist/types/interfaces/events-execution-options.interface.d.ts

@@ -0,0 +1,5 @@
+import { Event } from "../models/event";
+export interface EventsExecutionOptionsInterface<T> {
+    events: Event<T>[];
+    executionOrder: "sequential" | "parallel";
+}