@acorex/platform 20.6.0-next.10 → 20.6.0-next.11

package/fesm2022/acorex-platform-workflow.mjs

@@ -435,8 +435,11 @@ class Activity {
      */
     createResult(output, outcome = 'Done') {
         return {
-            output,
-            outcomes: { [outcome]: true }
+            success: true,
+            data: {
+                output,
+                outcomes: { [outcome]: true },
+            },
         };
     }
 }
@@ -943,15 +946,29 @@ class WorkflowCoordinator {
             // Execute activity via CommandBus
             // Activities registered as AXPCommand return {output, outcomes}
             const result = await this.commandService.execute(task.activityType, task.input || task.config || {});
-            // Extract outcome from outcomes (usually 'Done' or first key)
+            if (!result) {
+                return {
+                    output: null,
+                    outcome: 'Failed',
+                };
+            }
+            if (!result.success) {
+                return {
+                    output: {
+                        error: result.message?.text,
+                    },
+                    outcome: 'Failed',
+                };
+            }
+            const commandResult = result.data;
+            const outcomes = commandResult?.outcomes ?? {};
             let outcome = 'Done';
-            if (result?.outcomes) {
-                // Prefer 'Done' if exists, otherwise use first outcome key
-                outcome = result.outcomes['Done'] ? 'Done' : Object.keys(result.outcomes)[0] || 'Done';
+            if (Object.keys(outcomes).length > 0) {
+                outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || 'Done';
             }
             return {
-                output: result?.output || result,
-                outcome
+                output: commandResult?.output ?? null,
+                outcome,
             };
         }
         catch (error) {
@@ -1043,7 +1060,19 @@ class Sequence extends Activity {
     async execute(input) {
         // Execute all activities in sequence
         for (const activity of this.activities) {
-            await activity.execute(input);
+            const result = await activity.execute(input);
+            if (!result.success) {
+                return {
+                    success: false,
+                    message: result.message,
+                    data: {
+                        output: undefined,
+                        outcomes: {
+                            Failed: true,
+                        },
+                    },
+                };
+            }
         }
         return this.createResult(undefined, 'Done');
     }
@@ -1104,10 +1133,21 @@ class ShowConfirmDialog extends Activity {
         }
         catch (err) {
             console.error('[ShowConfirmDialog] Error showing dialog:', err);
-            return this.createResult({
-                result: false,
-                action: 'error'
-            }, 'Cancelled');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to show confirm dialog',
+                },
+                data: {
+                    output: {
+                        result: false,
+                        action: 'error',
+                    },
+                    outcomes: {
+                        Cancelled: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1164,10 +1204,21 @@ class ShowAlertDialog extends Activity {
         }
         catch (err) {
             console.error('[ShowAlertDialog] Error showing dialog:', err);
-            return this.createResult({
-                result: false,
-                action: 'error'
-            }, 'Done');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to show alert dialog',
+                },
+                data: {
+                    output: {
+                        result: false,
+                        action: 'error',
+                    },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1223,7 +1274,18 @@ class ShowToast extends Activity {
         }
         catch (err) {
             console.error('[ShowToast] Error showing toast:', err);
-            return this.createResult(undefined, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to show toast',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1273,13 +1335,35 @@ class Navigate extends Activity {
                     break;
                 default:
                     console.error(`[Navigate] Unknown navigation mode: ${mode}`);
-                    return this.createResult(undefined, 'Error');
+                    return {
+                        success: false,
+                        message: {
+                            text: `Unknown navigation mode: ${mode}`,
+                        },
+                        data: {
+                            output: undefined,
+                            outcomes: {
+                                Failed: true,
+                            },
+                        },
+                    };
             }
             return this.createResult(undefined, 'Done');
         }
         catch (err) {
             console.error('[Navigate] Error navigating:', err);
-            return this.createResult(undefined, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to navigate',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1315,7 +1399,18 @@ class SetVariable extends Activity {
         }
         catch (err) {
             console.error('[SetVariable] Error setting variable:', err);
-            return this.createResult(undefined, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to set variable',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1351,7 +1446,18 @@ class DispatchEvent extends Activity {
         }
         catch (err) {
             console.error('[DispatchEvent] Error dispatching event:', err);
-            return this.createResult(undefined, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to dispatch event',
+                },
+                data: {
+                    output: undefined,
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1393,13 +1499,36 @@ class If extends Activity {
             }
             // Execute activities in the chosen branch
             for (const activity of activities) {
-                await activity.execute(input);
+                const activityResult = await activity.execute(input);
+                if (!activityResult.success) {
+                    return {
+                        success: false,
+                        message: activityResult.message,
+                        data: {
+                            output: { branch: conditionResult ? 'then' : 'else', failedActivity: activity },
+                            outcomes: {
+                                Failed: true,
+                            },
+                        },
+                    };
+                }
             }
             return this.createResult(result, conditionResult ? 'Then' : 'Else');
         }
         catch (err) {
             console.error('[If] Error evaluating condition:', err);
-            return this.createResult({ branch: 'error' }, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to evaluate condition',
+                },
+                data: {
+                    output: { branch: 'error' },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
     evaluateCondition(condition) {
@@ -1441,7 +1570,22 @@ class While extends Activity {
             while (conditionResult && iteration < maxIterations) {
                 // Execute activities in the loop
                 for (const activity of activities) {
-                    await activity.execute(input);
+                    const activityResult = await activity.execute(input);
+                    if (!activityResult.success) {
+                        return {
+                            success: false,
+                            message: activityResult.message,
+                            data: {
+                                output: {
+                                    iterations: iteration,
+                                    completed: false,
+                                },
+                                outcomes: {
+                                    Failed: true,
+                                },
+                            },
+                        };
+                    }
                 }
                 iteration++;
                 conditionResult = this.evaluateCondition(condition);
@@ -1454,7 +1598,18 @@ class While extends Activity {
         }
         catch (err) {
             console.error('[While] Error in loop execution:', err);
-            return this.createResult({ iterations: 0, completed: false }, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed during loop execution',
+                },
+                data: {
+                    output: { iterations: 0, completed: false },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
     evaluateCondition(condition) {
@@ -1504,7 +1659,23 @@ class ForEach extends Activity {
                 };
                 // Execute activities for current item
                 for (const activity of activities) {
-                    await activity.execute(itemContext);
+                    const activityResult = await activity.execute(itemContext);
+                    if (!activityResult.success) {
+                        return {
+                            success: false,
+                            message: activityResult.message,
+                            data: {
+                                output: {
+                                    totalItems: items.length,
+                                    processedItems: results.length,
+                                    results,
+                                },
+                                outcomes: {
+                                    Failed: true,
+                                },
+                            },
+                        };
+                    }
                 }
                 results.push({
                     item: currentItem,
@@ -1521,7 +1692,18 @@ class ForEach extends Activity {
         }
         catch (err) {
             console.error('[ForEach] Error in iteration:', err);
-            return this.createResult({ totalItems: 0, processedItems: 0, results: [] }, 'Error');
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed during iteration',
+                },
+                data: {
+                    output: { totalItems: 0, processedItems: 0, results: [] },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1566,20 +1748,66 @@ class ExecuteCommand extends Activity {
             }
             // Execute command through Command Bus
             const result = await this.commandService.execute(commandKey, commandInput);
+            if (!result) {
+                return {
+                    success: false,
+                    message: {
+                        text: `Command '${commandKey}' returned no result`,
+                    },
+                    data: {
+                        output: {
+                            commandKey,
+                            success: false,
+                            executedAt: new Date().toISOString(),
+                        },
+                        outcomes: {
+                            Failed: true,
+                        },
+                    },
+                };
+            }
+            if (!result.success) {
+                return {
+                    success: false,
+                    message: result.message,
+                    data: {
+                        output: {
+                            commandKey,
+                            success: false,
+                            executedAt: new Date().toISOString(),
+                            error: result.message?.text,
+                        },
+                        outcomes: {
+                            Failed: true,
+                        },
+                    },
+                };
+            }
             return this.createResult({
                 commandKey,
                 success: true,
-                output: result,
-                executedAt: new Date().toISOString()
+                output: result.data,
+                executedAt: new Date().toISOString(),
             }, 'Done');
         }
         catch (err) {
             console.error('[ExecuteCommand] Error executing command:', err);
-            return this.createResult({
-                commandKey,
+            return {
                 success: false,
-                error: err instanceof Error ? err.message : 'Unknown error'
-            }, 'Failed');
+                message: {
+                    text: err instanceof Error ? err.message : 'Unknown error',
+                },
+                data: {
+                    output: {
+                        commandKey,
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Unknown error',
+                    },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }
@@ -1635,11 +1863,22 @@ class ExecuteQuery extends Activity {
         }
         catch (err) {
             console.error('[ExecuteQuery] Error executing query:', err);
-            return this.createResult({
-                queryKey,
+            return {
                 success: false,
-                error: err instanceof Error ? err.message : 'Unknown error'
-            }, 'Failed');
+                message: {
+                    text: err instanceof Error ? err.message : 'Unknown error',
+                },
+                data: {
+                    output: {
+                        queryKey,
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Unknown error',
+                    },
+                    outcomes: {
+                        Failed: true,
+                    },
+                },
+            };
         }
     }
 }