shopify-sdk 1.0.0

A Rust SDK for the Shopify API
Documentation 
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

//! Error types for the Shopify API SDK.
//!
//! This module contains error types used throughout the SDK for configuration
//! and validation errors.
//!
//! # Error Handling
//!
//! All configuration constructors return `Result<T, ConfigError>` to enable
//! fail-fast validation. Error messages are designed to be clear and actionable.
//!
//! # Example
//!
//! ```rust
//! use shopify_sdk::{ApiKey, ConfigError};
//!
//! let result = ApiKey::new("");
//! assert!(matches!(result, Err(ConfigError::EmptyApiKey)));
//! ```

use thiserror::Error;

/// Errors that can occur during SDK configuration.
///
/// This enum represents all possible errors that can occur when creating
/// or validating configuration types. Each variant provides a clear,
/// actionable error message.
#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum ConfigError {
    /// API key cannot be empty.
    #[error("API key cannot be empty. Please provide a valid Shopify API key.")]
    EmptyApiKey,

    /// API secret key cannot be empty.
    #[error("API secret key cannot be empty. Please provide a valid Shopify API secret key.")]
    EmptyApiSecretKey,

    /// Shop domain is invalid.
    #[error("Invalid shop domain '{domain}'. Expected format: 'shop-name' or 'shop-name.myshopify.com'.")]
    InvalidShopDomain {
        /// The invalid domain that was provided.
        domain: String,
    },

    /// API version is invalid.
    #[error("Invalid API version '{version}'. Expected format: 'YYYY-MM' (e.g., '2024-01') or 'unstable'.")]
    InvalidApiVersion {
        /// The invalid version string that was provided.
        version: String,
    },

    /// Scopes are invalid.
    #[error("Invalid scopes: {reason}")]
    InvalidScopes {
        /// The reason the scopes are invalid.
        reason: String,
    },

    /// A required field is missing.
    #[error("Missing required field: '{field}'. This field must be set before building the configuration.")]
    MissingRequiredField {
        /// The name of the missing field.
        field: &'static str,
    },

    /// Host URL is invalid.
    #[error("Invalid host URL '{url}'. Please provide a valid URL with scheme (e.g., 'https://myapp.example.com').")]
    InvalidHostUrl {
        /// The invalid URL that was provided.
        url: String,
    },

    /// API version is deprecated.
    #[error("API version '{version}' is deprecated. Please upgrade to '{latest}' or a newer supported version.")]
    DeprecatedApiVersion {
        /// The deprecated version that was provided.
        version: String,
        /// The latest supported version to upgrade to.
        latest: String,
    },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty_api_key_error_message() {
        let error = ConfigError::EmptyApiKey;
        let message = error.to_string();
        assert!(message.contains("API key cannot be empty"));
        assert!(message.contains("valid Shopify API key"));
    }

    #[test]
    fn test_invalid_shop_domain_error_message() {
        let error = ConfigError::InvalidShopDomain {
            domain: "bad domain!".to_string(),
        };
        let message = error.to_string();
        assert!(message.contains("bad domain!"));
        assert!(message.contains("Expected format"));
    }

    #[test]
    fn test_missing_required_field_error_message() {
        let error = ConfigError::MissingRequiredField { field: "api_key" };
        let message = error.to_string();
        assert!(message.contains("api_key"));
        assert!(message.contains("must be set"));
    }

    #[test]
    fn test_error_implements_std_error() {
        let error = ConfigError::EmptyApiKey;
        // Verify it implements std::error::Error by using it as a dyn Error
        let _: &dyn std::error::Error = &error;
    }

    #[test]
    fn test_deprecated_api_version_error_message() {
        let error = ConfigError::DeprecatedApiVersion {
            version: "2024-01".to_string(),
            latest: "2025-10".to_string(),
        };
        let message = error.to_string();
        assert!(message.contains("2024-01"));
        assert!(message.contains("deprecated"));
        assert!(message.contains("2025-10"));
        assert!(message.contains("upgrade"));
    }
}