𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗮 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 𝗧𝗼𝗼𝗹 𝘄𝗶𝘁𝗵 𝗣𝗿𝗶𝘀𝗺𝗮

I am building a collaborative project management tool like Trello.

I am using React, Express.js, PostgreSQL, and Socket.io. Before I write any backend routes, I must design the database schema.

The schema is the foundation. If the schema is wrong, the whole app fails. Here is my breakdown of the Prisma schema design.

𝗧𝗵𝗲 𝗠𝗼𝗱𝗲𝗹𝘀

• User: Stores names, emails, and passwords. I use cuid() for IDs. This creates long, unique strings. It is better than numbers because it does not leak your user count in the URL.

• Project: Holds the project name and description. I made the description optional using a question mark.

• ProjectMember: This is a junction table. It links Users to Projects. Since one user can join many projects, and one project has many users, you need this middle table to manage the many-to-many relationship. I added a unique constraint to prevent the same user from joining a project twice.

• Board: Tasks live inside boards. Boards live inside projects. This hierarchy makes drag-and-drop easy. Moving a task between columns is just a single field update.

• Task: This is the core model. It has two different relations to the User model:

• An assigned user (this is optional).
• A creator (this is required). I had to name these relations explicitly so Prisma knows which is which.

• Comment: Users can leave comments on tasks. I named the relation "author" instead of "user" to keep the code readable.

• Notification: A simple model to track messages for users.

𝗧𝗲𝗰𝗵𝗻𝗶𝗰𝗮𝗹 𝗟𝗲𝘀𝘀𝗼𝗻𝘀 𝗟𝗲𝗮𝗿𝗻𝘁

I ran into several errors while building this. Watch out for these:

• Relation Names: If two fields point to the same model, you must name the relations. If you do not, Prisma will throw an error.
• Nullable Fields: If a relation is optional, you must put a question mark on both the relation field and the foreign key field.
• Syntax Errors: Prisma requires double quotes for string defaults. Single quotes will fail.
• Relation Syntax: Always use the correct syntax: @relation(fields: [localField], references: [remoteField]).

The schema is now migrated. Next, I will build the Express backend and Socket.io setup for real-time updates.

Construire un outil de gestion de projet de zéro, en commençant par le schéma Prisma

Construire un outil de gestion de projet est un excellent moyen d'apprendre à concevoir une base de données et à gérer des relations complexes entre des entités. Dans cet article, nous commencerons par définir notre schéma de base de données en utilisant Prisma.

Introduction

Les outils de gestion de projet comme Trello, Asana ou Jira sont essentiels pour permettre aux équipes de collaborer efficacement. Ils permettent aux utilisateurs de créer des projets, d'assigner des tâches, de fixer des échéances et de suivre l'avancement.

Les entités de base

Pour construire une version de base d'un tel outil, nous devons identifier les entités principales :

1. User : La personne qui utilise l'application.
2. Project : Un conteneur pour les tâches.
3. Task : Un élément de travail spécifique à accomplir.
4. Comment : Un retour ou une discussion liée à une tâche.

Concevoir le schéma avec Prisma

Prisma est un ORM (Object-Relational Mapper) qui nous aide à interagir avec notre base de données via une approche avec sécurité de typage (type-safe).

1. Le modèle User

Chaque utilisateur a besoin d'un e-mail, d'un nom et d'un mot de passe.

model User {
  id        String   @id @default(uuid())
  email     String   @unique
  name      String?
  password  String
  projects  Project[]
  tasks     Task[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

2. Le modèle Project

Un projet appartient à un utilisateur (le propriétaire) et peut contenir plusieurs tâches.

model Project {
  id          String   @id @default(uuid())
  name        String
  description String?
  ownerId     String
  owner       User     @relation(fields: [ownerId], references: [id])
  tasks       Task[]
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt
}

3. Le modèle Task

Une tâche fait partie d'un projet et peut être assignée à un utilisateur.

model Task {
  id          String    @id @default(uuid())
  title       String
  description String?
  status      Status    @default(TODO)
  projectId   String
  project     Project   @relation(fields: [projectId], references: [id])
  assigneeId  String?
  assignee    User?     @relation(fields: [assigneeId], references: [id])
  comments    Comment[]
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt
}

enum Status {
  TODO
  IN_PROGRESS
  DONE
}

4. Le modèle Comment

Les commentaires permettent aux utilisateurs de discuter des tâches.

model Comment {
  id        String   @id @default(uuid())
  content   String
  taskId    String
  task      Task     @relation(fields: [taskId], references: [id])
  authorId  String
  author    User     @relation(fields: [authorId], references: [id])
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

Conclusion

Nous avons réussi à concevoir un schéma pour un outil de gestion de projet. Dans la prochaine partie, nous verrons comment configurer le backend et interagir avec ce schéma.