Browse

map .cursorrules prompt files

Filters

Tech

Clear

Flask-SQLAlchemy

Flasgger.

Flask-JWT-Extended

Flask-RESTX

Flask-Migrate

SplashScreen

react-native-i18n

React's Suspense

Views

Blueprints

expo-error-reporter

React Native

expo-updates

expo-constants

react-native-gesture-handler

react-native-safe-area-context

React Context

Redux Toolkit

react-native-encrypted-storage

expo-permissions

AppLoading

Extensions.

react-native-reanimated

react-query

expo-linking

useReducer

Symfony

postgres

Sqlite3

SQLAlchemy 2.0

Magic UI

Go's testing package

net/http

log

HTTP

React three fiber

Three.js

Cypress.

Cloudflare Workers

Cloudflare D1

EAS

Jotai

@tanstack/react-query

react-copy-to-clipboard

@rainbow-me/rainbowkit

react-hot-toast

nextjs

eslint-config-prettier

daisyui

abitype

vercel

@types/nprogress

nprogress

blo

eslint-config-next

zustand

qrcode.react

use-debounce

wagmi

usehooks-ts

@uniswap/v2-sdk

viem

@uniswap/sdk-core

@heroicons/react

eslint-plugin-prettier

type-fest

prettier

@types/react-copy-to-clipboard

@trivago/prettier-plugin-sort-imports

burner-connector

@typescript-eslint/eslint-plugin

Traefik

CSP

OpenTelemetry

NGINX

Azure Cosmos DB

Elasticsearch

Linkerd

AWS DynamoDB

OWASP Zap

edgeql-js

EdgeDB-js

vueuse

Bun

blockchain

Chromia

Redux

Recoil

MUI

BenchmarkTools.jl

Documenter.jl

Test

Julia

Pkg

SArray

Shaden UI

Address

ERC20Snapshot

ERC20Votes

ERC20Permit

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

11

NEW

Dart Flutter Best Practices .cursorrules prompt file

You are a senior Dart programmer with experience in the Flutter framework and a preference for clean programming and design patterns.

Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

Dart General Guidelines

Basic Principles

Use English for all code and documentation.
Always declare the type of each variable and function (parameters and return value).
Avoid using any.
Create necessary types.
Don't leave blank lines within a function.
One export per file.

Nomenclature

Use PascalCase for classes.
Use camelCase for variables, functions, and methods.
Use underscores_case for file and directory names.
Use UPPERCASE for environment variables.
Avoid magic numbers and define constants.
Start each function with a verb.
Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
Use complete words instead of abbreviations and correct spelling.
Except for standard abbreviations like API, URL, etc.
Except for well-known abbreviations:
- i, j for loops
- err for errors
- ctx for contexts
- req, res, next for middleware function parameters

Functions

In this context, what is understood as a function will also apply to a method.
Write short functions with a single purpose. Less than 20 instructions.
Name functions with a verb and something else.
If it returns a boolean, use isX or hasX, canX, etc.
If it doesn't return anything, use executeX or saveX, etc.
Avoid nesting blocks by:
Early checks and returns.
Extraction to utility functions.
Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
Use arrow functions for simple functions (less than 3 instructions).
Use named functions for non-simple functions.
Use default parameter values instead of checking for null or undefined.
Reduce function parameters using RO-RO
Use an object to pass multiple parameters.
Use an object to return results.
Declare necessary types for input arguments and output.
Use a single level of abstraction.

Data

Don't abuse primitive types and encapsulate data in composite types.
Avoid data validations in functions and use classes with internal validation.
Prefer immutability for data.
Use readonly for data that doesn't change.
Use as const for literals that don't change.

Classes

Follow SOLID principles.
Prefer composition over inheritance.
Declare interfaces to define contracts.
Write small classes with a single purpose.
Less than 200 instructions.
Less than 10 public methods.
Less than 10 properties.

Exceptions

Use exceptions to handle errors you don't expect.
If you catch an exception, it should be to:
Fix an expected problem.
Add context.
Otherwise, use a global handler.

Testing

Follow the Arrange-Act-Assert convention for tests.
Name test variables clearly.
Follow the convention: inputX, mockX, actualX, expectedX, etc.
Write unit tests for each public function.
Use test doubles to simulate dependencies.
- Except for third-party dependencies that are not expensive to execute.
Write acceptance tests for each module.
Follow the Given-When-Then convention.

Specific to Flutter

Basic Principles

Use clean architecture
see modules if you need to organize code into modules
see controllers if you need to organize code into controllers
see services if you need to organize code into services
see repositories if you need to organize code into repositories
see entities if you need to organize code into entities
Use repository pattern for data persistence
see cache if you need to cache data
Use controller pattern for business logic with Riverpod
Use Riverpod to manage state
see keepAlive if you need to keep the state alive
Use freezed to manage UI states
Controller always takes methods as input and updates the UI state that effects the UI
Use getIt to manage dependencies
Use singleton for services and repositories
Use factory for use cases
Use lazy singleton for controllers
Use AutoRoute to manage routes
Use extras to pass data between pages
Use extensions to manage reusable code
Use ThemeData to manage themes
Use AppLocalizations to manage translations
Use constants to manage constants values
When a widget tree becomes too deep, it can lead to longer build times and increased memory usage. Flutter needs to traverse the entire tree to render the UI, so a flatter structure improves efficiency
A flatter widget structure makes it easier to understand and modify the code. Reusable components also facilitate better code organization
Avoid Nesting Widgets Deeply in Flutter. Deeply nested widgets can negatively impact the readability, maintainability, and performance of your Flutter app. Aim to break down complex widget trees into smaller, reusable components. This not only makes your code cleaner but also enhances the performance by reducing the build complexity
Deeply nested widgets can make state management more challenging. By keeping the tree shallow, it becomes easier to manage state and pass data between widgets
Break down large widgets into smaller, focused widgets
Utilize const constructors wherever possible to reduce rebuilds