@adaas/a-utils 0.1.10 → 0.1.12

package/tests/A-Command.test.ts

@@ -16,7 +16,7 @@ describe('A-Command tests', () => {
         expect(command.code).toBe('a-command');
         expect(command.id).toBeDefined();
         expect(command.aseid).toBeDefined();
-        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
+        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);
     });
@@ -30,6 +30,30 @@ describe('A-Command tests', () => {
         expect(command.startedAt).toBeInstanceOf(Date);
         expect(command.endedAt).toBeInstanceOf(Date);
     });
+    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
+        > { }
+
+        const command = new MyCommand({ foo: 'baz' });
+
+        A_Context.root.register(command);
+
+        command.emit('A_CUSTOM_EVENT_1');
+        command.emit('compile');
+
+        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);
@@ -53,7 +77,7 @@ describe('A-Command tests', () => {
         expect(deserializedCommand.startedAt?.toISOString()).toBe(command.startedAt?.toISOString());
         expect(deserializedCommand.duration).toBe(command.duration);
     });
-    
+
     it('Should allow to execute a command with custom logic', async () => {
 
         // 1) create a scope 
@@ -131,4 +155,425 @@ describe('A-Command tests', () => {
         expect(command.errors?.size).toBe(1);
         expect(Array.from(command.errors?.values() || [])[0].message).toBe('Test error');
     });
+
+    describe('Command Lifecycle Tests', () => {
+        beforeEach(() => {
+            A_Context.reset();
+        });
+
+        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' });
+            A_Context.root.register(command);
+            
+            // Track lifecycle events
+            command.on('init', () => lifecycleOrder.push('init'));
+            command.on('compile', () => lifecycleOrder.push('compile'));
+            command.on('execute', () => lifecycleOrder.push('execute'));
+            command.on('complete', () => lifecycleOrder.push('complete'));
+            command.on('fail', () => lifecycleOrder.push('fail'));
+
+            await command.execute();
+
+            expect(lifecycleOrder).toEqual(['init', 'compile', 'execute', 'complete']);
+            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        });
+
+        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' });
+            A_Context.root.register(command);
+
+            // Initial status
+            expect(command.status).toBe(A_CONSTANTS__A_Command_Status.CREATED);
+            statusChanges.push(command.status);
+
+            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
+            ]);
+        });
+
+        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_CONSTANTS_A_Command_Features.EXECUTE]() {
+                    throw new A_Error({ title: 'Execution failed' });
+                }
+            }
+
+            A_Context.root.register(FailingComponent);
+            
+            const command = new FailingCommand({ input: 'test' });
+            A_Context.root.register(command);
+
+            const lifecycleOrder: string[] = [];
+            command.on('init', () => lifecycleOrder.push('init'));
+            command.on('compile', () => lifecycleOrder.push('compile'));
+            command.on('execute', () => lifecycleOrder.push('execute'));
+            command.on('complete', () => lifecycleOrder.push('complete'));
+            command.on('fail', () => lifecycleOrder.push('fail'));
+
+            await command.execute();
+
+            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);
+        });
+
+        it('Should track execution timing correctly', async () => {
+            const command = new A_Command({});
+            A_Context.root.register(command);
+
+            expect(command.startedAt).toBeUndefined();
+            expect(command.endedAt).toBeUndefined();
+            expect(command.duration).toBeUndefined();
+
+            const startTime = Date.now();
+            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());
+        });
+    });
+
+    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);
+
+            const listener1Calls: number[] = [];
+            const listener2Calls: number[] = [];
+
+            command.on('init', () => listener1Calls.push(1));
+            command.on('init', () => listener2Calls.push(2));
+
+            await command.init();
+
+            expect(listener1Calls).toEqual([1]);
+            expect(listener2Calls).toEqual([2]);
+        });
+
+        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({});
+            A_Context.root.register(command);
+
+            const customEvent1Calls: number[] = [];
+            const customEvent2Calls: number[] = [];
+
+            command.on('custom-event-1', () => customEvent1Calls.push(1));
+            command.on('custom-event-2', () => customEvent2Calls.push(2));
+
+            command.emit('custom-event-1');
+            command.emit('custom-event-2');
+            command.emit('custom-event-1');
+
+            expect(customEvent1Calls).toEqual([1, 1]);
+            expect(customEvent2Calls).toEqual([2]);
+        });
+
+        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);
+
+            command.on('init', listener);
+            await command.init();
+            expect(listenerCalls).toEqual([1]);
+
+            // Remove listener and verify it's not called again
+            command.off('init', 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
+        });
+
+        it('Should pass command instance to event listeners', async () => {
+            const command = new A_Command({ testParam: 'value' });
+            A_Context.root.register(command);
+
+            let receivedCommand: A_Command<any, any, any> | undefined = undefined;
+
+            command.on('init', (cmd) => {
+                receivedCommand = cmd;
+            });
+
+            await command.init();
+
+            expect(receivedCommand).toBe(command);
+            expect((receivedCommand as any)?.params).toEqual({ testParam: 'value' });
+        });
+
+        it('Should propagate listener errors during event emission', async () => {
+            const command = new A_Command({});
+            A_Context.root.register(command);
+
+            const successfulCalls: number[] = [];
+
+            command.on('init', () => {
+                throw new Error('Listener error');
+            });
+            command.on('init', () => 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
+        });
+    });
+
+    describe('Parameter Serialization and Transmission Tests', () => {
+        beforeEach(() => {
+            A_Context.reset();
+        });
+
+        it('Should preserve complex parameter types during serialization', async () => {
+            interface ComplexParams {
+                stringParam: string;
+                numberParam: number;
+                booleanParam: boolean;
+                objectParam: {
+                    nested: string;
+                    array: number[];
+                };
+                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 ComplexCommand extends A_Command<ComplexParams, { result: string }> {}
+            
+            const command = new ComplexCommand(complexParams);
+            A_Context.root.register(command);
+            
+            await command.execute();
+
+            const serialized = command.toJSON();
+            expect(serialized.params).toEqual(complexParams);
+
+            // 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']);
+        });
+
+        it('Should handle result serialization correctly', async () => {
+            A_Context.reset();
+
+            interface TestResult {
+                processedData: string;
+                count: number;
+                metadata: {
+                    timestamp: string;
+                    version: number;
+                };
+            }
+
+            class ResultCommand extends A_Command<{ input: string }, TestResult> {}
+
+            class ResultProcessor extends A_Component {
+                @A_Feature.Extend({ scope: [ResultCommand] })
+                async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                    @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
+                    });
+                }
+            }
+
+            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);
+        });
+
+        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_CONSTANTS_A_Command_Features.EXECUTE](
+                    @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' });
+                }
+            }
+
+            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);
+
+            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');
+        });
+
+        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()
+            };
+
+            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);
+        });
+
+        it('Should handle empty and edge case parameters', async () => {
+            const edgeCaseParams = {
+                emptyString: '',
+                emptyArray: [],
+                emptyObject: {},
+                zeroNumber: 0,
+                falseBoolean: false,
+                nullValue: null
+            };
+
+            class EdgeCaseCommand extends A_Command<typeof edgeCaseParams, {}> {}
+            
+            const command = new EdgeCaseCommand(edgeCaseParams);
+            A_Context.root.register(command);
+            await command.execute();
+
+            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);
+        });
+    });
 });

package/tests/A-Config.test.ts

@@ -9,7 +9,7 @@ import { A_Polyfill } from '@adaas/a-utils/lib/A-Polyfill/A-Polyfill.component';
 import { A_ConfigLoader } from '@adaas/a-utils/lib/A-Config/A-Config.container';
 import { ENVConfigReader } from '@adaas/a-utils/lib/A-Config/components/ENVConfigReader.component';
 import { FileConfigReader } from '@adaas/a-utils/lib/A-Config/components/FileConfigReader.component';
-import { A_TYPES__ComponentMetaKey } from '@adaas/a-concept/dist/src/global/A-Component/A-Component.constants';
+import { A_Logger } from '@adaas/a-utils/lib/A-Logger/A-Logger.component';
 
 jest.retryTimes(0);
 
@@ -51,7 +51,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Polyfill, FileConfigReader, ENVConfigReader]
+            components: [A_Logger, A_Polyfill, FileConfigReader, ENVConfigReader]
         })
 
         const concept = new A_Concept({
@@ -81,7 +81,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Polyfill, ENVConfigReader]
+            components: [A_Logger, A_Polyfill, ENVConfigReader]
         })
 
         const concept = new A_Concept({
@@ -130,7 +130,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Polyfill, FileConfigReader]
+            components: [A_Logger,A_Polyfill, FileConfigReader]
         })
 
         const concept = new A_Concept({
@@ -163,7 +163,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Polyfill, FileConfigReader]
+            components: [A_Logger,A_Polyfill, FileConfigReader]
         })
 
         const concept = new A_Concept({