@adaas/a-utils 0.1.17 → 0.1.19

package/src/lib/A-Command/A-Command.entity.ts

@@ -5,122 +5,276 @@ import {
 } from "./A-Command.types";
 import {
     A_CommandFeatures,
-    A_CONSTANTS__A_Command_Event,
-    A_CONSTANTS__A_Command_Status
+    A_Command_Event,
+    A_Command_Status,
+    A_CommandTransitions
 } from "./A-Command.constants";
-import { A_Component, A_Context, A_Entity, A_Error, A_Feature, A_Scope } from "@adaas/a-concept";
-import { A_Memory } from "../A-Memory/A-Memory.context";
+import { A_Caller, A_Context, A_Dependency, A_Entity, A_Error, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
 import { A_CommandError } from "./A-Command.error";
-
-
+import { A_OperationContext } from "../A-Operation/A-Operation.context";
+import { A_StateMachine } from "../A-StateMachine/A-StateMachine.component";
+import { A_StateMachineFeatures } from "../A-StateMachine/A-StateMachine.constants";
+import { A_Logger } from "../A-Logger/A-Logger.component";
+import { A_StateMachineTransition } from "../A-StateMachine/A-StateMachineTransition.context";
+
+/**
+ * A_Command - Advanced Command Pattern Implementation
+ * 
+ * A comprehensive command pattern implementation that encapsulates business logic
+ * as executable commands with full lifecycle management, event handling, and 
+ * state persistence capabilities.
+ * 
+ * ## Key Features
+ * - **Structured Lifecycle**: Automatic progression through init → compile → execute → complete/fail
+ * - **Event-Driven**: Subscribe to lifecycle events and emit custom events
+ * - **State Persistence**: Full serialization/deserialization for cross-service communication
+ * - **Type Safety**: Generic types for parameters, results, and custom events
+ * - **Dependency Injection**: Integrated with A-Concept's DI system
+ * - **Error Management**: Comprehensive error capture and handling
+ * - **Execution Tracking**: Built-in timing and performance metrics
+ * 
+ * ## Lifecycle Phases
+ * 1. **CREATED** - Command instantiated but not initialized
+ * 2. **INITIALIZED** - Execution scope and dependencies set up
+ * 3. **COMPILED** - Ready for execution with all resources prepared
+ * 4. **EXECUTING** - Currently running business logic
+ * 5. **COMPLETED** - Successfully finished execution
+ * 6. **FAILED** - Execution failed with errors captured
+ * 
+ * @template InvokeType - Type definition for command parameters
+ * @template ResultType - Type definition for command execution result
+ * @template LifecycleEvents - Union type of custom lifecycle event names
+ * 
+ * @example
+ * ```typescript
+ * // Define parameter and result types
+ * interface UserCreateParams {
+ *   name: string;
+ *   email: string;
+ *   role: 'admin' | 'user';
+ * }
+ * 
+ * interface UserCreateResult {
+ *   userId: string;
+ *   success: boolean;
+ * }
+ * 
+ * // Create custom command
+ * class CreateUserCommand extends A_Command<UserCreateParams, UserCreateResult> {}
+ * 
+ * // Execute command
+ * const command = new CreateUserCommand({
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   role: 'user'
+ * });
+ * 
+ * scope.register(command);
+ * await command.execute();
+ * 
+ * console.log('Result:', command.result);
+ * console.log('Status:', command.status);
+ * ```
+ */
 export class A_Command<
     InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init,
     ResultType extends Record<string, any> = Record<string, any>,
-    LifecycleEvents extends string | A_CONSTANTS__A_Command_Event = A_CONSTANTS__A_Command_Event
+    LifecycleEvents extends string | A_Command_Event = A_Command_Event,
 > extends A_Entity<InvokeType, A_TYPES__Command_Serialized<InvokeType, ResultType>> {
 
     // ====================================================================
-    // ================== Static A-Command Information ====================
+    // ================== Static Command Information ======================
     // ====================================================================
 
     /**
-     * Command Identifier that corresponds to the class name
+     * Static command identifier derived from the class name
+     * Used for command registration and serialization
      */
     static get code(): string {
         return super.entity;
     }
 
     // ====================================================================
-    // ================ Instance A-Command Information ====================
+    // ================== Instance Properties =============================
     // ====================================================================
-    protected _result?: ResultType;
+
+    /** The origin of the command, used to know has it been created from serialization or invoked */
+    protected _origin!: 'invoked' | 'serialized';
+
+    /** Command execution scope for dependency injection and feature resolution */
     protected _executionScope!: A_Scope;
-    protected _errors?: Set<A_Error>;
 
+    /** Result data produced by successful command execution */
+    protected _result?: ResultType;
+
+    /** Set of errors that occurred during command execution */
+    protected _error!: A_Error;
+
+    /** Command initialization parameters */
     protected _params!: InvokeType;
-    protected _status!: A_CONSTANTS__A_Command_Status
 
+    /** Current lifecycle status of the command */
+    protected _status!: A_Command_Status
+
+    /** Map of event listeners organized by event name */
     protected _listeners: Map<
-        // the name of the event
-        LifecycleEvents | A_CONSTANTS__A_Command_Event,
-        // the listeners for the event
+        LifecycleEvents | A_Command_Event,
         Set<A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>>
     > = new Map();
 
+    /** Timestamp when command execution started */
     protected _startTime?: Date;
-    protected _endTime?: Date
+
+    /** Timestamp when command execution ended */
+    protected _endTime?: Date;
+
+    /** Timestamp when command was created */
+    protected _createdAt!: Date;
+
+
+    // ====================================================================
+    // ================== Public Getter Properties =======================
+    // ====================================================================
 
     /**
-     * Execution Duration in milliseconds
+     * Total execution duration in milliseconds
+     * 
+     * - If completed/failed: Returns total time from start to end
+     * - If currently executing: Returns elapsed time since start
+     * - If not started: Returns undefined
      */
-    get duration() {
+    get duration(): number | undefined {
         return this._endTime && this._startTime
             ? this._endTime.getTime() - this._startTime.getTime()
             : this._startTime
                 ? new Date().getTime() - this._startTime.getTime()
                 : undefined;
     }
+
+    /**
+     * Idle time before execution started in milliseconds
+     * 
+     * Time between command creation and execution start.
+     * Useful for monitoring command queue performance.
+     */
+    get idleTime(): number | undefined {
+        return this._startTime && this._createdAt
+            ? this._startTime.getTime() - this._createdAt.getTime()
+            : undefined;
+    }
+
     /**
-     * A shared scope between all features of the command during its execution
+     * Command execution scope for dependency injection
+     * 
+     * Provides access to components, services, and shared resources
+     * during command execution. Inherits from the scope where the
+     * command was registered.
      */
     get scope(): A_Scope {
         return this._executionScope;
     }
+
     /**
-     * Unique code identifying the command type
-     * Example: 'user.create', 'task.complete', etc.
+     * Unique command type identifier
      * 
+     * Derived from the class name and used for:
+     * - Command registration and resolution
+     * - Serialization and deserialization
+     * - Logging and debugging
+     * 
+     * @example 'create-user-command', 'process-order-command'
      */
     get code(): string {
         return (this.constructor as typeof A_Command).code;
     }
     /**
-     * Current status of the command
+     * Current lifecycle status of the command
+     * 
+     * Indicates the current phase in the command execution lifecycle.
+     * Used to track progress and determine available operations.
      */
-    get status(): A_CONSTANTS__A_Command_Status {
+    get status(): A_Command_Status {
         return this._status;
     }
+
     /**
-     * Start time of the command execution
+     * Timestamp when the command was created
+     * 
+     * Marks the initial instantiation time, useful for tracking
+     * command age and queue performance metrics.
+     */
+    get createdAt(): Date {
+        return this._createdAt!;
+    }
+
+    /**
+     * Timestamp when command execution started
+     * 
+     * Undefined until execution begins. Used for calculating
+     * execution duration and idle time.
      */
     get startedAt(): Date | undefined {
         return this._startTime;
     }
+
     /**
-     * End time of the command execution
+     * Timestamp when command execution ended
+     * 
+     * Set when command reaches COMPLETED or FAILED status.
+     * Used for calculating total execution duration.
      */
     get endedAt(): Date | undefined {
         return this._endTime;
     }
+
     /**
-     * Result of the command execution stored in the context
+     * Result data produced by command execution
+     * 
+     * Contains the output data from successful command execution.
+     * Undefined until command completes successfully.
      */
     get result(): ResultType | undefined {
         return this._result;
     }
+
     /**
-     * Errors encountered during the command execution stored in the context
+     * Array of errors that occurred during execution
+     * 
+     * Automatically wraps native errors in A_Error instances
+     * for consistent error handling. Empty array if no errors occurred.
      */
-    get errors(): Set<A_Error> | undefined {
-        return this._errors;
+    get error(): A_Error | undefined {
+        return this._error;
     }
+
     /**
-     * Parameters used to invoke the command
-     */
-    get params(): InvokeType {
-        return this._params;
+     * Command initialization parameters
+     * 
+     * Contains the input data used to create and configure the command.
+     * These parameters are immutable during command execution.
+                    return new A_Error(err);
+                }
+            });
     }
+
     /**
-     * Indicates if the command has failed
+     * Command initialization parameters
+     * 
+     * Contains the input data used to create and configure the command.
+     * These parameters are immutable during command execution.
      */
-    get isFailed(): boolean {
-        return this._status === A_CONSTANTS__A_Command_Status.FAILED;
+    get params(): InvokeType {
+        return this._params;
     }
+
     /**
-     * Indicates if the command has completed successfully
+     * Indicates if the command has been processed (completed or failed)
+     * 
+     * Returns true if the command has completed or failed, false otherwise.
      */
-    get isCompleted(): boolean {
-        return this._status === A_CONSTANTS__A_Command_Status.COMPLETED;
+    get isProcessed(): boolean {
+        return this._status === A_Command_Status.COMPLETED
+            || this._status === A_Command_Status.FAILED;
     }
 
     /**
@@ -138,115 +292,280 @@ export class A_Command<
         /**
          * Command invocation parameters
          */
-        params: InvokeType | A_TYPES__Command_Serialized<InvokeType, ResultType> | string
+        params: InvokeType | A_TYPES__Command_Serialized<InvokeType, ResultType> | string,
     ) {
-        super(params as any)
+        super(params as any);
     }
 
-
     // --------------------------------------------------------------------------
-    // A-Command Lifecycle Methods
+    // A-StateMachine Feature Extensions
     // --------------------------------------------------------------------------
+    @A_Feature.Extend()
+    protected async [A_StateMachineFeatures.onBeforeTransition](
+        @A_Inject(A_StateMachineTransition) transition: A_StateMachineTransition,
+        @A_Inject(A_Logger) logger?: A_Logger,
+        ...args: any[]
+    ) {
+        this.checkScopeInheritance();
 
-    // should create a new Task in DB  with basic records
-    async init(): Promise<void> {
-        //  first check statuis if it passed then - skip
-        if (this._status !== A_CONSTANTS__A_Command_Status.CREATED) {
+        //  and register all allowed status transitions
+        //  switch across allowed transitions, if not allowed throw an error
+        logger?.debug('yellow', `Command ${this.aseid.toString()} transitioning from ${transition.from} to ${transition.to}`);
+    }
+
+    @A_Feature.Extend()
+    protected async [A_CommandTransitions.CREATED_TO_INITIALIZED](
+        @A_Inject(A_StateMachineTransition) transition: A_StateMachineTransition,
+        ...args: any[]
+    ): Promise<void> {
+        if (this._status !== A_Command_Status.CREATED) {
             return;
         }
 
-        this._status = A_CONSTANTS__A_Command_Status.INITIALIZATION;
-        this._startTime = new Date();
-
+        this._createdAt = new Date();
+        this._status = A_Command_Status.INITIALIZED;
 
         this.emit(A_CommandFeatures.onInit);
-        await this.call(A_CommandFeatures.onInit, this.scope);
-        this._status = A_CONSTANTS__A_Command_Status.INITIALIZED;
     }
 
-    // Should compile everything before execution
-    async compile() {
-        if (this._status !== A_CONSTANTS__A_Command_Status.INITIALIZED) {
+    @A_Feature.Extend()
+    protected async [A_CommandTransitions.INITIALIZED_TO_EXECUTING](
+        @A_Inject(A_StateMachineTransition) transition: A_StateMachineTransition,
+        ...args: any[]
+    ): Promise<void> {
+        if (this._status !== A_Command_Status.INITIALIZED
+            && this._status !== A_Command_Status.CREATED
+        ) {
             return;
         }
 
-        this.checkScopeInheritance();
+        this._startTime = new Date();
+        this._status = A_Command_Status.EXECUTING;
 
-        this._status = A_CONSTANTS__A_Command_Status.COMPILATION;
-        this.emit(A_CommandFeatures.onCompile);
-        await this.call(A_CommandFeatures.onCompile, this.scope);
-        this._status = A_CONSTANTS__A_Command_Status.COMPILED;
+        this.emit(A_CommandFeatures.onExecute);
     }
 
+    @A_Feature.Extend()
     /**
-     * Processes the command execution
+     * Handles command completion after successful execution
      * 
-     * @returns 
+     * EXECUTION -> COMPLETED transition
      */
-    async process() {
-        if (this._status !== A_CONSTANTS__A_Command_Status.COMPILED)
-            return;
+    protected async [A_CommandTransitions.EXECUTING_TO_COMPLETED](
+        @A_Inject(A_StateMachineTransition) transition: A_StateMachineTransition,
+        ...args: any[]
+    ): Promise<void> {
+        this._endTime = new Date();
+        this._status = A_Command_Status.COMPLETED;
 
-        this._status = A_CONSTANTS__A_Command_Status.IN_PROGRESS;
+        this.emit(A_CommandFeatures.onComplete);
+    }
 
-        this.checkScopeInheritance();
+    @A_Feature.Extend()
+    /**
+     * Handles command failure during execution
+     * 
+     * EXECUTION -> FAILED transition
+     */
+    protected async [A_CommandTransitions.EXECUTING_TO_FAILED](
+        @A_Inject(A_StateMachineTransition) transition: A_StateMachineTransition,
+        @A_Inject(A_Error) error: A_Error,
+        ...args: any[]
+    ): Promise<void> {
+        this._endTime = new Date();
 
-        this.emit(A_CommandFeatures.onExecute);
+        this._status = A_Command_Status.FAILED;
 
-        await this.call(A_CommandFeatures.onExecute, this.scope);
+        this.emit(A_CommandFeatures.onFail);
+    }
+
+
+    // --------------------------------------------------------------------------
+    // A-Command Lifecycle Feature Extensions
+    // --------------------------------------------------------------------------
+    @A_Feature.Extend()
+    /**
+     * Default behavior for Command Initialization uses StateMachine to transition states
+     */
+    protected async [A_CommandFeatures.onInit](
+        @A_Inject(A_StateMachine) stateMachine: A_StateMachine,
+        ...args: any[]
+    ): Promise<void> {
+        await stateMachine.transition(A_Command_Status.CREATED, A_Command_Status.INITIALIZED);
+    }
+
+    @A_Feature.Extend({
+        after: /.*/
+    })
+    protected async [A_CommandFeatures.onBeforeExecute](
+        @A_Dependency.Required()
+        @A_Inject(A_StateMachine) stateMachine: A_StateMachine,
+        ...args: any[]
+    ): Promise<void> {
+        await stateMachine.transition(A_Command_Status.INITIALIZED, A_Command_Status.EXECUTING);
+    }
+
+    @A_Feature.Extend()
+    protected async [A_CommandFeatures.onExecute](
+        ...args: any[]
+    ): Promise<void> {
+    }
+
+    @A_Feature.Extend()
+    /**
+     * By Default on AfterExecute calls the Completion method to mark the command as completed
+     * 
+     * [!] This can be overridden to implement custom behavior using A_Feature overrides
+     */
+    protected async [A_CommandFeatures.onAfterExecute](
+        ...args: any[]
+    ): Promise<void> {
+    }
+
+    @A_Feature.Extend({
+        after: /.*/
+    })
+    protected async [A_CommandFeatures.onComplete](
+        @A_Inject(A_StateMachine) stateMachine: A_StateMachine,
+        ...args: any[]
+    ): Promise<void> {
+        await stateMachine.transition(A_Command_Status.EXECUTING, A_Command_Status.COMPLETED);
+    }
+
+    @A_Feature.Extend({
+        after: /.*/
+    })
+    protected async [A_CommandFeatures.onFail](
+        @A_Dependency.Required()
+        @A_Inject(A_StateMachine) stateMachine: A_StateMachine,
+        @A_Inject(A_OperationContext) operation: A_OperationContext,
+        ...args: any[]
+    ): Promise<void> {
+        await stateMachine.transition(A_Command_Status.EXECUTING, A_Command_Status.FAILED);
+    }
+
+    // --------------------------------------------------------------------------
+    // A-Command Lifecycle Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Initializes the command before execution.
+     */
+    async init(): Promise<void> {
+        await this.call(A_CommandFeatures.onInit, this.scope);
     }
 
     /**
      * Executes the command logic.
      */
     async execute(): Promise<any> {
-        this.checkScopeInheritance();
+
+        if (this.isProcessed) return;
 
         try {
-            await this.init();
+            this.checkScopeInheritance();
+
+            const context = new A_OperationContext('execute-command');
+
+            this.scope.register(context);
+
+            await new Promise<void>(async (resolve, reject) => {
+
+                try {
+
+
+                    const onBeforeExecuteFeature = new A_Feature({
+                        name: A_CommandFeatures.onBeforeExecute,
+                        component: this,
+                        scope: this.scope
+                    })
+
+                    const onExecuteFeature = new A_Feature({
+                        name: A_CommandFeatures.onExecute,
+                        component: this,
+                        scope: this.scope
+                    })
 
-            await this.compile();
+                    const onAfterExecuteFeature = new A_Feature({
+                        name: A_CommandFeatures.onAfterExecute,
+                        component: this,
+                        scope: this.scope
+                    })
 
-            await this.process();
 
-            await this.complete();
 
+                    this.on(A_CommandFeatures.onComplete, () => {
+
+                        onBeforeExecuteFeature.interrupt();
+                        onExecuteFeature.interrupt();
+                        onAfterExecuteFeature.interrupt();
+
+                        resolve();
+                    });
+
+
+                    await onBeforeExecuteFeature.process(this.scope);
+
+                    await onExecuteFeature.process(this.scope);
+
+                    await onAfterExecuteFeature.process(this.scope);
+
+                    /** only in case it was really invoked we automatically transit it to COMPLETED state */
+                    if (this._origin === 'invoked') {
+                        await this.complete();
+                    }
+
+                    resolve();
+
+                } catch (error) {
+                    reject(error);
+                }
+            });
 
         } catch (error) {
-            await this.fail();
+            let targetError = error instanceof A_Error
+                ? error
+                : new A_CommandError({
+                    title: A_CommandError.ExecutionError,
+                    description: `An error occurred while executing command "${this.aseid.toString()}".`,
+                    originalError: error
+                });
+
+            await this.fail(targetError);
         }
-
-        this._executionScope.destroy();
     }
 
     /**
      * Marks the command as completed
      */
-    async complete() {
-        this.checkScopeInheritance();
+    async complete(result?: ResultType) {
+        if (this.isProcessed) return;
 
-        this._status = A_CONSTANTS__A_Command_Status.COMPLETED;
-        this._endTime = new Date();
-        this._result = this.scope.resolve(A_Memory)!.toJSON() as ResultType;
+        this._status = A_Command_Status.COMPLETED;
+
+        this._result = result;
 
-        this.emit(A_CommandFeatures.onComplete);
         await this.call(A_CommandFeatures.onComplete, this.scope);
 
+        this.scope.destroy();
     }
 
 
+
     /**
      * Marks the command as failed
      */
-    async fail() {
-        this.checkScopeInheritance();
+    async fail(error?: A_Error) {
+        if (this.isProcessed) return;
 
-        this._status = A_CONSTANTS__A_Command_Status.FAILED;
-        this._endTime = new Date();
-        this._errors = this.scope.resolve(A_Memory)!.Errors;
+        this._status = A_Command_Status.FAILED;
+        if (error) {
+            this._error = error;
+            this.scope.register(error);
+        }
 
-        this.emit(A_CommandFeatures.onFail);
         await this.call(A_CommandFeatures.onFail, this.scope);
+
+        this.scope.destroy();
     }
 
 
@@ -260,7 +579,7 @@ export class A_Command<
      * @param event 
      * @param listener 
      */
-    on(event: LifecycleEvents | A_CONSTANTS__A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>) {
+    on(event: LifecycleEvents | A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>) {
         if (!this._listeners.has(event)) {
             this._listeners.set(event, new Set());
         }
@@ -272,7 +591,7 @@ export class A_Command<
      * @param event 
      * @param listener 
      */
-    off(event: LifecycleEvents | A_CONSTANTS__A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>) {
+    off(event: LifecycleEvents | A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>) {
         this._listeners.get(event)?.delete(listener);
     }
     /**
@@ -280,8 +599,8 @@ export class A_Command<
      * 
      * @param event 
      */
-    emit(event: LifecycleEvents | A_CONSTANTS__A_Command_Event) {
-        this._listeners.get(event)?.forEach(listener => {
+    emit(event: LifecycleEvents | A_Command_Event) {
+        this._listeners.get(event)?.forEach(async listener => {
             listener(this);
         });
     }
@@ -302,13 +621,18 @@ export class A_Command<
     fromNew(newEntity: InvokeType): void {
         super.fromNew(newEntity);
 
-        this._executionScope = new A_Scope();
+        this._origin = 'invoked';
 
-        this._executionScope.register(new A_Memory<ResultType>());
+        this._executionScope = new A_Scope({
+            name: `A-Command-Execution-Scope-${this.aseid.toString()}`,
+            components: [A_StateMachine],
+        });
+
+        this._createdAt = new Date();
 
         this._params = newEntity;
 
-        this._status = A_CONSTANTS__A_Command_Status.CREATED;
+        this._status = A_Command_Status.CREATED;
     }
 
 
@@ -323,33 +647,25 @@ export class A_Command<
     fromJSON(serialized: A_TYPES__Command_Serialized<InvokeType, ResultType>): void {
         super.fromJSON(serialized);
 
-        this._executionScope = new A_Scope();
-
-        const memory = new A_Memory<ResultType>();
+        this._origin = 'serialized';
 
-        this._executionScope.register(memory);
+        this._executionScope = new A_Scope({
+            name: `A-Command-Execution-Scope-${this.aseid.toString()}`,
+            components: [A_StateMachine],
+        });
 
+        if (serialized.createdAt) this._createdAt = new Date(serialized.createdAt);
         if (serialized.startedAt) this._startTime = new Date(serialized.startedAt);
         if (serialized.endedAt) this._endTime = new Date(serialized.endedAt);
 
-
-        // Restore result and errors in the memory
-        if (serialized.result) {
-            Object.entries(serialized.result).forEach(([key, value]) => {
-                memory.set(key, value);
-            });
-        }
-
-        if (serialized.errors) {
-            serialized.errors.forEach(err => {
-                memory.error(new A_Error(err));
-            });
-        }
-
         this._params = serialized.params
+        this._status = serialized.status;
 
-        this._status = serialized.status || A_CONSTANTS__A_Command_Status.CREATED;
+        if (serialized.error)
+            this._error = new A_CommandError(serialized.error)
 
+        if (serialized.result)
+            this._result = serialized.result;
     }
 
 
@@ -364,23 +680,34 @@ export class A_Command<
             code: this.code,
             status: this._status,
             params: this._params,
+            createdAt: this._createdAt.toISOString(),
             startedAt: this._startTime ? this._startTime.toISOString() : undefined,
             endedAt: this._endTime ? this._endTime.toISOString() : undefined,
             duration: this.duration,
+            idleTime: this.idleTime,
             result: this.result,
-            errors: this.errors ? Array.from(this.errors).map(err => err.toJSON()) : undefined
+            error: this.error ? this.error.toJSON() : undefined,
         }
     };
 
 
+    //============================================================================================
+    //                                Helpers Methods
+    //============================================================================================
+    /**
+     * Ensures that the command's execution scope inherits from the context scope
+     * 
+     * Throws an error if the command is not bound to any context scope
+     */
     protected checkScopeInheritance(): void {
         let attachedScope: A_Scope;
+
         try {
             attachedScope = A_Context.scope(this);
         } catch (error) {
             throw new A_CommandError({
                 title: A_CommandError.CommandScopeBindingError,
-                description: `Command ${this.code} is not bound to any context scope. Ensure the command is properly registered within a context before execution.`,
+                description: `Command ${this.aseid.toString()} is not bound to any context scope. Ensure the command is properly registered within a context before execution.`,
                 originalError: error
             });
         }
@@ -389,4 +716,5 @@ export class A_Command<
             this.scope.inherit(A_Context.scope(this));
         }
     }
-}
+}
+