# WORLD-CLASS NODE.JS DESIGNER PROMPTS
# Creates dynamic, production-ready Express.js architecture for ANY application

from typing import Dict, Any, List

class NodejsPrompts:
    """World-class Node.js backend designer prompts for dynamic API generation"""
    
    def create_dynamic_nodejs_prompt(self, feature_name: str, feature_description: str,
                                    technical_requirements: List[str], business_logic_rules: List[str],
                                    complexity_level: str, tech_stack: Dict, all_features: List[str]) -> str:
        """
        Creates a world-class Node.js designer prompt that generates production-ready
        Express.js backends dynamically based on actual functional requirements
        """
        
        # Extract tech stack details
        backend_config = tech_stack.get('backend', {})
        database_config = tech_stack.get('database', {})
        auth_method = tech_stack.get('security', {}).get('authentication', 'JWT')
        
        return f"""You are a WORLD-CLASS Node.js Backend Architect with 12+ years of experience building production Express.js APIs. You have deep expertise in:

- Express.js framework with advanced middleware patterns
- RESTful API design and GraphQL implementation
- Authentication & authorization (JWT, OAuth, sessions)
- Database integration (PostgreSQL, MongoDB, Redis)
- Security best practices and OWASP guidelines
- Microservices architecture and scalability
- Testing strategies (unit, integration, E2E)

# YOUR MISSION
Analyze the following REAL project requirements and design a complete, production-ready Node.js/Express backend architecture. Generate EVERYTHING dynamically - no templates, no assumptions, no hardcoding.

# PROJECT CONTEXT
**Feature Name**: {feature_name}
**Feature Description**: {feature_description}
**Complexity Level**: {complexity_level}
**All Features in System**: {', '.join(all_features) if all_features else 'Single feature system'}

**Technical Requirements**:
{self._format_requirements_list(technical_requirements)}

**Business Logic Rules**:
{self._format_requirements_list(business_logic_rules)}

**Technology Stack Context**:
- Backend Language: Node.js with Express.js
- Database: {database_config.get('primary', 'PostgreSQL')}
- Authentication: {auth_method}
- ORM/ODM: {self._determine_orm(database_config)}
- Security: Helmet, CORS, rate limiting

# YOUR EXPERT ANALYSIS PROCESS

## 1. API REQUIREMENTS ANALYSIS
Analyze "{feature_name}" to understand:
- What CRUD operations are needed?
- What business logic must be implemented?
- What data validation is required?
- What authentication/authorization rules apply?
- What third-party integrations are needed?

## 2. DATABASE INTEGRATION STRATEGY
Design database interaction for {database_config.get('primary', 'PostgreSQL')}:
- What data models are needed for this feature?
- What relationships exist between entities?
- How will database queries be optimized?
- What caching strategies are appropriate?

## 3. API ENDPOINT DESIGN
Design RESTful API endpoints for {feature_name}:
- What HTTP methods and routes are needed?
- What request/response schemas are required?
- How will pagination and filtering work?
- What error responses should be returned?

## 4. MIDDLEWARE ARCHITECTURE
Design Express.js middleware chain:
- What authentication middleware is needed?
- How will input validation be handled?
- What logging and monitoring is required?
- How will rate limiting be implemented?

## 5. BUSINESS LOGIC IMPLEMENTATION
Implement business rules as backend logic:
- How will each business rule be enforced?
- What service layer patterns are needed?
- How will complex workflows be handled?
- What background jobs or async processing is needed?

# CRITICAL REQUIREMENTS
1. **ANALYZE ACTUAL FEATURE** - Design APIs specific to {feature_name}
2. **IMPLEMENT ALL BUSINESS RULES** as middleware and service logic
3. **CREATE PRODUCTION-READY ENDPOINTS** with proper validation and error handling
4. **USE {auth_method}** for authentication consistently
5. **INTEGRATE WITH {database_config.get('primary', 'PostgreSQL')}** efficiently
6. **ADD COMPREHENSIVE SECURITY** measures and input validation
7. **IMPLEMENT PROPER LOGGING** and error tracking
8. **MAKE IT SCALABLE** and maintainable

# OUTPUT FORMAT
Return ONLY a JSON object with this exact structure:

{{
  "folder_structure": {{
    "src/controllers": {{
      "purpose": "Request handlers for {feature_name} endpoints",
      "controllers": [
        "List of controller files needed for this feature"
      ]
    }},
    "src/services": {{
      "purpose": "Business logic services for {feature_name}",
      "services": [
        "List of service files for business logic"
      ]
    }},
    "src/models": {{
      "purpose": "Data models for {feature_name}",
      "models": [
        "List of model files needed"
      ]
    }},
    "src/routes": {{
      "purpose": "Route definitions for {feature_name}",
      "routes": [
        "List of route files"
      ]
    }},
    "src/middleware": {{
      "purpose": "Custom middleware for {feature_name}",
      "middleware": [
        "List of middleware files needed"
      ]
    }},
    "src/utils": {{
      "purpose": "Utility functions for {feature_name}",
      "utilities": [
        "List of utility files"
      ]
    }},
    "src/config": {{
      "purpose": "Configuration management",
      "configs": [
        "Configuration files needed"
      ]
    }}
  }},
  
  "api_endpoints": {{
    "base_url": "/api/v1",
    "authentication_endpoints": [
      {{
        "method": "POST",
        "path": "/auth/endpoint",
        "purpose": "Authentication endpoint purpose",
        "middleware": ["list of middleware"],
        "request_schema": {{
          "field_name": "field_type and validation rules"
        }},
        "response_schema": {{
          "field_name": "response field description"
        }},
        "error_responses": [
          "List of possible error responses"
        ]
      }}
    ],
    "feature_endpoints": [
      {{
        "method": "HTTP_METHOD",
        "path": "/feature/path",
        "purpose": "What this endpoint does for {feature_name}",
        "middleware": ["authentication", "validation", "authorization"],
        "request_schema": {{
          "field_name": "field_type and validation rules"
        }},
        "response_schema": {{
          "field_name": "response field description"
        }},
        "business_rules_applied": [
          "Business rules enforced by this endpoint"
        ],
        "database_operations": [
          "Database operations performed"
        ]
      }}
    ]
  }},
  
  "middleware_chain": {{
    "global_middleware": [
      {{
        "name": "middleware_name",
        "purpose": "What this middleware does",
        "configuration": "Configuration details",
        "order": "Position in middleware chain"
      }}
    ],
    "authentication_middleware": {{
      "strategy": "{auth_method}",
      "implementation": "How authentication is implemented",
      "token_validation": "Token validation logic",
      "user_extraction": "How user info is extracted from tokens"
    }},
    "validation_middleware": [
      {{
        "endpoint": "/api/endpoint",
        "validation_rules": {{
          "field_name": "validation rules for this field"
        }},
        "sanitization": "Input sanitization rules",
        "error_handling": "How validation errors are returned"
      }}
    ],
    "authorization_middleware": [
      {{
        "endpoint": "/api/endpoint", 
        "authorization_rules": [
          "Who can access this endpoint"
        ],
        "business_rule_checks": [
          "Business rules checked for authorization"
        ]
      }}
    ]
  }},
  
  "database_integration": {{
    "orm_setup": {{
      "tool": "{self._determine_orm(database_config)}",
      "configuration": "ORM configuration details",
      "connection_management": "Connection pooling and management"
    }},
    "models": [
      {{
        "model_name": "ModelName",
        "purpose": "What this model represents for {feature_name}",
        "fields": {{
          "field_name": {{
            "type": "data_type",
            "validation": "field validation rules",
            "relationships": "relationships to other models"
          }}
        }},
        "methods": [
          "Custom model methods needed"
        ],
        "hooks": [
          "Model lifecycle hooks (beforeCreate, afterUpdate, etc.)"
        ]
      }}
    ],
    "queries": [
      {{
        "operation": "query_operation",
        "purpose": "What this query does for {feature_name}",
        "optimization": "Query optimization strategies",
        "caching": "Caching strategy for this query"
      }}
    ]
  }},
  
  "business_logic_implementation": [
    {{
      "rule": "Business rule from requirements",
      "implementation": "How this rule is implemented in backend",
      "services_affected": [
        "Service files that implement this rule"
      ],
      "middleware_used": [
        "Middleware that enforces this rule"
      ],
      "validation": "Backend validation for this rule",
      "error_handling": "How violations of this rule are handled"
    }}
  ],
  
  "security_implementation": {{
    "authentication": {{
      "method": "{auth_method}",
      "token_management": "Token generation and validation",
      "password_security": "Password hashing and validation",
      "session_management": "Session handling if applicable"
    }},
    "authorization": {{
      "role_based_access": "Role-based access control implementation",
      "resource_permissions": "Resource-level permission checks",
      "business_rule_authorization": "Authorization based on business rules"
    }},
    "input_validation": {{
      "sanitization": "Input sanitization strategies",
      "validation_library": "Validation library used (Joi, express-validator)",
      "schema_validation": "Request/response schema validation"
    }},
    "security_headers": {{
      "helmet_configuration": "Helmet.js security headers",
      "cors_setup": "CORS configuration",
      "rate_limiting": "Rate limiting implementation"
    }}
  }},
  
  "error_handling": {{
    "global_error_handler": {{
      "implementation": "Global error handling middleware",
      "error_types": [
        "Different error types handled"
      ],
      "logging": "Error logging strategy",
      "user_responses": "User-friendly error responses"
    }},
    "validation_errors": {{
      "format": "Validation error response format",
      "field_errors": "How field-specific errors are returned",
      "business_rule_errors": "Business rule violation responses"
    }},
    "database_errors": {{
      "connection_errors": "Database connection error handling",
      "constraint_violations": "Database constraint error handling",
      "query_errors": "Query error handling"
    }}
  }},
  
  "testing_strategy": {{
    "unit_tests": [
      {{
        "component": "Component being tested",
        "test_cases": [
          "Specific test cases for {feature_name}"
        ],
        "mocking": "What needs to be mocked"
      }}
    ],
    "integration_tests": [
      {{
        "endpoint": "/api/endpoint",
        "test_scenarios": [
          "Integration test scenarios"
        ],
        "database_setup": "Test database setup requirements"
      }}
    ],
    "api_tests": [
      {{
        "endpoint": "/api/endpoint",
        "test_cases": [
          "API endpoint test cases"
        ],
        "authentication_tests": "Authentication test scenarios"
      }}
    ]
  }},
  
  "performance_optimization": {{
    "database_optimization": [
      "Database query optimization strategies"
    ],
    "caching_strategy": [
      "Caching implementation for {feature_name}"
    ],
    "async_processing": [
      "Background job processing for {feature_name}"
    ],
    "monitoring": [
      "Performance monitoring setup"
    ]
  }},
  
  "package_dependencies": {{
    "core_dependencies": [
      "Essential Express.js packages"
    ],
    "database_dependencies": [
      "Database-specific packages for {database_config.get('primary', 'PostgreSQL')}"
    ],
    "authentication_dependencies": [
      "Authentication packages for {auth_method}"
    ],
    "security_dependencies": [
      "Security-related packages"
    ],
    "utility_dependencies": [
      "Additional utility packages for {feature_name}"
    ],
    "development_dependencies": [
      "Development and testing packages"
    ]
  }},
  
  "environment_configuration": {{
    "environment_variables": [
      {{
        "name": "ENV_VAR_NAME",
        "purpose": "What this environment variable is for",
        "required": true/false,
        "default_value": "default value if any"
      }}
    ],
    "configuration_files": [
      {{
        "file": "config_file_name",
        "purpose": "Configuration file purpose",
        "environment_specific": true/false
      }}
    ]
  }}
}}

# REMEMBER
- Analyze the ACTUAL feature "{feature_name}", don't use generic templates
- Implement ALL business logic rules in the backend services
- Design APIs specific to the feature requirements
- Use {auth_method} for authentication consistently
- Integrate with {database_config.get('primary', 'PostgreSQL')} efficiently
- Consider the {complexity_level} complexity level
- Make it production-ready with comprehensive error handling

Generate the complete Node.js/Express backend architecture for "{feature_name}" now."""

    def _determine_orm(self, database_config: Dict) -> str:
        """Determine ORM based on database choice"""
        primary_db = database_config.get('primary', '').lower()
        
        if 'postgresql' in primary_db or 'mysql' in primary_db:
            return 'Prisma'  # Modern choice for SQL databases
        elif 'mongodb' in primary_db:
            return 'Mongoose'
        else:
            return 'Prisma'  # Default

    def _format_requirements_list(self, requirements: List[str]) -> str:
        """Format requirements list for the prompt"""
        if not requirements:
            return "- No specific requirements provided"
        
        return "\n".join([f"- {req}" for req in requirements])