refactor: unify token types under NatsToken in trogon-nats

Author: tsitsiridakisiosif

rsworkspace/crates/acp-nats/src/acp_prefix.rs

@@ -7,12 +7,9 @@
 //! malformed dots (consecutive, leading, trailing). Max 128 bytes. Validity is guaranteed at
 //! construction.
 
-use std::sync::Arc;
-
-use crate::nats::token;
+use crate::nats_token_policies::MultiTokenPolicy;
 use crate::subject_token_violation::SubjectTokenViolation;
-
-const MAX_PREFIX_LENGTH: usize = 128;
+use trogon_nats::NatsToken;
 
 /// Error returned when [`AcpPrefix`] validation fails.
 #[derive(Debug, Clone, PartialEq)]
@@ -36,28 +33,16 @@ impl std::error::Error for AcpPrefixError {}
 
 /// NATS-safe ACP prefix. Guarantees validity at construction—invalid instances are unrepresentable.
 #[derive(Clone)]
-pub struct AcpPrefix(Arc<str>);
+pub struct AcpPrefix(NatsToken<MultiTokenPolicy>);
 
 impl AcpPrefix {
     pub fn new(s: impl Into<String>) -> Result<Self, AcpPrefixError> {
         let s = s.into();
-        if s.is_empty() {
-            return Err(AcpPrefixError(SubjectTokenViolation::Empty));
-        }
-        if let Some(ch) = token::has_wildcards_or_whitespace(&s) {
-            return Err(AcpPrefixError(SubjectTokenViolation::InvalidCharacter(ch)));
-        }
-        if token::has_consecutive_or_boundary_dots(&s) {
-            return Err(AcpPrefixError(SubjectTokenViolation::InvalidCharacter('.')));
-        }
-        if s.len() > MAX_PREFIX_LENGTH {
-            return Err(AcpPrefixError(SubjectTokenViolation::TooLong(s.len())));
-        }
-        Ok(Self(s.into()))
+        NatsToken::new(s).map(Self).map_err(AcpPrefixError)
     }
 
     pub fn as_str(&self) -> &str {
-        &self.0
+        self.0.as_str()
     }
 }
 

rsworkspace/crates/acp-nats/src/ext_method_name.rs

@@ -5,12 +5,9 @@
 //! rejects `*`, `>`, whitespace; allows dotted namespaces (e.g. `vendor.operation`) but rejects
 //! malformed dots (consecutive, leading, trailing). Validity is guaranteed at construction.
 
-use std::sync::Arc;
-
-use crate::nats::token;
+use crate::nats_token_policies::MultiTokenPolicy;
 use crate::subject_token_violation::SubjectTokenViolation;
-
-const MAX_METHOD_NAME_LENGTH: usize = 128;
+use trogon_nats::NatsToken;
 
 /// Error returned when [`ExtMethodName`] validation fails.
 #[derive(Debug, Clone, PartialEq)]
@@ -36,32 +33,15 @@ impl std::error::Error for ExtMethodNameError {}
 ///
 /// Rejects empty, too-long, wildcard, whitespace, and malformed dotted names.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ExtMethodName(Arc<str>);
+pub struct ExtMethodName(NatsToken<MultiTokenPolicy>);
 
 impl ExtMethodName {
     pub fn new(method: impl AsRef<str>) -> Result<Self, ExtMethodNameError> {
-        let s = method.as_ref();
-        if s.is_empty() {
-            return Err(ExtMethodNameError(SubjectTokenViolation::Empty));
-        }
-        if s.len() > MAX_METHOD_NAME_LENGTH {
-            return Err(ExtMethodNameError(SubjectTokenViolation::TooLong(s.len())));
-        }
-        if let Some(ch) = token::has_wildcards_or_whitespace(s) {
-            return Err(ExtMethodNameError(SubjectTokenViolation::InvalidCharacter(
-                ch,
-            )));
-        }
-        if token::has_consecutive_or_boundary_dots(s) {
-            return Err(ExtMethodNameError(SubjectTokenViolation::InvalidCharacter(
-                '.',
-            )));
-        }
-        Ok(Self(s.into()))
+        NatsToken::new(method).map(Self).map_err(ExtMethodNameError)
     }
 
     pub fn as_str(&self) -> &str {
-        &self.0
+        self.0.as_str()
     }
 }
 

rsworkspace/crates/acp-nats/src/lib.rs

@@ -7,6 +7,7 @@ pub(crate) mod ext_method_name;
 pub(crate) mod in_flight_slot_guard;
 pub(crate) mod jsonrpc;
 pub mod nats;
+pub(crate) mod nats_token_policies;
 pub(crate) mod pending_prompt_waiters;
 pub mod session_id;
 pub mod subject_token_violation;

rsworkspace/crates/acp-nats/src/nats/mod.rs

@@ -1,7 +1,6 @@
 mod extensions;
 pub mod parsing;
 mod subjects;
-pub(crate) mod token;
 
 pub use extensions::ExtSessionReady;
 pub use parsing::{ClientMethod, ParsedClientSubject, parse_client_subject};

rsworkspace/crates/acp-nats/src/nats_token_policies.rs

@@ -0,0 +1,23 @@
+use trogon_nats::NatsTokenPolicy;
+
+/// Single NATS subject token: no dots, ASCII-only, max 128 chars.
+///
+/// Used for values embedded as a single token in a subject, e.g. session IDs.
+pub struct SingleTokenPolicy;
+
+impl NatsTokenPolicy for SingleTokenPolicy {
+    const ALLOW_DOTS: bool = false;
+    const REQUIRE_ASCII: bool = true;
+    const MAX_LENGTH: usize = 128;
+}
+
+/// Multi-token NATS subject segment: dots allowed as separators, max 128 bytes.
+///
+/// Used for values that may contain dotted namespaces, e.g. prefixes and method names.
+pub struct MultiTokenPolicy;
+
+impl NatsTokenPolicy for MultiTokenPolicy {
+    const ALLOW_DOTS: bool = true;
+    const REQUIRE_ASCII: bool = false;
+    const MAX_LENGTH: usize = 128;
+}

rsworkspace/crates/acp-nats/src/session_id.rs

@@ -4,13 +4,10 @@
 //! Validation follows [NATS subject naming](https://docs.nats.io/nats-concepts/subjects#characters-allowed-and-recommended-for-subject-names):
 //! ASCII only (recommended), rejecting `.` `*` `>` and whitespace (forbidden). Validity is
 //! guaranteed at construction.
-//!
-//! TODO: Consider extracting to `trogon-nats` as a generic `NatsSubject` (or `NatsToken`) type
-//! so prefix, session_id, and other subject tokens share the same validation.
 
+use crate::nats_token_policies::SingleTokenPolicy;
 use crate::subject_token_violation::SubjectTokenViolation;
-
-const MAX_SESSION_ID_LENGTH: usize = 128;
+use trogon_nats::NatsToken;
 
 /// Error returned when [`AcpSessionId`] validation fails.
 #[derive(Debug, Clone, PartialEq)]
@@ -37,32 +34,15 @@ impl std::error::Error for SessionIdError {}
 /// Follows [NATS subject naming](https://docs.nats.io/nats-concepts/subjects#characters-allowed-and-recommended-for-subject-names):
 /// ASCII only; rejects `.`, `*`, `>`, and whitespace. Max 128 characters.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct AcpSessionId(std::sync::Arc<str>);
+pub struct AcpSessionId(NatsToken<SingleTokenPolicy>);
 
 impl AcpSessionId {
     pub fn new(s: impl AsRef<str>) -> Result<Self, SessionIdError> {
-        let s = s.as_ref();
-        if s.is_empty() {
-            return Err(SessionIdError(SubjectTokenViolation::Empty));
-        }
-        let mut char_count = 0;
-        for ch in s.chars() {
-            char_count += 1;
-            if char_count > MAX_SESSION_ID_LENGTH {
-                return Err(SessionIdError(SubjectTokenViolation::TooLong(char_count)));
-            }
-            if !ch.is_ascii() {
-                return Err(SessionIdError(SubjectTokenViolation::InvalidCharacter(ch)));
-            }
-            if ch == '.' || ch == '*' || ch == '>' || ch.is_whitespace() {
-                return Err(SessionIdError(SubjectTokenViolation::InvalidCharacter(ch)));
-            }
-        }
-        Ok(Self(s.into()))
+        NatsToken::new(s).map(Self).map_err(SessionIdError)
     }
 
     pub fn as_str(&self) -> &str {
-        &self.0
+        self.0.as_str()
     }
 }
 

rsworkspace/crates/acp-nats/src/subject_token_violation.rs

@@ -1,7 +1 @@
-/// Describes what went wrong when validating a NATS subject token: empty, invalid character, or too long.
-#[derive(Debug, Clone, PartialEq)]
-pub enum SubjectTokenViolation {
-    Empty,
-    InvalidCharacter(char),
-    TooLong(usize),
-}
+pub use trogon_nats::SubjectTokenViolation;

rsworkspace/crates/trogon-nats/src/lib.rs

@@ -40,6 +40,9 @@ pub mod auth;
 pub mod client;
 pub mod connect;
 pub mod messaging;
+pub mod nats_token;
+pub mod subject_token_violation;
+pub mod token;
 
 #[cfg(feature = "test-support")]
 pub mod mocks;
@@ -53,6 +56,8 @@ pub use messaging::{
     RetryPolicy, headers_with_trace_context, inject_trace_context, publish, request,
     request_with_timeout,
 };
+pub use nats_token::{NatsToken, NatsTokenPolicy};
+pub use subject_token_violation::SubjectTokenViolation;
 
 #[cfg(feature = "test-support")]
 pub use mocks::{AdvancedMockNatsClient, MockNatsClient};