Support workflow definitions in execution command

Enhanced the `ExecuteWorkflowCommand` to support workflow
definitions via `-d`/`--definition` and `-f`/`--definition-file`
options. Updated `WorkflowId` to be optional and added logic
to handle workflows created from definitions.

- Modified `workflowIdOption` to accept nullable strings.
- Added `definitionOption` and `definitionFileOption`.
- Updated `ExecuteWorkflowCommandOptions` with new properties.
- Implemented logic to add workflows from definitions if no
  workflow ID is provided.
- Added `ExtractWorkflowId` helper for cleaner ID extraction.
- Improved error handling and logging for better feedback.

#131

Author: ziagham

src/FlowCtl/Commands/Workflows/Executions/Execute/ExecuteWorkflowCommand.cs

@@ -6,14 +6,21 @@ internal class ExecuteWorkflowCommand : BaseCommand<ExecuteWorkflowCommandOption
 {
     public ExecuteWorkflowCommand() : base("execute", Resources.Commands_Workflows_ExecuteDescription)
     {
-        var workflowIdOption = new Option<string>(new[] { "-w", "--workflow-id" },
-            description: Resources.Commands_Workflows_IdentityOption)
-        { IsRequired = true };
+        var workflowIdOption = new Option<string?>(new[] { "-w", "--workflow-id" },
+            description: Resources.Commands_Workflows_IdentityOption);
+
+        var definitionOption = new Option<string?>(new[] { "-d", "--definition" },
+            description: Resources.Commands_Workflows_Add_DefinitionData);
+
+        var definitionFileOption = new Option<string?>(new[] { "-f", "--definition-file" },
+            description: Resources.Commands_Workflows_Add_DefinitionDataFile);
 
         var addressOption = new Option<string?>(new[] { "-a", "--address" },
             description: Resources.Commands_FlowSynxAddress);
 
         AddOption(workflowIdOption);
+        AddOption(definitionOption);
+        AddOption(definitionFileOption);
         AddOption(addressOption);
     }
 }

src/FlowCtl/Commands/Workflows/Executions/Execute/ExecuteWorkflowCommandOptions.cs

@@ -2,6 +2,8 @@
 
 internal class ExecuteWorkflowCommandOptions : ICommandOptions
 {
-    public required string WorkflowId { get; set; }
+    public string? WorkflowId { get; set; }
+    public string Definition { get; set; } = string.Empty;
+    public string? DefinitionFile { get; set; }
     public string? Address { get; set; } = string.Empty;
 }

src/FlowCtl/Commands/Workflows/Executions/Execute/ExecuteWorkflowCommandOptionsHandler.cs

@@ -3,6 +3,7 @@
 using FlowCtl.Extensions;
 using FlowSynx.Client;
 using FlowSynx.Client.Messages.Requests.Workflows;
+using FlowSynx.Client.Messages.Responses.Workflows;
 
 namespace FlowCtl.Commands.Workflows.Executions.Execute;
 
@@ -41,24 +42,73 @@ private async Task Execute(ExecuteWorkflowCommandOptions options, CancellationTo
                 _flowSynxClient.SetConnection(connection);
             }
 
-            if (!Guid.TryParse(options.WorkflowId, out Guid workflowId))
-                throw new FormatException("Invalid workflow id format. Expected a valid GUID.");
+            Guid workflowId;
 
-            var request = new ExecuteWorkflowRequest { WorkflowId = workflowId };
-            var result = await _flowSynxClient.Workflows.ExecuteAsync(request, cancellationToken);
+            if (!string.IsNullOrWhiteSpace(options.WorkflowId))
+            {
+                // Execute existing workflow by id
+                if (!Guid.TryParse(options.WorkflowId, out workflowId))
+                    throw new FormatException("Invalid workflow id format. Expected a valid GUID.");
+            }
+            else
+            {
+                // Need to add workflow first using provided definition
+                if (string.IsNullOrWhiteSpace(options.Definition) && string.IsNullOrWhiteSpace(options.DefinitionFile))
+                    throw new Exception("Either a workflow id (-w) or a definition (-d / -f) must be provided.");
+
+                string? definitionJsonData;
+                if (!string.IsNullOrEmpty(options.DefinitionFile))
+                {
+                    if (!File.Exists(options.DefinitionFile))
+                        throw new Exception(string.Format(Resources.Command_Workflow_AddCommand_FileNotExist, options.DefinitionFile));
+
+                    definitionJsonData = await File.ReadAllTextAsync(options.DefinitionFile, cancellationToken);
+                }
+                else
+                {
+                    definitionJsonData = options.Definition;
+                }
+
+                if (string.IsNullOrWhiteSpace(definitionJsonData))
+                    throw new Exception("Workflow definition content is empty.");
+
+                var addRequest = new AddWorkflowRequest { Definition = definitionJsonData };
+                var addResult = await _flowSynxClient.Workflows.AddAsync(addRequest, cancellationToken);
 
-            if (result.StatusCode != 200)
+                if (addResult.StatusCode != 200)
+                    throw new Exception(Resources.Commands_Error_DuringProcessingRequest);
+
+                var addPayload = addResult.Payload;
+                if (addPayload is { Succeeded: false })
+                {
+                    _flowCtlLogger.WriteError(addPayload.Messages);
+                    return;
+                }
+
+                workflowId = ExtractWorkflowId(addPayload.Data) ?? throw new Exception("Unable to determine newly added workflow id from response.");
+            }
+
+            var execRequest = new ExecuteWorkflowRequest { WorkflowId = workflowId };
+            var execResult = await _flowSynxClient.Workflows.ExecuteAsync(execRequest, cancellationToken);
+
+            if (execResult.StatusCode != 200)
                 throw new Exception(Resources.Commands_Error_DuringProcessingRequest);
 
-            var payload = result.Payload;
-            if (payload is { Succeeded: false })
-                _flowCtlLogger.WriteError(payload.Messages);
+            var execPayload = execResult.Payload;
+            if (execPayload is { Succeeded: false })
+                _flowCtlLogger.WriteError(execPayload.Messages);
             else
-                _flowCtlLogger.Write(payload.Data);
+                _flowCtlLogger.Write(execPayload.Data);
         }
         catch (Exception ex)
         {
             _flowCtlLogger.WriteError(ex.Message);
         }
     }
+
+    private Guid? ExtractWorkflowId(AddWorkflowResponse? data)
+    {
+        if (data is null) return null;
+        return data.Id;
+    }
 }