@magek/core 0.0.1

package/dist/decorators/projects.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projects = Projects;
+const magek_1 = require("../magek");
+/**
+ * Type guard for Stage 3 method context
+ */
+function isStage3MethodContext(arg) {
+    return (arg !== null &&
+        typeof arg === 'object' &&
+        'kind' in arg &&
+        arg.kind === 'method' &&
+        'name' in arg);
+}
+/**
+ * Decorator to register a read model method as a projection
+ * for a specific entity
+ *
+ * @param originEntity The entity that this method will react to
+ * @param joinKey
+ * @param unProject
+ */
+function Projects(originEntity, joinKey, unProject) {
+    return (readModelClassOrMethod, methodNameOrContext) => {
+        // 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 () {
+                    const readModelClass = context.static ? this : this.constructor;
+                    const projectionMetadata = {
+                        joinKey: joinKey,
+                        class: readModelClass,
+                        methodName: context.name.toString(),
+                    };
+                    registerProjection(originEntity.name, projectionMetadata);
+                    if (unProject) {
+                        const unProjectionMetadata = {
+                            joinKey,
+                            class: readModelClass,
+                            methodName: unProject.name,
+                        };
+                        registerUnProjection(originEntity.name, unProjectionMetadata);
+                    }
+                });
+            }
+        }
+        else {
+            // Legacy decorator
+            const readModelClass = readModelClassOrMethod;
+            const methodName = methodNameOrContext;
+            const projectionMetadata = {
+                joinKey: joinKey,
+                class: readModelClass,
+                methodName: methodName,
+            };
+            registerProjection(originEntity.name, projectionMetadata);
+            if (unProject) {
+                const unProjectionMetadata = {
+                    joinKey,
+                    class: readModelClass,
+                    methodName: unProject.name,
+                };
+                registerUnProjection(originEntity.name, unProjectionMetadata);
+            }
+        }
+    };
+}
+function registerProjection(originName, projectionMetadata) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        configure(originName, projectionMetadata, config.projections);
+    });
+}
+function registerUnProjection(originName, projectionMetadata) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        configure(originName, projectionMetadata, config.unProjections);
+    });
+}
+function configure(originName, projectionMetadata, configuration) {
+    const entityProjections = configuration[originName] || [];
+    if (entityProjections.indexOf(projectionMetadata) < 0) {
+        // Skip duplicate registrations
+        entityProjections.push(projectionMetadata);
+        configuration[originName] = entityProjections;
+    }
+}

package/dist/decorators/query.d.ts

@@ -0,0 +1,2 @@
+import { CommandFilterHooks, QueryInterface, QueryRoleAccess } from '@magek/common';
+export declare function Query(attributes: QueryRoleAccess & CommandFilterHooks): <TCommand>(queryClass: QueryInterface<TCommand>) => void;

package/dist/decorators/query.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = Query;
+const magek_1 = require("../magek");
+const metadata_1 = require("./metadata");
+const authorizer_1 = require("../authorizer");
+function Query(attributes) {
+    return (queryClass) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            var _a;
+            if (config.queryHandlers[queryClass.name]) {
+                throw new Error(`A query called ${queryClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+            }
+            const metadata = (0, metadata_1.getClassMetadata)(queryClass);
+            config.queryHandlers[queryClass.name] = {
+                class: queryClass,
+                authorizer: authorizer_1.MagekAuthorizer.build(attributes),
+                properties: metadata.fields,
+                methods: metadata.methods,
+                before: (_a = attributes.before) !== null && _a !== void 0 ? _a : [],
+            };
+        });
+    };
+}

package/dist/decorators/read-model.d.ts

@@ -0,0 +1,39 @@
+import { Class, ReadModelFilterHooks, ReadModelInterface, ReadModelRoleAccess } 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 register a class as a ReadModel
+ * @param attributes
+ */
+export declare function ReadModel(attributes: ReadModelRoleAccess & ReadModelFilterHooks): (readModelClass: Class<ReadModelInterface>, context?: Stage3ClassContext) => void;
+interface CalculatedFieldOptions {
+    dependsOn: string[];
+}
+/**
+ * Stage 3 getter decorator context
+ */
+interface Stage3GetterContext {
+    kind: 'getter';
+    name: string | symbol;
+    static: boolean;
+    private: boolean;
+    metadata: Record<string | symbol, unknown>;
+    access?: {
+        get: () => unknown;
+    };
+    addInitializer?: (initializer: () => void) => void;
+}
+/**
+ * Decorator to mark a property as a calculated field with dependencies.
+ * Supports both legacy and Stage 3 decorators.
+ * @param options - A `CalculatedFieldOptions` object indicating the dependencies.
+ */
+export declare function CalculatedField(options: CalculatedFieldOptions): (target: object | Function, propertyKeyOrContext: string | symbol | Stage3GetterContext) => void;
+export {};

package/dist/decorators/read-model.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadModel = ReadModel;
+exports.CalculatedField = CalculatedField;
+const common_1 = require("@magek/common");
+const magek_1 = require("../magek");
+const authorizer_1 = require("../authorizer");
+const metadata_1 = require("./metadata");
+const stage3_utils_1 = require("./stage3-utils");
+const sequenced_by_1 = require("./sequenced-by");
+/**
+ * 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 register a class as a ReadModel
+ * @param attributes
+ */
+function ReadModel(attributes) {
+    return (readModelClass, context) => {
+        // Transfer Stage 3 field metadata if applicable
+        if (isStage3ClassContext(context)) {
+            (0, stage3_utils_1.transferStage3FieldMetadata)(readModelClass, context.metadata);
+            (0, sequenced_by_1.transferSequenceKeyMetadata)(readModelClass, context.metadata);
+            transferCalculatedFieldDependencies(readModelClass, context.metadata);
+        }
+        magek_1.Magek.configureCurrentEnv((config) => {
+            var _a;
+            if (config.readModels[readModelClass.name]) {
+                throw new Error(`A read model called ${readModelClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+            }
+            const authorizer = authorizer_1.MagekAuthorizer.build(attributes);
+            const classMetadata = (0, metadata_1.getClassMetadata)(readModelClass);
+            const dynamicDependencies = (0, common_1.getMetadata)('dynamic:dependencies', readModelClass) || {};
+            // Combine fields with dynamic dependencies
+            const fieldProperties = classMetadata.fields.map((field) => {
+                return {
+                    ...field,
+                    dependencies: dynamicDependencies[field.name] || [],
+                };
+            });
+            // Include calculated fields (getters) from methods with their dependencies
+            const methodProperties = classMetadata.methods.map((method) => {
+                return {
+                    ...method,
+                    // Dependencies already included in method from getAllGetters
+                };
+            });
+            // Merge fields and methods into properties
+            const properties = [...fieldProperties, ...methodProperties];
+            config.readModels[readModelClass.name] = {
+                class: readModelClass,
+                properties,
+                authorizer,
+                before: (_a = attributes.before) !== null && _a !== void 0 ? _a : [],
+            };
+        });
+    };
+}
+/**
+ * Type guard for Stage 3 getter context
+ */
+function isStage3GetterContext(arg) {
+    return (arg !== null &&
+        typeof arg === 'object' &&
+        'kind' in arg &&
+        arg.kind === 'getter' &&
+        'name' in arg &&
+        'metadata' in arg);
+}
+// Symbol for storing calculated field dependencies in Stage 3 decorator context.metadata
+const CALCULATED_FIELDS_SYMBOL = Symbol.for('magek:calculatedFields');
+/**
+ * Transfer calculated field dependencies from Stage 3 context.metadata to class metadata.
+ * Called by the ReadModel class decorator.
+ */
+function transferCalculatedFieldDependencies(classType, contextMetadata) {
+    const calculatedFields = contextMetadata[CALCULATED_FIELDS_SYMBOL];
+    if (calculatedFields) {
+        const existingDependencies = (0, common_1.getMetadata)('dynamic:dependencies', classType) || {};
+        for (const [propertyName, dependencies] of Object.entries(calculatedFields)) {
+            existingDependencies[propertyName] = dependencies;
+        }
+        (0, common_1.defineMetadata)('dynamic:dependencies', existingDependencies, classType);
+    }
+}
+/**
+ * Decorator to mark a property as a calculated field with dependencies.
+ * Supports both legacy and Stage 3 decorators.
+ * @param options - A `CalculatedFieldOptions` object indicating the dependencies.
+ */
+function CalculatedField(options) {
+    return (target, propertyKeyOrContext) => {
+        // Detect Stage 3 getter decorator
+        if (isStage3GetterContext(propertyKeyOrContext)) {
+            const context = propertyKeyOrContext;
+            const propertyName = String(context.name);
+            // Store in context.metadata for ReadModel decorator to pick up
+            if (!context.metadata[CALCULATED_FIELDS_SYMBOL]) {
+                context.metadata[CALCULATED_FIELDS_SYMBOL] = {};
+            }
+            const calculatedFields = context.metadata[CALCULATED_FIELDS_SYMBOL];
+            calculatedFields[propertyName] = options.dependsOn;
+            // Also use addInitializer to set Reflect metadata
+            if (context.addInitializer) {
+                context.addInitializer(function () {
+                    const klass = this.constructor;
+                    const existingDependencies = (0, common_1.getMetadata)('dynamic:dependencies', klass) || {};
+                    existingDependencies[propertyName] = options.dependsOn;
+                    (0, common_1.defineMetadata)('dynamic:dependencies', existingDependencies, klass);
+                });
+            }
+            return;
+        }
+        // Legacy decorator
+        const propertyKey = propertyKeyOrContext;
+        const existingDependencies = (0, common_1.getMetadata)('dynamic:dependencies', target.constructor) ||
+            {};
+        existingDependencies[propertyKey] = options.dependsOn;
+        (0, common_1.defineMetadata)('dynamic:dependencies', existingDependencies, target.constructor);
+    };
+}

package/dist/decorators/role.d.ts

@@ -0,0 +1,6 @@
+import { Class, RoleMetadata, RoleInterface } from '@magek/common';
+/**
+ * Annotation to tell Magek which classes represent your roles
+ * @param roleMetadata
+ */
+export declare function Role(roleMetadata?: RoleMetadata): (role: Class<RoleInterface>) => void;

package/dist/decorators/role.js

@@ -0,0 +1,15 @@
+"use strict";
+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
+ */
+function Role(roleMetadata = { auth: {} }) {
+    return (role) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            config.roles[role.name] = roleMetadata;
+        });
+    };
+}

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

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

package/dist/decorators/scheduled-command.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledCommand = ScheduledCommand;
+const magek_1 = require("../magek");
+/**
+ * Decorator to mark a class as a Magek Scheduled Command.
+ * Scheduled commands are executed automatically based on a schedule.
+ *
+ * @param attributes - Schedule configuration (e.g., cron expression)
+ * @returns A class decorator function
+ */
+function ScheduledCommand(attributes) {
+    return (commandClass) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.scheduledCommandHandlers[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.`);
+            }
+            config.scheduledCommandHandlers[commandClass.name] = {
+                class: commandClass,
+                scheduledOn: attributes,
+            };
+        });
+    };
+}

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

@@ -0,0 +1,36 @@
+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;
+}
+/**
+ * **NOTE:** Using this decorator for read model migrations is deprecated. Prefer using `@DataMigration` instead.
+ */
+export declare function SchemaMigration(conceptClass: AnyClass): (schemaMigrationClass: AnyClass, context?: Stage3ClassContext) => void;
+/**
+ * Decorator to tell Magek the version you are migrating to
+ * @param toVersion
+ * @param 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 {};

package/dist/decorators/schema-migration.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaMigration = SchemaMigration;
+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
+const MIGRATIONS_METADATA_KEY = Symbol.for('magek:migrationsMethods');
+/**
+ * **NOTE:** Using this decorator for read model migrations is deprecated. Prefer using `@DataMigration` instead.
+ */
+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
+            let migrationMethodsMetadata;
+            if (isStage3ClassContext(context)) {
+                // Stage 3: read from context.metadata
+                migrationMethodsMetadata =
+                    context.metadata[MIGRATIONS_METADATA_KEY] || [];
+                // Update each metadata entry with the actual class reference
+                migrationMethodsMetadata = migrationMethodsMetadata.map((m) => ({
+                    ...m,
+                    migrationClass: schemaMigrationClass,
+                }));
+            }
+            else {
+                // Legacy: read from Reflect.getMetadata
+                migrationMethodsMetadata = getMigrationMethods(schemaMigrationClass);
+            }
+            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()');
+            }
+            for (const schemaMigrationMetadata of migrationMethodsMetadata) {
+                if (conceptMigrations.has(schemaMigrationMetadata.toVersion)) {
+                    throw new Error(`Found duplicated migration for '${conceptClass.name}' in migration class '${schemaMigrationClass.name}': ` +
+                        `There is an already defined migration for version ${schemaMigrationMetadata.toVersion}`);
+                }
+                conceptMigrations.set(schemaMigrationMetadata.toVersion, schemaMigrationMetadata);
+            }
+        });
+    };
+}
+function getConceptMigrations(config, conceptClass) {
+    if (!config.schemaMigrations[conceptClass.name]) {
+        config.schemaMigrations[conceptClass.name] = new Map();
+    }
+    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
+ * @param toVersion
+ * @param 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;
+            // Get or initialize the migrations array in context.metadata
+            let migrationMethods = context.metadata[MIGRATIONS_METADATA_KEY];
+            if (!migrationMethods) {
+                migrationMethods = [];
+                context.metadata[MIGRATIONS_METADATA_KEY] = migrationMethods;
+            }
+            // Add this migration (migrationClass will be set by @SchemaMigration)
+            migrationMethods.push({
+                migrationClass: undefined, // Will be set by @SchemaMigration
+                methodName: context.name.toString(),
+                toVersion,
+                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,
+            });
+            // 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

@@ -0,0 +1,28 @@
+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;
+}
+/**
+ * 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.
+ */
+export declare function transferSequenceKeyMetadata(classType: AnyClass, contextMetadata: Record<string | symbol, unknown>): void;
+export {};

package/dist/decorators/sequenced-by.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+        }
+    });
+}
+/**
+ * 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.
+ */
+function transferSequenceKeyMetadata(classType, contextMetadata) {
+    const sequenceKey = contextMetadata[SEQUENCE_KEY_SYMBOL];
+    if (sequenceKey) {
+        registerSequenceKey(classType, sequenceKey);
+    }
+}

package/dist/decorators/stage3-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transfer field metadata from Stage 3 decorator context.metadata to the class constructor.
+ * This is needed because Symbol.metadata is not available in Node.js, so Stage 3 decorators
+ * need an explicit step to make field metadata accessible on the class.
+ */
+export declare function transferStage3FieldMetadata(classType: Function, contextMetadata: Record<string | symbol, unknown>): void;

package/dist/decorators/stage3-utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferStage3FieldMetadata = transferStage3FieldMetadata;
+// Symbol used by Stage 3 decorators to store field metadata
+const FIELDS_KEY = Symbol.for('magek:fields');
+/**
+ * Transfer field metadata from Stage 3 decorator context.metadata to the class constructor.
+ * This is needed because Symbol.metadata is not available in Node.js, so Stage 3 decorators
+ * need an explicit step to make field metadata accessible on the class.
+ */
+function transferStage3FieldMetadata(classType, contextMetadata) {
+    const fields = contextMetadata[FIELDS_KEY];
+    if (fields && fields.length > 0) {
+        const ctorWithFields = classType;
+        if (!ctorWithFields.__magek_fields__) {
+            ctorWithFields.__magek_fields__ = [];
+        }
+        // Add fields that aren't already present
+        for (const field of fields) {
+            if (!ctorWithFields.__magek_fields__.some((f) => f.name === field.name)) {
+                ctorWithFields.__magek_fields__.push(field);
+            }
+        }
+    }
+}