torc 0.20.7

Workflow management system
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Output formatting utilities for CLI commands.
//!
//! This module provides helper functions for consistent JSON output formatting
//! across all command handlers, reducing code duplication and ensuring consistent
//! error handling.

use serde::Serialize;

/// Print a single object as pretty-printed JSON.
///
/// This function handles serialization errors consistently by printing to stderr
/// and exiting with code 1.
///
/// # Arguments
/// * `value` - Any serializable value to print
/// * `type_name` - Human-readable name of the type for error messages
///
/// # Example
/// ```ignore
/// print_json(&job, "job");
/// ```
pub fn print_json<T: Serialize>(value: &T, type_name: &str) {
    match serde_json::to_string_pretty(value) {
        Ok(json) => println!("{}", json),
        Err(e) => {
            eprintln!("Error serializing {} to JSON: {}", type_name, e);
            std::process::exit(1);
        }
    }
}

/// Print a collection wrapped in a JSON object with a named field.
///
/// Output format: `{"field_name": [...]}`
///
/// # Arguments
/// * `field_name` - The name of the field to wrap the items in
/// * `items` - A slice of serializable items
/// * `type_name` - Human-readable name for error messages
///
/// # Example
/// ```ignore
/// print_json_wrapped("jobs", &jobs, "jobs");
/// // Outputs: {"jobs": [...]}
/// ```
pub fn print_json_wrapped<T: Serialize>(field_name: &str, items: &[T], type_name: &str) {
    let output = serde_json::json!({ field_name: items });
    print_json(&output, type_name);
}

/// Print a success response with workflow ID.
///
/// Output format: `{"workflow_id": N, "status": "success", "message": "..."}`
///
/// # Arguments
/// * `workflow_id` - The workflow ID to include
/// * `message` - Success message to display
pub fn print_success_response(workflow_id: i64, message: &str) {
    let output = serde_json::json!({
        "workflow_id": workflow_id,
        "status": "success",
        "message": message
    });
    // Success responses are simple and should never fail to serialize
    println!("{}", serde_json::to_string_pretty(&output).unwrap());
}

/// Print a success response with custom status and optional extra fields.
///
/// # Arguments
/// * `workflow_id` - The workflow ID to include
/// * `status` - Status string (e.g., "success", "partial_success")
/// * `message` - Message to display
/// * `extra` - Optional additional JSON value to merge into response
pub fn print_status_response(
    workflow_id: i64,
    status: &str,
    message: &str,
    extra: Option<serde_json::Value>,
) {
    let mut output = serde_json::json!({
        "workflow_id": workflow_id,
        "status": status,
        "message": message
    });
    if let Some(extra_fields) = extra
        && let Some(obj) = extra_fields.as_object()
    {
        for (key, value) in obj {
            output[key] = value.clone();
        }
    }
    println!("{}", serde_json::to_string_pretty(&output).unwrap());
}

/// Print an error response to stderr.
///
/// Output format: `{"status": "error", "message": "...", ...}`
///
/// Note: This function does NOT exit. Call `std::process::exit(1)` after if needed.
///
/// # Arguments
/// * `message` - Error message to display
/// * `details` - Optional additional JSON value with error details
pub fn print_error_json(message: &str, details: Option<serde_json::Value>) {
    let mut output = serde_json::json!({
        "status": "error",
        "message": message
    });
    if let Some(d) = details {
        output["details"] = d;
    }
    eprintln!("{}", serde_json::to_string_pretty(&output).unwrap());
}

/// Print an error response to stderr and exit with code 1.
///
/// # Arguments
/// * `message` - Error message to display
/// * `details` - Optional additional JSON value with error details
pub fn print_error_json_and_exit(message: &str, details: Option<serde_json::Value>) -> ! {
    print_error_json(message, details);
    std::process::exit(1);
}

/// Conditionally print as JSON or return for table formatting.
///
/// This is a helper for the common pattern where we check format and either
/// print JSON or continue with table formatting.
///
/// # Returns
/// `true` if JSON was printed, `false` if caller should handle table format
pub fn print_if_json<T: Serialize>(format: &str, value: &T, type_name: &str) -> bool {
    if format == "json" {
        print_json(value, type_name);
        true
    } else {
        false
    }
}

/// Conditionally print wrapped collection as JSON or return for table formatting.
///
/// # Returns
/// `true` if JSON was printed, `false` if caller should handle table format
pub fn print_wrapped_if_json<T: Serialize>(
    format: &str,
    field_name: &str,
    items: &[T],
    type_name: &str,
) -> bool {
    if format == "json" {
        print_json_wrapped(field_name, items, type_name);
        true
    } else {
        false
    }
}