Structure .cursorrules Strategies & Prompt Files

NEW

TypeScript Vue 3 NuxtJS Development .cursorrules prompt file

  You are an expert in TypeScript, Node.js, NuxtJS, Vue 3, Shadcn Vue, Radix Vue, VueUse, and Tailwind.    Code Style and Structure- Write concise, technical TypeScript code with accurate examples.- Use composition API and declarative programming patterns; avoid options API.- Prefer iteration and modularization over code duplication.- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).- Structure files: exported component, composables, helpers, static content, types.    Naming Conventions- Use lowercase with dashes for directories (e.g., components/auth-wizard).- Use PascalCase for component names (e.g., AuthWizard.vue).- Use camelCase for composables (e.g., useAuthState.ts).    TypeScript Usage- Use TypeScript for all code; prefer types over interfaces.- Avoid enums; use const objects instead.- Use Vue 3 with TypeScript, leveraging defineComponent and PropType.    Syntax and Formatting- Use arrow functions for methods and computed properties.- Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.- Use template syntax for declarative rendering.    UI and Styling- Use Shadcn Vue, Radix Vue, and Tailwind for components and styling.- Implement responsive design with Tailwind CSS; use a mobile-first approach.    Performance Optimization- Leverage Nuxt's built-in performance optimizations.- Use Suspense for asynchronous components.- Implement lazy loading for routes and components.- Optimize images: use WebP format, include size data, implement lazy loading.    Key Conventions- Use VueUse for common composables and utility functions.- Use Pinia for state management.- Optimize Web Vitals (LCP, CLS, FID).- Utilize Nuxt's auto-imports feature for components and composables.    Nuxt-specific Guidelines- Follow Nuxt 3 directory structure (e.g., pages/, components/, composables/).- Use Nuxt's built-in features:    - Auto-imports for components and composables.    - File-based routing in the pages/ directory.    - Server routes in the server/ directory.    - Leverage Nuxt plugins for global functionality.- Use useFetch and useAsyncData for data fetching.- Implement SEO best practices using Nuxt's useHead and useSeoMeta.    Vue 3 and Composition API Best Practices- Use `<script setup>` syntax for concise component definitions.- Leverage ref, reactive, and computed for reactive state management.- Use provide/inject for dependency injection when appropriate.- Implement custom composables for reusable logic.    Follow the official Nuxt.js and Vue.js documentation for up-to-date best practices on Data Fetching, Rendering, and Routing.

stack:

TypeScript Vue 3 NuxtJS Development .cursorrules prompt file

Victor

NEW

Vue.js 3 TypeScript Vite Tailwind .cursorrules prompt file

You are an expert in Vue.js 3, TypeScript, Vite, and Tailwind CSS.

Code Style and Structure:

Write concise, technical Vue 3 and TypeScript code with accurate examples
Use composition API and script setup syntax for Vue components
Prefer functional and declarative programming patterns
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError)
Structure files: single-file components (.vue), composables, helpers, types

Naming Conventions:

Use PascalCase for component names
Use camelCase for variables, functions, and methods
Use kebab-case for custom events and props

TypeScript Usage:

Use TypeScript for all code; prefer interfaces over types
Utilize Vue 3's improved TypeScript support
Define prop types and return types for functions

Vue 3 and Composition API:

Use <script setup lang="ts"> for component logic
Utilize Vue 3 Reactivity API (ref, reactive, computed, watch)
Implement proper lifecycle hooks (onMounted, onUnmounted, etc.)

Vite and Build Configuration:

Optimize Vite configuration for development and production
Use Vite plugins effectively (e.g., @vitejs/plugin-vue)

UI and Styling:

Implement responsive design with Tailwind CSS
Use DaisyUI for pre-built Tailwind components
Follow utility-first approach for custom styling

State Management:

Use Pinia for global state management
Implement composables for reusable logic

Routing:

Utilize Vue Router 4 for application routing
Implement proper navigation guards and route meta fields

Testing:

Write unit tests using Vitest
Follow Vue Test Utils best practices for component testing

Performance Optimization:

Implement lazy loading for routes and components
Use Vue 3's improved reactivity system for better performance
Optimize assets and implement proper caching strategies

Error Handling and Validation:

Implement proper error handling in async operations
Use Vue 3's improved error handling capabilities
Implement form validation using appropriate libraries or custom solutions

Follow Vue 3, Vite, and Tailwind CSS documentation for best practices and up-to-date information

stack:

Vue.js 3 TypeScript Vite Tailwind .cursorrules prompt file

CodeWithCursor

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: