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)   - Concise
✓ Database      (8 chars)   - Good length
✓ Validation    (10 chars)  - Good length
✓ TokenValidator (14 chars) - Still good
✓ ServiceRegistry (15 chars) - Near limit but OK

✓ ConfigValidator   (15 chars) - OK
✓ ConnectionPool    (14 chars) - OK
✗ AuthenticationService (21 chars) - Too long!
✗ ConfigurationManager  (20 chars) - Too long!

✓ 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

✓ Consistent:
  Auth, Database, Parser, Network, Cache

✗ Inconsistent:
  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

✓ 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)
✓ Auth          (lowercase allowed after first)
✓ Database      (mixed case OK)
✓ API           (all caps after first OK)
✓ Http2Server   (digit allowed)
✓ TokenValidator (14 chars)
✓ ConfigValidator (15 chars)
✓ ABCDEFGHIJKLMNO (16 chars - max length)

✗ auth           - Must start with uppercase
✗ Auth-Service   - No hyphens
✗ Auth_Service   - No underscores
✗ Auth Service   - No spaces
✗ Auth!          - No special characters
✗ 2Auth          - Cannot start with digit
✗ AuthenticationService - Too long (21 chars)

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

✓ Recommended:  Auth, Database, TokenValidator
⚠ Allowed:      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

All these produce the same hash:
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

Display:  E.Auth.Token.001
Hash:     E.AUTH.TOKEN.001 (uppercase)