Generate Application from OpenAPI Spec
Your goal is to generate a complete, working application from an OpenAPI specification using the active framework's conventions and best practices.
Input Requirements
- OpenAPI Specification: Provide either:
- A URL to the OpenAPI spec (e.g., https://api.example.com/openapi.json) - A local file path to the OpenAPI spec - The full OpenAPI specification content pasted directly
- Project Details (if not in spec):
- Project name and description - Target framework and version - Package/namespace naming conventions - Authentication method (if not specified in OpenAPI)
Generation Process
Step 1: Analyze the OpenAPI Specification
- Validate the OpenAPI spec for completeness and correctness
- Identify all endpoints, HTTP methods, request/response schemas
- Extract authentication requirements and security schemes
- Note data model relationships and constraints
- Flag any ambiguities or incomplete definitions
Step 2: Design Application Architecture
- Plan directory structure appropriate for the framework
- Identify controller/handler grouping by resource or domain
- Design service layer organization for business logic
- Plan data models and entity relationships
- Design configuration and initialization strategy
Step 3: Generate Application Code
- Create project structure with build/package configuration files
- Generate models/DTOs from OpenAPI schemas
- Generate controllers/handlers with route mappings
- Generate service layer with business logic
- Generate repository/data access layer if applicable
- Add error handling, validation, and logging
- Generate configuration and startup code
Step 4: Add Supporting Files
- Generate appropriate unit tests for services and controllers
- Create README with setup and running instructions
- Add.gitignore and environment configuration templates
- Generate API documentation files
- Create example requests/integration tests
Output Structure
The generated application will include:
project-name/
├── README.md # Setup and usage instructions
├── [build-config] # Framework-specific build files (pom.xml, build.gradle, package.json, etc.)
├── src/
│ ├── main/
│ │ ├── [language]/
│ │ │ ├── controllers/ # HTTP endpoint handlers
│ │ │ ├── services/ # Business logic
│ │ │ ├── models/ # Data models and DTOs
│ │ │ ├── repositories/ # Data access (if applicable)
│ │ │ └── config/ # Application configuration
│ │ └── resources/ # Configuration files
│ └── test/
│ ├── [language]/
│ │ ├── controllers/ # Controller tests
│ │ └── services/ # Service tests
│ └── resources/ # Test configuration
├── .gitignore
├── .env.example # Environment variables template
└── docker-compose.yml # Optional: Docker setup (if applicable)Best Practices Applied
- Framework Conventions: Follows framework-specific naming, structure, and patterns
- Separation of Concerns: Clear layers with controllers, services, and repositories
- Error Handling: Comprehensive error handling with meaningful responses
- Validation: Input validation and schema validation throughout
- Logging: Structured logging for debugging and monitoring
- Testing: Unit tests for services and controllers
- Documentation: Inline code documentation and setup instructions
- Security: Implements authentication/authorization from OpenAPI spec
- Scalability: Design patterns support growth and maintenance
Next Steps
After generation:
- Review the generated code structure and make customizations as needed
- Install dependencies according to framework requirements
- Configure environment variables and database connections
- Run tests to verify generated code
- Start the development server
- Test endpoints using the provided examples
Questions to Ask if Needed
- Should the application include database/ORM setup, or just in-memory/mock data?
- Do you want Docker configuration for containerization?
- Should authentication be JWT, OAuth2, API keys, or basic auth?
- Do you need integration tests or just unit tests?
- Any specific database technology preferences?
- Should the API include pagination, filtering, and sorting examples?