@adaas/a-utils 0.1.11 → 0.1.13

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-Memory.test.ts

@@ -0,0 +1,189 @@
+import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
+import { A_Error } from '@adaas/a-concept';
+
+jest.retryTimes(0);
+
+describe('A-Memory tests', () => {
+
+    it('Should allow to create memory instance', () => {
+        const memory = new A_Memory();
+        
+        expect(memory).toBeInstanceOf(A_Memory);
+        expect(memory.Errors).toBeUndefined();
+    });
+
+    it('Should allow to create memory with initial values', () => {
+        const initialValues = {
+            key1: 'value1',
+            key2: 42,
+            key3: { nested: 'object' }
+        };
+        
+        const memory = new A_Memory(initialValues);
+        
+        expect(memory.get('key1')).toBe('value1');
+        expect(memory.get('key2')).toBe(42);
+        expect(memory.get('key3')).toEqual({ nested: 'object' });
+    });
+
+    it('Should allow to set and get values', async () => {
+        const memory = new A_Memory<{ 
+            stringValue: string;
+            numberValue: number;
+            objectValue: { prop: string };
+        }>();
+        
+        await memory.set('stringValue', 'test string');
+        await memory.set('numberValue', 123);
+        await memory.set('objectValue', { prop: 'test' });
+        
+        expect(memory.get('stringValue')).toBe('test string');
+        expect(memory.get('numberValue')).toBe(123);
+        expect(memory.get('objectValue')).toEqual({ prop: 'test' });
+    });
+
+    it('Should return undefined for non-existent keys', () => {
+        const memory = new A_Memory<{ existingKey: string }>();
+        
+        expect(memory.get('existingKey')).toBeUndefined();
+        expect(memory.get('nonExistentKey' as any)).toBeUndefined();
+    });
+
+    it('Should allow to drop values', async () => {
+        const memory = new A_Memory<{ key1: string; key2: number }>();
+        
+        await memory.set('key1', 'value1');
+        await memory.set('key2', 42);
+        
+        expect(memory.get('key1')).toBe('value1');
+        expect(memory.get('key2')).toBe(42);
+        
+        await memory.drop('key1');
+        
+        expect(memory.get('key1')).toBeUndefined();
+        expect(memory.get('key2')).toBe(42);
+    });
+
+    it('Should allow to clear all values', async () => {
+        const memory = new A_Memory<{ key1: string; key2: number }>();
+        
+        await memory.set('key1', 'value1');
+        await memory.set('key2', 42);
+        
+        expect(memory.get('key1')).toBe('value1');
+        expect(memory.get('key2')).toBe(42);
+        
+        await memory.clear();
+        
+        expect(memory.get('key1')).toBeUndefined();
+        expect(memory.get('key2')).toBeUndefined();
+    });
+
+    it('Should handle errors correctly', async () => {
+        const memory = new A_Memory();
+        
+        expect(memory.Errors).toBeUndefined();
+        
+        const error1 = new A_Error({ title: 'Error 1' });
+        const error2 = new A_Error({ title: 'Error 2' });
+        
+        await memory.error(error1);
+        await memory.error(error2);
+        
+        expect(memory.Errors).toBeDefined();
+        expect(memory.Errors?.size).toBe(2);
+        expect(memory.Errors?.has(error1)).toBe(true);
+        expect(memory.Errors?.has(error2)).toBe(true);
+    });
+
+    it('Should verify prerequisites correctly', async () => {
+        const memory = new A_Memory<{ 
+            required1: string;
+            required2: number;
+            optional?: string;
+        }>();
+        
+        // No values set initially
+        expect(await memory.verifyPrerequisites(['required1', 'required2'])).toBe(false);
+        
+        // Set one required value
+        await memory.set('required1', 'value1');
+        expect(await memory.verifyPrerequisites(['required1', 'required2'])).toBe(false);
+        
+        // Set both required values
+        await memory.set('required2', 42);
+        expect(await memory.verifyPrerequisites(['required1', 'required2'])).toBe(true);
+        
+        // Test with empty requirements
+        expect(await memory.verifyPrerequisites([])).toBe(true);
+    });
+
+    it('Should serialize to JSON correctly', async () => {
+        const memory = new A_Memory<{
+            stringProp: string;
+            numberProp: number;
+            objectProp: { nested: string };
+            arrayProp: number[];
+        }>();
+        
+        await memory.set('stringProp', 'test');
+        await memory.set('numberProp', 42);
+        await memory.set('objectProp', { nested: 'value' });
+        await memory.set('arrayProp', [1, 2, 3]);
+        
+        const json = memory.toJSON();
+        
+        expect(json).toEqual({
+            stringProp: 'test',
+            numberProp: 42,
+            objectProp: { nested: 'value' },
+            arrayProp: [1, 2, 3]
+        });
+    });
+
+    it('Should handle objects with toJSON method in serialization', async () => {
+        class SerializableObject {
+            constructor(private value: string) {}
+            
+            toJSON() {
+                return { serialized: this.value };
+            }
+        }
+        
+        const memory = new A_Memory<{
+            regular: string;
+            serializable: SerializableObject;
+        }>();
+        
+        await memory.set('regular', 'normal value');
+        await memory.set('serializable', new SerializableObject('test'));
+        
+        const json = memory.toJSON();
+        
+        expect(json).toEqual({
+            regular: 'normal value',
+            serializable: { serialized: 'test' }
+        });
+    });
+
+    it('Should handle null and undefined values correctly', async () => {
+        const memory = new A_Memory<{
+            nullValue: null;
+            undefinedValue: undefined;
+            stringValue: string;
+        }>();
+        
+        await memory.set('nullValue', null);
+        await memory.set('undefinedValue', undefined);
+        await memory.set('stringValue', 'test');
+        
+        expect(memory.get('nullValue')).toBe(null);
+        expect(memory.get('undefinedValue')).toBe(undefined);
+        expect(memory.get('stringValue')).toBe('test');
+        
+        const json = memory.toJSON();
+        expect(json.nullValue).toBe(null);
+        expect(json.undefinedValue).toBe(undefined);
+        expect(json.stringValue).toBe('test');
+    });
+});