Struct AppCode 

#[non_exhaustive]
pub struct AppCode { /* private fields */ }

Stable machine-readable error code exposed to clients.

Values are serialized as SCREAMING_SNAKE_CASE strings (e.g., "NOT_FOUND"). This type is part of the public wire contract and supports both built-in constants and caller-defined codes created via AppCode::new or AppCode::try_new.

Design rules:

• Keep the set small and meaningful.
• Prefer adding new variants over overloading existing ones.
• Do not encode private/internal details in codes.
• Validate custom codes using AppCode::try_new before exposing them publicly.

Implementations

impl AppCode

pub const NotFound: Self

Machine code emitted when a resource is not found.

pub const Validation: Self

Machine code emitted when validation fails.

pub const Conflict: Self

Machine code emitted when a conflict is detected.

pub const UserAlreadyExists: Self

Machine code emitted when attempting to create an existing user.

pub const Unauthorized: Self

Machine code emitted when authentication fails or is required.

pub const Forbidden: Self

Machine code emitted when an operation is not permitted.

pub const NotImplemented: Self

Machine code emitted when functionality is missing.

pub const BadRequest: Self

Machine code emitted when a request is malformed.

pub const RateLimited: Self

Machine code emitted when a caller is throttled.

pub const TelegramAuth: Self

Machine code emitted when Telegram authentication fails.

pub const InvalidJwt: Self

Machine code emitted when a JWT token is invalid.

pub const Internal: Self

Machine code emitted for internal server failures.

pub const Database: Self

Machine code emitted for database-related issues.

pub const Service: Self

Machine code emitted for service-layer failures.

pub const Config: Self

Machine code emitted for configuration issues.

pub const Turnkey: Self

Machine code emitted for Turnkey integration failures.

pub const Timeout: Self

Machine code emitted for timeout failures.

pub const Network: Self

Machine code emitted for network issues.

pub const DependencyUnavailable: Self

Machine code emitted when dependencies are unavailable.

pub const Serialization: Self

Machine code emitted for serialization failures.

pub const Deserialization: Self

Machine code emitted for deserialization failures.

pub const ExternalApi: Self

Machine code emitted when an external API fails.

pub const Queue: Self

Machine code emitted for queue processing errors.

pub const Cache: Self

Machine code emitted for cache subsystem failures.

pub const fn new(code: &'static str) -> Self

Construct an AppCode from a compile-time string literal.

Examples

use masterror::AppCode;

let code = AppCode::new("INVALID_JSON");
assert_eq!(code.as_str(), "INVALID_JSON");

Panics

Panics when the literal is not SCREAMING_SNAKE_CASE. Use AppCode::try_new to validate dynamic strings at runtime.

pub fn try_new(code: impl Into<String>) -> Result<Self, ParseAppCodeError>

Construct an AppCode from a dynamically provided string.

The input must be SCREAMING_SNAKE_CASE. This constructor allocates to own the string, making it suitable for runtime-defined codes.

Errors

Returns ParseAppCodeError when the string is empty or contains characters outside of A-Z, 0-9, and _.

Examples

use masterror::AppCode;

let code = AppCode::try_new(String::from("THIRD_PARTY_FAILURE"))?;
assert_eq!(code.as_str(), "THIRD_PARTY_FAILURE");

pub fn as_str(&self) -> &str

Get the canonical string form of this code (SCREAMING_SNAKE_CASE).

This matches the JSON serialization.

Trait Implementations

impl Clone for AppCode

fn clone(&self) -> AppCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AppCode

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AppCode

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

Formats the value using the given formatter.

impl From<AppErrorKind> for AppCode

fn from(kind: AppErrorKind) -> Self

Map internal taxonomy (AppErrorKind) to public machine code (AppCode).

The mapping is 1:1 today and intentionally conservative.

impl FromStr for AppCode

Parse an AppCode from its canonical string representation.

Errors

Returns ParseAppCodeError when the input is not SCREAMING_SNAKE_CASE.

Examples

use std::str::FromStr;

use masterror::{AppCode, ParseAppCodeError};

let code = AppCode::from_str("NOT_FOUND")?;
assert_eq!(code, AppCode::NotFound);

type Err = ParseAppCodeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for AppCode

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AppCode

fn eq(&self, other: &Self) -> 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 Serialize for AppCode

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AppCode