@adaas/a-utils 0.1.18 → 0.1.20

package/tests/A-Command.test.ts

@@ -1,579 +1,667 @@
 import { A_Command } from '@adaas/a-utils/lib/A-Command/A-Command.entity';
-import { A_CONSTANTS__A_Command_Status, A_CommandFeatures } from '@adaas/a-utils/lib/A-Command/A-Command.constants';
-import { A_Component, A_Context, A_Error, A_Feature, A_Inject, A_Scope } from '@adaas/a-concept';
-import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
+import { A_CommandError } from '@adaas/a-utils/lib/A-Command/A-Command.error';
+import { A_Command_Status, A_CommandFeatures } from '@adaas/a-utils/lib/A-Command/A-Command.constants';
+import { A_TYPES__Command_Serialized } from '@adaas/a-utils/lib/A-Command/A-Command.types';
+import { A_StateMachine } from '@adaas/a-utils/lib/A-StateMachine/A-StateMachine.component';
+import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.component';
+import { A_MemoryContext } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
+import { A_Channel } from '@adaas/a-utils/lib/A-Channel/A-Channel.component';
+import { A_ChannelRequest } from '@adaas/a-utils/lib/A-Channel/A-ChannelRequest.context';
+import { A_Caller, A_Component, A_Concept, A_Container, A_Context, A_Error, A_Feature, A_FormatterHelper, A_Inject, A_Scope, ASEID } from '@adaas/a-concept';
 
 jest.retryTimes(0);
 
-describe('A-Command tests', () => {
-
-    it('Should Allow to create a command', async () => {
-        const command = new A_Command({});
-        A_Context.root.register(command);
+// Global test execution tracking arrays
+let testExecutionLog: string[] = [];
 
+describe('A-Command tests', () => {
 
-        expect(command).toBeInstanceOf(A_Command);
-        expect(command.code).toBe('a-command');
-        expect(command.id).toBeDefined();
-        expect(command.aseid).toBeDefined();
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.CREATED);
-        expect(command.scope).toBeInstanceOf(A_Scope);
-        expect(command.scope.resolve(A_Memory)).toBeInstanceOf(A_Memory);
-    });
-    it('Should allow to execute a command', async () => {
-        const command = new A_Command({});
-        A_Context.root.register(command);
-
-        await command.execute();
-
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
-        expect(command.startedAt).toBeInstanceOf(Date);
-        expect(command.endedAt).toBeInstanceOf(Date);
+    beforeEach(() => {
+        A_Context.reset();
+        testExecutionLog = [];
     });
-    it('Should Allow to create a command with custom generic types', async () => {
-        type LifecycleEvents = 'A_CUSTOM_EVENT_1' | 'A_CUSTOM_EVENT_2';
 
-        class MyCommand extends A_Command<
-            { foo: string },
-            { bar: string },
-            LifecycleEvents
-        > { }
+    // =============================================================================
+    // ======================== Basic Command Creation Tests =====================
+    // =============================================================================
 
-        const command = new MyCommand({ foo: 'baz' });
+    describe('Basic Command Creation', () => {
+        interface TestCommandParams {
+            userId: string;
+            action: string;
+        }
 
-        A_Context.root.register(command);
+        interface TestCommandResult {
+            success: boolean;
+            message: string;
+        }
 
-        command.emit('A_CUSTOM_EVENT_1');
-        command.emit('onCompile');
+        class TestCommand extends A_Command<TestCommandParams, TestCommandResult> { }
 
-        expect(command).toBeInstanceOf(A_Command);
-        expect(command.code).toBe('my-command');
-        expect(command.id).toBeDefined();
-        expect(command.aseid).toBeDefined();
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.CREATED);
-        expect(command.scope).toBeInstanceOf(A_Scope);
-        expect(command.scope.resolve(A_Memory)).toBeInstanceOf(A_Memory);
-    });
-    it('Should allow to serialize and deserialize a command', async () => {
-        const command = new A_Command({});
-        A_Context.root.register(command);
-
-        await command.execute();
-
-        const serialized = command.toJSON();
-        expect(serialized).toBeDefined();
-        expect(serialized.aseid).toBe(command.aseid.toString());
-        expect(serialized.code).toBe(command.code);
-        expect(serialized.status).toBe(command.status);
-        expect(serialized.startedAt).toBe(command.startedAt?.toISOString());
-        expect(serialized.duration).toBe(command.duration);
-
-
-        const deserializedCommand = new A_Command(serialized);
-        expect(deserializedCommand).toBeInstanceOf(A_Command);
-        expect(deserializedCommand.aseid.toString()).toBe(command.aseid.toString());
-        expect(deserializedCommand.code).toBe(command.code);
-        expect(deserializedCommand.status).toBe(command.status);
-        expect(deserializedCommand.startedAt?.toISOString()).toBe(command.startedAt?.toISOString());
-        expect(deserializedCommand.duration).toBe(command.duration);
-    });
+        it('Should allow to create a command with parameters', () => {
+            const params = { userId: '123', action: 'create' };
+            const command = new TestCommand(params);
 
-    it('Should allow to execute a command with custom logic', async () => {
+            expect(command).toBeInstanceOf(A_Command);
+            expect(command.params).toEqual(params);
+            expect(command.status).toBe(A_Command_Status.CREATED);
+            expect(command.result).toBeUndefined();
+            expect(command.error).toBeUndefined();
+        });
 
-        // 1) create a scope 
-        A_Context.reset();
+        it('Should have proper initial state and timestamps', () => {
+            const params = { userId: '123', action: 'create' };
+            const command = new TestCommand(params);
 
-        // 2) create a new command 
-        type resultType = { bar: string };
-        type invokeType = { foo: string };
-        class MyCommand extends A_Command<invokeType, resultType> { }
+            expect(command.status).toBe(A_Command_Status.CREATED);
+            expect(command.createdAt).toBeInstanceOf(Date);
+            expect(command.startedAt).toBeUndefined();
+            expect(command.endedAt).toBeUndefined();
+            expect(command.duration).toBeUndefined();
+            expect(command.idleTime).toBeUndefined();
+            expect(command.isProcessed).toBe(false);
+        });
 
-        A_Context.root.register(MyCommand);
+        it('Should have unique command code based on class name', () => {
+            const command = new TestCommand({ userId: '123', action: 'create' });
 
-        // 3) create a custom component with custom logic
-        class MyComponent extends A_Component {
+            expect(command.code).toBe('test-command');
+            expect((TestCommand as any).code).toBe('test-command');
+        });
 
-            @A_Feature.Extend({ scope: [MyCommand] })
-            async [A_CommandFeatures.onExecute](
-                @A_Inject(A_Memory) context: A_Memory<resultType>
-            ) {
-                context.set('bar', 'baz');
-            }
-        }
+        it('Should have event listener capabilities', () => {
+            const command = new TestCommand({ userId: '123', action: 'create' });
+            const listener = jest.fn();
 
-        // 4) register component in the scope
-        A_Context.root.register(MyComponent);
+            command.on(A_CommandFeatures.onComplete, listener);
+            command.emit(A_CommandFeatures.onComplete);
 
-        // 5) create a new command instance within the scope
-        const command = new MyCommand({ foo: 'bar' });
-        A_Context.root.register(command);
+            expect(listener).toHaveBeenCalledWith(command);
+        });
 
-        // 6) execute the command
-        await command.execute();
+        it('Should support removing event listeners', () => {
+            const command = new TestCommand({ userId: '123', action: 'create' });
+            const listener = jest.fn();
 
-        // 7) verify that command was executed with custom logic from MyComponent
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
-        expect(command.result).toBeDefined();
-        expect(command.result).toEqual({ bar: 'baz' });
-    })
-    it('Should allow to fail a command with custom logic', async () => {
-        // 1) reset context to have a clean scope
-        A_Context.reset();
+            command.on(A_CommandFeatures.onComplete, listener);
+            command.off(A_CommandFeatures.onComplete, listener);
+            command.emit(A_CommandFeatures.onComplete);
 
-        // 2) create a new command 
-        type resultType = { bar: string };
-        type invokeType = { foo: string };
-        class MyCommand extends A_Command<invokeType, resultType> { }
+            expect(listener).not.toHaveBeenCalled();
+        });
+    });
 
-        A_Context.root.register(MyCommand);
+    // =============================================================================
+    // ======================== Command Lifecycle Tests ==========================
+    // =============================================================================
 
-        // 3) create a custom component with custom logic
-        class MyComponent extends A_Component {
+    describe('Command Lifecycle', () => {
+        interface UserCommandParams {
+            userId: string;
+        }
 
-            @A_Feature.Extend({ scope: [MyCommand] })
-            async [A_CommandFeatures.onExecute](
-                @A_Inject(A_Memory) context: A_Memory<resultType>
-            ) {
-                context.error(new A_Error({ title: 'Test error' }));
-                //  it's optional to throw an error here, as the command may contain multiple errors that also can be a result of async operations
-                throw new A_Error({ title: 'Test error thrown' });
-            }
+        interface UserCommandResult {
+            success: boolean;
+            data: any;
         }
 
-        // 4) register component in the scope
-        A_Context.root.register(MyComponent);
-        // 5) create a new command instance within the scope
-        const command = new MyCommand({ foo: 'bar' });
-        A_Context.root.register(command);
+        class UserCommand extends A_Command<UserCommandParams, UserCommandResult> { }
 
-        // 6) execute the command
-        await command.execute();
+        it('Should properly initialize command with scope', async () => {
+            const command = new UserCommand({ userId: '123' });
+            A_Context.root.register(command);
 
-        // 7) verify that command was executed with custom logic from MyComponent
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
-        expect(command.errors).toBeDefined();
-        expect(command.errors?.size).toBe(1);
-        expect(Array.from(command.errors?.values() || [])[0].message).toBe('Test error');
-    });
+            await command.init();
 
-    describe('Command Lifecycle Tests', () => {
-        beforeEach(() => {
-            A_Context.reset();
+            expect(command.status).toBe(A_Command_Status.INITIALIZED);
+            expect(command.scope).toBeInstanceOf(A_Scope);
         });
 
-        it('Should follow correct lifecycle sequence during execution', async () => {
-            const lifecycleOrder: string[] = [];
-            
-            class TestCommand extends A_Command<{ input: string }, { output: string }> {}
-            
-            const command = new TestCommand({ input: 'test' });
+        it('Should transition through proper lifecycle states during execution', async () => {
+            const command = new UserCommand({ userId: '123' });
             A_Context.root.register(command);
-            
-            // Track lifecycle events
-            command.on(A_CommandFeatures.onInit, () => lifecycleOrder.push('init'));
-            command.on(A_CommandFeatures.onCompile, () => lifecycleOrder.push('compile'));
-            command.on(A_CommandFeatures.onExecute, () => lifecycleOrder.push('execute'));
-            command.on(A_CommandFeatures.onComplete, () => lifecycleOrder.push('complete'));
-            command.on(A_CommandFeatures.onFail, () => lifecycleOrder.push('fail'));
+
+            expect(command.status).toBe(A_Command_Status.CREATED);
 
             await command.execute();
 
-            expect(lifecycleOrder).toEqual(['init', 'compile', 'execute', 'complete']);
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            expect(command.startedAt).toBeInstanceOf(Date);
+            expect(command.endedAt).toBeInstanceOf(Date);
+            expect(command.duration).toBeGreaterThanOrEqual(0);
+            expect(command.isProcessed).toBe(true);
         });
 
-        it('Should track status changes through lifecycle', async () => {
-            const statusChanges: A_CONSTANTS__A_Command_Status[] = [];
-            
-            class TestCommand extends A_Command<{ input: string }, { output: string }> {}
-            
-            const command = new TestCommand({ input: 'test' });
+        it('Should handle command completion with result', async () => {
+            const command = new UserCommand({ userId: '123' });
             A_Context.root.register(command);
 
-            // Initial status
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.CREATED);
-            statusChanges.push(command.status);
+            const result = { success: true, data: { id: '123', name: 'Test User' } };
+            await command.complete(result);
 
-            await command.init();
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
-            statusChanges.push(command.status);
-
-            await command.compile();
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPILED);
-            statusChanges.push(command.status);
-
-            await command.complete();
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
-            statusChanges.push(command.status);
-
-            expect(statusChanges).toEqual([
-                A_CONSTANTS__A_Command_Status.CREATED,
-                A_CONSTANTS__A_Command_Status.INITIALIZED,
-                A_CONSTANTS__A_Command_Status.COMPILED,
-                A_CONSTANTS__A_Command_Status.COMPLETED
-            ]);
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            expect(command.result).toEqual(result);
+            expect(command.isProcessed).toBe(true);
         });
 
-        it('Should handle failed lifecycle correctly', async () => {
-            A_Context.reset();
-            
-            class FailingCommand extends A_Command<{ input: string }, { output: string }> {}
-            
-            class FailingComponent extends A_Component {
-                @A_Feature.Extend({ scope: [FailingCommand] })
-                async [A_CommandFeatures.onExecute]() {
-                    throw new A_Error({ title: 'Execution failed' });
-                }
-            }
-
-            A_Context.root.register(FailingComponent);
-            
-            const command = new FailingCommand({ input: 'test' });
+        it('Should handle command failure with error', async () => {
+            const command = new UserCommand({ userId: '123' });
             A_Context.root.register(command);
 
-            const lifecycleOrder: string[] = [];
-            command.on(A_CommandFeatures.onInit, () => lifecycleOrder.push('init'));
-            command.on(A_CommandFeatures.onCompile, () => lifecycleOrder.push('compile'));
-            command.on(A_CommandFeatures.onExecute, () => lifecycleOrder.push('execute'));
-            command.on(A_CommandFeatures.onComplete, () => lifecycleOrder.push('complete'));
-            command.on(A_CommandFeatures.onFail, () => lifecycleOrder.push('fail'));
+            const error = new A_CommandError({
+                title: 'Test Error',
+                description: 'Test error description'
+            });
 
-            await command.execute();
+            await command.fail(error);
 
-            expect(lifecycleOrder).toEqual(['init', 'compile', 'execute', 'fail']);
-            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
-            expect(command.isFailed).toBe(true);
-            expect(command.isCompleted).toBe(false);
+            expect(command.status).toBe(A_Command_Status.FAILED);
+            expect(command.error).toEqual(error);
+            expect(command.isProcessed).toBe(true);
         });
 
-        it('Should track execution timing correctly', async () => {
-            const command = new A_Command({});
+        it('Should not allow execution if already processed', async () => {
+            const command = new UserCommand({ userId: '123' });
             A_Context.root.register(command);
 
-            expect(command.startedAt).toBeUndefined();
-            expect(command.endedAt).toBeUndefined();
-            expect(command.duration).toBeUndefined();
+            await command.complete({ success: true, data: null });
+            expect(command.isProcessed).toBe(true);
 
-            const startTime = Date.now();
+            // Should not change state on second execution attempt
             await command.execute();
-            const endTime = Date.now();
-
-            expect(command.startedAt).toBeInstanceOf(Date);
-            expect(command.endedAt).toBeInstanceOf(Date);
-            expect(command.duration).toBeGreaterThanOrEqual(0);
-            expect(command.startedAt!.getTime()).toBeGreaterThanOrEqual(startTime);
-            expect(command.endedAt!.getTime()).toBeLessThanOrEqual(endTime);
-            expect(command.duration).toBe(command.endedAt!.getTime() - command.startedAt!.getTime());
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
         });
     });
 
-    describe('Command Subscribers/Event Listeners Tests', () => {
-        beforeEach(() => {
-            A_Context.reset();
-        });
-
-        it('Should allow multiple listeners for the same event', async () => {
-            const command = new A_Command({});
-            A_Context.root.register(command);
+    // =============================================================================
+    // ======================== Command Serialization Tests ======================
+    // =============================================================================
 
-            const listener1Calls: number[] = [];
-            const listener2Calls: number[] = [];
+    describe('Command Serialization', () => {
+        interface SerializationTestParams {
+            itemId: string;
+            quantity: number;
+        }
 
-            command.on(A_CommandFeatures.onInit, () => listener1Calls.push(1));
-            command.on(A_CommandFeatures.onInit, () => listener2Calls.push(2));
+        interface SerializationTestResult {
+            processed: boolean;
+            total: number;
+        }
 
-            await command.init();
+        class SerializationTestCommand extends A_Command<SerializationTestParams, SerializationTestResult> {
+            customProperty?: string;
 
-            expect(listener1Calls).toEqual([1]);
-            expect(listener2Calls).toEqual([2]);
-        });
+            toJSON(): A_TYPES__Command_Serialized<SerializationTestParams, SerializationTestResult> & { customProperty?: string } {
+                return {
+                    ...super.toJSON(),
+                    customProperty: this.customProperty
+                };
+            }
+        }
 
-        it('Should support custom lifecycle events', async () => {
-            type CustomEvents = 'custom-event-1' | 'custom-event-2';
-            
-            class CustomCommand extends A_Command<{}, {}, CustomEvents> {}
-            
-            const command = new CustomCommand({});
+        it('Should serialize command to JSON properly', async () => {
+            const params = { itemId: '999', quantity: 5 };
+            const command = new SerializationTestCommand(params);
             A_Context.root.register(command);
 
-            const customEvent1Calls: number[] = [];
-            const customEvent2Calls: number[] = [];
+            command.customProperty = 'test-value';
 
-            command.on('custom-event-1', () => customEvent1Calls.push(1));
-            command.on('custom-event-2', () => customEvent2Calls.push(2));
+            const result = { processed: true, total: 100 };
+            await command.complete(result);
 
-            command.emit('custom-event-1');
-            command.emit('custom-event-2');
-            command.emit('custom-event-1');
+            const serialized = command.toJSON();
 
-            expect(customEvent1Calls).toEqual([1, 1]);
-            expect(customEvent2Calls).toEqual([2]);
+            expect(serialized.code).toBe('serialization-test-command');
+            expect(serialized.status).toBe(A_Command_Status.COMPLETED);
+            expect(serialized.params).toEqual(params);
+            expect(serialized.result).toEqual(result);
+            expect(serialized.createdAt).toBeDefined();
+            expect((serialized as any).customProperty).toBe('test-value');
         });
 
-        it('Should allow removing event listeners', async () => {
-            const command = new A_Command({});
-            A_Context.root.register(command);
-
-            const listenerCalls: number[] = [];
-            const listener = () => listenerCalls.push(1);
+        it('Should create command from serialized data', () => {
+            // Create a valid ASEID first
+            const existingCommand = new SerializationTestCommand({ itemId: '123', quantity: 1 });
+            const validAseid = existingCommand.aseid.toString();
+
+            const serializedData: A_TYPES__Command_Serialized<SerializationTestParams, SerializationTestResult> = {
+                aseid: validAseid,
+                code: 'serialization-test-command',
+                status: A_Command_Status.COMPLETED,
+                params: { itemId: '999', quantity: 5 },
+                result: { processed: true, total: 100 },
+                createdAt: new Date().toISOString(),
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+                duration: 1000,
+                idleTime: 100
+            };
 
-            command.on(A_CommandFeatures.onInit, listener);
-            await command.init();
-            expect(listenerCalls).toEqual([1]);
+            const command = new SerializationTestCommand(serializedData);
 
-            // Remove listener and verify it's not called again
-            command.off(A_CommandFeatures.onInit, listener);
-            
-            // Reset to call init again
-            (command as any)._status = A_CONSTANTS__A_Command_Status.CREATED;
-            await command.init();
-            expect(listenerCalls).toEqual([1]); // Should still be 1, not 2
+            expect(command.params).toEqual(serializedData.params);
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            expect(command.result).toEqual(serializedData.result);
+            expect(command.createdAt).toBeInstanceOf(Date);
         });
+    });
 
-        it('Should pass command instance to event listeners', async () => {
-            const command = new A_Command({ testParam: 'value' });
-            A_Context.root.register(command);
+    // =============================================================================
+    // ======================== Component Integration Tests =======================
+    // =============================================================================
 
-            let receivedCommand: A_Command<any, any, any> | undefined = undefined;
+    describe('Component Integration', () => {
+        interface ComponentTestParams {
+            userId: string;
+        }
 
-            command.on(A_CommandFeatures.onInit, (cmd) => {
-                receivedCommand = cmd;
-            });
+        interface ComponentTestResult {
+            userInfo: any;
+            processed: boolean;
+        }
 
-            await command.init();
+        class ComponentTestCommand extends A_Command<ComponentTestParams, ComponentTestResult> { }
 
-            expect(receivedCommand).toBe(command);
-            expect((receivedCommand as any)?.params).toEqual({ testParam: 'value' });
-        });
+        class TestProcessor extends A_Component {
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onBeforeExecute](
+                @A_Inject(A_Caller) command: ComponentTestCommand
+            ) {
+                testExecutionLog.push('Pre-processing command');
+            }
 
-        it('Should propagate listener errors during event emission', async () => {
-            const command = new A_Command({});
-            A_Context.root.register(command);
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onExecute](
+                @A_Inject(A_Caller) command: ComponentTestCommand
+            ) {
+                testExecutionLog.push('Executing command');
+                const result = {
+                    userInfo: { id: command.params.userId, name: 'Test User' },
+                    processed: true
+                };
+                await command.complete(result);
+            }
 
-            const successfulCalls: number[] = [];
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onAfterExecute](
+                @A_Inject(A_Caller) command: ComponentTestCommand
+            ) {
+                testExecutionLog.push('Post-processing command');
+            }
+        }
+
+        it('Should execute with component processors', async () => {
+            const container = new A_Container({
+                name: 'Test Container',
+                components: [
+                    TestProcessor,
+                    A_StateMachine
+                ],
+                entities: [ComponentTestCommand]
+            });
 
-            command.on(A_CommandFeatures.onInit, () => {
-                throw new Error('Listener error');
+            const concept = new A_Concept({
+                containers: [container]
             });
-            command.on(A_CommandFeatures.onInit, () => successfulCalls.push(1));
 
-            // Listener errors are propagated and will cause the command to fail
-            await expect(command.init()).rejects.toThrow('Listener error');
-            // The second listener may not be called due to the error
+            await concept.load();
+
+            const command = new ComponentTestCommand({ userId: '123' });
+            container.scope.register(command);
+
+            await command.execute();
+
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            expect(command.result).toEqual({
+                userInfo: { id: '123', name: 'Test User' },
+                processed: true
+            });
         });
     });
 
-    describe('Parameter Serialization and Transmission Tests', () => {
-        beforeEach(() => {
-            A_Context.reset();
-        });
+    // =============================================================================
+    // ======================== Multi-Service Communication Tests ================
+    // =============================================================================
+
+    describe('Multi-Service Communication', () => {
+        interface MultiServiceParams {
+            orderId: string;
+        }
+
+        interface MultiServiceResult {
+            orderStatus: string;
+            processed: boolean;
+        }
 
-        it('Should preserve complex parameter types during serialization', async () => {
-            interface ComplexParams {
-                stringParam: string;
-                numberParam: number;
-                booleanParam: boolean;
-                objectParam: {
-                    nested: string;
-                    array: number[];
+        class MultiServiceCommand extends A_Command<MultiServiceParams, MultiServiceResult> {
+            toJSON(): A_TYPES__Command_Serialized<MultiServiceParams, MultiServiceResult> & { orderId: string } {
+                return {
+                    ...super.toJSON(),
+                    orderId: this.params.orderId
                 };
-                arrayParam: string[];
-                dateParam: string; // ISO string representation
-                nullParam: null;
-                undefinedParam?: undefined;
             }
+        }
 
-            const complexParams: ComplexParams = {
-                stringParam: 'test string',
-                numberParam: 42,
-                booleanParam: true,
-                objectParam: {
-                    nested: 'nested value',
-                    array: [1, 2, 3]
-                },
-                arrayParam: ['a', 'b', 'c'],
-                dateParam: new Date('2023-01-01').toISOString(),
-                nullParam: null
-            };
+        class ServiceAProcessor extends A_Component {
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onBeforeExecute](
+                @A_Inject(A_Caller) command: MultiServiceCommand,
+                @A_Inject(A_Memory) memory: A_Memory<{ orderData: any }>
+            ) {
+                testExecutionLog.push('ServiceA: Pre-processing');
+                await memory.set('orderData', { id: command.params.orderId, status: 'processing' });
+            }
 
-            class ComplexCommand extends A_Command<ComplexParams, { result: string }> {}
-            
-            const command = new ComplexCommand(complexParams);
-            A_Context.root.register(command);
-            
-            await command.execute();
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onExecute](
+                @A_Inject(A_Caller) command: MultiServiceCommand,
+                @A_Inject(A_Channel) channel: A_Channel
+            ) {
+                testExecutionLog.push('ServiceA: Routing to ServiceB');
 
-            const serialized = command.toJSON();
-            expect(serialized.params).toEqual(complexParams);
+                const response = await channel.request<any, A_TYPES__Command_Serialized<MultiServiceParams, MultiServiceResult>>({
+                    container: 'ServiceB',
+                    command: command.toJSON()
+                });
 
-            // Test deserialization
-            const deserializedCommand = new ComplexCommand(serialized);
-            expect(deserializedCommand.params).toEqual(complexParams);
-            expect(deserializedCommand.params.objectParam.nested).toBe('nested value');
-            expect(deserializedCommand.params.arrayParam).toEqual(['a', 'b', 'c']);
-        });
+                command.fromJSON(response.data!);
+            }
+        }
 
-        it('Should handle result serialization correctly', async () => {
-            A_Context.reset();
+        class ServiceBProcessor extends A_Component {
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onBeforeExecute](
+                @A_Inject(A_Caller) command: MultiServiceCommand,
+                @A_Inject(A_Memory) memory: A_Memory<{ orderData: any }>
+            ) {
+                testExecutionLog.push('ServiceB: Pre-processing');
+                const orderData = await memory.get('orderData');
+                expect(orderData).toBeDefined();
+            }
 
-            interface TestResult {
-                processedData: string;
-                count: number;
-                metadata: {
-                    timestamp: string;
-                    version: number;
-                };
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onExecute](
+                @A_Inject(A_Caller) command: MultiServiceCommand
+            ) {
+                testExecutionLog.push('ServiceB: Processing command');
+                await command.complete({
+                    orderStatus: 'completed',
+                    processed: true
+                });
             }
+        }
 
-            class ResultCommand extends A_Command<{ input: string }, TestResult> {}
-
-            class ResultProcessor extends A_Component {
-                @A_Feature.Extend({ scope: [ResultCommand] })
-                async [A_CommandFeatures.onExecute](
-                    @A_Inject(A_Memory) memory: A_Memory<TestResult>
-                ) {
-                    memory.set('processedData', 'processed-input');
-                    memory.set('count', 100);
-                    memory.set('metadata', {
-                        timestamp: new Date().toISOString(),
-                        version: 1
-                    });
+        class TestChannel extends A_Channel {
+            async onRequest(
+                @A_Inject(A_Memory) memory: A_Memory<{ containers: Array<A_Container> }>,
+                @A_Inject(A_ChannelRequest) context: A_ChannelRequest<{ container: string, command: A_TYPES__Command_Serialized }>
+            ): Promise<void> {
+                const containers = await memory.get('containers') || [];
+                const target = containers.find(c => c.name === context.params.container);
+
+                if (!target) {
+                    throw new A_Error(`Container ${context.params.container} not found`);
+                }
+
+                const commandConstructor = target.scope.resolveConstructor<A_Command>(context.params.command.code);
+                if (!commandConstructor) {
+                    throw new A_Error(`Command constructor not found: ${context.params.command.code}`);
                 }
+
+                const command = new commandConstructor(context.params.command);
+                target.scope.register(command);
+
+                await command.execute();
+                context.succeed(command.toJSON());
             }
+        }
+
+        class TestService extends A_Container {
+            @A_Concept.Load()
+            async init(
+                @A_Inject(A_Memory) memory: A_Memory<{ containers: Array<A_Container> }>
+            ) {
+                const containers = await memory.get('containers') || [];
+                containers.push(this);
+                await memory.set('containers', containers);
+                testExecutionLog.push(`Registered container: ${this.name}`);
+            }
+        }
+
+        it('Should handle multi-service command routing', async () => {
+            const sharedMemory = new A_MemoryContext();
+
+            const serviceA = new TestService({
+                name: 'ServiceA',
+                components: [
+                    ServiceAProcessor,
+                    TestChannel,
+                    A_Memory,
+                    A_StateMachine
+                ],
+                entities: [MultiServiceCommand],
+                fragments: [sharedMemory]
+            });
+
+            const serviceB = new TestService({
+                name: 'ServiceB',
+                components: [
+                    ServiceBProcessor,
+                    A_Memory,
+                    A_StateMachine
+                ],
+                entities: [MultiServiceCommand],
+                fragments: [sharedMemory]
+            });
+
+            const concept = new A_Concept({
+                containers: [serviceA, serviceB],
+                components: [A_Memory, TestChannel]
+            });
+
+            await concept.load();
+
+            const command = new MultiServiceCommand({ orderId: '999' });
+            serviceA.scope.register(command);
 
-            A_Context.root.register(ResultProcessor);
-            
-            const command = new ResultCommand({ input: 'test-input' });
-            A_Context.root.register(command);
-            
             await command.execute();
 
-            const serialized = command.toJSON();
-            expect(serialized.result).toBeDefined();
-            expect(serialized.result?.processedData).toBe('processed-input');
-            expect(serialized.result?.count).toBe(100);
-            expect(serialized.result?.metadata).toBeDefined();
-            expect(serialized.result?.metadata.version).toBe(1);
-
-            // Test deserialization - result is restored to memory and accessible through get method
-            const deserializedCommand = new ResultCommand(serialized);
-            const deserializedMemory = deserializedCommand.scope.resolve(A_Memory)!;
-            expect(deserializedMemory.get('processedData')).toBe('processed-input');
-            expect(deserializedMemory.get('count')).toBe(100);
-            expect(deserializedMemory.get('metadata')).toEqual(serialized.result?.metadata);
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            // The result might be set by ServiceB processor but we need to check the execution log
+            expect(testExecutionLog).toContain('ServiceA: Pre-processing');
+            expect(testExecutionLog).toContain('ServiceA: Routing to ServiceB');
+            expect(testExecutionLog).toContain('ServiceB: Pre-processing');
+            expect(testExecutionLog).toContain('ServiceB: Processing command');
         });
+    });
 
-        it('Should handle error serialization correctly', async () => {
-            A_Context.reset();
-
-            class ErrorCommand extends A_Command<{ input: string }, { output: string }> {}
-
-            class ErrorComponent extends A_Component {
-                @A_Feature.Extend({ scope: [ErrorCommand] })
-                async [A_CommandFeatures.onExecute](
-                    @A_Inject(A_Memory) memory: A_Memory<{ output: string }>
-                ) {
-                    memory.error(new A_Error({ 
-                        title: 'First error',
-                        message: 'First error message'
-                    }));
-                    memory.error(new A_Error({ 
-                        title: 'Second error',
-                        message: 'Second error message'
-                    }));
-                    throw new A_Error({ title: 'Thrown error' });
-                }
+    // =============================================================================
+    // ======================== Feature Template Tests ===========================
+    // =============================================================================
+
+    describe('Feature Template Processing', () => {
+        interface TemplateTestParams {
+            itemId: string;
+        }
+
+        interface TemplateTestResult {
+            itemName: string;
+            itemPrice: number;
+        }
+
+        class TemplateTestCommand extends A_Command<TemplateTestParams, TemplateTestResult> {
+            @A_Feature.Define({
+                template: [
+                    {
+                        name: 'itemName',
+                        component: 'ItemNameHandler',
+                        handler: 'getName'
+                    },
+                    {
+                        name: 'itemPrice',
+                        component: 'ItemPriceHandler',
+                        handler: 'getPrice'
+                    }
+                ]
+            })
+            protected async [A_CommandFeatures.onExecute](): Promise<void> {
+                testExecutionLog.push('Executing template-based command');
             }
+        }
+
+        class ItemNameHandler extends A_Component {
+            getName() {
+                testExecutionLog.push('Getting item name');
+                return 'Test Item';
+            }
+        }
+
+        class ItemPriceHandler extends A_Component {
+            getPrice() {
+                testExecutionLog.push('Getting item price');
+                return 99.99;
+            }
+        }
+
+        it('Should process feature templates correctly', async () => {
+            const container = new A_Container({
+                name: 'Template Test Container',
+                components: [
+                    ItemNameHandler,
+                    ItemPriceHandler,
+                    A_StateMachine
+                ],
+                entities: [TemplateTestCommand]
+            });
+
+            const concept = new A_Concept({
+                containers: [container]
+            });
+
+            await concept.load();
+
+            const command = new TemplateTestCommand({ itemId: '123' });
+            container.scope.register(command);
 
-            A_Context.root.register(ErrorComponent);
-            
-            const command = new ErrorCommand({ input: 'test' });
-            A_Context.root.register(command);
-            
             await command.execute();
 
-            expect(command.isFailed).toBe(true);
-            expect(command.errors?.size).toBe(2);
+            expect(command.status).toBe(A_Command_Status.COMPLETED);
+            // Note: The actual template processing depends on the A_Feature implementation
+            // This test validates the structure and execution flow
+        });
+    });
 
-            const serialized = command.toJSON();
-            expect(serialized.errors).toBeDefined();
-            expect(serialized.errors?.length).toBe(2);
-            expect(serialized.errors?.[0].title).toBe('First error');
-            expect(serialized.errors?.[1].title).toBe('Second error');
-
-            // Test deserialization - errors are restored to memory
-            const deserializedCommand = new ErrorCommand(serialized);
-            const deserializedMemory = deserializedCommand.scope.resolve(A_Memory)!;
-            expect(deserializedMemory.Errors?.size).toBe(2);
-            const errorArray = Array.from(deserializedMemory.Errors?.values() || []);
-            expect(errorArray[0].title).toBe('First error');
-            expect(errorArray[1].title).toBe('Second error');
+    // =============================================================================
+    // ======================== Error Handling Tests =============================
+    // =============================================================================
+
+    describe('Error Handling', () => {
+        interface ErrorTestParams {
+            shouldFail: boolean;
+        }
+
+        class ErrorTestCommand extends A_Command<ErrorTestParams, any> { }
+
+        class FailingProcessor extends A_Component {
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onExecute](
+                @A_Inject(A_Caller) command: ErrorTestCommand
+            ) {
+                if (command.params.shouldFail) {
+                    throw new Error('Simulated execution error');
+                }
+                await command.complete({ success: true });
+            }
+        }
+
+        it('Should handle execution errors properly', async () => {
+            const container = new A_Container({
+                name: 'Error Test Container',
+                components: [
+                    FailingProcessor,
+                    A_StateMachine
+                ],
+                entities: [ErrorTestCommand]
+            });
+
+            const concept = new A_Concept({
+                containers: [container]
+            });
+
+            await concept.load();
+
+            const command = new ErrorTestCommand({ shouldFail: true });
+            container.scope.register(command);
+
+            await command.execute();
+
+            expect(command.status).toBe(A_Command_Status.FAILED);
+            expect(command.error).toBeDefined();
+            expect(command.isProcessed).toBe(true);
         });
 
-        it('Should maintain parameter integrity across command transmission', async () => {
-            // Simulate command transmission across network/storage
-            const originalParams = {
-                userId: '12345',
-                action: 'update',
-                data: {
-                    email: 'test@example.com',
-                    preferences: {
-                        theme: 'dark',
-                        notifications: true
-                    }
-                },
-                timestamp: new Date().toISOString()
-            };
+        it('Should handle execution without explicit scope binding', async () => {
+            const command = new ErrorTestCommand({ shouldFail: false });
+
+            // Don't register in any scope - the command will execute but 
+            // without component processors it will complete with default behavior
+            await command.execute();
 
-            class TransmissionCommand extends A_Command<typeof originalParams, { success: boolean }> {}
-            
-            // Step 1: Create and execute original command
-            const originalCommand = new TransmissionCommand(originalParams);
-            A_Context.root.register(originalCommand);
-            await originalCommand.execute();
-
-            // Step 2: Serialize for transmission
-            const serializedForTransmission = JSON.stringify(originalCommand.toJSON());
-
-            // Step 3: Deserialize from transmission
-            const deserializedData = JSON.parse(serializedForTransmission);
-            const restoredCommand = new TransmissionCommand(deserializedData);
-
-            // Step 4: Verify parameter integrity
-            expect(restoredCommand.params).toEqual(originalParams);
-            expect(restoredCommand.params.data.email).toBe('test@example.com');
-            expect(restoredCommand.params.data.preferences.theme).toBe('dark');
-            expect(restoredCommand.aseid.toString()).toBe(originalCommand.aseid.toString());
-            expect(restoredCommand.code).toBe(originalCommand.code);
+            // Since there's no processor to call complete(), the command might
+            // be in COMPLETED or FAILED state depending on internal logic
+            expect([A_Command_Status.COMPLETED, A_Command_Status.FAILED])
+                .toContain(command.status);
         });
+    });
 
-        it('Should handle empty and edge case parameters', async () => {
-            const edgeCaseParams = {
-                emptyString: '',
-                emptyArray: [],
-                emptyObject: {},
-                zeroNumber: 0,
-                falseBoolean: false,
-                nullValue: null
-            };
+    // =============================================================================
+    // ======================== Performance and Timing Tests ====================
+    // =============================================================================
 
-            class EdgeCaseCommand extends A_Command<typeof edgeCaseParams, {}> {}
-            
-            const command = new EdgeCaseCommand(edgeCaseParams);
-            A_Context.root.register(command);
+    describe('Performance and Timing', () => {
+        interface TimingTestParams {
+            delay: number;
+        }
+
+        class TimingTestCommand extends A_Command<TimingTestParams, any> { }
+
+        class DelayProcessor extends A_Component {
+            @A_Feature.Extend()
+            async [A_CommandFeatures.onExecute](
+                @A_Inject(A_Caller) command: TimingTestCommand
+            ) {
+                await new Promise(resolve => setTimeout(resolve, command.params.delay));
+                await command.complete({ completed: true });
+            }
+        }
+
+        it('Should track execution timing correctly', async () => {
+            const container = new A_Container({
+                name: 'Timing Test Container',
+                components: [
+                    DelayProcessor,
+                    A_StateMachine
+                ],
+                entities: [TimingTestCommand]
+            });
+
+            const concept = new A_Concept({
+                containers: [container]
+            });
+
+            await concept.load();
+
+            const command = new TimingTestCommand({ delay: 100 });
+            container.scope.register(command);
+            const startTime = Date.now();
             await command.execute();
+            const endTime = Date.now();
 
-            const serialized = command.toJSON();
-            expect(serialized.params).toEqual(edgeCaseParams);
-
-            const deserializedCommand = new EdgeCaseCommand(serialized);
-            expect(deserializedCommand.params).toEqual(edgeCaseParams);
-            expect(deserializedCommand.params.emptyString).toBe('');
-            expect(deserializedCommand.params.emptyArray).toEqual([]);
-            expect(deserializedCommand.params.emptyObject).toEqual({});
-            expect(deserializedCommand.params.zeroNumber).toBe(0);
-            expect(deserializedCommand.params.falseBoolean).toBe(false);
-            expect(deserializedCommand.params.nullValue).toBe(null);
+            expect(command.duration).toBeGreaterThanOrEqual(100);
+            expect(command.duration).toBeLessThan(endTime - startTime + 50); // Allow some tolerance
+            expect(command.idleTime).toBeGreaterThanOrEqual(0);
+            expect(command.startedAt).toBeInstanceOf(Date);
+            expect(command.endedAt).toBeInstanceOf(Date);
         });
     });
 });