@magek/core 0.0.1

package/dist/authorizer.d.ts

@@ -0,0 +1,7 @@
+import { Class, UserEnvelope, RoleInterface, QueryAuthorizer, CommandRoleAccess, QueryRoleAccess, ReadModelRoleAccess, CommandAuthorizer, ReadModelAuthorizer, HealthRoleAccess, HealthAuthorizer } from '@magek/common';
+export declare class MagekAuthorizer {
+    static allowAccess(): Promise<void>;
+    static denyAccess(): Promise<void>;
+    static authorizeRoles(authorizedRoles: Array<Class<RoleInterface>>, user?: UserEnvelope): Promise<void>;
+    static build(attributes: CommandRoleAccess | QueryRoleAccess | ReadModelRoleAccess | HealthRoleAccess): CommandAuthorizer | QueryAuthorizer | ReadModelAuthorizer | HealthAuthorizer;
+}

package/dist/authorizer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekAuthorizer = void 0;
+const common_1 = require("@magek/common");
+class MagekAuthorizer {
+    static allowAccess() {
+        return Promise.resolve();
+    }
+    static denyAccess() {
+        return Promise.reject(new common_1.NotAuthorizedError('Access denied for this resource'));
+    }
+    static authorizeRoles(authorizedRoles, user) {
+        if (user && userHasSomeRole(user, authorizedRoles)) {
+            return MagekAuthorizer.allowAccess();
+        }
+        return MagekAuthorizer.denyAccess();
+    }
+    static build(attributes) {
+        let authorizer = MagekAuthorizer.denyAccess;
+        if (attributes.authorize === 'all') {
+            authorizer = MagekAuthorizer.allowAccess;
+        }
+        else if (Array.isArray(attributes.authorize)) {
+            authorizer = MagekAuthorizer.authorizeRoles.bind(null, attributes.authorize);
+        }
+        else if (typeof attributes.authorize === 'function') {
+            authorizer = attributes.authorize;
+        }
+        return authorizer;
+    }
+}
+exports.MagekAuthorizer = MagekAuthorizer;
+function userHasSomeRole(user, authorizedRoles) {
+    return authorizedRoles.some((roleClass) => { var _a; return (_a = user.roles) === null || _a === void 0 ? void 0 : _a.includes(roleClass.name); });
+}

package/dist/command-dispatcher.d.ts

@@ -0,0 +1,8 @@
+import { MagekConfig, CommandEnvelope } from '@magek/common';
+import { GraphQLResolverContext } from './services/graphql/common';
+export declare class MagekCommandDispatcher {
+    readonly config: MagekConfig;
+    private readonly globalErrorDispatcher;
+    constructor(config: MagekConfig);
+    dispatchCommand(commandEnvelope: CommandEnvelope, context: GraphQLResolverContext): Promise<unknown>;
+}

package/dist/command-dispatcher.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekCommandDispatcher = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const register_handler_1 = require("./register-handler");
+const filter_helpers_1 = require("./services/filter-helpers");
+const global_error_dispatcher_1 = require("./global-error-dispatcher");
+const schema_migrator_1 = require("./schema-migrator");
+const instrumentation_1 = require("./instrumentation");
+class MagekCommandDispatcher {
+    constructor(config) {
+        this.config = config;
+        this.globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(config);
+    }
+    async dispatchCommand(commandEnvelope, context) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekCommandDispatcher#dispatchCommand');
+        logger.debug('Dispatching the following command envelope: ', commandEnvelope);
+        if (!commandEnvelope.version) {
+            throw new common_1.InvalidParameterError('The required command "version" was not present');
+        }
+        const commandMetadata = this.config.commandHandlers[commandEnvelope.typeName];
+        if (!commandMetadata) {
+            throw new common_1.NotFoundError(`Could not find a proper handler for ${commandEnvelope.typeName}`);
+        }
+        await commandMetadata.authorizer(commandEnvelope.currentUser, commandEnvelope);
+        const commandClass = commandMetadata.class;
+        logger.debug('Found the following command:', commandClass.name);
+        const migratedCommandEnvelope = await new schema_migrator_1.SchemaMigrator(this.config).migrate(commandEnvelope);
+        let result;
+        const register = new common_1.Register(migratedCommandEnvelope.requestID, context.responseHeaders, register_handler_1.RegisterHandler.flush, migratedCommandEnvelope.currentUser, migratedCommandEnvelope.context);
+        try {
+            const commandInput = await (0, filter_helpers_1.applyBeforeFunctions)(migratedCommandEnvelope.value, commandMetadata.before, migratedCommandEnvelope.currentUser);
+            const commandInstance = (0, common_1.createInstance)(commandClass, commandInput);
+            logger.debug('Calling "handle" method on command: ', commandClass);
+            result = await commandClass.handle(commandInstance, register);
+        }
+        catch (err) {
+            const e = err;
+            const error = await this.globalErrorDispatcher.dispatch(new common_1.CommandHandlerGlobalError(migratedCommandEnvelope, commandMetadata, e));
+            if (error)
+                throw error;
+        }
+        logger.debug('Command dispatched with register: ', register);
+        await register_handler_1.RegisterHandler.handle(this.config, register);
+        return result;
+    }
+}
+exports.MagekCommandDispatcher = MagekCommandDispatcher;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.COMMAND_HANDLER),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekCommandDispatcher.prototype, "dispatchCommand", null);

package/dist/core-concepts/data-migration/entities/data-migration-entity.d.ts

@@ -0,0 +1,12 @@
+import { MagekDataMigrationEntityDuration, DataMigrationStatus } from '@magek/common';
+import { MagekDataMigrationStarted } from '../events/data-migration-started';
+import { MagekDataMigrationFinished } from '../events/data-migration-finished';
+export declare class MagekDataMigrationEntity {
+    id: string;
+    status: DataMigrationStatus;
+    lastUpdated: string;
+    duration?: MagekDataMigrationEntityDuration | undefined;
+    constructor(id: string, status: DataMigrationStatus, lastUpdated: string, duration?: MagekDataMigrationEntityDuration | undefined);
+    static started(event: MagekDataMigrationStarted, currentDataMigration: MagekDataMigrationEntity): MagekDataMigrationEntity;
+    static finished(event: MagekDataMigrationFinished, currentDataMigration: MagekDataMigrationEntity): MagekDataMigrationEntity;
+}

package/dist/core-concepts/data-migration/entities/data-migration-entity.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDataMigrationEntity = void 0;
+const common_1 = require("@magek/common");
+class MagekDataMigrationEntity {
+    constructor(id, status, lastUpdated, duration) {
+        this.id = id;
+        this.status = status;
+        this.lastUpdated = lastUpdated;
+        this.duration = duration;
+    }
+    static started(event, currentDataMigration) {
+        const duration = {
+            start: new Date().toISOString(),
+        };
+        return new MagekDataMigrationEntity(event.name, common_1.DataMigrationStatus.RUNNING, event.lastUpdated, duration);
+    }
+    static finished(event, currentDataMigration) {
+        var _a;
+        const current = new Date();
+        if ((_a = currentDataMigration.duration) === null || _a === void 0 ? void 0 : _a.start) {
+            const start = currentDataMigration.duration.start;
+            const end = current.toISOString();
+            const startTime = Date.parse(start);
+            const endTime = current.getTime();
+            const elapsedTime = endTime - startTime;
+            const duration = {
+                start: start,
+                end: end,
+                elapsedMilliseconds: elapsedTime,
+            };
+            return new MagekDataMigrationEntity(event.name, common_1.DataMigrationStatus.FINISHED, event.lastUpdated, duration);
+        }
+        return new MagekDataMigrationEntity(event.name, common_1.DataMigrationStatus.FINISHED, event.lastUpdated);
+    }
+}
+exports.MagekDataMigrationEntity = MagekDataMigrationEntity;

package/dist/core-concepts/data-migration/events/data-migration-finished.d.ts

@@ -0,0 +1,7 @@
+import { UUID } from '@magek/common';
+export declare class MagekDataMigrationFinished {
+    readonly name: string;
+    readonly lastUpdated: string;
+    constructor(name: string, lastUpdated?: string);
+    entityID(): UUID;
+}

package/dist/core-concepts/data-migration/events/data-migration-finished.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDataMigrationFinished = void 0;
+class MagekDataMigrationFinished {
+    constructor(name, lastUpdated) {
+        this.name = name;
+        this.lastUpdated = lastUpdated !== null && lastUpdated !== void 0 ? lastUpdated : new Date().toISOString();
+    }
+    entityID() {
+        return this.name;
+    }
+}
+exports.MagekDataMigrationFinished = MagekDataMigrationFinished;

package/dist/core-concepts/data-migration/events/data-migration-started.d.ts

@@ -0,0 +1,7 @@
+import { UUID } from '@magek/common';
+export declare class MagekDataMigrationStarted {
+    readonly name: string;
+    readonly lastUpdated: string;
+    constructor(name: string, lastUpdated?: string);
+    entityID(): UUID;
+}

package/dist/core-concepts/data-migration/events/data-migration-started.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDataMigrationStarted = void 0;
+class MagekDataMigrationStarted {
+    constructor(name, lastUpdated) {
+        this.name = name;
+        this.lastUpdated = lastUpdated !== null && lastUpdated !== void 0 ? lastUpdated : new Date().toISOString();
+    }
+    entityID() {
+        return this.name;
+    }
+}
+exports.MagekDataMigrationStarted = MagekDataMigrationStarted;

package/dist/core-concepts/data-migration/events/entity-migrated.d.ts

@@ -0,0 +1,9 @@
+import { EntityInterface, Instance, UUID } from '@magek/common';
+export declare class MagekEntityMigrated {
+    readonly oldEntityName: string;
+    readonly oldEntityId: UUID;
+    readonly newEntityName: string;
+    readonly newEntity: Instance & EntityInterface;
+    constructor(oldEntityName: string, oldEntityId: UUID, newEntityName: string, newEntity: Instance & EntityInterface);
+    entityID(): UUID;
+}

package/dist/core-concepts/data-migration/events/entity-migrated.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEntityMigrated = void 0;
+class MagekEntityMigrated {
+    constructor(oldEntityName, oldEntityId, newEntityName, newEntity) {
+        this.oldEntityName = oldEntityName;
+        this.oldEntityId = oldEntityId;
+        this.newEntityName = newEntityName;
+        this.newEntity = newEntity;
+    }
+    entityID() {
+        return this.oldEntityId;
+    }
+}
+exports.MagekEntityMigrated = MagekEntityMigrated;

package/dist/core-concepts/touch-entity/events/entity-touched.d.ts

@@ -0,0 +1,7 @@
+import { UUID } from '@magek/common';
+export declare class MagekEntityTouched {
+    readonly entityName: string;
+    readonly entityId: UUID;
+    constructor(entityName: string, entityId: UUID);
+    entityID(): UUID;
+}

package/dist/core-concepts/touch-entity/events/entity-touched.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekEntityTouched = void 0;
+class MagekEntityTouched {
+    constructor(entityName, entityId) {
+        this.entityName = entityName;
+        this.entityId = entityId;
+    }
+    entityID() {
+        return this.entityId;
+    }
+}
+exports.MagekEntityTouched = MagekEntityTouched;

package/dist/data-migrations.d.ts

@@ -0,0 +1,8 @@
+import { EntityInterface, Instance, UUID } from '@magek/common';
+export declare class MagekDataMigrations {
+    static run(): Promise<boolean>;
+    static migrateEntity(oldEntityName: string, oldEntityId: UUID, newEntity: Instance & EntityInterface): Promise<void>;
+    private static sortConfiguredMigrations;
+    private static migrate;
+    private static emitStarted;
+}

package/dist/data-migrations.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDataMigrations = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const register_handler_1 = require("./register-handler");
+const event_store_1 = require("./services/event-store");
+const data_migration_entity_1 = require("./core-concepts/data-migration/entities/data-migration-entity");
+const entity_migrated_1 = require("./core-concepts/data-migration/events/entity-migrated");
+const index_1 = require("./index");
+const data_migration_started_1 = require("./core-concepts/data-migration/events/data-migration-started");
+const instrumentation_1 = require("./instrumentation");
+class MagekDataMigrations {
+    static async run() {
+        const config = index_1.Magek.config;
+        const logger = (0, common_1.getLogger)(config, 'MagekDataMigrationDispatcher#dispatch');
+        let migrating = false;
+        const configuredMigrations = config.dataMigrationHandlers;
+        if (Object.keys(configuredMigrations).length === 0) {
+            logger.debug('No defined migrations found. Skipping...');
+            return false;
+        }
+        const sortedConfiguredMigrations = MagekDataMigrations.sortConfiguredMigrations(configuredMigrations);
+        const eventStore = new event_store_1.EventStore(config);
+        for (const configuredMigration of Object.values(sortedConfiguredMigrations)) {
+            const migrationEntityForConfiguredMigration = await eventStore.fetchEntitySnapshot(data_migration_entity_1.MagekDataMigrationEntity.name, configuredMigration.class.name);
+            if (!migrationEntityForConfiguredMigration) {
+                logger.debug('Not found running or finished migrations for the DataMigration', configuredMigration);
+                migrating = true;
+                await MagekDataMigrations.migrate(configuredMigration);
+            }
+            else {
+                const dataMigrationEntity = migrationEntityForConfiguredMigration.value;
+                if (dataMigrationEntity.status === common_1.DataMigrationStatus.RUNNING) {
+                    logger.debug('Found running migrations for the DataMigration', configuredMigration);
+                    migrating = true;
+                }
+            }
+        }
+        return migrating;
+    }
+    static migrateEntity(oldEntityName, oldEntityId, newEntity) {
+        const requestID = common_1.UUID.generate();
+        const register = new common_1.Register(requestID, {}, register_handler_1.RegisterHandler.flush);
+        register.events(new entity_migrated_1.MagekEntityMigrated(oldEntityName, oldEntityId, newEntity.constructor.name, newEntity));
+        return register_handler_1.RegisterHandler.handle(index_1.Magek.config, register);
+    }
+    static sortConfiguredMigrations(configuredMigrations) {
+        return Object.values(configuredMigrations).sort((a, b) => {
+            return a.migrationOptions.order - b.migrationOptions.order;
+        });
+    }
+    static async migrate(migrationHandler) {
+        const startedRegister = new common_1.Register(common_1.UUID.generate(), {}, register_handler_1.RegisterHandler.flush);
+        await MagekDataMigrations.emitStarted(startedRegister, migrationHandler.class.name);
+        await register_handler_1.RegisterHandler.handle(index_1.Magek.config, startedRegister);
+        const finishedRegister = new common_1.Register(common_1.UUID.generate(), {}, register_handler_1.RegisterHandler.flush);
+        await migrationHandler.class.start(finishedRegister);
+        await register_handler_1.RegisterHandler.handle(index_1.Magek.config, finishedRegister);
+    }
+    static async emitStarted(register, configuredMigrationName) {
+        const logger = (0, common_1.getLogger)(index_1.Magek.config, 'MagekMigration#emitStarted');
+        logger.info('Migration started', configuredMigrationName);
+        register.events(new data_migration_started_1.MagekDataMigrationStarted(configuredMigrationName, new Date().toISOString()));
+    }
+}
+exports.MagekDataMigrations = MagekDataMigrations;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.MIGRATION_RUN),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekDataMigrations, "run", null);

package/dist/decorators/command.d.ts

@@ -0,0 +1,19 @@
+import { CommandFilterHooks, CommandInterface, CommandRoleAccess } from '@magek/common';
+/**
+ * Stage 3 class decorator context
+ */
+interface Stage3ClassContext {
+    kind: 'class';
+    name: string | undefined;
+    metadata: Record<string | symbol, unknown>;
+    addInitializer?: (initializer: () => void) => void;
+}
+/**
+ * Decorator to mark a class as a Magek Command.
+ * Commands represent user intentions and trigger business logic.
+ *
+ * @param attributes - Role access control and filter hooks configuration
+ * @returns A class decorator function
+ */
+export declare function Command(attributes: CommandRoleAccess & CommandFilterHooks): <TCommand>(commandClass: CommandInterface<TCommand>, context?: Stage3ClassContext) => void;
+export {};

package/dist/decorators/command.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = Command;
+const magek_1 = require("../magek");
+const metadata_1 = require("./metadata");
+const authorizer_1 = require("../authorizer");
+const stage3_utils_1 = require("./stage3-utils");
+/**
+ * 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);
+}
+/**
+ * Decorator to mark a class as a Magek Command.
+ * Commands represent user intentions and trigger business logic.
+ *
+ * @param attributes - Role access control and filter hooks configuration
+ * @returns A class decorator function
+ */
+function Command(attributes) {
+    return (commandClass, context) => {
+        // Transfer Stage 3 field metadata if applicable
+        if (isStage3ClassContext(context)) {
+            (0, stage3_utils_1.transferStage3FieldMetadata)(commandClass, context.metadata);
+        }
+        magek_1.Magek.configureCurrentEnv((config) => {
+            var _a;
+            if (config.commandHandlers[commandClass.name]) {
+                throw new Error(`A command called ${commandClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+            }
+            const metadata = (0, metadata_1.getClassMetadata)(commandClass);
+            config.commandHandlers[commandClass.name] = {
+                class: commandClass,
+                authorizer: authorizer_1.MagekAuthorizer.build(attributes),
+                before: (_a = attributes.before) !== null && _a !== void 0 ? _a : [],
+                properties: metadata.fields,
+                methods: metadata.methods,
+            };
+        });
+    };
+}

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

@@ -0,0 +1,9 @@
+import { DataMigrationInterface, DataMigrationParameters } from '@magek/common';
+/**
+ * Decorator to mark a class as a Magek Data Migration.
+ * Data migrations are background processes that update existing data in the database.
+ *
+ * @param attributes - Migration configuration (e.g., execution order)
+ * @returns A class decorator function
+ */
+export declare function DataMigration(attributes: DataMigrationParameters): (dataMigrationClass: DataMigrationInterface) => void;

package/dist/decorators/data-migration.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataMigration = DataMigration;
+const magek_1 = require("../magek");
+/**
+ * Decorator to mark a class as a Magek Data Migration.
+ * Data migrations are background processes that update existing data in the database.
+ *
+ * @param attributes - Migration configuration (e.g., execution order)
+ * @returns A class decorator function
+ */
+function DataMigration(attributes) {
+    return (migrationClass) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.dataMigrationHandlers[migrationClass.name]) {
+                throw new Error(`A data migration called ${migrationClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+            }
+            config.dataMigrationHandlers[migrationClass.name] = {
+                class: migrationClass,
+                migrationOptions: attributes,
+            };
+        });
+    };
+}

package/dist/decorators/entity.d.ts

@@ -0,0 +1,32 @@
+import { Class, EntityInterface, EventInterface, EventStreamRoleAccess, AnyClass } from '@magek/common';
+type EntityAttributes = EventStreamRoleAccess;
+type EntityDecoratorParam = AnyClass | EntityAttributes;
+type EntityDecoratorResult<TEntity, TParam> = TParam extends EntityAttributes ? (entityClass: Class<TEntity>) => void : void;
+/**
+ * Decorator to mark a class as a Magek Entity.
+ * Entities represent the current state derived from events.
+ *
+ * @param classOrAttributes - Either the class itself or entity configuration attributes
+ * @returns A class decorator function or void if used without parentheses
+ */
+export declare function Entity<TEntity extends EntityInterface, TParam extends EntityDecoratorParam>(classOrAttributes: TParam): EntityDecoratorResult<TEntity, TParam>;
+/**
+ * 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;
+}
+/**
+ * Decorator to register an entity class method as a reducer function
+ * for a specific event.
+ *
+ * @param eventClass The event that this method will react to
+ */
+export declare function Reduces<TEvent extends EventInterface>(eventClass: Class<TEvent>): <TEntity>(entityClassOrMethod: Class<TEntity> | Function, methodNameOrContext: string | Stage3MethodContext, methodDescriptor?: ReducerMethod<TEvent, TEntity>) => void;
+type ReducerMethod<TEvent, TEntity> = TypedPropertyDescriptor<(event: TEvent, entity: TEntity) => TEntity> | TypedPropertyDescriptor<(event: TEvent, entity?: TEntity) => TEntity>;
+export {};

package/dist/decorators/entity.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = Entity;
+exports.Reduces = Reduces;
+const magek_1 = require("../magek");
+const authorizer_1 = require("../authorizer");
+/**
+ * Decorator to mark a class as a Magek Entity.
+ * Entities represent the current state derived from events.
+ *
+ * @param classOrAttributes - Either the class itself or entity configuration attributes
+ * @returns A class decorator function or void if used without parentheses
+ */
+function Entity(classOrAttributes) {
+    let authorizeReadEvents;
+    // This function will be either returned or executed, depending on the parameters passed to the decorator
+    const mainLogicFunction = (entityClass) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.entities[entityClass.name]) {
+                throw new Error(`An entity called ${entityClass.name} is already registered
+        If you think that this is an error, try performing a clean build..`);
+            }
+            let eventStreamAuthorizer = authorizer_1.MagekAuthorizer.denyAccess;
+            if (authorizeReadEvents === 'all') {
+                eventStreamAuthorizer = authorizer_1.MagekAuthorizer.allowAccess;
+            }
+            else if (Array.isArray(authorizeReadEvents)) {
+                eventStreamAuthorizer = authorizer_1.MagekAuthorizer.authorizeRoles.bind(null, authorizeReadEvents);
+            }
+            else if (typeof authorizeReadEvents === 'function') {
+                eventStreamAuthorizer = authorizeReadEvents;
+            }
+            config.entities[entityClass.name] = {
+                class: entityClass,
+                eventStreamAuthorizer,
+            };
+        });
+    };
+    if (isEntityAttributes(classOrAttributes)) {
+        authorizeReadEvents = classOrAttributes.authorizeReadEvents;
+        return mainLogicFunction;
+    }
+    return mainLogicFunction(classOrAttributes);
+}
+function isEntityAttributes(param) {
+    return 'authorizeReadEvents' in param;
+}
+/**
+ * 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);
+}
+/**
+ * Decorator to register an entity class method as a reducer function
+ * for a specific event.
+ *
+ * @param eventClass The event that this method will react to
+ */
+function Reduces(eventClass) {
+    return (entityClassOrMethod, methodNameOrContext, _methodDescriptor) => {
+        // Detect Stage 3 vs Legacy decorator
+        if (isStage3MethodContext(methodNameOrContext)) {
+            // Stage 3 decorator - use addInitializer to get the class
+            const context = methodNameOrContext;
+            if (context.addInitializer) {
+                context.addInitializer(function () {
+                    // For static methods, 'this' is the class itself
+                    // For instance methods, 'this' is an instance and we need this.constructor
+                    const targetClass = context.static ? this : this.constructor;
+                    registerReducer(eventClass.name, {
+                        class: targetClass,
+                        methodName: context.name.toString(),
+                    });
+                });
+            }
+        }
+        else {
+            // Legacy decorator
+            registerReducer(eventClass.name, {
+                class: entityClassOrMethod,
+                methodName: methodNameOrContext,
+            });
+        }
+    };
+}
+function registerReducer(eventName, reducerMetadata) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        const reducerPath = config.reducers[eventName];
+        if (reducerPath) {
+            throw new Error(`Error registering reducer: The event ${eventName} was already registered to be reduced by method ${reducerPath.methodName} in the entity ${reducerPath.class.name}.
+        If you think that this is an error, try performing a clean build.`);
+        }
+        config.reducers[eventName] = reducerMetadata;
+    });
+}

package/dist/decorators/event-handler.d.ts

@@ -0,0 +1,3 @@
+import { EventInterface, EventHandlerInterface, Class, NotificationInterface } from '@magek/common';
+export declare function EventHandler<TEvent extends EventInterface | NotificationInterface>(event: Class<TEvent>): <TEventHandler extends EventHandlerInterface>(eventHandlerClass: TEventHandler) => void;
+export declare function registerEventHandler<TEventHandler extends EventHandlerInterface>(eventName: string, eventHandlerClass: TEventHandler): void;

package/dist/decorators/event-handler.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = EventHandler;
+exports.registerEventHandler = registerEventHandler;
+const magek_1 = require("../magek");
+function EventHandler(event) {
+    return (eventHandlerClass) => registerEventHandler(event.name, eventHandlerClass);
+}
+function registerEventHandler(eventName, eventHandlerClass) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        const registeredEventHandlers = config.eventHandlers[eventName] || [];
+        if (registeredEventHandlers.some((klass) => klass == eventHandlerClass)) {
+            return;
+        }
+        registeredEventHandlers.push(eventHandlerClass);
+        config.eventHandlers[eventName] = registeredEventHandlers;
+    });
+}

package/dist/decorators/event.d.ts

@@ -0,0 +1,8 @@
+import { Class, EventInterface } from '@magek/common';
+/**
+ * Decorator to mark a class as a Magek Event.
+ * Events are immutable records of facts that occurred in your system.
+ *
+ * @param eventClass - The event class to register
+ */
+export declare function Event<TEvent extends EventInterface>(eventClass: Class<TEvent>): void;

package/dist/decorators/event.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = Event;
+const magek_1 = require("../magek");
+/**
+ * Decorator to mark a class as a Magek Event.
+ * Events are immutable records of facts that occurred in your system.
+ *
+ * @param eventClass - The event class to register
+ */
+// Disabling unused vars here, because it won't allow us to call the decorator without parens
+function Event(eventClass) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        if (config.events[eventClass.name]) {
+            throw new Error(`A event called ${eventClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+        }
+        config.events[eventClass.name] = {
+            class: eventClass,
+        };
+    });
+}

package/dist/decorators/field-metadata-reader.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { AnyClass, ClassMetadata } from '@magek/common';
+/**
+ * Build ClassMetadata from @Field() decorators
+ */
+export declare function buildClassMetadataFromFields(classType: AnyClass): ClassMetadata;