@magek/core 0.0.6 → 0.0.7

package/dist/decorators/schema-migration.d.ts

@@ -1,36 +1,20 @@
-import { Class, AnyClass, Instance } from '@magek/common';
-/**
- * Stage 3 method decorator context
- */
-interface Stage3MethodContext {
-    kind: 'method';
-    name: string | symbol;
-    static: boolean;
-    private: boolean;
-    metadata: Record<string | symbol, unknown>;
-    addInitializer?: (initializer: () => void) => void;
-}
-/**
- * Stage 3 class decorator context
- */
-interface Stage3ClassContext {
-    kind: 'class';
-    name: string | undefined;
-    metadata: Record<string | symbol, unknown>;
-    addInitializer?: (initializer: () => void) => void;
-}
+import { Class, AnyClass } from '@magek/common';
+import { MethodDecoratorContext, ClassDecoratorContext } from './decorator-types';
 /**
  * **NOTE:** Using this decorator for read model migrations is deprecated. Prefer using `@DataMigration` instead.
+ *
+ * Uses TC39 Stage 3 decorators.
  */
-export declare function SchemaMigration(conceptClass: AnyClass): (schemaMigrationClass: AnyClass, context?: Stage3ClassContext) => void;
+export declare function SchemaMigration(conceptClass: AnyClass): (schemaMigrationClass: AnyClass, context: ClassDecoratorContext) => void;
 /**
- * Decorator to tell Magek the version you are migrating to
+ * Decorator to tell Magek the version you are migrating to.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param toVersion
  * @param props
  */
-export declare function ToVersion<TOldSchema, TNewSchema>(toVersion: number, props: {
+export declare function toVersion<TOldSchema, TNewSchema>(toVersion: number, props: {
     fromSchema: Class<TOldSchema>;
     toSchema: Class<TNewSchema>;
-}): (migrationInstanceOrMethod: Instance | Function, propertyNameOrContext: string | Stage3MethodContext, propertyDescriptor?: MigrationMethod<TOldSchema, TNewSchema>) => void;
-type MigrationMethod<TOldSchema, TNewSchema> = TypedPropertyDescriptor<(old: TOldSchema) => Promise<TNewSchema>>;
-export {};
+}): (method: Function, context: MethodDecoratorContext) => void;

package/dist/decorators/schema-migration.js

@@ -1,43 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaMigration = SchemaMigration;
-exports.ToVersion = ToVersion;
+exports.toVersion = toVersion;
 const magek_1 = require("../magek");
 const common_1 = require("@magek/common");
 const migrationMethodsMetadataKey = 'magek:migrationsMethods';
-/**
- * Type guard to detect Stage 3 method decorator context
- */
-function isStage3MethodContext(arg) {
-    return (arg !== null &&
-        typeof arg === 'object' &&
-        'kind' in arg &&
-        arg.kind === 'method' &&
-        'name' in arg);
-}
-/**
- * Type guard to detect Stage 3 class decorator context
- */
-function isStage3ClassContext(arg) {
-    return (arg !== null &&
-        typeof arg === 'object' &&
-        'kind' in arg &&
-        arg.kind === 'class' &&
-        'metadata' in arg);
-}
-// Symbol for storing migration metadata in Stage 3 decorator context.metadata
+// Symbol for storing migration metadata in decorator context.metadata
 const MIGRATIONS_METADATA_KEY = Symbol.for('magek:migrationsMethods');
 /**
  * **NOTE:** Using this decorator for read model migrations is deprecated. Prefer using `@DataMigration` instead.
+ *
+ * Uses TC39 Stage 3 decorators.
  */
 function SchemaMigration(conceptClass) {
     return (schemaMigrationClass, context) => {
         magek_1.Magek.configureCurrentEnv((config) => {
             const conceptMigrations = getConceptMigrations(config, conceptClass);
-            // Get migration methods - for Stage 3, read from context.metadata first
+            // Get migration methods from context.metadata
             let migrationMethodsMetadata;
-            if (isStage3ClassContext(context)) {
-                // Stage 3: read from context.metadata
+            if (context.metadata) {
                 migrationMethodsMetadata =
                     context.metadata[MIGRATIONS_METADATA_KEY] || [];
                 // Update each metadata entry with the actual class reference
@@ -47,11 +28,10 @@ function SchemaMigration(conceptClass) {
                 }));
             }
             else {
-                // Legacy: read from Reflect.getMetadata
-                migrationMethodsMetadata = getMigrationMethods(schemaMigrationClass);
+                migrationMethodsMetadata = [];
             }
             if (!migrationMethodsMetadata || migrationMethodsMetadata.length === 0) {
-                throw new Error('No migration methods found in this class. Define at least one migration and annotate it with @ToVersion()');
+                throw new Error('No migration methods found in this class. Define at least one migration and annotate it with @toVersion()');
             }
             for (const schemaMigrationMetadata of migrationMethodsMetadata) {
                 if (conceptMigrations.has(schemaMigrationMetadata.toVersion)) {
@@ -69,27 +49,21 @@ function getConceptMigrations(config, conceptClass) {
     }
     return config.schemaMigrations[conceptClass.name];
 }
-function getMigrationMethods(migrationClass) {
-    const migrationMethods = (0, common_1.getMetadata)(migrationMethodsMetadataKey, migrationClass);
-    if (!migrationMethods || migrationMethods.length == 0) {
-        throw new Error('No migration methods found in this class. Define at least one migration and annotate it with @ToVersion()');
-    }
-    return migrationMethods;
-}
 /**
- * Decorator to tell Magek the version you are migrating to
+ * Decorator to tell Magek the version you are migrating to.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param toVersion
  * @param props
  */
-function ToVersion(toVersion, props) {
+function toVersion(toVersion, props) {
     if (toVersion <= 1) {
         throw new Error('Migration versions must always be greater than 1');
     }
-    return (migrationInstanceOrMethod, propertyNameOrContext) => {
-        // Detect Stage 3 vs Legacy decorator
-        if (isStage3MethodContext(propertyNameOrContext)) {
-            // Stage 3 decorator - store in context.metadata so @SchemaMigration can read it
-            const context = propertyNameOrContext;
+    return (_method, context) => {
+        // Stage 3 decorator - store in context.metadata so @SchemaMigration can read it
+        if (context.metadata) {
             // Get or initialize the migrations array in context.metadata
             let migrationMethods = context.metadata[MIGRATIONS_METADATA_KEY];
             if (!migrationMethods) {
@@ -104,43 +78,24 @@ function ToVersion(toVersion, props) {
                 fromSchema: props.fromSchema,
                 toSchema: props.toSchema,
             });
-            // Also store in Reflect metadata for the standalone test case
-            if (context.addInitializer) {
-                context.addInitializer(function () {
-                    const migrationClass = context.static ? this : this.constructor;
-                    let reflectMethods = (0, common_1.getMetadata)(migrationMethodsMetadataKey, migrationClass);
-                    if (!reflectMethods) {
-                        reflectMethods = [];
-                    }
-                    reflectMethods.push({
-                        migrationClass,
-                        methodName: context.name.toString(),
-                        toVersion,
-                        fromSchema: props.fromSchema,
-                        toSchema: props.toSchema,
-                    });
-                    (0, common_1.defineMetadata)(migrationMethodsMetadataKey, reflectMethods, migrationClass);
-                });
-            }
         }
-        else {
-            // Legacy decorator
-            const migrationInstance = migrationInstanceOrMethod;
-            const propertyName = propertyNameOrContext;
-            const migrationClass = migrationInstance.constructor;
-            let migrationMethods = (0, common_1.getMetadata)(migrationMethodsMetadataKey, migrationClass);
-            if (!migrationMethods) {
-                migrationMethods = [];
-            }
-            migrationMethods.push({
-                migrationClass,
-                methodName: propertyName,
-                toVersion,
-                fromSchema: props.fromSchema,
-                toSchema: props.toSchema,
+        // Also store in Reflect metadata for standalone usage
+        if (context.addInitializer) {
+            context.addInitializer(function () {
+                const migrationClass = context.static ? this : this.constructor;
+                let reflectMethods = (0, common_1.getMetadata)(migrationMethodsMetadataKey, migrationClass);
+                if (!reflectMethods) {
+                    reflectMethods = [];
+                }
+                reflectMethods.push({
+                    migrationClass,
+                    methodName: context.name.toString(),
+                    toVersion,
+                    fromSchema: props.fromSchema,
+                    toSchema: props.toSchema,
+                });
+                (0, common_1.defineMetadata)(migrationMethodsMetadataKey, reflectMethods, migrationClass);
             });
-            // Here we just store the information (version and method). All the checks will be done in the @Migrates decorator
-            (0, common_1.defineMetadata)(migrationMethodsMetadataKey, migrationMethods, migrationClass);
         }
     };
 }

package/dist/decorators/sequenced-by.d.ts

@@ -1,28 +1,10 @@
-import { Class, ReadModelInterface, AnyClass } from '@magek/common';
-/**
- * Stage 3 field decorator context
- */
-interface Stage3FieldContext {
-    kind: 'field';
-    name: string | symbol;
-    static: boolean;
-    private: boolean;
-    metadata: Record<string | symbol, unknown>;
-    access?: {
-        get: () => unknown;
-        set: (value: unknown) => void;
-    };
-    addInitializer?: (initializer: () => void) => void;
-}
+import { FieldDecoratorContext } from './decorator-types';
+/** Symbol for storing sequence key in decorator context.metadata */
+export declare const SEQUENCE_KEY_SYMBOL: unique symbol;
 /**
  * Decorator to specify the sequencing key for a ReadModel.
- * Can be used as both a parameter decorator and property decorator.
- * Supports both legacy (experimentalDecorators) and Stage 3 decorators.
- */
-export declare function sequencedBy(target: Class<ReadModelInterface> | Object | undefined, propertyKeyOrContext?: string | symbol | Stage3FieldContext, parameterIndex?: number): void;
-/**
- * Transfer sequence key metadata from Stage 3 context to class.
- * Called by the ReadModel class decorator.
+ *
+ * Uses TC39 Stage 3 decorators.
+ * The sequence key is stored in context.metadata and read by @ReadModel.
  */
-export declare function transferSequenceKeyMetadata(classType: AnyClass, contextMetadata: Record<string | symbol, unknown>): void;
-export {};
+export declare function sequencedBy(_value: undefined, context: FieldDecoratorContext): void;

package/dist/decorators/sequenced-by.js

@@ -1,79 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEQUENCE_KEY_SYMBOL = void 0;
 exports.sequencedBy = sequencedBy;
-exports.transferSequenceKeyMetadata = transferSequenceKeyMetadata;
-const magek_1 = require("../magek");
-const metadata_1 = require("./metadata");
-// Symbol for storing sequence key in Stage 3 decorator context.metadata
-const SEQUENCE_KEY_SYMBOL = Symbol.for('magek:sequenceKey');
-/**
- * Type guard to detect Stage 3 field context
- */
-function isStage3FieldContext(arg) {
-    return (arg !== null &&
-        typeof arg === 'object' &&
-        'kind' in arg &&
-        arg.kind === 'field' &&
-        'name' in arg &&
-        'metadata' in arg);
-}
-/**
- * Register sequence key for a class
- */
-function registerSequenceKey(klass, propertyName) {
-    magek_1.Magek.configureCurrentEnv((config) => {
-        if (config.readModelSequenceKeys[klass.name] && config.readModelSequenceKeys[klass.name] !== propertyName) {
-            throw new Error(`Error trying to register a sort key named \`${propertyName}\` for class \`${klass.name}\`. It already had the sort key \`${config.readModelSequenceKeys[klass.name]}\` defined and only one sort key is allowed for each read model.`);
-        }
-        else {
-            config.readModelSequenceKeys[klass.name] = propertyName;
-        }
-    });
-}
+/** Symbol for storing sequence key in decorator context.metadata */
+exports.SEQUENCE_KEY_SYMBOL = Symbol.for('magek:sequenceKey');
 /**
  * Decorator to specify the sequencing key for a ReadModel.
- * Can be used as both a parameter decorator and property decorator.
- * Supports both legacy (experimentalDecorators) and Stage 3 decorators.
- */
-function sequencedBy(target, propertyKeyOrContext, parameterIndex) {
-    // Detect Stage 3 field decorator
-    if (isStage3FieldContext(propertyKeyOrContext)) {
-        const context = propertyKeyOrContext;
-        const propertyName = String(context.name);
-        // Store the sequence key in context.metadata for ReadModel decorator to pick up
-        context.metadata[SEQUENCE_KEY_SYMBOL] = propertyName;
-        // Also use addInitializer to register immediately when class is defined
-        if (context.addInitializer) {
-            context.addInitializer(function () {
-                const klass = this.constructor;
-                registerSequenceKey(klass, propertyName);
-            });
-        }
-        return;
-    }
-    // Legacy decorator handling
-    const propertyKey = propertyKeyOrContext;
-    // Property decorator usage: @sequencedBy on a class property
-    if (propertyKey !== undefined && parameterIndex === undefined) {
-        const klass = target.constructor;
-        const propertyName = String(propertyKey);
-        registerSequenceKey(klass, propertyName);
-    }
-    // Parameter decorator usage: @sequencedBy on constructor parameter
-    else if (parameterIndex !== undefined) {
-        const klass = target;
-        const args = (0, metadata_1.getFunctionArguments)(klass);
-        const propertyName = args[parameterIndex];
-        registerSequenceKey(klass, propertyName);
-    }
-}
-/**
- * Transfer sequence key metadata from Stage 3 context to class.
- * Called by the ReadModel class decorator.
+ *
+ * Uses TC39 Stage 3 decorators.
+ * The sequence key is stored in context.metadata and read by @ReadModel.
  */
-function transferSequenceKeyMetadata(classType, contextMetadata) {
-    const sequenceKey = contextMetadata[SEQUENCE_KEY_SYMBOL];
-    if (sequenceKey) {
-        registerSequenceKey(classType, sequenceKey);
+function sequencedBy(_value, context) {
+    const propertyName = String(context.name);
+    // Store the sequence key in context.metadata for ReadModel decorator to pick up
+    if (context.metadata) {
+        context.metadata[exports.SEQUENCE_KEY_SYMBOL] = propertyName;
     }
 }

package/dist/event-dispatcher.js

@@ -8,30 +8,35 @@ 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));
+let MagekEventDispatcher = (() => {
+    let _staticExtraInitializers = [];
+    let _static_dispatch_decorators;
+    return class MagekEventDispatcher {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _static_dispatch_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.DISPATCH_EVENTS)];
+            tslib_1.__esDecorate(this, null, _static_dispatch_decorators, { kind: "method", name: "dispatch", static: true, private: false, access: { has: obj => "dispatch" in obj, get: obj => obj.dispatch }, 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 dispatching event: ', e);
+        /**
+         * 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.js

@@ -7,119 +7,122 @@ 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 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);
                 }
-                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 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;
                     }
-                    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 common_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 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);
+            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);
+        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);