@push.rocks/smartproxy 12.0.0 → 13.1.3

package/readme.plan.md

@@ -1,471 +1,255 @@
-# SmartProxy Unified Forwarding Configuration Plan
+# SmartProxy Interface & Type Naming Standardization Plan
 
 ## Project Goal
-Create a clean, use-case driven forwarding configuration interface for SmartProxy that elegantly handles all forwarding scenarios: SNI-based forwarding, termination-based forwarding (NetworkProxy), HTTP forwarding, and ACME challenge forwarding.
-
-## Current State
-Currently, SmartProxy has several different forwarding mechanisms configured separately:
-1. **HTTPS/SNI forwarding** via `IDomainConfig` properties
-2. **NetworkProxy forwarding** via `useNetworkProxy` in domain configs
-3. **HTTP forwarding** via Port80Handler's `forward` configuration
-4. **ACME challenge forwarding** via `acmeForward` configuration
-
-This separation creates configuration complexity and reduced cohesion between related settings.
-
-## Proposed Solution: Clean Use-Case Driven Forwarding Interface
-
-### Phase 1: Design Streamlined Forwarding Interface
-
-- [ ] Create a use-case driven `IForwardConfig` interface that simplifies configuration:
-
-```typescript
-export interface IForwardConfig {
-  // Define the primary forwarding type - use-case driven approach
-  type: 'http-only' | 'https-passthrough' | 'https-terminate-to-http' | 'https-terminate-to-https';
-  
-  // Target configuration
-  target: {
-    host: string | string[];  // Support single host or round-robin
-    port: number;
-  };
-  
-  // HTTP-specific options
-  http?: {
-    enabled?: boolean;                 // Defaults to true for http-only, optional for others
-    redirectToHttps?: boolean;         // Redirect HTTP to HTTPS
-    headers?: Record<string, string>;  // Custom headers for HTTP responses
-  };
-  
-  // HTTPS-specific options
-  https?: {
-    customCert?: {                    // Use custom cert instead of auto-provisioned
-      key: string;
-      cert: string;
-    };
-    forwardSni?: boolean;             // Forward SNI info in passthrough mode
-  };
-  
-  // ACME certificate handling
-  acme?: {
-    enabled?: boolean;                // Enable ACME certificate provisioning  
-    maintenance?: boolean;            // Auto-renew certificates
-    production?: boolean;             // Use production ACME servers
-    forwardChallenges?: {             // Forward ACME challenges
-      host: string;
-      port: number;
-      useTls?: boolean;
-    };
-  };
-  
-  // Security options
-  security?: { 
-    allowedIps?: string[];            // IPs allowed to connect
-    blockedIps?: string[];            // IPs blocked from connecting
-    maxConnections?: number;          // Max simultaneous connections
-  };
-  
-  // Advanced options
-  advanced?: {
-    portRanges?: Array<{ from: number; to: number }>; // Allowed port ranges
-    networkProxyPort?: number;        // Custom NetworkProxy port if using terminate mode
-    keepAlive?: boolean;              // Enable TCP keepalive
-    timeout?: number;                 // Connection timeout in ms
-    headers?: Record<string, string>; // Custom headers with support for variables like {sni}
-  };
-}
-```
-
-### Phase 2: Create New Domain Configuration Interface
-
-- [ ] Replace existing `IDomainConfig` interface with a new one using the forwarding pattern:
-
-```typescript
-export interface IDomainConfig {
-  // Core properties
-  domains: string[];  // Domain patterns to match
-  
-  // Unified forwarding configuration
-  forwarding: IForwardConfig;
-}
-```
-
-### Phase 3: Implement Forwarding Handler System
-
-- [ ] Create an implementation strategy focused on the new forwarding types:
-
-```typescript
-/**
- * Base class for all forwarding handlers
- */
-abstract class ForwardingHandler {
-  constructor(protected config: IForwardConfig) {}
-  
-  abstract handleConnection(socket: Socket): void;
-  abstract handleHttpRequest(req: IncomingMessage, res: ServerResponse): void;
-}
-
-/**
- * Factory for creating the appropriate handler based on forwarding type
- */
-class ForwardingHandlerFactory {
-  public static createHandler(config: IForwardConfig): ForwardingHandler {
-    switch (config.type) {
-      case 'http-only':
-        return new HttpForwardingHandler(config);
-        
-      case 'https-passthrough':
-        return new HttpsPassthroughHandler(config);
-        
-      case 'https-terminate-to-http':
-        return new HttpsTerminateToHttpHandler(config);
-        
-      case 'https-terminate-to-https':
-        return new HttpsTerminateToHttpsHandler(config);
-        
-      default:
-        throw new Error(`Unknown forwarding type: ${config.type}`);
-    }
-  }
-}
-```
-
-## Usage Examples for Common Scenarios
-
-### 1. Basic HTTP Server
-
-```typescript
-{
-  domains: ['example.com'],
-  forwarding: {
-    type: 'http-only',
-    target: {
-      host: 'localhost',
-      port: 3000
-    }
-  }
-}
-```
-
-### 2. HTTPS Termination with HTTP Backend
-
-```typescript
-{
-  domains: ['secure.example.com'],
-  forwarding: {
-    type: 'https-terminate-to-http',
-    target: {
-      host: 'localhost',
-      port: 3000
-    },
-    acme: {
-      production: true  // Use production Let's Encrypt
-    }
-  }
-}
-```
-
-### 3. HTTPS Termination with HTTPS Backend
-
-```typescript
-{
-  domains: ['secure-backend.example.com'],
-  forwarding: {
-    type: 'https-terminate-to-https',
-    target: {
-      host: 'internal-api',
-      port: 8443
-    },
-    http: {
-      redirectToHttps: true  // Redirect HTTP requests to HTTPS
-    }
-  }
-}
-```
-
-### 4. SNI Passthrough
-
-```typescript
-{
-  domains: ['passthrough.example.com'],
-  forwarding: {
-    type: 'https-passthrough',
-    target: {
-      host: '10.0.0.5',
-      port: 443
-    }
-  }
-}
-```
-
-### 5. Mixed HTTP/HTTPS with Custom ACME Forwarding
-
-```typescript
-{
-  domains: ['mixed.example.com'],
-  forwarding: {
-    type: 'https-terminate-to-http',
-    target: {
-      host: 'localhost',
-      port: 3000
-    },
-    http: {
-      redirectToHttps: false  // Allow both HTTP and HTTPS access
-    },
-    acme: {
-      enabled: true,
-      maintenance: true,
-      forwardChallenges: {
-        host: '192.168.1.100',
-        port: 8080
-      }
-    }
-  }
-}
-```
-
-### 6. Load-Balanced Backend
-
-```typescript
-{
-  domains: ['api.example.com'],
-  forwarding: {
-    type: 'https-terminate-to-https',
-    target: {
-      host: ['10.0.0.10', '10.0.0.11', '10.0.0.12'], // Round-robin
-      port: 8443
-    },
-    security: {
-      allowedIps: ['10.0.0.*', '192.168.1.*']  // Restrict access
-    }
-  }
-}
-```
-
-### 7. Advanced Proxy Chain with Custom Headers
-
-```typescript
-{
-  domains: ['secure-chain.example.com'],
-  forwarding: {
-    type: 'https-terminate-to-https',
-    target: {
-      host: 'backend-gateway.internal',
-      port: 443
-    },
-    advanced: {
-      // Pass original client info to backend
-      headers: {
-        'X-Original-SNI': '{sni}',
-        'X-Client-IP': '{clientIp}'
-      }
-    }
-  }
-}
-```
-
-## Implementation Plan
-
-### Task 1: Core Types and Interfaces (Week 1)
-- [ ] Create the new `IForwardConfig` interface in `classes.pp.interfaces.ts`
-- [ ] Design the new `IDomainConfig` interface using the forwarding property
-- [ ] Define the internal data types for expanded configuration
-
-### Task 2: Forwarding Handlers (Week 1-2)
-- [ ] Create abstract `ForwardingHandler` base class
-- [ ] Implement concrete handlers for each forwarding type:
-  - [ ] `HttpForwardingHandler` - For HTTP-only configurations
-  - [ ] `HttpsPassthroughHandler` - For SNI passthrough
-  - [ ] `HttpsTerminateToHttpHandler` - For TLS termination to HTTP backends
-  - [ ] `HttpsTerminateToHttpsHandler` - For TLS termination to HTTPS backends
-- [ ] Implement `ForwardingHandlerFactory` to create the appropriate handler
-
-### Task 3: SmartProxy Integration (Week 2-3)
-- [ ] Update `SmartProxy` class to use the new forwarding system
-- [ ] Modify `ConnectionHandler` to delegate to forwarding handlers
-- [ ] Refactor domain configuration processing to use forwarding types
-- [ ] Update `Port80Handler` integration to work with the new system
-
-### Task 4: Certificate Management (Week 3)
-- [ ] Create a certificate management system that works with forwarding types
-- [ ] Implement automatic ACME provisioning based on forwarding type
-- [ ] Add custom certificate support
-
-### Task 5: Testing & Helper Functions (Week 4)
-- [ ] Create helper functions for common forwarding patterns
-- [ ] Implement comprehensive test suite for each forwarding handler
-- [ ] Add validation for forwarding configurations
-
-### Task 6: Documentation (Week 4)
-- [ ] Create detailed documentation for the new forwarding system
-- [ ] Document the forwarding types and their use cases
-- [ ] Update README with the new configuration examples
-
-## Detailed Type Documentation
-
-### Core Forwarding Types
-
-```typescript
-/**
- * The primary forwarding types supported by SmartProxy
- */
-export type ForwardingType = 
-  | 'http-only'                // HTTP forwarding only (no HTTPS)
-  | 'https-passthrough'        // Pass-through TLS traffic (SNI forwarding)
-  | 'https-terminate-to-http'  // Terminate TLS and forward to HTTP backend
-  | 'https-terminate-to-https'; // Terminate TLS and forward to HTTPS backend
-```
-
-### Type-Specific Behavior
-
-Each forwarding type has specific default behavior:
-
-#### HTTP-Only
-- Handles only HTTP traffic
-- No TLS/HTTPS support
-- No certificate management
-
-#### HTTPS Passthrough
-- Forwards raw TLS traffic to backend (no termination)
-- Passes SNI information through
-- No HTTP support (TLS only)
-- No certificate management
-
-#### HTTPS Terminate to HTTP
-- Terminates TLS at SmartProxy
-- Connects to backend using HTTP (non-TLS)
-- Manages certificates automatically (ACME)
-- Supports HTTP requests with option to redirect to HTTPS
-
-#### HTTPS Terminate to HTTPS
-- Terminates client TLS at SmartProxy
-- Creates new TLS connection to backend
-- Manages certificates automatically (ACME)
-- Supports HTTP requests with option to redirect to HTTPS
-
-## Handler Implementation Strategy
-
-```typescript
-/**
- * Handler for HTTP-only forwarding
- */
-class HttpForwardingHandler extends ForwardingHandler {
-  public handleConnection(socket: Socket): void {
-    // Process HTTP connection
-    // For HTTP-only, we'll mostly defer to handleHttpRequest
-  }
-  
-  public handleHttpRequest(req: IncomingMessage, res: ServerResponse): void {
-    // Forward HTTP request to target
-    const target = this.getTargetFromConfig();
-    this.proxyRequest(req, res, target);
-  }
-}
-
-/**
- * Handler for HTTPS passthrough (SNI forwarding)
- */
-class HttpsPassthroughHandler extends ForwardingHandler {
-  public handleConnection(socket: Socket): void {
-    // Extract SNI from TLS ClientHello if needed
-    // Forward raw TLS traffic to target without termination
-    const target = this.getTargetFromConfig();
-    this.forwardTlsConnection(socket, target);
-  }
-  
-  public handleHttpRequest(req: IncomingMessage, res: ServerResponse): void {
-    // HTTP not supported in SNI passthrough mode
-    res.statusCode = 404;
-    res.end('HTTP not supported for this domain');
-  }
-}
-
-/**
- * Handler for HTTPS termination with HTTP backend
- */
-class HttpsTerminateToHttpHandler extends ForwardingHandler {
-  private tlsContext: SecureContext;
-  
-  public async initialize(): Promise<void> {
-    // Set up TLS termination context
-    this.tlsContext = await this.createTlsContext();
-  }
-  
-  public handleConnection(socket: Socket): void {
-    // Terminate TLS
-    const tlsSocket = this.createTlsSocket(socket, this.tlsContext);
-    
-    // Forward to HTTP backend after TLS termination
-    tlsSocket.on('data', (data) => {
-      this.forwardToHttpBackend(data);
-    });
-  }
-  
-  public handleHttpRequest(req: IncomingMessage, res: ServerResponse): void {
-    if (this.config.http?.redirectToHttps) {
-      // Redirect to HTTPS if configured
-      this.redirectToHttps(req, res);
-    } else {
-      // Handle HTTP request
-      const target = this.getTargetFromConfig();
-      this.proxyRequest(req, res, target);
-    }
-  }
-}
-
-/**
- * Handler for HTTPS termination with HTTPS backend
- */
-class HttpsTerminateToHttpsHandler extends ForwardingHandler {
-  private tlsContext: SecureContext;
-  
-  public async initialize(): Promise<void> {
-    // Set up TLS termination context
-    this.tlsContext = await this.createTlsContext();
-  }
-  
-  public handleConnection(socket: Socket): void {
-    // Terminate client TLS
-    const tlsSocket = this.createTlsSocket(socket, this.tlsContext);
-    
-    // Create new TLS connection to backend
-    tlsSocket.on('data', (data) => {
-      this.forwardToHttpsBackend(data);
-    });
-  }
-  
-  public handleHttpRequest(req: IncomingMessage, res: ServerResponse): void {
-    if (this.config.http?.redirectToHttps) {
-      // Redirect to HTTPS if configured
-      this.redirectToHttps(req, res);
-    } else {
-      // Handle HTTP request via HTTPS to backend
-      const target = this.getTargetFromConfig();
-      this.proxyRequestOverHttps(req, res, target);
-    }
-  }
-}
-```
-
-## Benefits of This Approach
-
-1. **Clean, Type-Driven Design**
-   - Forwarding types clearly express intent
-   - No backward compatibility compromises
-   - Code structure follows the domain model
-
-2. **Explicit Configuration**
-   - Configuration directly maps to behavior
-   - Reduced chance of unexpected behavior
-
-3. **Modular Implementation**
-   - Each forwarding type handled by dedicated class
-   - Clear separation of concerns
-   - Easier to test and extend
-
-4. **Simplified Mental Model**
-   - Users think in terms of use cases, not low-level settings
-   - Configuration matches mental model
-
-5. **Future-Proof**
-   - Easy to add new forwarding types
-   - Clean extension points for new features
+Standardize interface and type naming throughout the SmartProxy codebase to improve maintainability, readability, and developer experience by:
+1. Ensuring all interfaces are prefixed with "I"
+2. Ensuring all type aliases are prefixed with "T"
+3. Maintaining backward compatibility through type aliases
+4. Updating documentation to reflect naming conventions
+
+## Phase 2: Core Module Standardization
+
+- [ ] Update core module interfaces and types
+  - [ ] Rename interfaces in `ts/core/models/common-types.ts`
+    - [ ] `AcmeOptions` → `IAcmeOptions`
+    - [ ] `DomainOptions` → `IDomainOptions`
+    - [ ] Other common interfaces
+  - [ ] Add backward compatibility aliases
+  - [ ] Update imports throughout core module
+
+- [ ] Update core utility type definitions
+  - [ ] Update `ts/core/utils/validation-utils.ts`
+  - [ ] Update `ts/core/utils/ip-utils.ts`
+  - [ ] Standardize event type definitions
+
+- [ ] Test core module changes
+  - [ ] Run unit tests for core modules
+  - [ ] Verify type compatibility
+  - [ ] Ensure backward compatibility
+
+## Phase 3: Certificate Module Standardization
+
+- [ ] Update certificate interfaces
+  - [ ] Rename interfaces in `ts/certificate/models/certificate-types.ts`
+    - [ ] `CertificateData` → `ICertificateData`
+    - [ ] `Certificates` → `ICertificates`
+    - [ ] `CertificateFailure` → `ICertificateFailure`
+    - [ ] `CertificateExpiring` → `ICertificateExpiring`
+    - [ ] `ForwardConfig` → `IForwardConfig`
+    - [ ] `DomainForwardConfig` → `IDomainForwardConfig`
+  - [ ] Update ACME challenge interfaces
+  - [ ] Standardize storage provider interfaces
+
+- [ ] Ensure certificate provider compatibility
+  - [ ] Update provider implementations
+  - [ ] Rename internal interfaces
+  - [ ] Maintain public API compatibility
+
+- [ ] Test certificate module
+  - [ ] Verify ACME functionality
+  - [ ] Test certificate provisioning
+  - [ ] Validate challenge handling
+
+## Phase 4: Forwarding System Standardization
+
+- [ ] Update forwarding configuration interfaces
+  - [ ] Rename interfaces in `ts/forwarding/config/forwarding-types.ts`
+    - [ ] `TargetConfig` → `ITargetConfig`
+    - [ ] `HttpOptions` → `IHttpOptions`
+    - [ ] `HttpsOptions` → `IHttpsOptions`
+    - [ ] `AcmeForwardingOptions` → `IAcmeForwardingOptions`
+    - [ ] `SecurityOptions` → `ISecurityOptions`
+    - [ ] `AdvancedOptions` → `IAdvancedOptions`
+    - [ ] `ForwardConfig` → `IForwardConfig`
+  - [ ] Rename type definitions
+    - [ ] `ForwardingType` → `TForwardingType`
+  - [ ] Update domain configuration interfaces
+
+- [ ] Standardize handler interfaces
+  - [ ] Update base handler interfaces
+  - [ ] Rename handler-specific interfaces
+  - [ ] Update factory interfaces
+
+- [ ] Verify forwarding system functionality
+  - [ ] Test all forwarding types
+  - [ ] Verify configuration parsing
+  - [ ] Ensure backward compatibility
+
+## Phase 5: Proxy Implementation Standardization
+
+- [ ] Update SmartProxy interfaces
+  - [ ] Rename interfaces in `ts/proxies/smart-proxy/models/interfaces.ts`
+  - [ ] Update domain configuration interfaces
+  - [ ] Standardize manager interfaces
+
+- [ ] Update NetworkProxy interfaces
+  - [ ] Rename in `ts/proxies/network-proxy/models/types.ts`
+    - [ ] `NetworkProxyOptions` → `INetworkProxyOptions`
+    - [ ] `CertificateEntry` → `ICertificateEntry`
+    - [ ] `ReverseProxyConfig` → `IReverseProxyConfig`
+    - [ ] `ConnectionEntry` → `IConnectionEntry`
+    - [ ] `WebSocketWithHeartbeat` → `IWebSocketWithHeartbeat`
+    - [ ] `Logger` → `ILogger`
+  - [ ] Update request handler interfaces
+  - [ ] Standardize connection interfaces
+
+- [ ] Update NfTablesProxy interfaces
+  - [ ] Rename interfaces in `ts/proxies/nftables-proxy/models/interfaces.ts`
+  - [ ] Update configuration interfaces
+  - [ ] Standardize firewall rule interfaces
+
+- [ ] Test proxy implementations
+  - [ ] Verify SmartProxy functionality
+  - [ ] Test NetworkProxy with renamed interfaces
+  - [ ] Validate NfTablesProxy operations
+
+## Phase 6: HTTP & TLS Module Standardization
+
+- [ ] Update HTTP interfaces
+  - [ ] Rename in `ts/http/port80/acme-interfaces.ts`
+    - [ ] `SmartAcmeCert` → `ISmartAcmeCert`
+    - [ ] `SmartAcmeOptions` → `ISmartAcmeOptions`
+    - [ ] `Http01Challenge` → `IHttp01Challenge`
+    - [ ] `SmartAcme` → `ISmartAcme`
+  - [ ] Standardize router interfaces
+  - [ ] Update port80 handler interfaces
+  - [ ] Update redirect interfaces
+
+- [ ] Update TLS/SNI interfaces
+  - [ ] Standardize SNI handler interfaces
+  - [ ] Update client hello parser types
+  - [ ] Rename TLS alert interfaces
+
+- [ ] Test HTTP & TLS functionality
+  - [ ] Verify router operation
+  - [ ] Test SNI extraction
+  - [ ] Validate redirect functionality
+
+## Phase 7: Backward Compatibility Layer
+
+- [ ] Implement comprehensive type aliases
+  - [ ] Create aliases for all renamed interfaces
+  - [ ] Add deprecation notices via JSDoc
+  - [ ] Ensure all exports include both named versions
+
+- [ ] Update main entry point
+  - [ ] Update `ts/index.ts` with all exports
+  - [ ] Include both prefixed and non-prefixed names
+  - [ ] Organize exports by module
+
+- [ ] Add compatibility documentation
+  - [ ] Document renaming strategy
+  - [ ] Provide migration examples
+  - [ ] Create deprecation timeline
+
+## Phase 8: Documentation & Examples
+
+- [ ] Update README and API documentation
+  - [ ] Update interface references in README.md
+  - [ ] Document naming convention in README.md
+  - [ ] Update API reference documentation
+
+- [ ] Update examples
+  - [ ] Modify example code to use new interface names
+  - [ ] Add compatibility notes
+  - [ ] Create migration examples
+
+- [ ] Add contributor guidelines
+  - [ ] Document naming conventions
+  - [ ] Add interface/type style guide
+  - [ ] Update PR templates
+
+## Phase 9: Testing & Validation
+
+- [ ] Run comprehensive test suite
+  - [ ] Run all unit tests
+  - [ ] Execute integration tests
+  - [ ] Verify example code
+
+- [ ] Build type declarations
+  - [ ] Generate TypeScript declaration files
+  - [ ] Verify exported types
+  - [ ] Validate documentation generation
+
+- [ ] Final compatibility check
+  - [ ] Verify import compatibility
+  - [ ] Test with existing dependent projects
+  - [ ] Validate backward compatibility claims
+
+## Implementation Strategy
+
+### Naming Pattern Rules
+
+1. **Interfaces**:
+   - All interfaces should be prefixed with "I"
+   - Example: `DomainConfig` → `IDomainConfig`
+
+2. **Type Aliases**:
+   - All type aliases should be prefixed with "T"
+   - Example: `ForwardingType` → `TForwardingType`
+
+3. **Enums**:
+   - Enums should be named in PascalCase without prefix
+   - Example: `CertificateSource`
+
+4. **Backward Compatibility**:
+   - No Backward compatibility. Remove old names.
+
+### Module Implementation Order
+
+1. Core module
+2. Certificate module
+3. Forwarding module
+4. Proxy implementations
+5. HTTP & TLS modules
+6. Main exports and entry points
+
+### Testing Strategy
+
+For each module:
+1. Rename interfaces and types
+2. Add backward compatibility aliases
+3. Update imports throughout the module
+4. Run tests to verify functionality
+5. Commit changes module by module
+
+## File-Specific Changes
+
+### Core Module Files
+- `ts/core/models/common-types.ts` - Primary interfaces
+- `ts/core/utils/validation-utils.ts` - Validation type definitions
+- `ts/core/utils/ip-utils.ts` - IP utility type definitions
+- `ts/core/utils/event-utils.ts` - Event type definitions 
+
+### Certificate Module Files
+- `ts/certificate/models/certificate-types.ts` - Certificate interfaces
+- `ts/certificate/acme/acme-factory.ts` - ACME factory types
+- `ts/certificate/providers/cert-provisioner.ts` - Provider interfaces
+- `ts/certificate/storage/file-storage.ts` - Storage interfaces
+
+### Forwarding Module Files
+- `ts/forwarding/config/forwarding-types.ts` - Forwarding interfaces and types
+- `ts/forwarding/config/domain-config.ts` - Domain configuration
+- `ts/forwarding/factory/forwarding-factory.ts` - Factory interfaces
+- `ts/forwarding/handlers/*.ts` - Handler interfaces
+
+### Proxy Module Files
+- `ts/proxies/network-proxy/models/types.ts` - NetworkProxy interfaces
+- `ts/proxies/smart-proxy/models/interfaces.ts` - SmartProxy interfaces
+- `ts/proxies/nftables-proxy/models/interfaces.ts` - NfTables interfaces
+- `ts/proxies/smart-proxy/connection-manager.ts` - Connection types
+
+### HTTP/TLS Module Files
+- `ts/http/models/http-types.ts` - HTTP module interfaces
+- `ts/http/port80/acme-interfaces.ts` - ACME interfaces
+- `ts/tls/sni/client-hello-parser.ts` - TLS parser types
+- `ts/tls/alerts/tls-alert.ts` - TLS alert interfaces
+
+## Success Criteria
+
+- All interfaces are prefixed with "I"
+- All type aliases are prefixed with "T"
+- All tests pass with new naming conventions
+- Documentation is updated with new naming conventions
+- Backward compatibility is maintained through type aliases
+- Declaration files correctly export both naming conventions