Struct JsonResponse 

pub struct JsonResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<String>,
}

Standard JSON response structure for all CLI commands.

This structure provides a consistent format for all command outputs when JSON format is requested. Every command must wrap its output data in this structure to ensure API consistency.

Structure

{
  "success": true,
  "data": { ... }
}

Or on error:

{
  "success": false,
  "error": "Error message"
}

Examples

Creating a success response:

use sublime_cli_tools::output::JsonResponse;
use serde::Serialize;

#[derive(Serialize)]
struct InitResult {
    config_file: String,
    strategy: String,
}

let result = InitResult {
    config_file: "repo.config.yaml".to_string(),
    strategy: "independent".to_string(),
};

let response = JsonResponse::success(result);
assert_eq!(response.success, true);
assert!(response.data.is_some());
assert!(response.error.is_none());

Creating an error response:

use sublime_cli_tools::output::JsonResponse;

let response: JsonResponse<()> = JsonResponse::error(
    "Failed to initialize: directory is not empty".to_string()
);

assert_eq!(response.success, false);
assert!(response.data.is_none());
assert!(response.error.is_some());

Fields

success: bool

Indicates whether the operation was successful.

• true: Operation completed successfully, data field will be present
• false: Operation failed, error field will be present

data: Option<T>

The response data (only present when success is true).

This field contains the command-specific output data. It is omitted from the JSON output when None to keep responses clean.

error: Option<String>

The error message (only present when success is false).

This field contains a human-readable error message explaining what went wrong. It is omitted from the JSON output when None.

Implementations

impl<T> JsonResponse<T>

pub fn success(data: T) -> Self

Creates a successful response with data.

The resulting JSON will include success: true and the provided data.

Examples

use sublime_cli_tools::output::JsonResponse;
use serde::Serialize;

#[derive(Serialize)]
struct PackageInfo {
    name: String,
    version: String,
}

let info = PackageInfo {
    name: "@org/core".to_string(),
    version: "1.2.3".to_string(),
};

let response = JsonResponse::success(info);
assert!(response.success);
assert!(response.data.is_some());
assert!(response.error.is_none());

pub fn error(message: String) -> Self

Creates an error response with a message.

The resulting JSON will include success: false and the provided error message.

Examples

use sublime_cli_tools::output::JsonResponse;

let response: JsonResponse<String> = JsonResponse::error(
    "Package not found in workspace".to_string()
);

assert!(!response.success);
assert!(response.data.is_none());
assert_eq!(response.error, Some("Package not found in workspace".to_string()));

pub fn is_success(&self) -> bool

Returns whether this response represents a success.

Examples

use sublime_cli_tools::output::JsonResponse;

let success_response = JsonResponse::success("data");
assert!(success_response.is_success());

let error_response: JsonResponse<String> = JsonResponse::error("failed".to_string());
assert!(!error_response.is_success());

pub fn is_error(&self) -> bool

Returns whether this response represents an error.

Examples

use sublime_cli_tools::output::JsonResponse;

let success_response = JsonResponse::success("data");
assert!(!success_response.is_error());

let error_response: JsonResponse<String> = JsonResponse::error("failed".to_string());
assert!(error_response.is_error());

Trait Implementations

impl<T: Clone> Clone for JsonResponse<T>

fn clone(&self) -> JsonResponse<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for JsonResponse<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for JsonResponse<T>

fn default() -> Self

Creates a default error response.

This is primarily used for initialization purposes and represents an error state with a generic message.

Examples

use sublime_cli_tools::output::JsonResponse;

let response: JsonResponse<String> = JsonResponse::default();
assert!(!response.success);
assert_eq!(response.error, Some("Unknown error".to_string()));

impl<T: PartialEq> PartialEq for JsonResponse<T>

fn eq(&self, other: &JsonResponse<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for JsonResponse<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for JsonResponse<T>

impl<T> StructuralPartialEq for JsonResponse<T>