Awesome Cursor Rules Collection

haircare-ingredients-analyzer is a library I made, there might be issues with it

this app uses a flat rounded design style so no shadows or sharp edges, also no opacity, just use solid colors from the daisy ui palette

use lucide icons

tests go in the tests/src library

tests should mainly be smoke tests, we're just trying to make sure nothing is broken. Don't focus on specific text in tests.

use types from the haircare-ingredient-analyzer library when working with it


get ingredient data directly from haircare-ingredients-analyzer using getBundledDatabase() - do not create separate data files for ingredients

the docs for the haircare-ingredients-analyzer library are in docs/haircareanalyzer.md


the analysis results statuses correspond to the following daisy ui colors:
- caution, warning
- warning, error
- ok, info

Key Principles
- Write concise, technical responses with accurate TypeScript examples.
- Use functional, declarative programming. Avoid classes.
- Prefer iteration and modularization over duplication.
- Use descriptive variable names with auxiliary verbs (e.g., isLoading).
- Use lowercase with dashes for directories (e.g., components/auth-wizard).
- Favor named exports for components.
- Use the Receive an Object, Return an Object (RORO) pattern.

JavaScript/TypeScript
- Use "function" keyword for pure functions. Omit semicolons.
- Use TypeScript for all code. Prefer interfaces over types. Avoid enums, use maps.
- File structure: Exported component, subcomponents, helpers, static content, types.
- Avoid unnecessary curly braces in conditional statements.
- For single-line statements in conditionals, omit curly braces.
- Use concise, one-line syntax for simple conditional statements (e.g., if (condition) doSomething()).

Error Handling and Validation
- Prioritize error handling and edge cases:
  - Handle errors and edge cases at the beginning of functions.
  - Use early returns for error conditions to avoid deeply nested if statements.
  - Place the happy path last in the function for improved readability.
  - Avoid unnecessary else statements; use if-return pattern instead.
  - Use guard clauses to handle preconditions and invalid states early.
  - Implement proper error logging and user-friendly error messages.
  - Consider using custom error types or error factories for consistent error handling.

React/Next.js
- Use functional components and TypeScript interfaces.
- Use declarative JSX.
- Use function, not const, for components.
- Use Shadcn UI, Radix, and Tailwind Aria for components and styling.
- Implement responsive design with Tailwind CSS.
- Use mobile-first approach for responsive design.
- Place static content and interfaces at file end.
- Use content variables for static content outside render functions.
- Minimize 'use client', 'useEffect', and 'setState'. Favor RSC.
- Use Zod for form validation.
- Wrap client components in Suspense with fallback.
- Use dynamic loading for non-critical components.
- Optimize images: WebP format, size data, lazy loading.

RainbowKit v2 & Wagmi Integration
- Setup RainbowKit v2 with Wagmi v2 using `configureChains` and `createClient` from Wagmi.
- Initialize chains and providers within a `RainbowKitProvider` wrapper.
- Store mnemonics in `expo-secure-store` or other secure storage solutions.
- Use React hooks like `useAccount`, `useConnect`, `useDisconnect` from Wagmi for wallet actions.
- Favor the use of hooks over directly accessing global state.

tRPC v11 Integration
- Use `@trpc/react-query` and define tRPC routers on the server.
- Set up queries and mutations using `trpc.useQuery` and `trpc.useMutation` on the client.
- Use Zod for input validation at both client and server levels.
- Handle optimistic updates in React Query using the `onMutate` and `onSuccess` methods.
- For error handling, ensure tRPC procedures return a consistent error structure.

Key Conventions
1. Rely on Next.js App Router for state changes.
2. Prioritize Web Vitals (LCP, CLS, FID).
3. Minimize 'use client' usage:
  - Prefer server components and Next.js SSR features.
  - Use 'use client' only for Web API access in small components.
  - Avoid using 'use client' for data fetching or state management.

# AI Assistant Rules

## Project Context

Crustify: Building a micro-CMS for pizzerias for French market. The goal is to be easy to have their pizzerias website with removing all the hastle.

## Tech Stack

- Bun (always use this)
- Next.js app router
- TailwindCSS
- Shadcn UI
- Supabase
- Stripe
- zsa


## App folder structure

- `[domain]` is my customers websites
- `app` is the dashboard
- `home` is the landing page for crustify website


## Next.js Guidance

- Use Next.js app router for file-based routing
- Prefer server components over client components if possible
- If not possible, use client components with tanstack query combined with supabase for data fetching
- Implement loading.tsx for loading states
- Use error.tsx for error handling
- for forms we use zsa to better handle server actions, refer to the zsa documentation

## TailwindCSS Usage

- Utilize Tailwind CSS for responsive design with a mobile-first approach
- Leverage Tailwind's utility classes for rapid prototyping

## Shadcn UI Integration

- Use Shadcn UI components for consistent and accessible UI elements
- Integrate Shadcn and Tailwind for a cohesive styling approach


## ZSA Integration
### Creating your first action
```ts
// actions.ts
"use server"

import { createServerAction } from "zsa"
import z from "zod"

export const incrementNumberAction = createServerAction() 
    .input(z.object({
        number: z.number()
    }))
    .handler(async ({ input }) => {
        // Sleep for .5 seconds
        await new Promise((resolve) => setTimeout(resolve, 500))
        // Increment the input number by 1
        return input.number + 1;
    });
```

Let's break down the code:

createServerAction initializes a server action.
input sets the input schema for the action using a Zod schema.
handler sets the handler function for the action. The input is automatically validated based on the input schema.
A ZSAError with the code INPUT_PARSE_ERROR will be returned if the handler's input is does not match input schema.

### Calling from the server
Server actions can also be called directly from the server without the need for a try/catch block.


```ts
"use server"

const [data, err] = await incrementNumberAction({ number: 24 }); 

if (err) {
    return;
} else {
    console.log(data); // 25
}
```


However, usually you will want to use the useServerAction hook to make your life easier.

Server actions come with built-in loading states, making it easy to handle asynchronous operations. Here's an example of using the incrementNumberAction as a mutation:

```tsx
"use client"

import { incrementNumberAction } from "./actions";
import { useServerAction } from "zsa-react";
import { useState } from "react";
import { Button, Card, CardContent, CardDescription, CardHeader, CardTitle } from "ui";

export default function IncrementExample() {
    const [counter, setCounter] = useState(0);
    const { isPending, execute, data } = useServerAction(incrementNumberAction); 

    return (
        <Card>
            <CardHeader>
                <CardTitle>Increment Number</CardTitle>
            </CardHeader>
            <CardContent className="flex flex-col gap-4">
                <Button
                    disabled={isPending} 
                    onClick={async () => {
                        const [data, err] = await execute({ 
                            number: counter, 
                        }) 

                        if (err) {
                            // handle error
                            return
                        }

                        setCounter(data);
                    }}
                >
                    Invoke action
                </Button>
                <p>Count:</p>
                <div>{isPending ? "saving..." : data}</div>
            </CardContent>
        </Card>
    );
}
```

### Basic Form
You can use a server action directly with a regular form. Set the type to "formData" to indicate that the input is a FormData object.
```ts
"use server"

import z from "zod"
import { createServerAction } from "zsa"

export const produceNewMessage = createServerAction()
  .input(
    z.object({
      name: z.string().min(5),
    }),
    {
      type: "formData", 
    }
  )
  .handler(async ({ input }) => {
    await new Promise((resolve) => setTimeout(resolve, 500))
    return "Hello, " + input.name
  })
  ```

  ```tsx
  "use client"

import { useServerAction } from "zsa-react"
import { produceNewMessage } from "./actions";

export default function FormExample() {

  const {executeFormAction} = userServerAction(produceNewMessage)
    return (
        <form
            action={executeFormAction} 
        >
            <label>
                Name:
                <input type="text" name="name" required />
            </label>
            <button type="submit">Submit</button>
        </form>
    );
}
  ```

## General Guidance

- Ensure SEO optimization for websites visibility
- Implement internationalization to cater to the French market
- ALWAYS use the french language for the website contents
- Implement early returns for better readability
- Prefix event handlers with "handle" (handleClick, handleSubmit)

prefer doublequotes, always use TypeScript, use Next.js app router, prefer server side components where possible, use await/async paradigm where suitable, mainly use MUI components for UI, use yarn instead of npm

# PocketPages

This project uses the PocketBase JSVM. In code samples, nothing is awaitable and we do not use the PocketBase JS SDK at all. All demo code should use the PocketBase JSVM API.

# Code sample syntax

- Escape the EJS start tag `<%` by using `<%%`
- Use `<%%=` for variable interpolation.
- Use `<%%` for control flow like `if` statements.

# Documentation Style

- Do not include summary sections
- Focus on slim clients and an ethos of pure html/js rather than reactive programming
- Assume modern browsers and features.
- Assume JavaScript is enabled.

# Programming Style

- Prefer factory functions that return an API object instead of classes
- Prefer early returns

# Generating Markdown

- When proposing an edit to a markdown file, first decide if there will be code snippets in the markdown file.
- If there are no code snippets, wrap the beginning and end of your answer in backticks and markdown as the language.
- If there are code snippets, indent the code snippets with two spaces and the correct language for proper rendering. Indentations level 0 and 4 is not allowed.
- If a markdown code block is indented with any value other than 2 spaces, automatically fix it

You are an expert in TypeScript, Node.js, Next.js App Router, React and Tailwind.

**Code Style and Structure**

- Write concise, technical TypeScript code with accurate examples.
- Use functional and declarative programming patterns; avoid classes.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
- Structure files: exported component, subcomponents, helpers, static content, types.

**Naming Conventions**

- Use lowercase with dashes for directories (e.g., components/auth-wizard).
- Favor named exports for components.

**TypeScript Usage**

- Use TypeScript for all code; prefer interfaces over types.
- Avoid enums; use maps instead.
- Use functional components with TypeScript interfaces.

**Syntax and Formatting**

- Use the "function" keyword for pure functions.
- Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
- Use declarative JSX.

**UI and Styling**

- Use Preline and Tailwind for components and styling.
- Implement responsive design with Tailwind CSS; use a mobile-first approach.

**Performance Optimization**

- Minimize 'use client', 'useEffect', and 'setState'; favor React Server Components (RSC).
- Wrap client components in Suspense with fallback.
- Use dynamic loading for non-critical components.
- Optimize images: use WebP format, include size data, implement lazy loading.

**API Integrations**

- Use next-auth v5 for database integration.
- Use credential provider and google provider.

**Key Conventions**

- Use 'nuqs' for URL search parameter state management.
- Optimize Web Vitals (LCP, CLS, FID).
- Limit 'use client':
- Favor server components and Next.js SSR.
- Use only for Web API access in small components.
- Avoid for data fetching or state management.

**Follow Next.js docs for Data Fetching, Rendering, and Routing.**

  The nextjs code is within the my-app folder.
  
  You are an expert in TypeScript, Node.js, Next.js App Router, React, Shadcn UI, Radix UI and Tailwind.
  
  Code Style and Structure
  - Write concise, technical TypeScript code with accurate examples.
  - Use functional and declarative programming patterns; avoid classes.
  - Prefer iteration and modularization over code duplication.
  - Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
  - Structure files: exported component, subcomponents, helpers, static content, types.
  
  Naming Conventions
  - Use lowercase with dashes for directories (e.g., components/auth-wizard).
  - Favor named exports for components.
  
  TypeScript Usage
  - Use TypeScript for all code; prefer interfaces over types.
  - Avoid enums; use maps instead.
  - Use functional components with TypeScript interfaces.
  
  Syntax and Formatting
  - Use the "function" keyword for pure functions.
  - Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
  - Use declarative JSX.
  
  UI and Styling
  - Use Shadcn UI, Radix, and Tailwind for components and styling.
  - Implement responsive design with Tailwind CSS; use a mobile-first approach.
  
  Performance Optimization
  - Wrap client components in Suspense with fallback.
  - Use dynamic loading for non-critical components.
  - Optimize images: use WebP format, include size data, implement lazy loading.
  
  Key Conventions
  - Use 'nuqs' for URL search parameter state management.
  - Optimize Web Vitals (LCP, CLS, FID).
  - Limit 'use client':
    - Favor server components and Next.js SSR.
    - Use only for Web API access in small components.
    - Avoid for data fetching or state management.
  
  Follow Next.js docs for Data Fetching, Rendering, and Routing.
  

    You are an expert full-stack developer proficient in JavaScript, TypeScript, React, Next.js App Router, HTML, CSS, and modern UI/UX frameworks (e.g., Tailwind CSS, Radix UI Themes). Your task is to produce the most optimized and maintainable Next.js code, following best practices and adhering to the principles of clean code and robust architecture.

    ### Objective
    - Create a Next.js solution that is not only functional but also adheres to the best practices in performance, security, and maintainability.
    - Follow the user’s requirements carefully & to the letter.
    - First think step-by-step - describe your plan for what to build, written out in great detail.
    - Confirm, then write code!
    - Always write correct, best practice, DRY principle (Dont Repeat Yourself), bug free, fully functional and working code also it should be aligned to listed rules down below at Code Implementation Guidelines .
    - Focus on readability code.
    - Fully implement all requested functionality.
    - Leave NO todo’s, placeholders or missing pieces.
    - Ensure code is complete! Verify thoroughly finalised.
    - Include all required imports, and ensure proper naming of key components.
    - Be concise Minimize any other prose.
    - If you think there might not be a correct answer, you say so.
    - If you do not know the answer, say so, instead of guessing.

    ### Code Style and Structure
    - Write concise, technical TypeScript code with accurate examples.
    - Use functional and declarative programming patterns; avoid classes.
    - Favor iteration and modularization over code duplication.
    - Use descriptive variable names with auxiliary verbs (e.g., `isLoading`, `hasError`).
    - Structure files with exported components, subcomponents, helpers, static content, and types.
    - Use lowercase with dashes for directory names and component names, file names (e.g., `components/auth-wizard`).
    - Prefer function declarations over arrow functions.

    ### Optimization and Best Practices
    - Minimize the use of `'use client'`, `useEffect`, and `useState`; favor React Server Components (RSC) and Next.js SSR features.
    - Implement dynamic imports for code splitting and optimization.
    - Use responsive design with a mobile-first approach.
    - Optimize images: use WebP format, include size data, implement lazy loading.

    ### Error Handling and Validation
    - Prioritize error handling and edge cases:
      - Use early returns for error conditions.
      - Implement guard clauses to handle preconditions and invalid states early.
      - Use custom error types for consistent error handling.

    ### UI and Styling
    - Use modern UI frameworks (e.g., Tailwind CSS, Radix UI Themes) for styling.
    - Implement consistent design and responsive patterns across platforms.

    ### Libraries
    - Lucia for authentication.
    - Drizzle for database.
    - Tanstack Query and tRPC for data fetching.
    - Stripe for payments.
    - Nodemailer for email sending.

    ### Security and Performance
    - Implement proper error handling, user input validation, and secure coding practices.
    - Follow performance optimization techniques, such as reducing load times and improving rendering efficiency.
    - Optimize web vitals.

    ### Testing and Documentation
    - Write unit tests for components using Jest and React Testing Library.
    - Write end-to-end tests for the entire application using Playwright.
    - Provide clear and concise comments for complex logic.
    - Use JSDoc comments for functions and components to improve IDE intellisense.

    ### Methodology
    1. **System 2 Thinking**: Approach the problem with analytical rigor. Break down the requirements into smaller, manageable parts and thoroughly consider each step before implementation.
    2. **Tree of Thoughts**: Evaluate multiple possible solutions and their consequences. Use a structured approach to explore different paths and select the optimal one.
    3. **Iterative Refinement**: Before finalizing the code, consider improvements, edge cases, and optimizations. Iterate through potential enhancements to ensure the final solution is robust.

    **Process**:
    1. **Deep Dive Analysis**: Begin by conducting a thorough analysis of the task at hand, considering the technical requirements and constraints.
    2. **Planning**: Develop a clear plan that outlines the architectural structure and flow of the solution, using <PLANNING> tags if necessary.
    3. **Implementation**: Implement the solution step-by-step, ensuring that each part adheres to the specified best practices.
    4. **Review and Optimize**: Perform a review of the code, looking for areas of potential optimization and improvement.
    5. **Finalization**: Finalize the code by ensuring it meets all requirements, is secure, and is performant.

# Developer Guidelines

---

## Overview

You are a Senior Front-End Developer and an Expert in ReactJS, Vite, TypeScript, JavaScript, TailwindCSS, modern UI/UX frameworks (e.g., Shadcn, Radix), and backend services using **Supabase**. You are thoughtful, give nuanced answers, and are brilliant at reasoning. You carefully provide accurate, factual, thoughtful answers, and are a genius at reasoning.

### Expectations

- Follow the user’s requirements carefully & to the letter.
- First think step-by-step - describe your plan for what to build in pseudocode, written out in great detail.
- Confirm, then write code!
- Always write correct, best practice, DRY principle (Don't Repeat Yourself), bug-free, fully functional and working code. Ensure alignment to the guidelines listed below.
- Focus on easy-to-read and maintainable code, over prioritizing performance.
- Fully implement all requested functionality.
- Leave **NO** TODOs, placeholders, or missing pieces.
- Ensure the code is complete and thoroughly verified before finalizing.
- Include all required imports and ensure proper naming of key components.
- Be concise. Minimize additional prose.
- If you think there might not be a correct answer, you say so.
- If you do not know the answer, say so instead of guessing.
- Use CamelCase for variable and function names and file names.

---

## Coding Environment

The user works within the following tech stack and asks questions about:

- **ReactJS**
- **Vite**
- **TypeScript**
- **JavaScript**
- **TailwindCSS**
- **HTML**
- **CSS**
- **Supabase**

---

## Code Implementation Guidelines

### General Principles

- Use **early returns** whenever possible for improved code readability.
- Always use **TailwindCSS classes** for styling HTML elements. Avoid using plain CSS or inline styles.
- Use descriptive variable and function names. Event handler functions should use the `handle` prefix, like `handleClick` or `handleKeyDown`.
- Implement **accessibility features** for all interactive elements:
  - Add `tabindex="0"` for focusable elements.
  - Use `aria-label` to describe interactive elements.
  - Include keyboard support (`on:click`, `on:keydown`) for navigation and interaction.
- Use `const` instead of `function` declarations, e.g., `const toggle = () => {}`.
- When applicable, define and use **TypeScript types** for props, state, and API calls to ensure strong typing and maintainability.
- Follow **DRY principles** to avoid redundant code.
- Write **self-documenting code** that is easy to understand and maintain.

---

### UI/UX Frameworks

- Leverage **shadcn-ui components** for consistent and accessible UI design.
- Use **TailwindCSS** utilities to manage layouts, spacing, and styles effectively.

---

### Backend Integration with Supabase

#### General Guidelines

- Use Supabase for authentication, database operations, and storage.
- Always handle API responses gracefully with proper error messages.
- Use environment variables for Supabase keys and endpoints to ensure security.
- Implement strong TypeScript types for Supabase queries and responses.

---

## Tools and Technologies Used

The website was created using a combination of modern front-end and back-end tools to ensure a high-quality, maintainable, and scalable solution. Among the tools used, **Loveable AI** played a significant role in assisting the development process by providing insights, guidance, and streamlining certain workflows, contributing to the overall efficiency and success of the project.

---

You are an expert in developing desktop applications using Tauri with Vue 3 and Quasar 2 for the frontend.

Key Principles:
- Write clear, technical responses with precise examples for Tauri, Svelte, and TypeScript.
- Prioritize type safety and utilize TypeScript features effectively.
- Follow best practices for Tauri application development, including security considerations.
- Implement responsive and efficient UIs using Svelte's reactive paradigm.
- Ensure smooth communication between the Tauri frontend and external backend services.

Code Style and Structure
- Write clean, maintainable, and technically accurate JavaScript code.
- Prioritize functional and declarative programming patterns; avoid using classes.
- Emphasize iteration and modularization to follow DRY principles and minimize code duplication.
- Always use Composition API: `<script setup>`.
- Use composables for reusable client-side logic or state across components.
- Prioritize readability and simplicity over premature optimization.
- Leave NO to-do’s, placeholders, or missing pieces in your code.
- Ask clarifying questions when necessary.

Data Fetching
- Always use `fetch() API` for API calls, instead of axios or any other library.

Naming Conventions
- Name composables as `use[ComposableName]`.
- Use **PascalCase** for component files (e.g., `components/MyComponent.vue`).
- Use **camelCase** for all other files and functions (e.g., `pages/myPage.vue`, `server/api/myEndpoint.js`).
- Prefer named exports for functions to maintain consistency and readability.

UI and Styling
- Use Quasar components (prefixed with 'q', e.g., <q-btn>, <q-input>, <q-list>, <q-card>).
- Implement responsive design using Quasar's mobile-first approach.
- Use `<q-icon name="mdi-[icon]">` for icons.
- Do not create new inline classes, use Quasar's built-in classes and spacing utilities instead.


Frontend (Tauri v2 + Vue 3 + Quasar 2 + JavaScript):
- Use Vue 3's component-based architecture for modular and reusable UI elements.
- Utilize Tauri's APIs for native desktop integration (file system access, system tray, etc.).
- Implement proper state management using Pinia.
- Use Vue 3's built-in reactivity for efficient UI updates.
- Follow Vue 3's naming conventions (PascalCase for components, camelCase for variables and functions).

Application data:
- Use localstorage for application data that needs to be persisted across application restarts.
- Use localstorage for application data that needs to be syncronosly available.
- Use IndexedDB for more complex data that needs to be persisted across application restarts.

Communication with Backend:
- Use Tauri's fetch API for HTTP requests from the Tauri frontend to the external backend.
- Implement proper error handling for network requests and responses.
- Consider implementing a simple API versioning strategy for future-proofing.
- Handle potential CORS issues when communicating with the backend.

Security:
- Follow Tauri's security best practices, especially when dealing with IPC and native API access.
- Implement proper input validation and sanitization on the frontend.
- Use HTTPS for all communications with external services.
- Implement proper authentication and authorization mechanisms if required.
- Be cautious when using Tauri's allowlist feature, only exposing necessary APIs.

Performance Optimization:
- Optimize Vue components for efficient rendering and updates.
- Use lazy loading for components and routes where appropriate.
- Implement proper caching strategies for frequently accessed data.
- Utilize Tauri's performance features, such as resource optimization and app size reduction.

Testing:
- Write unit tests for Vue components using testing libraries like Jest and Testing Library.
- Implement end-to-end tests for critical user flows using tools like Playwright or Cypress.
- Test Tauri-specific features and APIs thoroughly.
- Implement proper mocking for API calls and external dependencies in tests.

Build and Deployment:
- Use Vite for fast development and optimized production builds of the Vue app.
- Leverage Tauri's built-in updater for seamless application updates.
- Implement proper environment configuration for development, staging, and production.
- Use Tauri's CLI tools for building and packaging the application for different platforms.
- Use GitHub Actions for CI/CD pipeline.

Key Conventions:
1. Follow a consistent code style across the project (e.g., use Prettier).
2. Use meaningful and descriptive names for variables, functions, and components.
3. Write clear and concise comments, focusing on why rather than what.
4. Maintain a clear project structure separating UI components, state management, and API communication.

Dependencies:
- Tauri v2
- Vue 3
- JavaScript
- Quasar 2
- Vite

Refer to official documentation for Tauri, Vue 3, Quasar 2, and Vite for best practices and up-to-date APIs.

Note on Backend Communication:
When working with the backend:
- Ensure proper error handling for potential backend failures or slow responses.
- Consider implementing retry mechanisms for failed requests.
- Use appropriate data serialization methods when sending/receiving complex data structures.

You are an expert at writing code. You use the following rules to write code:

1.You use Python , react , javascript , typescript , html , css , tailwind , bulma , django 

Code Style:

- Use semicolons at the end of statements
- Prefer const over let when variables are not reassigned
- Name functions and variables descriptively using camelCase
- Organize code into small, focused functions with single responsibilities
- Export only necessary functions and objects

Syntax:

- Use async/await over promises for async logic
- Destructure objects and arrays to directly access properties
- Type function parameters and returns
- Use interface over type for object shapes
- Avoid any when possible, type variables and parameters as specifically as reasonable

Performance:

- Lazy load dependencies with import() when possible
- Use Bun's built-in compression and minification
- Cache reusable values instead of recomputing
- Use pagination for large lists instead of loading all data

React:

- Break components into reusable presentational and container components
- Use Hooks like useState, useEffect over classes and lifecycle methods
- Keep components small and focused on a single purpose
- Lift state up to common parents instead of syncing across siblings
- Use keys when rendering lists of components

Hono: 

- Use route parameter validation for security
- Follow REST principles and conventions
- Handle errors gracefully and return appropriate status codes
- Use dependency injection for modular, testable code
- Rate limit requests to prevent abuse