@acorex/platform 20.6.0-next.9 → 21.0.0-next.1

package/fesm2022/acorex-platform-workflow.mjs

@@ -6,6 +6,7 @@ import { setSmart } from '@acorex/platform/core';
 import { AXPCommandService, AXPCommandRegistry, AXPQueryService, provideCommandSetups, AXP_COMMAND_SETUP } from '@acorex/platform/runtime';
 import { AXDialogService } from '@acorex/components/dialog';
 import { AXTranslationService } from '@acorex/core/translation';
+import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
 import { AXToastService } from '@acorex/components/toast';
 import { Router } from '@angular/router';
 
@@ -415,6 +416,162 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+/**
+ * Injection token for workflow definition loaders.
+ * Multiple loaders can be provided (multi: true).
+ */
+const AXP_WORKFLOW_DEFINITION_LOADER = new InjectionToken('AXP_WORKFLOW_DEFINITION_LOADER');
+/**
+ * Resolver service for workflow definitions.
+ * Aggregates all registered loaders and resolves workflow definitions.
+ */
+class AXPWorkflowDefinitionResolver {
+    constructor() {
+        this.loaders = inject(AXP_WORKFLOW_DEFINITION_LOADER, { optional: true });
+    }
+    /**
+     * Get workflow definition by name (unique key).
+     * Tries all registered loaders until one returns a definition.
+     * @param name - The workflow name (unique key)
+     * @returns Workflow definition or null if not found
+     */
+    async get(name) {
+        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
+        for (const loader of loaderArray) {
+            try {
+                const definition = await loader.get(name);
+                if (definition) {
+                    return definition;
+                }
+            }
+            catch (error) {
+                console.warn(`[AXPWorkflowDefinitionResolver] Loader failed for ${name}:`, error);
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all available workflow names from all loaders.
+     * @returns Array of unique workflow names
+     */
+    async getAllNames() {
+        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
+        const allNames = new Set();
+        for (const loader of loaderArray) {
+            if (loader.getAllNames) {
+                try {
+                    const names = await loader.getAllNames();
+                    names.forEach((name) => allNames.add(name));
+                }
+                catch (error) {
+                    console.warn('[AXPWorkflowDefinitionResolver] Failed to get names from loader:', error);
+                }
+            }
+        }
+        return Array.from(allNames);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Registry service for workflow definitions.
+ * Caches loaded definitions and provides change notifications.
+ */
+class AXPWorkflowDefinitionRegistryService {
+    constructor() {
+        this.resolver = inject(AXPWorkflowDefinitionResolver);
+        this.cache = new Map();
+        this.onChanged = new Subject();
+    }
+    /**
+     * Observable for workflow definition changes.
+     */
+    get onChanged$() {
+        return this.onChanged.asObservable();
+    }
+    /**
+     * Get workflow definition by name (unique key).
+     * Uses cache if available, otherwise loads from resolver.
+     * @param name - The workflow name (unique key)
+     * @returns Workflow definition or null if not found
+     */
+    async get(name) {
+        // Check cache first
+        if (this.cache.has(name)) {
+            return this.cache.get(name);
+        }
+        // Load from resolver
+        const definition = await this.resolver.get(name);
+        if (definition) {
+            this.cache.set(name, definition);
+            this.onChanged.next({ name, action: 'registered' });
+        }
+        return definition;
+    }
+    /**
+     * Register a workflow definition in the cache.
+     * @param definition - The workflow definition to register
+     */
+    register(definition) {
+        this.cache.set(definition.name, definition);
+        this.onChanged.next({ name: definition.name, action: 'registered' });
+    }
+    /**
+     * Update a workflow definition in the cache.
+     * @param definition - The updated workflow definition
+     */
+    update(definition) {
+        if (this.cache.has(definition.name)) {
+            this.cache.set(definition.name, definition);
+            this.onChanged.next({ name: definition.name, action: 'updated' });
+        }
+    }
+    /**
+     * Remove a workflow definition from the cache.
+     * @param name - The workflow name to remove
+     */
+    remove(name) {
+        if (this.cache.has(name)) {
+            this.cache.delete(name);
+            this.onChanged.next({ name, action: 'removed' });
+        }
+    }
+    /**
+     * Clear all cached workflow definitions.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Check if a workflow definition is cached.
+     * @param definitionId - The workflow definition ID
+     * @returns True if cached, false otherwise
+     */
+    has(definitionId) {
+        return this.cache.has(definitionId);
+    }
+    /**
+     * Get all cached workflow definition IDs.
+     * @returns Array of definition IDs (only those that have been loaded)
+     */
+    getAllIds() {
+        return Array.from(this.cache.keys());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 // ============================================
 // WORKFLOW INSTANCE v3.0.0 TYPES
 // Based on Elsa Workflow Instance schema: https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json
@@ -435,8 +592,11 @@ class Activity {
      */
     createResult(output, outcome = 'Done') {
         return {
-            output,
-            outcomes: { [outcome]: true }
+            success: true,
+            data: {
+                output,
+                outcomes: { [outcome]: true },
+            },
         };
     }
 }
@@ -720,7 +880,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * - Backend activities: Execute via API calls to backend
  * - State caching: Caches workflow state in client for performance
  *
- * ✅ Suitable for production use.
  */
 class WorkflowCoordinator {
     constructor() {
@@ -764,15 +923,17 @@ class WorkflowCoordinator {
     async startWorkflow(workflowId, input = {}) {
         try {
             const execution = await this.startWorkflowExecution(workflowId, input);
-            return {
+            const result = {
                 success: true,
                 output: execution.state.output,
                 nextTask: execution.pendingTask || null,
                 executionId: execution.executionId,
                 state: execution.state
             };
+            return result;
         }
         catch (error) {
+            console.error('[WorkflowCoordinator] ❌ Error in startWorkflow', error);
             return {
                 success: false,
                 error: error.message || 'Failed to start workflow',
@@ -933,8 +1094,9 @@ class WorkflowCoordinator {
     async executeFrontendActivity(task) {
         try {
             // Check if command exists
-            if (!this.commandService.exists(task.activityType)) {
-                console.warn(`[WorkflowCoordinator] Frontend activity '${task.activityType}' is not registered. Skipping execution.`);
+            const commandExists = this.commandService.exists(task.activityType);
+            if (!commandExists) {
+                console.warn(`[WorkflowCoordinator] ⚠️ Frontend activity '${task.activityType}' is not registered. Skipping execution.`);
                 return {
                     output: null,
                     outcome: 'Done'
@@ -942,20 +1104,40 @@ 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)
+            // 🎯 Flatten properties if nested (workflow-studio format)
+            let commandInput = task.input || task.config || {};
+            if (commandInput['properties'] && typeof commandInput['properties'] === 'object') {
+                // Flatten: {properties: {text: "..."}} -> {text: "..."}
+                commandInput = { ...commandInput['properties'] };
+            }
+            const result = await this.commandService.execute(task.activityType, commandInput);
+            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) {
-            console.error(`[WorkflowCoordinator] Error executing frontend activity '${task.activityType}':`, error);
+            console.error(`[WorkflowCoordinator] ❌ Error executing frontend activity '${task.activityType}':`, error);
             return {
                 output: { error: error.message || 'Unknown error' },
                 outcome: 'Failed'
@@ -1043,7 +1225,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 +1298,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 +1369,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,
+                    },
+                },
+            };
         }
     }
 }
@@ -1177,6 +1393,215 @@ var showAlertDialog_activity = /*#__PURE__*/Object.freeze({
     ShowAlertDialog: ShowAlertDialog
 });
 
+/**
+ * Show Dialog Layout Builder Activity - Displays dialog using Layout Builder.
+ *
+ * This activity allows you to create custom dialogs using the Layout Builder API.
+ * It accepts JSON-serializable content (AXPWidgetNode) and actions configuration.
+ *
+ * The content can be created using Layout Builder and then converted to JSON:
+ * ```typescript
+ * const builder = layoutBuilderService.create();
+ * builder.flex(flex => {
+ *   flex.setDirection('column')
+ *     .formField('First Name', field => {
+ *       field.path('firstName');
+ *       field.textBox({ placeholder: 'Enter first name' });
+ *     });
+ * });
+ * const contentNode = builder.build();
+ * ```
+ *
+ * Usage in Workflow:
+ * ```typescript
+ * const dialog = new ShowDialogLayoutBuilder();
+ * await dialog.execute({
+ *   title: 'User Information',
+ *   size: 'md',
+ *   context: { firstName: '', lastName: '' },
+ *   content: {
+ *     type: 'flex-layout',
+ *     mode: 'edit',
+ *     options: {
+ *       flexDirection: 'column',
+ *       gap: '16px'
+ *     },
+ *     children: [
+ *       {
+ *         type: 'form-field',
+ *         mode: 'edit',
+ *         options: {
+ *           label: 'First Name',
+ *           showLabel: true
+ *         },
+ *         children: [{
+ *           type: 'text-editor',
+ *           path: 'firstName',
+ *           options: {
+ *             placeholder: 'Enter first name'
+ *           }
+ *         }]
+ *       }
+ *     ]
+ *   },
+ *   actions: {
+ *     cancel: '@general:actions.cancel.title',
+ *     submit: '@general:actions.submit.title',
+ *     custom: [{
+ *       title: 'Save Draft',
+ *       icon: 'fa-save',
+ *       color: 'secondary',
+ *       command: { name: 'save-draft' }
+ *     }]
+ *   }
+ * });
+ * ```
+ *
+ * Usage in JSON Workflow Definition:
+ * ```json
+ * {
+ *   "type": "ShowDialogLayoutBuilder",
+ *   "properties": {
+ *     "title": "User Information",
+ *     "size": "md",
+ *     "context": { "firstName": "", "lastName": "" },
+ *     "content": {
+ *       "type": "flex-layout",
+ *       "mode": "edit",
+ *       "options": {
+ *         "flexDirection": "column",
+ *         "gap": "16px"
+ *       },
+ *       "children": [
+ *         {
+ *           "type": "form-field",
+ *           "mode": "edit",
+ *           "options": {
+ *             "label": "First Name",
+ *             "showLabel": true
+ *           },
+ *           "children": [{
+ *             "type": "text-editor",
+ *             "path": "firstName",
+ *             "options": {
+ *               "placeholder": "Enter first name"
+ *             }
+ *           }]
+ *         }
+ *       ]
+ *     },
+ *     "actions": {
+ *       "cancel": "@general:actions.cancel.title",
+ *       "submit": "@general:actions.submit.title"
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class ShowDialogLayoutBuilder extends Activity {
+    //#endregion
+    constructor() {
+        super('ShowDialogLayoutBuilder');
+        //#region ----   Services & Dependencies   ----
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+    }
+    async execute(input) {
+        const { title = '', size = 'md', context = {}, closeButton = false, message, content, actions } = input;
+        try {
+            // Create dialog using layout builder
+            const dialogRef = await this.layoutBuilder
+                .create()
+                .dialog(dialog => {
+                // Set basic dialog options
+                dialog
+                    .setTitle(title)
+                    .setSize(size)
+                    .setCloseButton(closeButton)
+                    .setContext(context);
+                // Set message if provided
+                if (message) {
+                    dialog.setMessage(message);
+                }
+                // Set content if provided
+                if (content) {
+                    // If content is already a flex-layout, use it directly
+                    // Otherwise, wrap it in a flex container with column direction
+                    if (content.type === 'flex-layout') {
+                        // Set content layout directly (accessing internal state of DialogContainerBuilder)
+                        dialog.contentLayout = content;
+                    }
+                    else {
+                        // Wrap content in a flex container
+                        const wrappedContent = {
+                            type: 'flex-layout',
+                            mode: 'edit',
+                            options: {
+                                flexDirection: 'column',
+                                gap: '10px',
+                            },
+                            children: [content],
+                        };
+                        dialog.contentLayout = wrappedContent;
+                    }
+                }
+                // Set actions if provided
+                if (actions) {
+                    dialog.setActions(actionBuilder => {
+                        if (actions.cancel) {
+                            actionBuilder.cancel(actions.cancel);
+                        }
+                        if (actions.submit) {
+                            actionBuilder.submit(actions.submit);
+                        }
+                        if (actions.custom) {
+                            actions.custom.forEach(action => {
+                                actionBuilder.custom(action);
+                            });
+                        }
+                    });
+                }
+            })
+                .show();
+            // Get user action and context
+            const action = dialogRef.action() || 'cancel';
+            const dialogContext = dialogRef.context();
+            // Determine outcomes
+            const cancelled = action === 'cancel';
+            const confirmed = action === 'submit' || (!cancelled && action !== 'error');
+            // Close dialog
+            dialogRef.close();
+            // Return result with appropriate outcome
+            const outcome = cancelled ? 'Cancelled' : confirmed ? 'Confirmed' : 'Done';
+            return this.createResult({
+                context: dialogContext,
+                action,
+                cancelled,
+                confirmed
+            }, outcome);
+        }
+        catch (err) {
+            console.error('[ShowDialogLayoutBuilder] Error showing dialog:', err);
+            return {
+                success: false,
+                message: {
+                    text: err instanceof Error ? err.message : 'Failed to show dialog',
+                },
+                data: {
+                    output: {
+                        context: {},
+                        action: 'error',
+                        cancelled: true,
+                        confirmed: false,
+                    },
+                    outcomes: {
+                        Error: true,
+                    },
+                },
+            };
+        }
+    }
+}
+
 /**
  * Show Toast Activity - Displays toast notification to user.
  *
@@ -1223,7 +1648,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 +1709,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 +1773,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 +1820,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 +1873,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 +1944,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 +1972,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 +2033,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 +2066,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 +2122,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 +2237,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,
+                    },
+                },
+            };
         }
     }
 }
@@ -1899,5 +2512,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
+export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map