scim-server 0.5.3

A comprehensive SCIM 2.0 server library for Rust with multi-tenant support and type-safe operations
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

//! Error types for resource provider implementations.
//!
//! This module provides error types that are shared across different resource
//! provider implementations, independent of the underlying storage backend.
//!
//! # Key Types
//!
//! - [`ProviderError`] - Generic provider error type for resource operations
//!
//! # Usage
//!
//! This error type is used with `StandardResourceProvider<T>` regardless of storage backend:
//!
//! ```rust
//! use scim_server::providers::StandardResourceProvider;
//! use scim_server::storage::InMemoryStorage;
//!
//! let storage = InMemoryStorage::new();
//! let provider = StandardResourceProvider::new(storage);
//! ```

use thiserror::Error;

/// Errors that can occur during resource provider operations.
///
/// This error type is used by resource providers to represent various failure
/// conditions during SCIM operations, independent of the underlying storage backend.
#[derive(Debug, Clone, Error)]
pub enum ProviderError {
    #[error("Resource not found: {resource_type} with id '{id}' in tenant '{tenant_id}'")]
    ResourceNotFound {
        /// The type of resource that was not found
        resource_type: String,
        /// The ID of the resource that was not found
        id: String,
        /// The tenant ID where the resource was not found
        tenant_id: String,
    },

    #[error(
        "Duplicate attribute '{attribute}' with value '{value}' for {resource_type} in tenant '{tenant_id}'"
    )]
    DuplicateAttribute {
        /// The type of resource with duplicate attribute
        resource_type: String,
        /// The name of the duplicate attribute
        attribute: String,
        /// The duplicate value
        value: String,
        /// The tenant ID where the duplicate was found
        tenant_id: String,
    },

    #[error("Invalid resource data: {message}")]
    InvalidData {
        /// Description of the invalid data
        message: String,
    },

    #[error("Query error: {message}")]
    QueryError {
        /// Description of the query error
        message: String,
    },

    #[error("Storage error: {message}")]
    Storage {
        /// Description of the storage error
        message: String,
    },

    #[error("Internal error: {message}")]
    Internal {
        /// Description of the internal error
        message: String,
    },

    #[error("Invalid input: {message}")]
    InvalidInput {
        /// Description of what input was invalid
        message: String,
    },

    #[error("Resource not found: {resource_type} with id '{id}'")]
    NotFound {
        /// The type of resource that was not found
        resource_type: String,
        /// The ID of the resource that was not found
        id: String,
    },

    #[error("Precondition failed: {message}")]
    PreconditionFailed {
        /// Description of the precondition failure
        message: String,
    },

    #[error(
        "Duplicate resource: {resource_type} with userName '{username}' already exists in tenant '{tenant_id}'"
    )]
    DuplicateUserName {
        /// The resource type that had the duplicate
        resource_type: String,
        /// The duplicate userName
        username: String,
        /// The tenant where the duplicate was found
        tenant_id: String,
    },

    #[error("Patch operation failed: {message}")]
    PatchOperationFailed {
        /// Description of why the patch operation failed
        message: String,
    },

    #[error("Version conflict: {conflict}")]
    VersionConflict {
        /// Details of the version conflict
        #[from]
        conflict: crate::resource::version::VersionConflict,
    },
}

impl From<String> for ProviderError {
    fn from(message: String) -> Self {
        ProviderError::Internal { message }
    }
}