Struct ApiResponse 

pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<ApiError>,
    pub message: Option<String>,
}

Standard API response wrapper.

Encapsulates success/error status, optional data payload, optional error details, and an optional human-readable message.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::success("hello");
assert!(resp.success);
assert_eq!(resp.data, Some("hello"));

Fields

success: bool

data: Option<T>

error: Option<ApiError>

message: Option<String>

Implementations

impl<T> ApiResponse<T>

pub fn success(data: T) -> Self

Create a successful response carrying data.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::success(42u32);
assert!(resp.success);
assert_eq!(resp.data, Some(42));

pub fn cast<U>(self) -> ApiResponse<U>

Convert this response to another data type, discarding the payload.

Useful for propagating error responses where the data type differs.

Example

use auth_framework::api::responses::ApiResponse;

let err = ApiResponse::<()>::error("FAIL", "oops");
let typed: ApiResponse<String> = err.cast();
assert!(!typed.success);

pub fn forbidden_typed() -> ApiResponse<T>

Create a forbidden (403) response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<String> = ApiResponse::forbidden_typed();
assert!(!resp.success);

pub fn unauthorized_typed() -> ApiResponse<T>

Create an unauthorized (401) response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<Vec<u8>> = ApiResponse::unauthorized_typed();
assert!(!resp.success);

pub fn error_typed(code: &str, message: impl Into<String>) -> ApiResponse<T>

Create an error response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<i32> = ApiResponse::error_typed("FAIL", "bad input");
assert!(!resp.success);

pub fn validation_error_typed(message: impl Into<String>) -> ApiResponse<T>

Create a validation error (400) response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<()> = ApiResponse::validation_error_typed("bad field");
assert!(!resp.success);

pub fn not_found_typed(message: impl Into<String>) -> ApiResponse<T>

Create a not-found (404) response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<String> = ApiResponse::not_found_typed("user");
assert!(!resp.success);

pub fn forbidden_with_message_typed( message: impl Into<String>, ) -> ApiResponse<T>

Create a forbidden (403) response with a custom message for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<()> = ApiResponse::forbidden_with_message_typed("admin only");
assert!(!resp.success);

pub fn error_with_message_typed( code: &str, message: impl Into<String>, ) -> ApiResponse<T>

Create an error response with a custom code and message for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<()> = ApiResponse::error_with_message_typed("QUOTA", "exceeded");
assert_eq!(resp.error.unwrap().code, "QUOTA");

pub fn not_found_with_message_typed( message: impl Into<String>, ) -> ApiResponse<T>

Create a not-found (404) response with a custom message for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<()> = ApiResponse::not_found_with_message_typed("gone");
assert!(!resp.success);

pub fn internal_error_typed() -> ApiResponse<T>

Create an internal server error (500) response for any data type T.

Example

use auth_framework::api::responses::ApiResponse;

let resp: ApiResponse<()> = ApiResponse::internal_error_typed();
assert!(!resp.success);

pub fn success_with_message(data: T, message: impl Into<String>) -> Self

Create a successful response with data and a human-readable message.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::success_with_message("done", "operation complete");
assert!(resp.success);
assert_eq!(resp.message, Some("operation complete".into()));

pub fn ok() -> ApiResponse<()>

Create a simple success response with no data.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::ok();
assert!(resp.success);
assert!(resp.data.is_none());

pub fn ok_with_message(message: impl Into<String>) -> ApiResponse<()>

Create a success response with a message but no data.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::ok_with_message("saved");
assert!(resp.success);
assert_eq!(resp.message, Some("saved".into()));

impl ApiResponse<()>

pub fn error(code: impl Into<String>, message: impl Into<String>) -> Self

Create an error response with a code and message.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::error("BAD_REQUEST", "missing param");
assert!(!resp.success);
assert_eq!(resp.error.as_ref().unwrap().code, "BAD_REQUEST");

pub fn error_with_details( code: impl Into<String>, message: impl Into<String>, details: Value, ) -> Self

Create an error response with structured details.

Example

use auth_framework::api::responses::ApiResponse;

let details = serde_json::json!({"fields": ["name"]});
let resp = ApiResponse::<()>::error_with_details("VALIDATION", "invalid", details);
assert!(resp.error.as_ref().unwrap().details.is_some());

pub fn validation_error(message: impl Into<String>) -> Self

Create a validation error (400) response.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::validation_error("email is invalid");
assert_eq!(resp.error.as_ref().unwrap().code, "VALIDATION_ERROR");

pub fn unauthorized() -> Self

Create an unauthorized (401) error response.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::unauthorized();
assert_eq!(resp.error.as_ref().unwrap().code, "UNAUTHORIZED");

pub fn forbidden() -> Self

Create a forbidden (403) error response.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::forbidden();
assert_eq!(resp.error.as_ref().unwrap().code, "FORBIDDEN");

pub fn forbidden_with_message(message: impl Into<String>) -> Self

Create a forbidden (403) error with a custom message.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::forbidden_with_message("admin area");
assert_eq!(resp.error.as_ref().unwrap().message, "admin area");

pub fn not_found(resource: impl Into<String>) -> Self

Create a not-found (404) error naming the missing resource.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::not_found("User");
assert!(resp.error.as_ref().unwrap().message.contains("not found"));

pub fn not_found_with_message(message: impl Into<String>) -> Self

Create a not-found (404) error with a custom message.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::not_found_with_message("deleted");
assert_eq!(resp.error.as_ref().unwrap().code, "NOT_FOUND");

pub fn error_with_message( code: impl Into<String>, message: impl Into<String>, ) -> Self

Create an error response with a custom code and message (alias for error).

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::error_with_message("LIMIT", "rate exceeded");
assert_eq!(resp.error.as_ref().unwrap().code, "LIMIT");

pub fn internal_error() -> Self

Create an internal server error (500) response.

Example

use auth_framework::api::responses::ApiResponse;

let resp = ApiResponse::<()>::internal_error();
assert_eq!(resp.error.as_ref().unwrap().code, "SERVER_ERROR");

Trait Implementations

impl<T: Debug> Debug for ApiResponse<T>

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

Formats the value using the given formatter.

impl From<AuthError> for ApiResponse<()>

Convert an AuthError into an appropriate API error response.

Maps error variants to HTTP-semantic error codes:

• Token → INVALID_TOKEN
• Validation → VALIDATION_ERROR
• AuthMethod → INVALID_CREDENTIALS
• UserNotFound → NOT_FOUND
• Permission → FORBIDDEN
• RateLimit → RATE_LIMITED
• everything else → SERVER_ERROR

fn from(error: AuthError) -> Self

Converts to this type from the input type.

impl<T> IntoResponse for ApiResponse<T>

where T: Serialize,

fn into_response(self) -> Response

Create a response.

impl<T> Serialize for ApiResponse<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.