@magek/core 0.0.1

package/dist/delete-event-dispatcher.d.ts

@@ -0,0 +1,4 @@
+import { MagekConfig, EventDeleteParameters } from '@magek/common';
+export declare class MagekDeleteEventDispatcher {
+    static deleteEvent(config: MagekConfig, parameters: EventDeleteParameters): Promise<boolean>;
+}

package/dist/delete-event-dispatcher.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDeleteEventDispatcher = void 0;
+const read_model_store_1 = require("./services/read-model-store");
+class MagekDeleteEventDispatcher {
+    static async deleteEvent(config, parameters) {
+        const readModelStore = new read_model_store_1.ReadModelStore(config);
+        const events = await config.eventStore.findDeletableEvent(config, parameters);
+        if (!events || events.length === 0) {
+            return false;
+        }
+        for (const event of events) {
+            const snapshots = await config.eventStore.findDeletableSnapshot(config, event);
+            for (const snapshot of snapshots) {
+                await readModelStore.project(snapshot, true);
+            }
+            await config.eventStore.deleteSnapshot(config, snapshots);
+        }
+        await config.eventStore.deleteEvent(config, events);
+        return true;
+    }
+}
+exports.MagekDeleteEventDispatcher = MagekDeleteEventDispatcher;

package/dist/event-dispatcher.d.ts

@@ -0,0 +1,9 @@
+import { MagekConfig } from '@magek/common';
+export declare class MagekEventDispatcher {
+    /**
+     * Entry point to dispatch events.
+     * @param rawEvents List of raw events
+     * @param config
+     */
+    static dispatch(rawEvents: unknown, config: MagekConfig): Promise<void>;
+}

package/dist/event-dispatcher.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEventDispatcher = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const event_store_1 = require("./services/event-store");
+const raw_events_parser_1 = require("./services/raw-events-parser");
+const read_model_store_1 = require("./services/read-model-store");
+const instrumentation_1 = require("./instrumentation");
+const event_processor_1 = require("./event-processor");
+class MagekEventDispatcher {
+    /**
+     * Entry point to dispatch events.
+     * @param rawEvents List of raw events
+     * @param config
+     */
+    static async dispatch(rawEvents, config) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventDispatcher#dispatch');
+        const eventStore = new event_store_1.EventStore(config);
+        const readModelStore = new read_model_store_1.ReadModelStore(config);
+        logger.debug('Event workflow started for raw events:', require('util').inspect(rawEvents, false, null, false));
+        try {
+            const eventEnvelopes = config.eventStore.rawToEnvelopes(rawEvents);
+            await raw_events_parser_1.RawEventsParser.streamPerEntityEvents(config, eventEnvelopes, event_processor_1.MagekEventProcessor.eventProcessor(eventStore, readModelStore));
+        }
+        catch (e) {
+            logger.error('Unhandled error while dispatching event: ', e);
+        }
+    }
+}
+exports.MagekEventDispatcher = MagekEventDispatcher;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.DISPATCH_EVENTS),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, common_1.MagekConfig]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekEventDispatcher, "dispatch", null);

package/dist/event-processor.d.ts

@@ -0,0 +1,15 @@
+import { EventStore } from './services/event-store';
+import { EventsStreamingCallback } from './services/raw-events-parser';
+import { ReadModelStore } from './services/read-model-store';
+export declare class MagekEventProcessor {
+    /**
+     * Function that will be called once for each entity from the `RawEventsParser.streamPerEntityEvents` method
+     * after the page of events is grouped by entity.
+     */
+    static eventProcessor(eventStore: EventStore, readModelStore: ReadModelStore): EventsStreamingCallback;
+    private static filterDispatched;
+    private static snapshotAndUpdateReadModels;
+    private static dispatchEntityEventsToEventHandlers;
+    private static getEventInstance;
+    private static callEventHandler;
+}

package/dist/event-processor.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEventProcessor = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const register_handler_1 = require("./register-handler");
+const global_error_dispatcher_1 = require("./global-error-dispatcher");
+const instrumentation_1 = require("./instrumentation");
+const decorators_1 = require("./decorators");
+class MagekEventProcessor {
+    /**
+     * Function that will be called once for each entity from the `RawEventsParser.streamPerEntityEvents` method
+     * after the page of events is grouped by entity.
+     */
+    static eventProcessor(eventStore, readModelStore) {
+        return async (entityName, entityID, eventEnvelopes, config) => {
+            // Filter events that have already been dispatched
+            const eventsNotDispatched = await MagekEventProcessor.filterDispatched(config, eventEnvelopes, eventStore);
+            const eventEnvelopesProcessors = [
+                MagekEventProcessor.dispatchEntityEventsToEventHandlers(eventsNotDispatched, config),
+            ];
+            // Read models are not updated for notification events (events that are not related to an entity but a topic)
+            if (!(entityName in config.topicToEvent)) {
+                eventEnvelopesProcessors.push(MagekEventProcessor.snapshotAndUpdateReadModels(config, entityName, entityID, eventStore, readModelStore));
+            }
+            await common_1.Promises.allSettledAndFulfilled(eventEnvelopesProcessors);
+        };
+    }
+    static async filterDispatched(config, eventEnvelopes, eventStore) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventDispatcher#filterDispatched');
+        const filteredResults = await Promise.all(eventEnvelopes.map(async (eventEnvelope) => {
+            const result = await eventStore.storeDispatchedEvent(eventEnvelope);
+            if (!result) {
+                logger.warn('Event has already been dispatched. Skipping.', eventEnvelope);
+            }
+            return result;
+        }));
+        return eventEnvelopes.filter((_, index) => filteredResults[index]);
+    }
+    static async snapshotAndUpdateReadModels(config, entityName, entityID, eventStore, readModelStore) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventDispatcher#snapshotAndUpdateReadModels');
+        let entitySnapshot = undefined;
+        try {
+            entitySnapshot = await eventStore.fetchEntitySnapshot(entityName, entityID);
+        }
+        catch (e) {
+            logger.error('Error while fetching or reducing entity snapshot:', e);
+        }
+        if (!entitySnapshot) {
+            logger.debug('No new snapshot generated, skipping read models projection');
+            return;
+        }
+        logger.debug('Snapshot loaded and started read models projection:', entitySnapshot);
+        await readModelStore.project(entitySnapshot);
+    }
+    static async dispatchEntityEventsToEventHandlers(entityEventEnvelopes, config) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventDispatcher.dispatchEntityEventsToEventHandlers');
+        try {
+            await common_1.Promises.allSettledAndFulfilled(entityEventEnvelopes.map(async (eventEnvelope) => {
+                let eventHandlers = config.eventHandlers[eventEnvelope.typeName] || [];
+                const globalEventHandler = config.eventHandlers[decorators_1.GLOBAL_EVENT_HANDLERS];
+                if (globalEventHandler && globalEventHandler.length > 0) {
+                    eventHandlers = eventHandlers.concat(globalEventHandler);
+                }
+                if (!eventHandlers || eventHandlers.length == 0) {
+                    logger.debug(`No event-handlers found for event ${eventEnvelope.typeName}. Skipping...`);
+                    return;
+                }
+                const eventInstance = this.getEventInstance(config, eventEnvelope);
+                if (eventHandlers && eventHandlers.length > 0) {
+                    try {
+                        await common_1.Promises.allSettledAndFulfilled(eventHandlers.map(async (eventHandler) => {
+                            logger.debug('Calling "handle" method on event handler: ', eventHandler);
+                            await this.callEventHandler(eventHandler, eventInstance, eventEnvelope, config);
+                        }));
+                    }
+                    catch (error) {
+                        if (error instanceof common_1.PromisesError) {
+                            logger.error(`Failed to process handlers for event ${eventEnvelope.typeName}:`, error.failedReasons);
+                        }
+                        else {
+                            logger.error(`Unexpected error processing handlers for event ${eventEnvelope.typeName}:`, error);
+                        }
+                    }
+                }
+            }));
+        }
+        catch (error) {
+            if (error instanceof common_1.PromisesError) {
+                logger.error('Failed to process events:', error.failedReasons);
+            }
+            else {
+                logger.error('Unexpected error processing events:', error);
+            }
+        }
+    }
+    static getEventInstance(config, eventEnvelope) {
+        var _a;
+        const eventClass = (_a = config.events[eventEnvelope.typeName]) !== null && _a !== void 0 ? _a : config.notifications[eventEnvelope.typeName];
+        return (0, common_1.createInstance)(eventClass.class, eventEnvelope.value);
+    }
+    static async callEventHandler(eventHandler, eventInstance, eventEnvelope, config) {
+        const register = new common_1.Register(eventEnvelope.requestID, {}, register_handler_1.RegisterHandler.flush, eventEnvelope.currentUser);
+        try {
+            const logger = (0, common_1.getLogger)(config, 'MagekEventProcessor#handleEvent');
+            logger.debug('Calling "handle" method on event handler: ', eventHandler);
+            await eventHandler.handle(eventInstance, register);
+        }
+        catch (e) {
+            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(config);
+            const error = await globalErrorDispatcher.dispatch(new common_1.EventHandlerGlobalError(eventEnvelope, eventInstance, e.eventHandlerMetadata, e));
+            if (error)
+                throw error;
+        }
+        await register_handler_1.RegisterHandler.handle(config, register);
+    }
+}
+exports.MagekEventProcessor = MagekEventProcessor;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.EVENT_HANDLERS_PROCESS),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Array,
+        common_1.MagekConfig]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekEventProcessor, "dispatchEntityEventsToEventHandlers", null);

package/dist/event-search.d.ts

@@ -0,0 +1,2 @@
+import { MagekConfig, EventSearchParameters, EventSearchResponse } from '@magek/common';
+export declare function eventSearch(config: MagekConfig, request: EventSearchParameters): Promise<Array<EventSearchResponse>>;

package/dist/event-search.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventSearch = eventSearch;
+const common_1 = require("@magek/common");
+async function eventSearch(config, request) {
+    const events = await config.eventStore.search(config, request);
+    return events.map((event) => createEventValueInstance(config, event));
+}
+function createEventValueInstance(config, event) {
+    const logger = (0, common_1.getLogger)(config, 'magek-event-search#createEventValueInstance');
+    const eventMetadata = config.events[event.type];
+    if (eventMetadata) {
+        event.value = (0, common_1.createInstance)(eventMetadata.class, event.value);
+        logger.debug(`Found @Event for "${event.type}". Created value instance`);
+        return event;
+    }
+    const notificationMetadata = config.notifications[event.type];
+    if (notificationMetadata) {
+        event.value = (0, common_1.createInstance)(notificationMetadata.class, event.value);
+        logger.debug(`Found @Notification for "${event.type}"`);
+    }
+    else {
+        logger.warn(`Could not find @Event or @Notification class for "${event.type}". Returned the event as it was`);
+    }
+    return event;
+}

package/dist/event-stream-consumer.d.ts

@@ -0,0 +1,7 @@
+import { MagekConfig } from '@magek/common';
+/**
+ * This class consumes events from the event stream and dispatches them to the event handlers
+ */
+export declare class MagekEventStreamConsumer {
+    static consume(rawEvents: unknown, config: MagekConfig): Promise<void>;
+}

package/dist/event-stream-consumer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEventStreamConsumer = void 0;
+const tslib_1 = require("tslib");
+const instrumentation_1 = require("./instrumentation");
+const common_1 = require("@magek/common");
+const event_store_1 = require("./services/event-store");
+const read_model_store_1 = require("./services/read-model-store");
+const raw_events_parser_1 = require("./services/raw-events-parser");
+const event_processor_1 = require("./event-processor");
+/**
+ * This class consumes events from the event stream and dispatches them to the event handlers
+ */
+class MagekEventStreamConsumer {
+    static async consume(rawEvents, config) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventDispatcher#dispatch');
+        const eventStore = new event_store_1.EventStore(config);
+        const readModelStore = new read_model_store_1.ReadModelStore(config);
+        logger.debug('Stream event workflow started for raw events:', require('util').inspect(rawEvents, false, null, false));
+        try {
+            const dedupEvents = await config.eventStore.dedupEventStream(config, rawEvents);
+            const eventEnvelopes = config.eventStore.rawStreamToEnvelopes(config, rawEvents, dedupEvents);
+            await raw_events_parser_1.RawEventsParser.streamPerEntityEvents(config, eventEnvelopes, event_processor_1.MagekEventProcessor.eventProcessor(eventStore, readModelStore));
+        }
+        catch (e) {
+            logger.error('Unhandled error while consuming event: ', e);
+        }
+    }
+}
+exports.MagekEventStreamConsumer = MagekEventStreamConsumer;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.CONSUME_STREAM_EVENTS),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, common_1.MagekConfig]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekEventStreamConsumer, "consume", null);

package/dist/event-stream-producer.d.ts

@@ -0,0 +1,7 @@
+import { MagekConfig } from '@magek/common';
+/**
+ * Produces events to the event stream
+ */
+export declare class MagekEventStreamProducer {
+    static produce(request: unknown, config: MagekConfig): Promise<void>;
+}

package/dist/event-stream-producer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEventStreamProducer = void 0;
+const tslib_1 = require("tslib");
+const instrumentation_1 = require("./instrumentation");
+const common_1 = require("@magek/common");
+const raw_events_parser_1 = require("./services/raw-events-parser");
+/**
+ * Produces events to the event stream
+ */
+class MagekEventStreamProducer {
+    static async produce(request, config) {
+        const logger = (0, common_1.getLogger)(config, 'MagekEventStreamProducer#produce');
+        logger.debug('Produce event workflow started for request:', require('util').inspect(request, false, null, false));
+        try {
+            const eventEnvelopes = config.eventStore.rawToEnvelopes(request);
+            await raw_events_parser_1.RawEventsParser.streamPerEntityEvents(config, eventEnvelopes, config.eventStore.produce);
+        }
+        catch (e) {
+            logger.error('Unhandled error while producing events: ', e);
+        }
+    }
+}
+exports.MagekEventStreamProducer = MagekEventStreamProducer;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.PRODUCE_STREAM_EVENTS),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, common_1.MagekConfig]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekEventStreamProducer, "produce", null);

package/dist/events-reader.d.ts

@@ -0,0 +1,11 @@
+import { EventSearchRequest, MagekConfig, EventSearchResponse } from '@magek/common';
+export declare class MagekEventsReader {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    fetch(eventRequest: EventSearchRequest): Promise<Array<EventSearchResponse>>;
+    private validateRequest;
+    private entityMetadataFromRequest;
+    private entityMetadataFromEntityName;
+    private entityMetadataFromEventName;
+    private processFetch;
+}

package/dist/events-reader.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEventsReader = void 0;
+const common_1 = require("@magek/common");
+const magek_1 = require("./magek");
+class MagekEventsReader {
+    constructor(config) {
+        this.config = config;
+    }
+    async fetch(eventRequest) {
+        await this.validateRequest(eventRequest);
+        return this.processFetch(eventRequest);
+    }
+    async validateRequest(eventRequest) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekEventsReader#validateRequest');
+        logger.debug('Validating the following event request: ', eventRequest);
+        const entityMetadata = this.entityMetadataFromRequest(eventRequest);
+        await entityMetadata.eventStreamAuthorizer(eventRequest.currentUser, eventRequest);
+    }
+    entityMetadataFromRequest(eventRequest) {
+        const { parameters } = eventRequest;
+        if (!isByEntitySearch(parameters) && !isByEventTypeSearch(parameters)) {
+            throw new common_1.InvalidParameterError('Invalid event search request. It should contain either "type" or "entity" field, but it included none');
+        }
+        if (isByEntitySearch(parameters) && isByEventTypeSearch(parameters)) {
+            throw new common_1.InvalidParameterError('Invalid event search request. It should contain either "type" or "entity" field, but it included both');
+        }
+        if (isByEntitySearch(parameters)) {
+            return this.entityMetadataFromEntityName(parameters.entity);
+        }
+        if (isByEventTypeSearch(parameters)) {
+            return this.entityMetadataFromEventName(parameters.type);
+        }
+        // We would never reach this point
+        throw new common_1.InvalidParameterError('Could not determine event search kind');
+    }
+    entityMetadataFromEntityName(entityName) {
+        const entityMetadata = this.config.entities[entityName];
+        if (!entityMetadata) {
+            throw new common_1.NotFoundError(`Could not find entity metadata for "${entityName}"`);
+        }
+        return entityMetadata;
+    }
+    entityMetadataFromEventName(eventName) {
+        // All the events must be reduced by an entity, so we can get the associated entity from the
+        // reducers
+        const reducerMetadata = this.config.reducers[eventName];
+        if (!reducerMetadata) {
+            throw new common_1.NotFoundError(`Could not find the entity associated to event type "${eventName}"`);
+        }
+        return this.entityMetadataFromEntityName(reducerMetadata.class.name);
+    }
+    async processFetch(eventRequest) {
+        return magek_1.Magek.events(eventRequest.parameters);
+    }
+}
+exports.MagekEventsReader = MagekEventsReader;
+function isByEntitySearch(parameters) {
+    return 'entity' in parameters;
+}
+function isByEventTypeSearch(parameters) {
+    return 'type' in parameters;
+}

package/dist/global-error-dispatcher.d.ts

@@ -0,0 +1,16 @@
+import { MagekConfig, GlobalErrorHandlerInterface, GlobalErrorContainer } from '@magek/common';
+export declare class MagekGlobalErrorDispatcher {
+    readonly config: MagekConfig;
+    readonly errorHandler: GlobalErrorHandlerInterface | undefined;
+    constructor(config: MagekConfig);
+    dispatch(error: GlobalErrorContainer): Promise<Error | undefined>;
+    private handleCommandError;
+    private handleQueryError;
+    private handleScheduleError;
+    private handleEventHandlerError;
+    private handleReducerError;
+    private handleProjectionError;
+    private handleSnapshotPersistError;
+    private handleEventError;
+    private handleGenericError;
+}

package/dist/global-error-dispatcher.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekGlobalErrorDispatcher = void 0;
+const common_1 = require("@magek/common");
+class MagekGlobalErrorDispatcher {
+    constructor(config) {
+        var _a;
+        this.config = config;
+        this.errorHandler = (_a = this.config.globalErrorsHandler) === null || _a === void 0 ? void 0 : _a.class;
+    }
+    async dispatch(error) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGlobalErrorDispatcher#dispatch');
+        if (!this.errorHandler)
+            return error.originalError;
+        let newError = error.originalError;
+        try {
+            switch (error.constructor) {
+                case common_1.CommandHandlerGlobalError:
+                    newError = await this.handleCommandError(error);
+                    break;
+                case common_1.QueryHandlerGlobalError:
+                    newError = await this.handleQueryError(error);
+                    break;
+                case common_1.ScheduleCommandGlobalError:
+                    newError = await this.handleScheduleError(error);
+                    break;
+                case common_1.EventHandlerGlobalError:
+                    newError = await this.handleEventHandlerError(error);
+                    break;
+                case common_1.ReducerGlobalError:
+                    newError = await this.handleReducerError(error);
+                    break;
+                case common_1.ProjectionGlobalError:
+                    newError = await this.handleProjectionError(error);
+                    break;
+                case common_1.SnapshotPersistHandlerGlobalError:
+                    newError = await this.handleSnapshotPersistError(error);
+                    break;
+                case common_1.EventGlobalError:
+                    newError = await this.handleEventError(error);
+                    break;
+            }
+            newError = await this.handleGenericError(newError);
+        }
+        catch (e) {
+            logger.error(`Unhandled error inside the global error handler. When handling error ${error.originalError}`, e);
+            return e;
+        }
+        if (newError)
+            return newError;
+        return undefined;
+    }
+    async handleCommandError(error) {
+        if (!this.errorHandler || !this.errorHandler.onCommandHandlerError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onCommandHandlerError(currentError.originalError, currentError.commandEnvelope, currentError.commandMetadata);
+    }
+    async handleQueryError(error) {
+        if (!this.errorHandler || !this.errorHandler.onQueryHandlerError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onQueryHandlerError(currentError.originalError, currentError.query);
+    }
+    async handleScheduleError(error) {
+        if (!this.errorHandler || !this.errorHandler.onScheduledCommandHandlerError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onScheduledCommandHandlerError(currentError.originalError, currentError.scheduleCommandEnvelope, currentError.scheduleCommandMetadata);
+    }
+    async handleEventHandlerError(error) {
+        if (!this.errorHandler || !this.errorHandler.onDispatchEventHandlerError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onDispatchEventHandlerError(currentError.originalError, currentError.eventEnvelope, currentError.eventHandlerMetadata, currentError.eventInstance);
+    }
+    async handleReducerError(error) {
+        if (!this.errorHandler || !this.errorHandler.onReducerError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onReducerError(currentError.originalError, currentError.eventEnvelope, currentError.reducerMetadata, currentError.eventInstance, currentError.snapshotInstance);
+    }
+    async handleProjectionError(error) {
+        if (!this.errorHandler || !this.errorHandler.onProjectionError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onProjectionError(currentError.originalError, currentError.entityEnvelope, currentError.projectionMetadata, currentError.entity, currentError.readModel);
+    }
+    async handleSnapshotPersistError(error) {
+        if (!this.errorHandler || !this.errorHandler.onSnapshotPersistError)
+            throw error.originalError;
+        const currentError = error;
+        return this.errorHandler.onSnapshotPersistError(currentError.originalError, currentError.snapshot);
+    }
+    async handleEventError(error) {
+        if (!this.errorHandler || !this.errorHandler.onEventError)
+            throw error.originalError;
+        const currentError = error;
+        return await this.errorHandler.onEventError(currentError.originalError, currentError.eventEnvelope);
+    }
+    async handleGenericError(error) {
+        if (!error)
+            return undefined;
+        if (!this.errorHandler || !this.errorHandler.onError)
+            throw error;
+        return await this.errorHandler.onError(error);
+    }
+}
+exports.MagekGlobalErrorDispatcher = MagekGlobalErrorDispatcher;

package/dist/graphql-dispatcher.d.ts

@@ -0,0 +1,16 @@
+import { MagekConfig } from '@magek/common';
+export declare class MagekGraphQLDispatcher {
+    private config;
+    private readonly graphQLSchema;
+    private readonly websocketHandler;
+    private readonly readModelDispatcher;
+    private readonly tokenVerifier;
+    constructor(config: MagekConfig);
+    dispatch(request: unknown): Promise<unknown>;
+    private verifyTokenFromEnvelope;
+    private handleMessage;
+    private runGraphQLOperation;
+    private handleQueryOrMutation;
+    private handleSubscription;
+    private handleDisconnect;
+}