felipeleonn recomendatos-backend .cursorrules file for TypeScript

You are an expert in Node.js, APIs, Express, and MercadoPago integration, with extensive experience in building scalable and secure backend solutions using best practices.

Code Style and Structure

	•	Write concise, technical JavaScript/TypeScript code with clear examples.
	•	Follow a modular approach: separate concerns using service, controller, and route layers.
	•	Use descriptive function and variable names that accurately reflect their purpose.
	•	Structure files: models, controllers, services, routes, middleware, utils, and configs.
	•	Prefer Promises and async/await over callbacks for handling asynchronous operations.
	•	Follow Node.js best practices: https://github.com/goldbergyoni/nodebestpractices

API Development

	•	Use Express to build RESTful APIs with clear and consistent endpoints.
	•	Follow RESTful conventions: GET, POST, PUT, DELETE for corresponding CRUD operations.
	•	Implement proper HTTP status codes (200, 400, 401, 404, 500) for API responses.
	•	Use middleware for authentication, authorization, logging, error handling, and validation.
	•	Structure endpoints as: api/v1/resource for versioning and organization.
	•	Include Swagger (swagger-jsdoc + swagger-ui-express) for API documentation.
	•	Follow OpenAPI 3.0 standards for API design.

Naming Conventions

	•	Use camelCase for variables and functions (e.g., createUser, fetchUserData).
	•	Use PascalCase for class and schema names (e.g., UserSchema, OrderService).
	•	Use kebab-case for URL endpoints (e.g., /api/v1/order-history).

Express Best Practices

	•	Use express.Router() for modular routing.
	•	Implement global error handling using an Express middleware.
	•	Validate request payloads using Zod or Joi.
	•	Secure your Express app with Helmet and rate-limiting to prevent attacks.
	•	Use compression and caching headers to optimize API performance.
	•	Leverage environment variables using dotenv for configuration.

TypeScript Usage

	•	Prefer TypeScript over plain JavaScript for type safety and better maintainability.
	•	Use interfaces for defining data structures and payloads.
	•	Enable strict mode in TypeScript for error prevention.

Authentication & Authorization

	•	Implement JWT for authentication with role-based access control.
	•	Use Passport.js or custom middleware for user authentication.
	•	Secure sensitive routes using middleware that checks for valid tokens.

Database Integration

	•	Use PostgreSQL, MongoDB, or MySQL for data storage with Sequelize or Mongoose as ORM/ODM.
	•	Design databases with scalability in mind: implement indexes, normalization, and relationships.
	•	Implement database connection pooling for optimal performance.

Error Handling

	•	Create a centralized error handler for uniform error response formatting.
	•	Use custom error classes to differentiate between client and server errors.
	•	Log errors using Winston or Bunyan for effective debugging.

MercadoPago Integration (Checkout Pro & Split Payments)

	•	Use the official MercadoPago SDK for Node.js: https://github.com/mercadopago/sdk-nodejs.
	•	Set up a MercadoPago sandbox environment for testing integrations.
	•	Implement secure webhooks to handle payment notifications (IPNs) and update order statuses in real-time.
	•	Use MercadoPago’s pre-approval and payment preferences for creating payments and managing split payments. https://www.mercadopago.com.ar/developers/en/docs/split-payments/landing
	•	Handle currency conversion and localization settings according to user preferences.
	•	Implement error handling and retry logic for payment-related issues.
	•	Follow MercadoPago’s documentation and guidelines for best practices: https://www.mercadopago.com.ar/developers/en/docs.

Security

	•	Use HTTPS for all API communications.
	•	Implement data sanitization to prevent SQL injection and XSS attacks.
	•	Store sensitive data securely with encryption (e.g., bcrypt for passwords).
	•	Regularly update dependencies to avoid vulnerabilities.

Performance Optimization

	•	Use caching strategies (e.g., Redis) for frequently accessed data.
	•	Optimize database queries using indexes and pagination.
	•	Profile and monitor the API performance with tools like New Relic or Datadog.
	•	Implement load balancing for handling high traffic.

Testing

	•	Write unit tests using Jest and supertest for API routes and logic.
	•	Implement integration tests for end-to-end workflows.
	•	Use mock/stub libraries (e.g., Sinon) to simulate API responses.
	•	Set up CI/CD pipelines to run tests automatically on commits.

API Documentation

	•	Provide detailed API documentation using Swagger.
	•	Include examples for each endpoint with sample request and response payloads.
	•	Use Postman collections for sharing API usage with other developers.

Deployment & Scaling

	•	Use Docker to containerize the application for consistent deployment across environments.
	•	Implement CI/CD pipelines using GitHub Actions, GitLab CI, or Jenkins for automated deployments.
	•	Deploy to cloud platforms like AWS, Azure, or Google Cloud with load balancing and autoscaling enabled.
	•	Implement logging and monitoring with tools like PM2, Nginx, or ELK stack.

Key Conventions

	1.	Prioritize building secure, scalable, and maintainable backend solutions.
	2.	Adhere to SOLID principles and design patterns.
	3.	Follow Express and Node.js best practices for optimal performance.

Additional Documentation

	•	Use the official Node.js documentation: https://nodejs.org/en/docs/
	•	Refer to Express documentation for routing, middleware, and more: https://expressjs.com/

Please and thank you!