hexser 0.4.7

Zero-boilerplate hexagonal architecture with graph-based introspection
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
132

//! Role enum for component roles in hexagonal architecture.
//!
//! The Role enum identifies what role a component plays within its layer.
//! Roles provide finer-grained classification than layers and are used
//! for pattern detection, intent inference, and architectural analysis.
//! Each role represents a specific responsibility or pattern in the architecture.
//!
//! Revision History
//! - 2025-10-01T00:01:00Z @AI: Renamed Command to Directive for consistency.
//! - 2025-10-01T00:00:00Z @AI: Initial Role enum definition for component classification.

/// Enum representing component roles in hexagonal architecture.
///
/// Roles identify the specific responsibility of a component within its layer,
/// enabling pattern detection and architectural analysis.
///
/// # Example
///
/// ```rust
/// use hexser::graph::Role;
///
/// let role = Role::Entity;
/// assert!(matches!(role, Role::Entity));
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Role {
  /// Domain entity with unique identity.
  Entity,

  /// Value object defined by its values.
  ValueObject,

  /// Aggregate root defining consistency boundary.
  Aggregate,

  /// Domain event representing significant occurrence.
  DomainEvent,

  /// Domain service for domain operations.
  DomainService,

  /// Input port for use case entry points.
  InputPort,

  /// Output port for external system interfaces.
  OutputPort,

  /// Repository for persistence abstraction.
  Repository,

  /// Use case for business operations.
  UseCase,

  /// Query for read-only operations.
  Query,

  /// Adapter implementing ports.
  Adapter,

  /// Mapper for data transformation.
  Mapper,

  /// Directive for write operations.
  Directive,

  /// Directive handler for executing directives.
  DirectiveHandler,

  /// Query handler for executing queries.
  QueryHandler,

  /// Configuration component.
  Config,

  /// Unknown or unclassified role.
  Unknown,
}

impl Role {
  /// Returns the name of the role as a string.
  pub fn as_str(&self) -> &'static str {
    match self {
      Self::Entity => "Entity",
      Self::ValueObject => "ValueObject",
      Self::Aggregate => "Aggregate",
      Self::DomainEvent => "DomainEvent",
      Self::DomainService => "DomainService",
      Self::InputPort => "InputPort",
      Self::OutputPort => "OutputPort",
      Self::Repository => "Repository",
      Self::UseCase => "UseCase",
      Self::Query => "Query",
      Self::Adapter => "Adapter",
      Self::Mapper => "Mapper",
      Self::Directive => "Directive",
      Self::DirectiveHandler => "DirectiveHandler",
      Self::QueryHandler => "QueryHandler",
      Self::Config => "Config",
      Self::Unknown => "Unknown",
    }
  }
}

impl std::fmt::Display for Role {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "{}", self.as_str())
  }
}

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

  #[test]
  fn test_role_equality() {
    assert_eq!(Role::Entity, Role::Entity);
    assert_ne!(Role::Entity, Role::ValueObject);
  }

  #[test]
  fn test_role_as_str() {
    assert_eq!(Role::Entity.as_str(), "Entity");
    assert_eq!(Role::Repository.as_str(), "Repository");
    assert_eq!(Role::Directive.as_str(), "Directive");
  }

  #[test]
  fn test_role_display() {
    let role = Role::Entity;
    assert_eq!(format!("{}", role), "Entity");
  }
}