prisma

Project Tech Stack:

ALWAYS USE THE FOLLOWING IN CONJUNCTION WITH EACHOTHER TO HAVE A SAFE CODEBASE WHERE WE CAN MOVE FAST AND BREAK NOTHING

• Next.js

• Typescript + ESlint

• Zod + Prisma + tRPC + React Query

• Prisma (supabase) + Redis

• ShadCN + TailwindCSS v4

• Vitest Unit Tests

• General Principles:

  • Never expose the raw Prisma client directly in APIs. Instead, create abstraction layers (e.g., repositories or services) to handle data access logic. This protects you from accidentally exposing sensitive database details and allows you to easily change your data access implementation in the future.
  • Always use input validation before performing any database operations. Use a validation library like Zod or Yup to ensure that user input conforms to your expected schema and data types. This helps prevent injection attacks and data corruption.
  • Implement row-level security (RLS) where applicable. If your application handles sensitive data, use Prisma policies or database-level RLS to restrict data access based on user roles or permissions. Carefully design your policies to prevent unauthorized data access.
  • Sanitize and validate all user inputs to prevent injection attacks, such as SQL injection. Use Prisma's built-in features to escape user input and prevent it from being interpreted as code.

• Code Organization and Structure:

  • Directory Structure:
    • prisma/: Contains the schema.prisma file and any seed scripts or migrations.
    • src/: Contains the main application code.
    • src/lib/prisma.ts: A single module that exports an instance of the Prisma client. This promotes reuse and simplifies dependency injection.
    • src/models/: Database model definitions as classes, abstracting Prisma calls.
    • src/repositories/: Contains data access logic, abstracting Prisma queries.
    • src/services/: Contains business logic, orchestrating data access through repositories.
  • File Naming Conventions:
    • Use descriptive names for files and directories that reflect their purpose.
    • Use consistent naming conventions (e.g., camelCase for variables, PascalCase for components).
    • Consistent Case: Maintain a consistent casing convention (e.g., camelCase for variables, PascalCase for components). Use kebab-case for file names e.g. user-profile.tsx or user.router.ts
  • Module Organization:
    • Organize code into logical modules with clear responsibilities.
    • Use dependency injection to decouple modules and improve testability.
  • Component Architecture:
    • Design components that are reusable, testable, and maintainable.
    • Follow the single responsibility principle for each component.
  • Code Splitting Strategies:
    • Use dynamic imports to load code on demand and reduce initial bundle size.
    • Split code based on routes, features, or user roles.