@adaas/a-utils 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "A-Utils is a set of utilities that are used across the ADAAS ecosystem. This package is designed to be a collection of utilities that are used across the ADAAS ecosystem.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",
@@ -80,7 +80,7 @@
     "build": "tsup --config tsup.config.ts"
   },
   "dependencies": {
-    "@adaas/a-concept": "^0.1.46"
+    "@adaas/a-concept": "^0.1.47"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

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

@@ -478,8 +478,6 @@ export class A_Command<
             await new Promise<void>(async (resolve, reject) => {
 
                 try {
-
-
                     const onBeforeExecuteFeature = new A_Feature({
                         name: A_CommandFeatures.onBeforeExecute,
                         component: this,
@@ -509,6 +507,15 @@ export class A_Command<
                         resolve();
                     });
 
+                    this.on(A_CommandEvent.onFail, () => {
+
+                        onBeforeExecuteFeature.interrupt();
+                        onExecuteFeature.interrupt();
+                        onAfterExecuteFeature.interrupt();
+
+                        reject(this.error);
+                    });
+
 
                     await onBeforeExecuteFeature.process(this.scope);
 

package/tests/A-Command.test.ts

@@ -612,6 +612,71 @@ describe('A-Command tests', () => {
             expect([A_Command_Status.COMPLETED, A_Command_Status.FAILED])
                 .toContain(command.status);
         });
+
+        it('Should stop command execution in case of error', async () => {
+
+            class FailingProcessor extends A_Component {
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step1(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+
+                    testExecutionLog.push('Step 1 executed');
+                }
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step2(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    testExecutionLog.push('Step 2 executed');
+                    throw new Error('Simulated error in step 2');
+                }
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step3(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    testExecutionLog.push('Step 3 executed');
+                }
+            }
+
+            const container = new A_Container({
+                name: 'Error Stop 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);
+            expect(testExecutionLog).toEqual([
+                'Step 1 executed',
+                'Step 2 executed'
+            ]); // Step 3 should not be executed
+        });
     });
 
     // =============================================================================