@magek/core 0.0.6 → 0.0.8

package/dist/event-processor.js

@@ -3,123 +3,127 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagekEventProcessor = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@magek/common");
+const promises_1 = require("./utils/promises");
 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);
+let MagekEventProcessor = (() => {
+    let _staticExtraInitializers = [];
+    let _static_dispatchEntityEventsToEventHandlers_decorators;
+    return class MagekEventProcessor {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _static_dispatchEntityEventsToEventHandlers_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.EVENT_HANDLERS_PROCESS)];
+            tslib_1.__esDecorate(this, null, _static_dispatchEntityEventsToEventHandlers_decorators, { kind: "method", name: "dispatchEntityEventsToEventHandlers", static: true, private: false, access: { has: obj => "dispatchEntityEventsToEventHandlers" in obj, get: obj => obj.dispatchEntityEventsToEventHandlers }, metadata: _metadata }, null, _staticExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            tslib_1.__runInitializers(this, _staticExtraInitializers);
         }
-        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);
+        /**
+         * 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));
                 }
-                if (!eventHandlers || eventHandlers.length == 0) {
-                    logger.debug(`No event-handlers found for event ${eventEnvelope.typeName}. Skipping...`);
-                    return;
+                await promises_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);
                 }
-                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);
-                        }));
+                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 promises_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;
                     }
-                    catch (error) {
-                        if (error instanceof common_1.PromisesError) {
-                            logger.error(`Failed to process handlers for event ${eventEnvelope.typeName}:`, error.failedReasons);
+                    const eventInstance = this.getEventInstance(config, eventEnvelope);
+                    if (eventHandlers && eventHandlers.length > 0) {
+                        try {
+                            await promises_1.Promises.allSettledAndFulfilled(eventHandlers.map(async (eventHandler) => {
+                                logger.debug('Calling "handle" method on event handler: ', eventHandler);
+                                await this.callEventHandler(eventHandler, eventInstance, eventEnvelope, config);
+                            }));
                         }
-                        else {
-                            logger.error(`Unexpected error processing handlers for event ${eventEnvelope.typeName}:`, error);
+                        catch (error) {
+                            if (error instanceof promises_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);
+            catch (error) {
+                if (error instanceof promises_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);
+        static getEventInstance(config, eventEnvelope) {
+            const eventClass = config.events[eventEnvelope.typeName] ?? config.notifications[eventEnvelope.typeName];
+            return (0, common_1.createInstance)(eventClass.class, eventEnvelope.value);
         }
-        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;
+        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);
         }
-        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-stream-consumer.js

@@ -11,26 +11,31 @@ 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));
+let MagekEventStreamConsumer = (() => {
+    let _staticExtraInitializers = [];
+    let _static_consume_decorators;
+    return class MagekEventStreamConsumer {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _static_consume_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.CONSUME_STREAM_EVENTS)];
+            tslib_1.__esDecorate(this, null, _static_consume_decorators, { kind: "method", name: "consume", static: true, private: false, access: { has: obj => "consume" in obj, get: obj => obj.consume }, metadata: _metadata }, null, _staticExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            tslib_1.__runInitializers(this, _staticExtraInitializers);
         }
-        catch (e) {
-            logger.error('Unhandled error while consuming event: ', e);
+        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.js

@@ -8,23 +8,28 @@ 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);
+let MagekEventStreamProducer = (() => {
+    let _staticExtraInitializers = [];
+    let _static_produce_decorators;
+    return class MagekEventStreamProducer {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _static_produce_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.PRODUCE_STREAM_EVENTS)];
+            tslib_1.__esDecorate(this, null, _static_produce_decorators, { kind: "method", name: "produce", static: true, private: false, access: { has: obj => "produce" in obj, get: obj => obj.produce }, metadata: _metadata }, null, _staticExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            tslib_1.__runInitializers(this, _staticExtraInitializers);
         }
-        catch (e) {
-            logger.error('Unhandled error while producing events: ', e);
+        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.js

@@ -4,6 +4,7 @@ exports.MagekEventsReader = void 0;
 const common_1 = require("@magek/common");
 const magek_1 = require("./magek");
 class MagekEventsReader {
+    config;
     constructor(config) {
         this.config = config;
     }

package/dist/global-error-dispatcher.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagekGlobalErrorDispatcher = void 0;
 const common_1 = require("@magek/common");
 class MagekGlobalErrorDispatcher {
+    config;
+    errorHandler;
     constructor(config) {
-        var _a;
         this.config = config;
-        this.errorHandler = (_a = this.config.globalErrorsHandler) === null || _a === void 0 ? void 0 : _a.class;
+        this.errorHandler = this.config.globalErrorsHandler?.class;
     }
     async dispatch(error) {
         const logger = (0, common_1.getLogger)(this.config, 'MagekGlobalErrorDispatcher#dispatch');