WDP Part 2: Component Field Specification

Severity.Component.Primary.Sequence -> CompactID
    ^         ^        ^        ^          ^
  Part 1    Part 2   Part 3   Part 4    Part 5

Severity.Component.Primary.Sequence -> CompactID
          ^^^^^^^^^
          Part 2: System module or domain (THIS DOCUMENT)

Component: Auth
  ├─ Primary: Token
  ├─ Primary: Session
  └─ Primary: Permission

Component: Database
  ├─ Primary: Connection
  ├─ Primary: Query
  └─ Primary: Transaction

^[A-Z][a-zA-Z0-9]{0,15}$

Database          - Database server or layer
Network           - Network communication layer
FileSystem        - File I/O subsystem
Cache             - Caching layer (Redis, Memcached, etc.)
Queue             - Message queue (RabbitMQ, Kafka, etc.)
Storage           - Object storage (S3, blob storage)
Memory            - Memory management
Disk              - Disk I/O operations

Auth              - Authentication/authorization logic
Validation        - Input validation logic
BusinessLogic     - Core domain logic
Parser            - Parsing and syntax analysis
Serializer        - Data serialization/deserialization
Transformer       - Data transformation
Mapper            - Object mapping (ORM, DTO conversion)
Encoder           - Encoding/decoding logic

UserService       - User management service
OrderService      - Order processing service
PaymentGateway    - Payment integration service
NotificationSvc   - Notification service
AuthService       - Authentication service
InventoryService  - Inventory management
EmailService      - Email sending service

Api               - API/presentation layer
Domain            - Domain/business logic layer
Infrastructure    - Infrastructure layer
Persistence       - Data persistence layer
Application       - Application service layer
Presentation      - UI/presentation layer

Auth              - Logical module
Database          - Physical subsystem
UserService       - Service boundary
Api               - Architectural layer
Parser            - Logical module
Network           - Physical subsystem

Auth              - Clear purpose
Database          - Descriptive
TokenValidator    - Specific and clear
PaymentGateway    - Understandable
Parser            - Standard term

Auth                 (4 chars)
Database             (8 chars)
Validation           (10 chars)
TokenValidator       (14 chars)
ServiceRegistry      (15 chars)

ConfigValidator      (15 chars)
ConnectionPool       (14 chars)
AuthenticationService (21 chars) - Too long! (Invalid)
ConfigurationManager  (20 chars) - Too long! (Invalid)

Auth          - Widely understood in web development
Catalog       - Makes sense for e-commerce
Fulfillment   - E-commerce/logistics term
Ledger        - Financial/accounting term
Parser        - Compiler/language processing

Auth, Database, Parser, Network, Cache

Auth, DB, parser, NetworkLayer, caching

Module        - Too generic
System        - Too vague
Error         - Meaningless (everything is an error)
Handler       - What does it handle?
Manager       - What does it manage?
Service       - Too generic (which service?)

AuthV2        - Version numbers shouldn't be in error codes
ApiV1         - Use different component name if truly different
Parser2       - Indicates poor naming

Valid examples:
Auth          - Version-agnostic
Api           - Can evolve without renaming

HTTP          - Universally recognized
API           - Widely understood
JWT           - Standard in auth context
DB            - Commonly used (though "Database" is better)
IO            - Standard abbreviation
UI            - Widely understood

AuthZ         - Use "Auth" or "Authorization"
PersCtx       - Use "PersistenceContext"
UsrMgmt       - Use "UserManagement" or "UserService"
TxnProc       - Use "Transaction" or "TransactionProcessor"

Auth              - General authentication/authorization
AuthService       - Authentication service
Security          - Security operations
Crypto            - Cryptographic operations
Encryption        - Encryption/decryption

Database          - Database operations
DB                - Database (abbreviated)
Persistence       - Data persistence layer
Storage           - File/object storage
Cache             - Caching layer
Repository        - Repository pattern
ORM               - Object-relational mapping

Network           - Network operations
Net               - Network (abbreviated)
HTTP              - HTTP client/server
API               - API layer
Gateway           - API gateway or service gateway
Queue             - Message queue
EventBus          - Event bus
WebSocket         - WebSocket communication

Parser            - Parsing and syntax analysis
Compiler          - Compilation
Validator         - Validation logic
Validation        - Input validation
Transformer       - Data transformation
Processor         - Data processing
Engine            - Processing engine
Workflow          - Workflow execution

BusinessLogic     - Core business logic
Domain            - Domain layer
Order             - Order management
Payment           - Payment processing
Inventory         - Inventory management
Fulfillment       - Order fulfillment
Catalog           - Product catalog

Config            - Configuration management
Logger            - Logging subsystem
Monitoring        - Monitoring/metrics
Scheduler         - Task scheduling
Background        - Background job processing
Migration         - Database migration
Deployment        - Deployment operations

UI                - User interface
Frontend          - Frontend application
Api               - API/presentation layer
Controller        - MVC controller
View              - View/rendering
Form              - Form handling

A                    // 1 char minimum - Valid
Auth                 // lowercase allowed after first - Valid
Database             // mixed case allowed - Valid
API                  // all caps after first allowed - Valid
Http2Server          // digit allowed - Valid
TokenValidator       // 14 chars - Valid
ConfigValidator      // 15 chars - Valid
ABCDEFGHIJKLMNO      // 16 chars (maximum length) - Valid

auth                 // MUST start with uppercase - Invalid
Auth-Service         // hyphens NOT permitted - Invalid
Auth_Service         // underscores NOT permitted - Invalid
Auth Service         // spaces NOT permitted - Invalid
Auth!                // special characters NOT permitted - Invalid
2Auth                // MUST NOT start with digit - Invalid
AuthenticationService // exceeds 16-char maximum (21 chars) - Invalid

^[A-Z][a-zA-Z0-9]{0,15}$

RECOMMENDED:  Auth, Database, TokenValidator
Permitted:    AUTH, auth, database, TOKENVALIDATOR

E.Auth.Token.001
E.Database.Connection.021
E.TokenValidator.Parse.003

E.AUTH.TOKEN.001
E.DATABASE.CONNECTION.021
E.TOKENVALIDATOR.PARSE.003

E.Auth.Token.001    → E.AUTH.TOKEN.001 → Xy8Qz
E.AUTH.TOKEN.001    → E.AUTH.TOKEN.001 → Xy8Qz
e.auth.token.001    → E.AUTH.TOKEN.001 → Xy8Qz
E.auth.Token.001    → E.AUTH.TOKEN.001 → Xy8Qz

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Component {
    name: String,
}

impl Component {
    /// Create a new component with validation
    pub fn new(name: impl Into<String>) -> Result<Self, ValidationError> {
        let name = name.into();
        
        // Validate format
        if !Self::is_valid(&name) {
            return Err(ValidationError::InvalidComponent(name));
        }
        
        Ok(Self { name })
    }
    
    /// Validate component format
    pub fn is_valid(name: &str) -> bool {
        // Regex: ^[A-Z][a-zA-Z0-9]{0,15}$
        if name.is_empty() || name.len() > 16 {
            return false;
        }
        
        let mut chars = name.chars();
        
        // First character must be uppercase letter
        if !matches!(chars.next(), Some('A'..='Z')) {
            return false;
        }
        
        // Remaining characters must be letters or digits
        chars.all(|c| c.is_ascii_alphanumeric())
    }
    
    /// Get display form (PascalCase)
    pub fn as_str(&self) -> &str {
        &self.name
    }
    
    /// Get hash canonical form (UPPERCASE)
    pub fn canonical(&self) -> String {
        self.name.to_uppercase()
    }
}

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

import re

class Component:
    """Represents a WDP component field."""
    
    # Validation regex
    PATTERN = re.compile(r'^[A-Z][a-zA-Z0-9]{0,15}$')
    
    def __init__(self, name: str):
        """Create a new component with validation."""
        if not self.is_valid(name):
            raise ValueError(f"Invalid component: {name}")
        self.name = name
    
    @staticmethod
    def is_valid(name: str) -> bool:
        """Validate component format."""
        return bool(Component.PATTERN.match(name))
    
    def __str__(self) -> str:
        """Get display form (PascalCase)."""
        return self.name
    
    def canonical(self) -> str:
        """Get hash canonical form (UPPERCASE)."""
        return self.name.upper()
    
    def __eq__(self, other) -> bool:
        return isinstance(other, Component) and self.name == other.name
    
    def __hash__(self) -> int:
        return hash(self.name)

class Component {
  private static readonly PATTERN = /^[A-Z][a-zA-Z0-9]{0,15}$/;
  
  constructor(private readonly name: string) {
    if (!Component.isValid(name)) {
      throw new Error(`Invalid component: ${name}`);
    }
  }
  
  static isValid(name: string): boolean {
    return Component.PATTERN.test(name);
  }
  
  toString(): string {
    return this.name;
  }
  
  canonical(): string {
    return this.name.toUpperCase();
  }
  
  equals(other: Component): boolean {
    return this.name === other.name;
  }
}

E.Database.Connection.021     - Database connection failed
E.Network.Connection.028      - Network host unreachable
E.FileSystem.File.021         - File not found
E.Cache.Connection.027        - Cache server unavailable
E.Queue.Connection.029        - Message queue disconnected

E.Auth.Token.001              - Authentication token missing
E.Validation.Input.003        - Input validation failed
E.Parser.Syntax.003           - Syntax error in input
E.BusinessLogic.Rule.008      - Business rule violation
E.Crypto.Key.001              - Encryption key missing

E.UserService.Query.021       - User not found
E.OrderService.Create.008     - Order creation denied
E.PaymentGateway.Process.017  - Payment timeout
E.EmailService.Send.027       - Email service unavailable

E.Api.Request.003             - Invalid API request
E.Domain.Validation.003       - Domain validation failed
E.Persistence.Save.027        - Persistence layer unavailable

E.Auth.Login.008              - Login denied
E.Api.RateLimit.008           - Rate limit exceeded
E.Database.Query.017          - Query timeout
E.Cache.Get.021               - Cache key not found
E.Session.Expired.018         - Session expired

E.Lexer.Token.001             - Unexpected token
E.Parser.Syntax.003           - Syntax error
E.Semantic.Type.002           - Type mismatch
E.Codegen.Output.027          - Code generation failed

E.UserService.Auth.008        - User authentication failed
E.OrderService.Create.003     - Invalid order data
E.InventoryService.Stock.026  - Out of stock
E.PaymentGateway.Charge.017   - Payment processing timeout
E.NotificationSvc.Send.027    - Notification service down

Format:   PascalCase
Regex:    ^[A-Z][a-zA-Z0-9]{0,15}$
Length:   1-16 characters (recommended: 8-12)
Position: Second field
Required: YES

Physical:      Database, Network, FileSystem, Cache
Logical:       Auth, Validation, Parser, BusinessLogic
Service:       UserService, OrderService, PaymentGateway