@magek/core 0.0.5 → 0.0.7

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

@@ -1,3 +1,13 @@
 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;
+import { ClassDecoratorContext } from './decorator-types';
+/**
+ * Decorator to mark a class as an Event Handler.
+ * Event handlers react to specific events and perform side effects.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param event - The event class to handle
+ * @returns A class decorator function
+ */
+export declare function EventHandler<TEvent extends EventInterface | NotificationInterface>(event: Class<TEvent>): <TEventHandler extends EventHandlerInterface>(eventHandlerClass: TEventHandler, context: ClassDecoratorContext) => void;
 export declare function registerEventHandler<TEventHandler extends EventHandlerInterface>(eventName: string, eventHandlerClass: TEventHandler): void;

package/dist/decorators/event-handler.js

@@ -3,8 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandler = EventHandler;
 exports.registerEventHandler = registerEventHandler;
 const magek_1 = require("../magek");
+/**
+ * Decorator to mark a class as an Event Handler.
+ * Event handlers react to specific events and perform side effects.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param event - The event class to handle
+ * @returns A class decorator function
+ */
 function EventHandler(event) {
-    return (eventHandlerClass) => registerEventHandler(event.name, eventHandlerClass);
+    // Note: `_context` is required for the Stage 3 decorator signature but is not used here.
+    return (eventHandlerClass, _context) => {
+        registerEventHandler(event.name, eventHandlerClass);
+    };
 }
 function registerEventHandler(eventName, eventHandlerClass) {
     magek_1.Magek.configureCurrentEnv((config) => {

package/dist/decorators/event.d.ts

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

package/dist/decorators/event.js

@@ -6,10 +6,11 @@ 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.
  *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @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) {
+function Event(eventClass, _context) {
     magek_1.Magek.configureCurrentEnv((config) => {
         if (config.events[eventClass.name]) {
             throw new Error(`A event called ${eventClass.name} is already registered.

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

@@ -1,6 +1,11 @@
-import 'reflect-metadata';
 import { AnyClass, ClassMetadata } from '@magek/common';
+import { DecoratorMetadataObject } from './decorator-types';
 /**
- * Build ClassMetadata from @Field() decorators
+ * Build ClassMetadata from @field() decorators.
+ *
+ * @param classType - The class to build metadata for
+ * @param contextMetadata - Optional context.metadata from class decorator.
+ *   IMPORTANT: During class decorator execution, Symbol.metadata isn't yet attached to the class.
+ *   Class decorators must pass context.metadata to read field metadata correctly.
  */
-export declare function buildClassMetadataFromFields(classType: AnyClass): ClassMetadata;
+export declare function buildClassMetadataFromFields(classType: AnyClass, contextMetadata?: DecoratorMetadataObject): ClassMetadata;

package/dist/decorators/field-metadata-reader.js

@@ -1,24 +1,19 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildClassMetadataFromFields = buildClassMetadataFromFields;
-require("reflect-metadata");
-// Symbol used by Stage 3 decorators to store field metadata
-const FIELDS_KEY = Symbol.for('magek:fields');
-// Symbol.metadata may not be defined in all TypeScript lib versions
-// Use a well-known symbol that Stage 3 decorators use
-const METADATA_KEY = (_a = Symbol.metadata) !== null && _a !== void 0 ? _a : Symbol.for('Symbol.metadata');
+const decorator_types_1 = require("./decorator-types");
+const read_model_1 = require("./read-model");
 /**
- * Extract TypeMetadata from a @Field() decorator's metadata
+ * Extract TypeMetadata from a @field() decorator's metadata
  */
 function extractTypeMetadata(fieldMeta, isGetter = false) {
     let targetType;
     let isArray = false;
     let isReadonlyArray = false;
-    // If typeFunction is provided, use it
+    // If typeFunction is provided, use it to determine the type
     if (fieldMeta.typeFunction) {
         const result = fieldMeta.typeFunction();
-        // Handle array syntax: @Field(type => [String])
+        // Handle array syntax: @field(type => [String])
         if (Array.isArray(result)) {
             isArray = true;
             targetType = result[0];
@@ -27,10 +22,7 @@ function extractTypeMetadata(fieldMeta, isGetter = false) {
             targetType = result;
         }
     }
-    else {
-        // Fall back to design:type from emitDecoratorMetadata
-        targetType = fieldMeta.designType;
-    }
+    // If no typeFunction, targetType remains undefined and will be treated as 'any' type
     // Determine type group and construct TypeMetadata
     return analyzeType(targetType, {
         isNullable: fieldMeta.options.nullable || false,
@@ -129,61 +121,52 @@ function analyzeType(targetType, options) {
     };
 }
 /**
- * Get all fields from a class, including inherited fields
+ * Get metadata object, preferring contextMetadata (from class decorator) over Symbol.metadata.
+ * During class decorator execution, Symbol.metadata isn't yet attached to the class,
+ * so we need to use context.metadata directly.
  */
-function getAllFields(classType) {
-    const fields = [];
-    // First, check for Stage 3 decorator metadata (Symbol.metadata on the class)
-    // Stage 3 decorators store metadata in classType[Symbol.metadata]
-    const classAsRecord = classType;
-    const metadata = classAsRecord[METADATA_KEY];
-    if (metadata && metadata[FIELDS_KEY]) {
-        const stage3Fields = metadata[FIELDS_KEY];
-        for (const field of stage3Fields) {
-            if (!fields.some((f) => f.name === field.name)) {
-                fields.push(field);
-            }
-        }
+function getMetadataObject(classType, contextMetadata) {
+    if (contextMetadata) {
+        return contextMetadata;
     }
-    // Then walk up the prototype chain for legacy decorator metadata
-    let currentPrototype = classType.prototype;
-    while (currentPrototype && currentPrototype !== Object.prototype) {
-        const constructor = currentPrototype.constructor;
-        // Try Reflect.getMetadata first, then fallback to __magek_fields__
-        let prototypeFields = [];
-        if (typeof Reflect.getMetadata === 'function') {
-            prototypeFields = Reflect.getMetadata('magek:fields', constructor) || [];
-        }
-        // Also check fallback property
-        if (prototypeFields.length === 0 && constructor.__magek_fields__) {
-            prototypeFields = constructor.__magek_fields__;
-        }
-        // Add fields that aren't already in the list (child overrides parent)
-        for (const field of prototypeFields) {
-            if (!fields.some((f) => f.name === field.name)) {
-                fields.push(field);
-            }
-        }
-        currentPrototype = Object.getPrototypeOf(currentPrototype);
+    // Fall back to Symbol.metadata (for post-decorator access)
+    const classRecord = classType;
+    return classRecord[decorator_types_1.SYMBOL_METADATA];
+}
+/**
+ * Get all fields from a class, including inherited fields.
+ * Reads from Symbol.metadata (set by TC39 Stage 3 decorators).
+ *
+ * @param classType - The class to get fields from
+ * @param contextMetadata - Optional context.metadata from class decorator (used during decorator execution)
+ */
+function getAllFields(classType, contextMetadata) {
+    const metadata = getMetadataObject(classType, contextMetadata);
+    if (metadata?.[decorator_types_1.FIELDS_METADATA_KEY]) {
+        return [...metadata[decorator_types_1.FIELDS_METADATA_KEY]];
     }
-    return fields;
+    return [];
 }
 /**
- * Get all getters (calculated fields) from a class
+ * Get all getters (calculated fields) from a class.
+ * Reads dependencies from Symbol.metadata (set by @calculatedField decorator).
+ *
+ * @param classType - The class to get getters from
+ * @param contextMetadata - Optional context.metadata from class decorator (used during decorator execution)
  */
-function getAllGetters(classType) {
-    var _a;
+function getAllGetters(classType, contextMetadata) {
     const getters = [];
     const prototype = classType.prototype;
+    // Get calculated field dependencies from metadata
+    const metadata = getMetadataObject(classType, contextMetadata);
+    const calculatedFields = metadata?.[read_model_1.CALCULATED_FIELDS_SYMBOL];
     // Get property descriptors
     const descriptors = Object.getOwnPropertyDescriptors(prototype);
     for (const [propertyKey, descriptor] of Object.entries(descriptors)) {
         if (descriptor.get) {
-            // This is a getter, check if it has @CalculatedField metadata
-            const dependencies = ((_a = Reflect.getMetadata('dynamic:dependencies', classType)) === null || _a === void 0 ? void 0 : _a[propertyKey]) || [];
-            // Get return type from design:returntype if available
-            const returnType = Reflect.getMetadata('design:returntype', prototype, propertyKey);
-            const typeMetadata = analyzeType(returnType || Object, {
+            // This is a getter, check if it has @calculatedField metadata
+            const dependencies = calculatedFields?.[propertyKey] || [];
+            const typeMetadata = analyzeType(Object, {
                 isNullable: false,
                 isGetAccessor: true,
                 isArray: false,
@@ -199,19 +182,24 @@ function getAllGetters(classType) {
     return getters;
 }
 /**
- * Build ClassMetadata from @Field() decorators
+ * Build ClassMetadata from @field() decorators.
+ *
+ * @param classType - The class to build metadata for
+ * @param contextMetadata - Optional context.metadata from class decorator.
+ *   IMPORTANT: During class decorator execution, Symbol.metadata isn't yet attached to the class.
+ *   Class decorators must pass context.metadata to read field metadata correctly.
  */
-function buildClassMetadataFromFields(classType) {
+function buildClassMetadataFromFields(classType, contextMetadata) {
     // Get all fields (including inherited)
-    const fieldMetadatas = getAllFields(classType);
+    const fieldMetadatas = getAllFields(classType, contextMetadata);
     // Convert to PropertyMetadata
     const fields = fieldMetadatas.map((fieldMeta) => ({
         name: fieldMeta.name,
         typeInfo: extractTypeMetadata(fieldMeta, false),
         dependencies: [],
     }));
-    // Get getter methods (for @CalculatedField)
-    const methods = getAllGetters(classType);
+    // Get getter methods (for @calculatedField)
+    const methods = getAllGetters(classType, contextMetadata);
     return {
         name: classType.name,
         type: classType,

package/dist/decorators/field.d.ts

@@ -0,0 +1,23 @@
+import { FieldOptions, TypeFunction } from '@magek/common';
+import { FieldDecoratorContext } from './decorator-types';
+/**
+ * Stage 3 field decorator type
+ */
+type Stage3FieldDecorator = (value: undefined, context: FieldDecoratorContext) => void;
+/**
+ * @field() decorator for explicit type declaration
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * Usage:
+ *   @field() - Simple type
+ *   @field(type => String) - Explicit type
+ *   @field(type => [String]) - Array type
+ *   @field({ nullable: true }) - With options
+ *   @field(type => String, { nullable: true }) - Type with options
+ */
+export declare function field(): Stage3FieldDecorator;
+export declare function field(options: FieldOptions): Stage3FieldDecorator;
+export declare function field(typeFunction: TypeFunction): Stage3FieldDecorator;
+export declare function field(typeFunction: TypeFunction, options: FieldOptions): Stage3FieldDecorator;
+export {};

package/dist/decorators/field.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.field = field;
+const decorator_types_1 = require("./decorator-types");
+/**
+ * Handle Stage 3 decorator format (TC39 decorators)
+ */
+function handleStage3Decorator(context, typeFunction, fieldOptions) {
+    const fieldMetadata = {
+        name: context.name.toString(),
+        typeFunction,
+        options: fieldOptions,
+    };
+    // Store in context.metadata for later retrieval by class decorators
+    // Class decorators (like @Command, @Entity, etc.) will transfer this to the class constructor
+    if (context.metadata) {
+        if (!context.metadata[decorator_types_1.FIELDS_METADATA_KEY]) {
+            context.metadata[decorator_types_1.FIELDS_METADATA_KEY] = [];
+        }
+        const fields = context.metadata[decorator_types_1.FIELDS_METADATA_KEY];
+        const filteredFields = fields.filter((f) => f.name !== fieldMetadata.name);
+        filteredFields.push(fieldMetadata);
+        context.metadata[decorator_types_1.FIELDS_METADATA_KEY] = filteredFields;
+    }
+}
+function field(typeFunctionOrOptions, options) {
+    // Parse arguments
+    let typeFunction;
+    let fieldOptions = {};
+    if (typeof typeFunctionOrOptions === 'function') {
+        typeFunction = typeFunctionOrOptions;
+        fieldOptions = options || {};
+    }
+    else if (typeFunctionOrOptions) {
+        fieldOptions = typeFunctionOrOptions;
+    }
+    // Return Stage 3 decorator
+    return function fieldDecorator(_value, context) {
+        handleStage3Decorator(context, typeFunction, fieldOptions);
+    };
+}

package/dist/decorators/global-error-handler.d.ts

@@ -1,2 +1,11 @@
 import { GlobalErrorHandlerInterface } from '@magek/common';
-export declare function GlobalErrorHandler(): (errorHandlerClass: GlobalErrorHandlerInterface) => void;
+import { ClassDecoratorContext } from './decorator-types';
+/**
+ * Decorator to mark a class as a Global Error Handler.
+ * Global error handlers catch and handle errors from the entire system.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @returns A class decorator function
+ */
+export declare function GlobalErrorHandler(): (errorHandlerClass: GlobalErrorHandlerInterface, context: ClassDecoratorContext) => void;

package/dist/decorators/global-error-handler.js

@@ -2,8 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalErrorHandler = GlobalErrorHandler;
 const magek_1 = require("../magek");
+/**
+ * Decorator to mark a class as a Global Error Handler.
+ * Global error handlers catch and handle errors from the entire system.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @returns A class decorator function
+ */
 function GlobalErrorHandler() {
-    return (errorHandlerClass) => {
+    return (errorHandlerClass, _context) => {
         magek_1.Magek.configureCurrentEnv((config) => {
             if (config.globalErrorsHandler) {
                 throw new Error(`An error handler called ${errorHandlerClass.name} is already registered.

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

@@ -1,3 +1,12 @@
 import { EventHandlerInterface } from '@magek/common';
+import { ClassDecoratorContext } from './decorator-types';
 export declare const GLOBAL_EVENT_HANDLERS = "GLOBAL_EVENT_HANDLERS";
-export declare function GlobalEventHandler<TEventHandler extends EventHandlerInterface>(eventHandlerClass: TEventHandler): void;
+/**
+ * Decorator to mark a class as a Global Event Handler.
+ * Global event handlers react to all events in the system.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param eventHandlerClass - The event handler class
+ */
+export declare function GlobalEventHandler<TEventHandler extends EventHandlerInterface>(eventHandlerClass: TEventHandler, context: ClassDecoratorContext): void;

package/dist/decorators/global-event-handler.js

@@ -4,6 +4,14 @@ exports.GLOBAL_EVENT_HANDLERS = void 0;
 exports.GlobalEventHandler = GlobalEventHandler;
 const event_handler_1 = require("./event-handler");
 exports.GLOBAL_EVENT_HANDLERS = 'GLOBAL_EVENT_HANDLERS';
-function GlobalEventHandler(eventHandlerClass) {
+/**
+ * Decorator to mark a class as a Global Event Handler.
+ * Global event handlers react to all events in the system.
+ *
+ * Uses TC39 Stage 3 decorators.
+ *
+ * @param eventHandlerClass - The event handler class
+ */
+function GlobalEventHandler(eventHandlerClass, context) {
     (0, event_handler_1.registerEventHandler)(exports.GLOBAL_EVENT_HANDLERS, eventHandlerClass);
 }

package/dist/decorators/health-sensor.d.ts

@@ -1,8 +1,11 @@
 import { Class, HealthIndicatorConfiguration, HealthIndicatorInterface } from '@magek/common';
+import { ClassDecoratorContext } from './decorator-types';
 /**
  * Decorator to mark a class as a Magek Health Sensor.
  * Health sensors provide health status information for monitoring endpoints.
  *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param attributes - Health indicator configuration
  * @param attributes.id - Unique indicator identifier
  * @param attributes.name - Indicator description
@@ -11,4 +14,4 @@ import { Class, HealthIndicatorConfiguration, HealthIndicatorInterface } from '@
  * @param attributes.showChildren - If false, children components won't be included in the tree
  * @returns A class decorator function
  */
-export declare function HealthSensor(attributes: HealthIndicatorConfiguration): <TIndicator extends HealthIndicatorInterface>(healthIndicator: Class<TIndicator>) => void;
+export declare function HealthSensor(attributes: HealthIndicatorConfiguration): <TIndicator extends HealthIndicatorInterface>(healthIndicator: Class<TIndicator>, context: ClassDecoratorContext) => void;

package/dist/decorators/health-sensor.js

@@ -7,6 +7,8 @@ const health_indicators_1 = require("../sensor/health/health-indicators");
  * Decorator to mark a class as a Magek Health Sensor.
  * Health sensors provide health status information for monitoring endpoints.
  *
+ * Uses TC39 Stage 3 decorators.
+ *
  * @param attributes - Health indicator configuration
  * @param attributes.id - Unique indicator identifier
  * @param attributes.name - Indicator description
@@ -18,7 +20,6 @@ const health_indicators_1 = require("../sensor/health/health-indicators");
 function HealthSensor(attributes) {
     return (healthIndicator) => {
         magek_1.Magek.configureCurrentEnv((config) => {
-            var _a;
             if (Object.keys(config.userHealthIndicators).length === 0) {
                 config.userHealthIndicators = (0, health_indicators_1.defaultMagekHealthIndicators)(config);
             }
@@ -30,7 +31,7 @@ function HealthSensor(attributes) {
                     name: attributes.name,
                     enabled: attributes.enabled,
                     details: attributes.details,
-                    showChildren: (_a = attributes.showChildren) !== null && _a !== void 0 ? _a : true,
+                    showChildren: attributes.showChildren ?? true,
                 },
             };
         });

package/dist/decorators/index.d.ts

@@ -1,4 +1,6 @@
+export type { ClassDecoratorContext, FieldDecoratorContext, MethodDecoratorContext, GetterDecoratorContext, DecoratorMetadataObject, } from './decorator-types';
 export * from './command';
+export * from './field';
 export * from './query';
 export * from './data-migration';
 export * from './entity';
@@ -14,3 +16,4 @@ export * from './schema-migration';
 export * from './sequenced-by';
 export * from './global-event-handler';
 export * from './non-exposed';
+export * from './health-sensor';

package/dist/decorators/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./command"), exports);
+tslib_1.__exportStar(require("./field"), exports);
 tslib_1.__exportStar(require("./query"), exports);
 tslib_1.__exportStar(require("./data-migration"), exports);
 tslib_1.__exportStar(require("./entity"), exports);
@@ -17,3 +18,4 @@ tslib_1.__exportStar(require("./schema-migration"), exports);
 tslib_1.__exportStar(require("./sequenced-by"), exports);
 tslib_1.__exportStar(require("./global-event-handler"), exports);
 tslib_1.__exportStar(require("./non-exposed"), exports);
+tslib_1.__exportStar(require("./health-sensor"), exports);

package/dist/decorators/metadata.d.ts

@@ -1,5 +1,21 @@
 import { AnyClass, ClassMetadata } from '@magek/common';
-export declare function getClassMetadata(classType: AnyClass): ClassMetadata;
+import { DecoratorMetadataObject } from './decorator-types';
+/**
+ * Get non-exposed fields from decorator metadata.
+ *
+ * @param metadata - The context.metadata object from a class decorator
+ * @returns Array of field names marked with @nonExposed
+ */
+export declare function getNonExposedFields(metadata?: DecoratorMetadataObject): string[];
+/**
+ * Get class metadata from @field() decorators.
+ *
+ * @param classType - The class to get metadata for
+ * @param contextMetadata - Optional context.metadata from class decorator.
+ *   IMPORTANT: During class decorator execution, Symbol.metadata isn't yet attached to the class.
+ *   Class decorators must pass context.metadata to read field metadata correctly.
+ */
+export declare function getClassMetadata(classType: AnyClass, contextMetadata?: DecoratorMetadataObject): ClassMetadata;
 /**
  * Get the argument names from a given function.
  *

package/dist/decorators/metadata.js

@@ -1,28 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNonExposedFields = getNonExposedFields;
 exports.getClassMetadata = getClassMetadata;
 exports.getFunctionArguments = getFunctionArguments;
-const common_1 = require("@magek/common");
 const field_metadata_reader_1 = require("./field-metadata-reader");
-function getClassMetadata(classType) {
-    // Try new @Field() decorator system first
-    try {
-        const fieldMetadata = (0, field_metadata_reader_1.buildClassMetadataFromFields)(classType);
-        // Check if any fields were actually found
-        if (fieldMetadata.fields.length > 0 || fieldMetadata.methods.length > 0) {
-            return fieldMetadata;
-        }
-    }
-    catch (error) {
-        // If field metadata reading fails, try old system
-    }
-    // Fall back to old transformer-based system
-    const meta = (0, common_1.getMetadata)('magek:typeinfo', classType);
-    if (!meta) {
-        throw Error(`Couldn't get proper metadata information of ${classType.name}. ` +
-            'Make sure to decorate all properties with @Field() or enable the TypeScript transformer.');
-    }
-    return meta;
+const non_exposed_1 = require("./non-exposed");
+/**
+ * Get non-exposed fields from decorator metadata.
+ *
+ * @param metadata - The context.metadata object from a class decorator
+ * @returns Array of field names marked with @nonExposed
+ */
+function getNonExposedFields(metadata) {
+    return metadata?.[non_exposed_1.NON_EXPOSED_SYMBOL] || [];
+}
+/**
+ * Get class metadata from @field() decorators.
+ *
+ * @param classType - The class to get metadata for
+ * @param contextMetadata - Optional context.metadata from class decorator.
+ *   IMPORTANT: During class decorator execution, Symbol.metadata isn't yet attached to the class.
+ *   Class decorators must pass context.metadata to read field metadata correctly.
+ */
+function getClassMetadata(classType, contextMetadata) {
+    return (0, field_metadata_reader_1.buildClassMetadataFromFields)(classType, contextMetadata);
 }
 /**
  * Get the argument names from a given function.
@@ -36,9 +37,8 @@ function getClassMetadata(classType) {
  */
 // TODO: Consider extending `@magek/metadata` to yield constructor argument types
 function getFunctionArguments(func) {
-    var _a;
     // First match everything inside the function argument parens.
-    const args = (_a = func.toString().match(/([^(])*\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[2];
+    const args = func.toString().match(/([^(])*\(([^)]*)\)/)?.[2];
     if (!args)
         return [];
     // Split the arguments string into an array comma delimited.

package/dist/decorators/non-exposed.d.ts

@@ -1,2 +1,13 @@
-import { AnyClass } from '@magek/common';
-export declare function NonExposed(target: AnyClass | InstanceType<AnyClass>, methodName: string | undefined, parameterIndex?: number): void;
+import { FieldDecoratorContext, MethodDecoratorContext } from './decorator-types';
+type FieldOrMethodDecoratorContext = FieldDecoratorContext | MethodDecoratorContext;
+/** Symbol for storing non-exposed fields in decorator context.metadata */
+export declare const NON_EXPOSED_SYMBOL: unique symbol;
+/**
+ * Decorator to mark a field or method as non-exposed in GraphQL.
+ *
+ * Uses TC39 Stage 3 decorators.
+ * Non-exposed fields are stored in context.metadata and read by class decorators
+ * (@Entity, @ReadModel, @Command, @Query) which register them to config.
+ */
+export declare function nonExposed(_value: undefined | Function, context: FieldOrMethodDecoratorContext): void;
+export {};

package/dist/decorators/non-exposed.js

@@ -1,24 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonExposed = NonExposed;
-const magek_1 = require("../magek");
-const metadata_1 = require("./metadata");
-function NonExposed(target, methodName, parameterIndex) {
-    magek_1.Magek.configureCurrentEnv((config) => {
-        var _a;
-        const className = (_a = target.name) !== null && _a !== void 0 ? _a : target.constructor.name;
-        const value = config.nonExposedGraphQLMetadataKey[className] || [];
-        const fieldName = getFieldName(methodName, target, parameterIndex);
-        config.nonExposedGraphQLMetadataKey[className] = [...value, fieldName];
-    });
-}
-function getFieldName(methodName, target, parameterIndex) {
-    if (methodName) {
-        return methodName;
-    }
-    if (!parameterIndex) {
-        throw new Error(`We could not get field name information in ${target} for method ${methodName}`);
+exports.NON_EXPOSED_SYMBOL = void 0;
+exports.nonExposed = nonExposed;
+/** Symbol for storing non-exposed fields in decorator context.metadata */
+exports.NON_EXPOSED_SYMBOL = Symbol.for('magek:nonExposed');
+/**
+ * Decorator to mark a field or method as non-exposed in GraphQL.
+ *
+ * Uses TC39 Stage 3 decorators.
+ * Non-exposed fields are stored in context.metadata and read by class decorators
+ * (@Entity, @ReadModel, @Command, @Query) which register them to config.
+ */
+function nonExposed(_value, context) {
+    const fieldName = String(context.name);
+    // Store in context.metadata (becomes class[Symbol.metadata])
+    if (context.metadata) {
+        if (!context.metadata[exports.NON_EXPOSED_SYMBOL]) {
+            context.metadata[exports.NON_EXPOSED_SYMBOL] = [];
+        }
+        const nonExposedFields = context.metadata[exports.NON_EXPOSED_SYMBOL];
+        if (!nonExposedFields.includes(fieldName)) {
+            nonExposedFields.push(fieldName);
+        }
     }
-    const argumentNames = (0, metadata_1.getFunctionArguments)(target);
-    return argumentNames[parameterIndex];
 }