@magek/core 0.0.6 → 0.0.8

package/dist/decorators/returns.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURNS_METADATA_KEY = void 0;
+exports.getReturnTypeMetadata = getReturnTypeMetadata;
+exports.returns = returns;
+/** Symbol used to store return type metadata in decorator context.metadata */
+exports.RETURNS_METADATA_KEY = Symbol.for('magek:returns');
+/**
+ * Analyze a type and convert it to TypeMetadata for return types.
+ * This returns the GraphQL-compatible type directly (not wrapped in Promise).
+ */
+function analyzeReturnType(targetType) {
+    // Handle primitives
+    if (targetType === String) {
+        return {
+            name: 'string',
+            typeGroup: 'String',
+            typeName: 'String',
+            parameters: [],
+            isNullable: false,
+            isGetAccessor: false,
+            type: String,
+        };
+    }
+    if (targetType === Number) {
+        return {
+            name: 'number',
+            typeGroup: 'Number',
+            typeName: 'Number',
+            parameters: [],
+            isNullable: false,
+            isGetAccessor: false,
+            type: Number,
+        };
+    }
+    if (targetType === Boolean) {
+        return {
+            name: 'boolean',
+            typeGroup: 'Boolean',
+            typeName: 'Boolean',
+            parameters: [],
+            isNullable: false,
+            isGetAccessor: false,
+            type: Boolean,
+        };
+    }
+    // Handle void - return never to signal void return
+    if (targetType === undefined || targetType === null) {
+        return {
+            name: 'never',
+            typeGroup: 'Other',
+            typeName: 'never',
+            parameters: [],
+            isNullable: false,
+            isGetAccessor: false,
+        };
+    }
+    // Handle Array
+    if (Array.isArray(targetType)) {
+        if (targetType.length === 0) {
+            throw new Error('@returns decorator array type must specify an element type, e.g., @returns(type => [String])');
+        }
+        const elementType = targetType[0];
+        const elementMetadata = analyzeReturnType(elementType);
+        return {
+            name: `${elementMetadata.name}[]`,
+            typeGroup: 'Array',
+            typeName: 'Array',
+            parameters: [elementMetadata],
+            isNullable: false,
+            isGetAccessor: false,
+        };
+    }
+    // Handle Class types (e.g., UUID, custom types)
+    if (typeof targetType === 'function') {
+        return {
+            name: targetType.name || 'Unknown',
+            typeGroup: 'Class',
+            typeName: targetType.name,
+            parameters: [],
+            isNullable: false,
+            isGetAccessor: false,
+            type: targetType,
+        };
+    }
+    // Default fallback
+    return {
+        name: 'unknown',
+        typeGroup: 'Other',
+        typeName: 'unknown',
+        parameters: [],
+        isNullable: false,
+        isGetAccessor: false,
+    };
+}
+/**
+ * Get the return type metadata for a method from decorator metadata.
+ *
+ * @param contextMetadata - The context.metadata from a class decorator
+ * @param methodName - The name of the method to get return type for
+ */
+function getReturnTypeMetadata(contextMetadata, methodName) {
+    if (!contextMetadata) {
+        return undefined;
+    }
+    const returnsMetadataList = contextMetadata[exports.RETURNS_METADATA_KEY];
+    if (!returnsMetadataList) {
+        return undefined;
+    }
+    const metadata = returnsMetadataList.find((m) => m.methodName === methodName);
+    if (!metadata) {
+        return undefined;
+    }
+    // Evaluate the type function and analyze the result
+    const typeResult = metadata.typeFunction();
+    // Return the actual type (not wrapped in Promise) - this is the GraphQL return type
+    return analyzeReturnType(typeResult);
+}
+/**
+ * @returns() decorator for explicit return type declaration on methods.
+ *
+ * Uses TC39 Stage 3 decorators to capture return type metadata that is used
+ * for GraphQL schema generation. The type specified should be the GraphQL
+ * return type (not wrapped in Promise).
+ *
+ * Usage:
+ *   @returns(type => UUID)
+ *   public static async handle(...): Promise<UUID> { ... }
+ *
+ *   @returns(type => String)
+ *   public static async handle(...): Promise<string> { ... }
+ *
+ *   @returns(type => [CartItem])
+ *   public static async handle(...): Promise<CartItem[]> { ... }
+ */
+function returns(typeFunction) {
+    return function returnsDecorator(_target, context) {
+        const methodName = context.name.toString();
+        // Store in context.metadata for later retrieval by class decorators
+        if (context.metadata) {
+            if (!context.metadata[exports.RETURNS_METADATA_KEY]) {
+                context.metadata[exports.RETURNS_METADATA_KEY] = [];
+            }
+            const returnsList = context.metadata[exports.RETURNS_METADATA_KEY];
+            // Remove any existing entry for this method (in case of decorator re-application)
+            const filteredList = returnsList.filter((m) => m.methodName !== methodName);
+            filteredList.push({
+                methodName,
+                typeFunction,
+            });
+            context.metadata[exports.RETURNS_METADATA_KEY] = filteredList;
+        }
+    };
+}

package/dist/decorators/role.d.ts

@@ -1,6 +1,12 @@
 import { Class, RoleMetadata, RoleInterface } from '@magek/common';
+import { ClassDecoratorContext } from './decorator-types';
 /**
- * Annotation to tell Magek which classes represent your roles
- * @param roleMetadata
+ * Decorator to mark a class as a Magek Role.
+ * Roles define authorization and authentication configurations.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param roleMetadata - Role configuration including auth settings
+ * @returns A class decorator function
  */
-export declare function Role(roleMetadata?: RoleMetadata): (role: Class<RoleInterface>) => void;
+export declare function Role(roleMetadata?: RoleMetadata): (role: Class<RoleInterface>, context: ClassDecoratorContext) => void;

package/dist/decorators/role.js

@@ -3,11 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Role = Role;
 const magek_1 = require("../magek");
 /**
- * Annotation to tell Magek which classes represent your roles
- * @param roleMetadata
+ * Decorator to mark a class as a Magek Role.
+ * Roles define authorization and authentication configurations.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param roleMetadata - Role configuration including auth settings
+ * @returns A class decorator function
  */
 function Role(roleMetadata = { auth: {} }) {
-    return (role) => {
+    return (role, _context) => {
         magek_1.Magek.configureCurrentEnv((config) => {
             config.roles[role.name] = roleMetadata;
         });

package/dist/decorators/scheduled-command.d.ts

@@ -1,9 +1,12 @@
 import { ScheduledCommandInterface, ScheduleInterface } from '@magek/common';
+import { ClassDecoratorContext } from './decorator-types';
 /**
  * Decorator to mark a class as a Magek Scheduled Command.
  * Scheduled commands are executed automatically based on a schedule.
  *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param attributes - Schedule configuration (e.g., cron expression)
  * @returns A class decorator function
  */
-export declare function ScheduledCommand(attributes: ScheduleInterface): (scheduledCommandClass: ScheduledCommandInterface) => void;
+export declare function ScheduledCommand(attributes: ScheduleInterface): (scheduledCommandClass: ScheduledCommandInterface, context: ClassDecoratorContext) => void;

package/dist/decorators/scheduled-command.js

@@ -6,11 +6,13 @@ const magek_1 = require("../magek");
  * Decorator to mark a class as a Magek Scheduled Command.
  * Scheduled commands are executed automatically based on a schedule.
  *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param attributes - Schedule configuration (e.g., cron expression)
  * @returns A class decorator function
  */
 function ScheduledCommand(attributes) {
-    return (commandClass) => {
+    return (commandClass, _context) => {
         magek_1.Magek.configureCurrentEnv((config) => {
             if (config.scheduledCommandHandlers[commandClass.name]) {
                 throw new Error(`A command called ${commandClass.name} is already registered.

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);