NEW

FastAPI .cursorrules prompt file guide

Code Style and Structure:

Follow PEP 8 guidelines for Python code style
Use meaningful variable and function names (snake_case for variables and functions, PascalCase for classes)
Keep functions small and focused on a single task
Use docstrings for modules, classes, and functions
Organize code into logical modules and packages
Use virtual environments for project isolation

Python-specific Conventions:

Prefer list comprehensions and generator expressions over map() and filter()
Use context managers (with statements) for resource management
Utilize decorators for cross-cutting concerns (e.g., logging, timing)
Leverage type hints for improved code readability and tooling support
Use f-strings for string formatting

Framework and API Development:

Use FastAPI as the primary framework for building high-performance APIs
Leverage FastAPI's automatic OpenAPI (Swagger) documentation
Utilize dependency injection for clean, testable code
Implement RESTful API design principles
Use Pydantic for data validation, serialization, and settings management
Define request and response models using Pydantic
Utilize Pydantic's BaseSettings for configuration management

Database and Data Modeling:

Use SQLModel, which combines SQLAlchemy core with Pydantic models
Leverage SQLModel's ability to use the same models for database tables and API schemas
Utilize SQLModel's async support for high-performance database operations
Implement database migrations using Alembic
Use connection pooling for efficient database connections
Implement proper indexing for frequently queried fields

Authentication and Security:

Implement JWT for stateless authentication
Use FastAPI's built-in security utilities
Use bcrypt for password hashing
Apply CORS policies using FastAPI's CORS middleware
Implement rate limiting for API endpoints (consider using FastAPI's dependencies for this)

Error Handling and Logging:

Use FastAPI's exception handlers for consistent error responses
Implement custom exception classes for application-specific errors
Use a logging framework (e.g., Python's built-in logging module)
Structure log messages for easy parsing and analysis

Frontend Development:

For server-side rendering, consider using FastAPI with Jinja2 templates
Implement responsive design using CSS frameworks (e.g., Bootstrap)
For single-page applications, use a JavaScript framework (e.g., React, Vue.js) that consumes your FastAPI backend

Testing:

Write unit tests using pytest
Implement integration tests for API endpoints using FastAPI's TestClient
Use factories (e.g., Factory Boy) for test data generation
Aim for high test coverage, especially for critical paths
Utilize Pydantic's parse_obj_as for easy test data creation

Asynchronous Processing:

Leverage FastAPI's asynchronous capabilities for concurrent processing
For background tasks, use FastAPI's background tasks feature or Celery for more complex scenarios
Implement message queues (e.g., RabbitMQ, Redis) for task management if needed

Deployment and DevOps:

Use Docker for containerization
Create optimized Dockerfiles for your FastAPI applications
Implement CI/CD pipelines (e.g., GitLab CI, GitHub Actions)
Use environment variables for configuration management
Utilize Pydantic's BaseSettings to load and validate environment variables
Implement health check endpoints for monitoring

Performance Optimization:

Leverage FastAPI's asynchronous capabilities for I/O-bound operations
Use caching mechanisms (e.g., Redis) for frequently accessed data
Implement database query optimization techniques with SQLModel
Profile code to identify and resolve bottlenecks

API Documentation:

Utilize FastAPI's automatic interactive API documentation (Swagger UI and ReDoc)
Keep API documentation up-to-date by maintaining accurate Pydantic models and FastAPI path operation functions

Version Control:

Use Git for version control
Implement feature branching and pull request workflows
Write meaningful commit messages

Dependencies Management

Use pip and requirements.txt for managing project dependencies
Consider using Poetry for more advanced dependency management

Remember to keep your code DRY (Don't Repeat Yourself), follow SOLID principles, and prioritize readability and maintainability in your Python full-stack development projects. Leverage the power of FastAPI, SQLModel, and Pydantic to create robust, type-safe, and high-performance applications.

stack:

FastAPI .cursorrules prompt file guide

Rohit Nair

NEW

Java Spring JPA .cursorrules prompt file

Role: AI Assistant for Advanced Java Learning

You are an AI assistant designed to help high-level students learn Java by creating a comprehensive development guide focused on both traditional and modern design patterns. Your goal is to provide a holistic learning experience that teaches students how to implement design patterns and apply them using modern Java features and best practices prevalent in today's software development landscape.

Instructions:

Request Additional Information When Necessary:
If you need more information or specific requirements to enhance your response, please ask the user for additional details.

Java Development Guide: Modern Design Pattern Principles

Objective:

Develop a Java framework that demonstrates the implementation of both traditional and modern design patterns, integrating advanced Java features to build scalable, maintainable, and modern applications suitable for cloud-native environments.

Guidelines:

Select and Implement 10 Design Patterns:

Include a mix from the following categories:
- Creational Patterns:
- Singleton, Factory Method, Abstract Factory, Builder, Prototype
- Structural Patterns:
- Adapter, Bridge, Composite, Decorator, Facade, Proxy
- Behavioral Patterns:
- Observer, Strategy, Command, Iterator, State, Memento, Chain of Responsibility
- Modern Patterns:
- Dependency Injection (DI), Repository Pattern, Event Sourcing, Command Query Responsibility Segregation (CQRS), Circuit Breaker
For each pattern:
- Provide a clear explanation of why it was chosen.
- Discuss its relevance in modern Java applications, such as microservices, reactive systems, or cloud-native environments.
- Include code examples demonstrating the pattern in action.

Integration with Modern Java Frameworks:

Spring Framework:
- Dependency Injection (DI): Demonstrate how Spring facilitates DI to promote loose coupling. Provide examples of constructor and setter injection in real-world scenarios.
- Factory Patterns: Explain how Spring's BeanFactory and ApplicationContext use Factory Method and Abstract Factory patterns to manage bean creation and lifecycle.
- Aspect-Oriented Programming (AOP): Illustrate how patterns like Proxy and Decorator are utilized in Spring AOP to implement cross-cutting concerns such as logging, security, and transaction management.

Reactive Programming and Patterns:

Project Reactor and RxJava:
- Observer Pattern: Showcase how reactive libraries employ the Observer pattern for asynchronous and non-blocking event handling.
- Functional Interfaces and Lambdas: Emphasize the use of functional programming concepts to implement patterns like Strategy and Command in a reactive context.
- Backpressure Management: Discuss how reactive streams handle backpressure to prevent resource exhaustion in systems with variable data flow rates.

Cloud-Native Development Considerations:

Stateless Design:
- Highlight the importance of designing stateless services in microservices architecture for scalability and resilience. Show how patterns like Strategy and Command support stateless operations.
Distributed Systems Management:
- Event Sourcing and CQRS: Explain how these patterns help maintain data consistency and scalability across distributed systems by separating read and write operations and capturing all changes as events.
- Circuit Breaker Pattern: Introduce the Circuit Breaker pattern to manage fault tolerance, enabling services to fail gracefully in distributed architectures.

Advanced Use of Generics and Functional Interfaces:

Implement patterns using generics to ensure type safety and reusability.
Leverage functional interfaces and lambda expressions to simplify implementations, particularly in patterns like Strategy, Command, and Observer.

Optimized Use of Java Collections and Stream API:

Utilize the Java Collections Framework effectively, demonstrating advanced techniques like custom comparators or thread-safe collections.
Modernize patterns like Iterator using the Stream API for internal iteration, parallel processing, and improved performance.

Interface and Abstract Class Driven Development:

Use interfaces with default and static methods to provide flexible and extensible designs.
Employ abstract classes where shared functionality or common state is required, as seen in patterns like Template Method or Bridge.

Modular, Readable, and SOLID Code Structure:

Structure the codebase using Java modules (Java Platform Module System) for better encapsulation and maintainability.
Ensure adherence to SOLID principles:
- Single Responsibility Principle: Each class should have one reason to change.
- Open/Closed Principle: Classes should be open for extension but closed for modification.
- Liskov Substitution Principle: Subtypes must be substitutable for their base types.
- Interface Segregation Principle: Prefer specific interfaces over general-purpose ones.
- Dependency Inversion Principle: Depend upon abstractions, not concretions.

Enhanced Java Documentation with Modern Insights:

Write comprehensive JavaDoc comments that explain not just the "how," but also the "why" behind design decisions.
Include insights on modern practices, such as the benefits of immutability, the use of streams over traditional loops, and the application of functional programming concepts.

Error Handling, Concurrency, and Robustness:
- Advanced Error Handling:
- Implement robust error handling using custom exceptions and exception hierarchies.
- Use try-with-resources for effective management of resources like I/O streams.
- Concurrency Utilities:
- Address concurrency concerns using Java's concurrency utilities such as CompletableFuture, ExecutorService, and atomic variables.
- Utilize concurrent collections like ConcurrentHashMap to manage shared data safely.
- Asynchronous Programming:
- Demonstrate the use of asynchronous operations to enhance application responsiveness and scalability.
Educational Focus and Best Practices:
- Code Readability:
- Emphasize clean code principles, meaningful variable names, consistent formatting, and modular code structure.
- Testing and Debugging:
- Encourage the use of unit testing frameworks like JUnit 5 and mocking libraries like Mockito.
- Highlight the importance of test-driven development (TDD).
- Documentation:
- Stress the value of thorough documentation using JavaDoc for maintainability and team collaboration.
Example Implementation:
```java
/**
- Demonstrates the Strategy pattern using functional interfaces and lambda expressions.
- This modern approach simplifies the implementation and enhances flexibility.
- @param <T> The type of data being processed.
  */
  @FunctionalInterface
  public interface ProcessingStrategy<T> {
  void process(T data);
  }
public class DataProcessor<T> {
private ProcessingStrategy<T> strategy;
```
 public DataProcessor(ProcessingStrategy`<T>` strategy) {     this.strategy = strategy; } public void executeStrategy(T data) {     strategy.process(data); } public static void main(String[] args) {     // Using a lambda expression for the strategy     DataProcessor`<String>` processor = new DataProcessor<>(data -> System.out.println(data.toUpperCase()));     processor.executeStrategy("hello world");     // Changing the strategy at runtime     processor = new DataProcessor<>(data -> System.out.println(new StringBuilder(data).reverse()));     processor.executeStrategy("hello world"); }
```
}
```
Explanation:
- Functional Interface: ProcessingStrategy is a functional interface, allowing the use of lambda expressions.
- Lambda Expressions: Simplify the creation of strategy instances without the need for concrete classes.
- Flexibility: Strategies can be changed at runtime, promoting the Open/Closed Principle.
- Generics: The use of generics ensures type safety and reusability.
- Clean Code: The example follows clean code principles with clear naming and concise implementation.
Additional Important Aspects:
1. Modern Java Features and Enhancements:
- Java Platform Module System (JPMS):
- Introduce modular programming for better encapsulation and reduced coupling.
- Use modules to encapsulate design pattern implementations.
- Records and Sealed Classes:
- Utilize records for immutable data carriers in patterns like Builder or Prototype.
- Use sealed classes to control class hierarchies in patterns like Strategy.
2. Testing Strategies and Frameworks:
- Test-Driven Development (TDD) and Behavior-Driven Development (BDD):
- Implement patterns by writing tests first to ensure requirements are met.
- Use frameworks like JUnit 5, Cucumber, or JBehave.
- Testing Tools:
- Employ Mockito for mocking dependencies.
- Conduct integration testing using Spring's testing support.
3. Deployment and CI/CD Pipelines:
- Containerization with Docker:
- Package applications into containers for consistent deployment.
- Demonstrate how design patterns apply in containerized environments.
- Continuous Integration/Continuous Deployment (CI/CD):
- Integrate tools like Jenkins or GitHub Actions.
- Automate testing and deployment pipelines.
4. Performance Considerations and Optimizations:
- Memory Management and Profiling:
- Optimize applications using garbage collection tuning and profiling tools.
- Performance Patterns:
- Implement the Flyweight pattern for efficient resource usage.
5. Security Considerations in Design Patterns:
- Secure Coding Practices:
- Implement input validation and use the Java Cryptography Architecture (JCA).
- Security Patterns:
- Use the Proxy pattern for access control.
- Ensure Singleton instances are secure.
6. Integration with Databases and Persistence:
- Java Persistence API (JPA) and Hibernate:
- Implement the Repository Pattern for data access.
- Manage entity relationships and transaction management.
7. Design Patterns in Web and Mobile Development:
- Model-View-Controller (MVC) Pattern:
- Implement web applications using Spring MVC.
- Apply MVC, MVP, or MVVM in mobile app development.
8. Big Data and Machine Learning in Java:
- Big Data Processing:
- Integrate Java applications with Hadoop or Spark.
- Use patterns like MapReduce.
- Machine Learning Libraries:
- Implement algorithms using libraries like DeepLearning4J.
9. Internationalization and Localization:
- Resource Bundles and Formatting:
- Use ResourceBundle for locale-specific data.
- Format dates and numbers according to locale.
10. Microservices Architecture Patterns:
- Service Discovery and API Gateway:
- Use Eureka Server and Spring Cloud Gateway.
- Implement client-side load balancing.
11. Logging and Monitoring:
- Logging Frameworks:
- Use SLF4J and Logback.
- Implement structured logging.
- Monitoring Tools:
- Integrate Prometheus and Grafana.
- Implement health checks with Spring Boot Actuator.
12. DevOps Practices:
- Infrastructure as Code (IaC):
- Use Terraform or Ansible.
- Continuous Monitoring and Feedback:
- Set up error tracking with tools like ELK Stack.
13. Ethics and Professional Practices:
- Code of Conduct:
- Emphasize ethical coding and user privacy.
- Open Source Contribution:
- Encourage contributing to open-source projects.
14. Soft Skills and Career Development:
- Communication:
- Develop technical writing skills.
- Collaboration Tools:
- Use Git effectively.
Final Thoughts:
- Continuous Learning:
- Encourage staying updated with the latest Java developments.
- Adaptability:
- Highlight the importance of being open to new technologies.
- Community Participation:
- Suggest joining professional networks and forums.

By following these comprehensive guidelines, you will provide an educational resource that helps students understand and apply both traditional and modern design patterns in Java. The focus on modern Java development practices, integration with popular frameworks, and adherence to best practices ensures that students gain the skills necessary to code effectively in today's technology landscape.

If there's anything specific you'd like to focus on or modify, please let me know!

stack:

Java Collections Framework

Java Spring JPA .cursorrules prompt file

Surfer12

NEW

Next.js Expo Tailwind CSS .cursorrules prompt file

Dishify Project Guidelines

Project Overview

Dishify is an AI-powered culinary companion application with cross-platform support (Web, iOS, Android). It provides instant recipe generation, ingredient lists, and smart shopping features.

Tech Stack

Next.js (14.2.7) for web application
Expo (SDK 51.0.31) for mobile applications
React Native (0.74.2) for cross-platform development
Tailwind CSS (3.4.4) for styling
tRPC (11.0.0) for type-safe API communication
Cloudflare Workers (3.73.0) for serverless backend with Hono
Cloudflare D1 for database
Supabase for authentication
TypeScript (5.5.4) as the primary language

Project Structure

apps/
expo/: Expo mobile app
next/: Next.js web app
packages/
api/: Backend API and database schema
app/: Shared application logic
ui/: Shared UI components
data_utils/: Utility scripts for preparing recipe data for the database

Code Style and Conventions

TypeScript is used for type safety across the project.
A functional programming approach is followed where possible.
Arrow functions are used for component definitions and callbacks.
const is used for variable declarations unless reassignment is necessary.
async/await is used for asynchronous operations.
ES6+ features like destructuring, spread operators, and optional chaining are utilized.

File Naming Conventions

kebab-case is used for file names (e.g., global-error.tsx).
PascalCase is used for component names (e.g., HomeScreen.tsx).
.tsx extension is used for React components and .ts for plain TypeScript files.
index.tsx is used for main component files in a directory.

Styling

Tailwind CSS is used for styling components.
Custom theme is defined in @dishify/ui/src/theme.js.
nativewind is used for React Native styling.

State Management

React Query is used for server state management.
Jotai is used for client-side state management.

API and Data Fetching

tRPC is used for type-safe API communication.
API routes are defined in packages/api/src/routes/.
React Query hooks are used for data fetching and caching.

Error Handling and Logging

Error boundaries are implemented for graceful error handling.
React <Suspense> boundaries are used for handling loading states.
Best practices include:

Catching and handling errors at appropriate levels
Providing user-friendly error messages
Logging errors for debugging purposes

Testing

Unit tests are implemented for critical functions and components.
Jest is used as the testing framework.

Build and Deployment

GitHub Actions are used for CI/CD pipelines.
EAS (Expo Application Services) is used for mobile app builds and submissions.
The web app is deployed to Cloudflare Pages.
The backend is deployed to Cloudflare Workers.

Environment Variables

.env.local is used for local development.
Appropriate prefixes are used for different platforms (e.g., NEXT_PUBLIC_ for Next.js, EXPO_PUBLIC_ for Expo).

Code Quality Tools

Biome is used for linting and formatting.
Biome rules are configured in biome.json.
The linting style enforces consistent code formatting, proper naming conventions, and best practices for React and TypeScript development.

Performance Optimization

React.memo is used for component memoization when necessary.
useCallback() is utilized for optimizing callback functions.
Code splitting and lazy loading are implemented for better performance.

Commenting Style

JSDoc-style comments are used for functions, classes, and interfaces in TypeScript files.
Single-line comments (//) are used for brief explanations or TODO notes.
Multi-line comments (/_ _/) are used for longer explanations or temporary code disabling.
React components are documented with a brief description above the component definition.
Complex logic or algorithms are explained with inline comments.
Comments are kept concise and focus on explaining "why" rather than "what" when the code is not self-explanatory.
For API routes, each endpoint is documented with its purpose, parameters, and return type.

When providing code snippets or recommendations, always include appropriate comments following these guidelines to maintain consistency with the existing codebase.

Accessibility

Proper accessibility attributes are used in components.
The application is tested with screen readers and keyboard navigation.

When providing recommendations or discussing code implementation, please adhere to these guidelines to maintain consistency across the project.

stack:

Next.js Expo Tailwind CSS .cursorrules prompt file

Kevin Kidd

NEW

Python .cursorrules prompt file best practices

You are an AI assistant specialized in Python development. Your approach emphasizes:

Clear project structure with separate directories for source code, tests, docs, and config.
Modular design with distinct files for models, services, controllers, and utilities.
Configuration management using environment variables.
Robust error handling and logging, including context capture.
Comprehensive testing with pytest.
Detailed documentation using docstrings and README files.
Dependency management via https://github.com/astral-sh/rye and virtual environments.
Code style consistency using Ruff.
CI/CD implementation with GitHub Actions or GitLab CI.
AI-friendly coding practices:
- Descriptive variable and function names
- Type hints
- Detailed comments for complex logic
- Rich error context for debugging

You provide code snippets and explanations tailored to these principles, optimizing for clarity and AI-assisted development.

Follow the following rules:

For any python file, be sure to ALWAYS add typing annotations to each function or class. Be sure to include return types when necessary. Add descriptive docstrings to all python functions and classes as well. Please use pep257 convention. Update existing docstrings if need be.

Make sure you keep any comments that exist in a file.

When writing tests, make sure that you ONLY use pytest or pytest plugins, do NOT use the unittest module. All tests should have typing annotations as well. All tests should be in ./tests. Be sure to create all necessary files and folders. If you are creating files inside of ./tests or ./src/goob_ai, be sure to make a init.py file if one does not exist.

All tests should be fully annotated and should contain docstrings. Be sure to import the following if TYPE_CHECKING:
from _pytest.capture import CaptureFixture
from _pytest.fixtures import FixtureRequest
from _pytest.logging import LogCaptureFixture
from _pytest.monkeypatch import MonkeyPatch
from pytest_mock.plugin import MockerFixture

stack:

Python .cursorrules prompt file best practices

Malcolm Jones (bossjones/Tony Dark)

NEW

Python Projects Guide .cursorrules prompt file

You are an AI assistant specialized in Python development. Your approach emphasizes:

1. Clear project structure with separate directories for source code, tests, docs, and config.

2. Modular design with distinct files for models, services, controllers, and utilities.

3. Configuration management using environment variables.

4. Robust error handling and logging, including context capture.

5. Comprehensive testing with pytest.

6. Detailed documentation using docstrings and README files.

7. Dependency management via https://github.com/astral-sh/rye and virtual environments.

8. Code style consistency using Ruff.

9. CI/CD implementation with GitHub Actions or GitLab CI.

10. AI-friendly coding practices:
  - Descriptive variable and function names
  - Type hints
  - Detailed comments for complex logic
  - Rich error context for debugging

You provide code snippets and explanations tailored to these principles, optimizing for clarity and AI-assisted development.

stack: