C. Frontend Architecture

1. Technology Stack

• Framework: React.js (or Angular/Vue.js based on preference and team expertise)
• Language: TypeScript (for type safety and improved developer experience)
• Styling: Tailwind CSS or Styled Components (for efficient and maintainable styling)
• Build Tool: Vite (for fast development and optimized builds)

2. Component Structure

• Atomic Design Principles: Organize components into Atoms, Molecules, Organisms, Templates, and Pages.
• Feature-Based Modules: Group related components, services, and routes within dedicated feature folders (e.g., src/features/auth, src/features/projects).
• Shared Components: Reusable UI elements placed in a src/components directory.

3. State Management

• Global State: React Context API + useReducer for simpler global states, or Redux Toolkit / Zustand / Recoil for more complex, application-wide state management.
• Local Component State: useState and useRef hooks.
• Server State (Data Fetching): React Query (TanStack Query) or SWR for efficient data fetching, caching, and synchronization.

4. Routing

• React Router DOM: For declarative client-side routing, nested routes, and route protection.

5. Build & Deployment

• Build Process: Vite will compile TypeScript, bundle assets, and optimize for production.
• Deployment: Static site hosting (e.g., Vercel, Netlify, AWS S3 + CloudFront) for optimal performance and scalability.

D. Backend API Architecture

1. Technology Stack

• Language: Node.js
• Framework: Express.js (for RESTful API development)
• Database ORM/ODM: Prisma (for PostgreSQL) or Mongoose (for MongoDB)
• Validation: Joi or Zod
• Logging: Winston or Pino
• Testing: Jest, Supertest

2. API Endpoints & Design Principles (RESTful)

• Resource-Oriented: API endpoints will be designed around resources (e.g., /users, /projects, /tasks).
• Standard HTTP Methods: Utilize GET, POST, PUT, DELETE, PATCH for respective CRUD operations.
• Stateless: Each request from client to server must contain all information necessary to understand the request.
• Versioned: APIs will be versioned (e.g., /api/v1/users) to allow for future changes without breaking existing clients.
• Pagination, Filtering, Sorting: Implement query parameters for efficient data retrieval.

3. Business Logic Layer

• Service Layer: Separate business logic from controllers. Controllers handle request/response, while services contain the core application logic (e.g., userService.createUser(), projectService.getProjectById()).

4. Data Access Layer

• Repository Pattern: Abstract database interactions through repositories or use the ORM directly within services for simpler applications.
• Error Handling: Centralized error handling middleware to catch and format API errors consistently.

5. Error Handling & Logging

• Centralized Error Middleware: Catch errors globally and send standardized error responses (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found, 500 Internal Server Error).
• Structured Logging: Implement a logging library (Winston/Pino) to log requests, errors, and critical application events, with levels (info, warn, error).

E. Database Architecture

1. Database Type & Rationale

• Relational Database: PostgreSQL
• Rationale: Chosen for its robustness, ACID compliance, data integrity, extensibility, and strong community support, suitable for applications requiring complex queries and structured data.

2. Schema Design Principles

• Normalization: Design tables to reduce data redundancy and improve data integrity (up to 3NF initially).
• Indexing: Strategically add indexes to frequently queried columns to improve read performance.
• Foreign Keys: Enforce referential integrity between related tables.
• Soft Deletes: Consider using is_deleted flags instead of hard deletes for certain data.

3. Example Entities & Relationships

• User: id (PK), username, email, password_hash, created_at, updated_at, role_id (FK)
• Role: id (PK), name (e.g., 'admin', 'user')
• Project: id (PK), name, description, created_by (FK to User), created_at, updated_at
• Task: id (PK), title, description, status, due_date, project_id (FK to Project), assigned_to (FK to User), created_at, updated_at

F. Authentication & Authorization

1. Strategy

• Authentication: JWT (JSON Web Tokens)

* Flow: User sends credentials to backend, backend verifies, issues a signed JWT. Client stores JWT (e.g., in localStorage or HttpOnly cookie for CSRF protection) and sends it with subsequent requests in the Authorization header.

• Authorization: Role-Based Access Control (RBAC)

* Users are assigned roles (e.g., 'admin', 'editor', 'viewer').

* Backend middleware checks the user's role from the JWT payload against required roles for specific routes/actions.

2. Flow for User Registration/Login

1. Registration: Frontend sends POST /api/v1/auth/register with username, email, password. Backend hashes password, creates user, returns success.
2. Login: Frontend sends POST /api/v1/auth/login with email, password. Backend verifies credentials, generates JWT, returns JWT and user info.
3. Logout: Frontend discards JWT. Backend can optionally implement a JWT blacklist for immediate invalidation.

G. Deployment & Infrastructure

1. Cloud Provider

• AWS (Amazon Web Services): Offers a comprehensive suite of services, high scalability, and global reach. (Alternatives: Google Cloud Platform, Microsoft Azure).

2. Containerization

• Docker: Containerize both frontend and backend applications for consistent environments across development, testing, and production.

3. Orchestration

• Backend: AWS ECS (Elastic Container Service) or AWS EKS (Elastic Kubernetes Service)

This deliverable provides the comprehensive, detailed, and professional code blueprint for your full-stack application. This output is designed to be immediately actionable, offering a solid foundation for development.

The chosen technology stack for this blueprint is:

• Frontend: React with TypeScript
• Backend: Node.js with Express and TypeScript
• Database: PostgreSQL with TypeORM
• Authentication: JSON Web Tokens (JWT)
• Deployment: Docker, GitHub Actions
• Testing: Jest (Backend/Frontend Unit/Integration), Cypress (E2E)

1. Project Structure Overview

The application will follow a monorepo structure, making it easier to manage frontend and backend code, share configurations, and streamline development and deployment.

.
├── backend/
│   ├── src/
│   │   ├── config/             # Database, environment variables
│   │   ├── controllers/        # Request handlers
│   │   ├── entities/           # TypeORM entities (database models)
│   │   ├── migrations/         # Database schema changes
│   │   ├── middleware/         # Express middleware (auth, error handling)
│   │   ├── routes/             # API routes definitions
│   │   ├── services/           # Business logic, database interactions
│   │   ├── utils/              # Helper functions
│   │   └── app.ts              # Express app setup
│   │   └── server.ts           # Server entry point
│   ├── .env.example
│   ├── ormconfig.ts            # TypeORM configuration
│   ├── package.json
│   ├── tsconfig.json
│   └── Dockerfile
├── frontend/
│   ├── public/
│   ├── src/
│   │   ├── api/                # API service calls
│   │   ├── assets/             # Static assets
│   │   ├── components/         # Reusable UI components
│   │   ├── contexts/           # React Context API for global state
│   │   ├── hooks/              # Custom React hooks
│   │   ├── pages/              # Page-level components (routes)
│   │   ├── utils/              # Utility functions
│   │   ├── App.tsx             # Main application component
│   │   └── index.tsx           # Entry point
│   ├── .env.example
│   ├── package.json
│   ├── tsconfig.json
│   └── Dockerfile
├── .github/
│   └── workflows/
│       └── ci.yml              # GitHub Actions CI/CD workflow
├── docker-compose.yml          # Local development setup
└── README.md

2. Backend API (Node.js, Express, TypeScript, PostgreSQL with TypeORM)

2.1. Setup & Configuration

backend/package.json

{
  "name": "backend",
  "version": "1.0.0",
  "description": "Backend API for the full-stack application",
  "main": "dist/server.js",
  "scripts": {
    "start": "node dist/server.js",
    "dev": "nodemon --exec ts-node src/server.ts",
    "build": "tsc",
    "typeorm": "typeorm-ts-node-commonjs",
    "migration:create": "npm run typeorm migration:create ./src/migrations/$npm_config_name",
    "migration:run": "npm run typeorm migration:run -d ./src/config/data-source.ts",
    "migration:revert": "npm run typeorm migration:revert -d ./src/config/data-source.ts",
    "test": "jest --detectOpenHandles"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "bcryptjs": "^2.4.3",
    "cors": "^2.8.5",
    "dotenv": "^16.4.5",
    "express": "^4.19.2",
    "helmet": "^7.1.0",
    "jsonwebtoken": "^9.0.2",
    "pg": "^8.11.5",
    "reflect-metadata": "^0.2.2",
    "typeorm": "^0.3.20"
  },
  "devDependencies": {
    "@types/bcryptjs": "^2.4.6",
    "@types/cors": "^2.8.17",
    "@types/express": "^4.17.21",
    "@types/jest": "^29.5.12",
    "@types/jsonwebtoken": "^9.0.6",
    "@types/node": "^20.12.11",
    "@types/pg": "^8.11.6",
    "@types/supertest": "^6.0.2",
    "jest": "^29.7.0",
    "nodemon": "^3.1.0",
    "supertest": "^7.0.0",
    "ts-jest": "^29.1.2",
    "ts-node": "^10.9.2",
    "typescript": "^5.4.5"
  }
}

backend/tsconfig.json

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",
    "lib": ["es2017"],
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "typeRoots": ["./node_modules/@types", "./src/types"],
    "baseUrl": "./src",
    "paths": {
      "@config/*": ["config/*"],
      "@controllers/*": ["controllers/*"],
      "@entities/*": ["entities/*"],
      "@migrations/*": ["migrations/*"],
      "@middleware/*": ["middleware/*"],
      "@routes/*": ["routes/*"],
      "@services/*": ["services/*"],
      "@utils/*": ["utils/*"]
    }
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
}

backend/.env.example

PORT=5000
DATABASE_URL=postgresql://user:password@localhost:5432/mydatabase
JWT_SECRET=your_jwt_secret_key
JWT_EXPIRES_IN=1h
NODE_ENV=development

backend/src/config/data-source.ts (TypeORM Data Source)

import 'reflect-metadata';
import { DataSource } from 'typeorm';
import dotenv from 'dotenv';
import path from 'path';
import { User } from '../entities/User'; // Example entity

dotenv.config({ path: path.resolve(__dirname, '../../.env') });

export const AppDataSource = new DataSource({
  type: 'postgres',
  url: process.env.DATABASE_URL,
  synchronize: false, // Set to true only for development, use migrations in production
  logging: process.env.NODE_ENV === 'development',
  entities: [User], // Add all your entities here
  migrations: [path.join(__dirname, '../migrations/*.ts')],
  subscribers: [],
});

export const initializeDatabase = async () => {
  try {
    if (!AppDataSource.isInitialized) {
      await AppDataSource.initialize();
      console.log('Data Source has been initialized!');
    }
  } catch (err) {
    console.error('Error during Data Source initialization:', err);
    process.exit(1);
  }
};

2.2. Database Design & Entities

backend/src/entities/User.ts (TypeORM Entity)

import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
import bcrypt from 'bcryptjs';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn('uuid')
  id!: string;

  @Column({ unique: true })
  email!: string;

  @Column()
  password!: string;

  @Column({ default: 'user' })
  role!: string; // e.g., 'user', 'admin'

  @CreateDateColumn({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
  createdAt!: Date;

  @UpdateDateColumn({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' })
  updatedAt!: Date;

  // Hash password before saving
  async hashPassword() {
    this.password = await bcrypt.hash(this.password, 10);
  }

  // Compare password
  async comparePassword(candidatePassword: string): Promise<boolean> {
    return bcrypt.compare(candidatePassword, this.password);
  }
}

backend/src/migrations/1701010000000-CreateUserTable.ts (Example Migration)

import { MigrationInterface, QueryRunner, Table } from 'typeorm';

export class CreateUserTable1701010000000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'users',
        columns: [
          {
            name: 'id',
            type: 'uuid',
            isPrimary: true,
            default: 'uuid_generate_v4()',
          },
          {
            name: 'email',
            type: 'varchar',
            isUnique: true,
          },
          {
            name: 'password',
            type: 'varchar',
          },
          {
            name: 'role',
            type: 'varchar',
            default: "'user'",
          },
          {
            name: 'createdAt',
            type: 'timestamp',
            default: 'CURRENT_TIMESTAMP',
          },
          {
            name: 'updatedAt',
            type: 'timestamp',
            default: 'CURRENT_TIMESTAMP',
            onUpdate: 'CURRENT_TIMESTAMP',
          },
        ],
      }),
      true
    );
    // Enable uuid-ossp extension for uuid_generate_v4() if not already enabled
    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('users');
  }
}

2.3. Authentication (JWT)

backend/src/middleware/auth.middleware.ts

import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import { AppDataSource } from '../config/data-source';
import { User } from '../entities/User';

interface JwtPayload {
  id: string;
}

// Extend Request to include user property
declare global {
  namespace Express {
    interface Request {
      user?: User;
    }
  }
}

export const protect = async (req: Request, res: Response, next: NextFunction) => {
  let token;

  if (req.headers.authorization && req.headers.authorization.startsWith('Bearer')) {
    try {
      token = req.headers.authorization.split(' ')[1];
      const decoded = jwt.verify(token, process.env.JWT_SECRET as string) as JwtPayload;

      const userRepository = AppDataSource.getRepository(User);
      req.user = await userRepository.findOneBy({ id: decoded.id });

      if (!req.user) {
        return res.status(401).json({ message: 'Not authorized, user not found' });
      }

      next();
    } catch (error) {
      console.error(error);
      res.status(401).json({ message: 'Not authorized, token failed' });
    }
  }

  if (!token) {
    res.status(401).json({ message: 'Not authorized, no token' });
  }
};

export const authorize = (...roles: string[]) => {
  return (req: Request, res: Response, next: NextFunction) => {
    if (!req.user || !roles.includes(req.user.role)) {
      return res.status(403).json({ message: `User role ${req.user?.role} is not authorized to access this route` });
    }
    next();
  };
};

backend/src/utils/jwt.ts

import jwt from 'jsonwebtoken';

export const generateToken = (id: string): string => {
  return jwt.sign({ id }, process.env.JWT_SECRET as string, {
    expiresIn: process.env.JWT_EXPIRES_IN,
  });
};

2.4. Services & Controllers

backend/src/services/auth.service.ts

import { AppDataSource } from '../config/data-source';
import { User } from '../entities/User';
import { RegisterUserDto, LoginUserDto } from '../types/dtos';
import {

Full Stack Application Blueprint: TaskFlow Pro - Review and Documentation

This document provides a comprehensive review and detailed documentation of the "TaskFlow Pro" full-stack application blueprint. It covers the proposed architecture, technology stack, component breakdown, database design, authentication strategy, deployment plan, and testing approach. This blueprint is designed to be a complete guide, ready for your development team to commence building.

1. Executive Summary

The "TaskFlow Pro" application blueprint outlines a robust, scalable, and secure project management tool. It leverages modern full-stack technologies to deliver a responsive user experience, a powerful backend API, and a reliable data store. The architecture emphasizes modularity, maintainability, and extensibility, ensuring the application can evolve with future business needs. This document serves as the definitive guide for the initial build phase, detailing every critical aspect from UI components to deployment pipelines.

2. Overall Architecture Overview

The application follows a client-server architecture with a clear separation of concerns, utilizing a monorepo structure for streamlined development and deployment.

• Frontend (Client): A rich Single-Page Application (SPA) built with React, consuming data from the backend API.
• Backend (Server): A RESTful API service developed with Node.js (Express), handling business logic, data persistence, and authentication.
• Database: A relational PostgreSQL database for structured data storage.
• Authentication: JWT-based authentication for secure user access.
• Deployment: Containerized services deployed on AWS, managed via Infrastructure as Code (IaC) and CI/CD pipelines.

High-Level Diagram Description:

[User Browser] <--- HTTPS ---> [AWS Load Balancer]
       |                            |
       |                   +------------------+
       |                   |  AWS ECS Cluster |
       |                   | (Docker Containers)|
       |                   |                  |
       |                   |  +------------+  |
       |                   |  | Frontend   |  |
       |                   |  | (React.js) |  |
       |                   |  +------------+  |
       |                   |         ^        |
       |                   |         | REST   |
       |                   |         v        |
       |                   |  +------------+  |
       |                   |  | Backend    |  |
       |                   |  | (Node.js)  |  |
       |                   |  +------------+  |
       |                   +------------------+
       |                            |
       |                            | PostgreSQL
       |                            v
       |                   [AWS RDS - PostgreSQL]
       |                            |
       |                            v
       |                   [AWS S3 (Static Assets/Media)]

3. Frontend Component Blueprint

Technology Stack:

• Framework: React.js (v18+)
• Language: TypeScript
• UI Library: Material-UI (MUI v5)
• State Management: Redux Toolkit with RTK Query
• Routing: React Router DOM (v6)
• Styling: Emotion (integrated with MUI)
• Build Tool: Vite

Key Components & Modules:

1. Authentication Module:

* LoginPage: User login form (email/password).

* RegisterPage: New user registration form.

* ForgotPasswordPage: Request password reset.

* ResetPasswordPage: Set new password.

* AuthLayout: Common layout for auth pages.

1. Dashboard Module:

* DashboardOverview: Displays summary of active projects, tasks due soon, recent activities.

* WidgetContainer: Reusable container for dashboard widgets.

* TaskDueWidget: Lists upcoming tasks.

* ProjectProgressWidget: Overview of project statuses.

1. Project Management Module:

* ProjectListPage: Displays all projects, with filtering/sorting.

* ProjectCard: Individual project summary card.

* ProjectDetailsPage: Comprehensive view of a single project (tasks, members, settings).

* ProjectFormModal: Create/Edit project form.

* ProjectSettingsPanel: Manage project members, roles, and settings.

1. Task Management Module:

* TaskList: Displays tasks, filterable by project, assignee, status.

* TaskCard: Individual task display (title, assignee, due date, status).

* TaskDetailsModal: Detailed view and editing for a task (description, comments, attachments).

* TaskForm: Create/Edit task form.

1. User Profile & Settings Module:

* UserProfilePage: View and edit user profile information.

* AccountSettingsPage: Change password, notification preferences.

1. Common UI Components:

* AppHeader: Navigation, user menu, search.

* AppSidebar: Main navigation menu.

* NotificationsPanel: Displays in-app notifications.

* LoadingSpinner, ErrorMessage, AlertDialog: Generic UI feedback components.

* RichTextEditor: For task descriptions, comments.

State Management (Redux Toolkit & RTK Query):

• Global State Slices:

* authSlice: Manages user authentication status, tokens, user info.

* uiSlice: Manages global UI states (e.g., sidebar open/closed, loading indicators).

* projectsApi: RTK Query service for projects data fetching/mutation.

* tasksApi: RTK Query service for tasks data fetching/mutation.

* usersApi: RTK Query service for user-related data.

• Data Flow: Components dispatch actions to update state or trigger API calls via RTK Query. Selectors retrieve data from the store. RTK Query handles caching, revalidation, and loading states automatically.

Routing:

• Protected Routes: Use AuthGuard component to wrap routes requiring authentication.
• Public Routes: Login, Register, Forgot Password.
• Nested Routes: For Project Details (e.g., /projects/:id/tasks, /projects/:id/settings).

4. Backend API Blueprint

Technology Stack:

• Framework: Node.js with Express.js
• Language: TypeScript
• ORM: TypeORM
• Database Driver: pg (for PostgreSQL)
• Authentication: jsonwebtoken, bcryptjs
• Validation: express-validator
• Logging: Winston
• Environment Variables: dotenv
• Testing: Jest, Supertest

Core API Endpoints (RESTful):

1. Authentication (/api/auth):

* POST /register: Register a new user.

* POST /login: Authenticate user, return JWT and refresh token.

* POST /refresh-token: Generate a new access token using a refresh token.

* POST /logout: Invalidate refresh token.

* POST /forgot-password: Send password reset link.

* POST /reset-password: Reset user's password.

1. Users (/api/users):

* GET /me: Get current authenticated user's profile.

* PUT /me: Update current user's profile.

* GET /: Get all users (admin only or for project member selection).

* GET /:id: Get user by ID.

1. Projects (/api/projects):

* GET /: Get all projects for the authenticated user.

* GET /:id: Get a specific project by ID.

* POST /: Create a new project.

* PUT /:id: Update an existing project.

* DELETE /:id: Delete a project.

* GET /:id/members: Get members of a project.

* POST /:id/members: Add members to a project.

* DELETE /:id/members/:userId: Remove a member from a project.

1. Tasks (/api/tasks):

* GET /: Get all tasks for the authenticated user (can filter by project).

* GET /:id: Get a specific task by ID.

* POST /: Create a new task (within a project).

* PUT /:id: Update an existing task.

* DELETE /:id: Delete a task.

* POST /:id/comments: Add a comment to a task.

* GET /:id/comments: Get comments for a task.

1. Notifications (/api/notifications):

* GET /: Get notifications for the authenticated user.

* PUT /:id/read: Mark a notification as read.

* PUT /mark-all-read: Mark all notifications as read.

Business Logic & Middleware:

• Authentication Middleware: Verifies JWT for protected routes.
• Authorization Middleware: Checks user roles/permissions for specific actions (e.g., project owner can delete project).
• Validation Middleware: Uses express-validator to sanitize and validate incoming request bodies.
• Error Handling Middleware: Centralized error handling for consistent API responses.
• Logging: Request logging and error logging with Winston.

5. Database Design Blueprint (PostgreSQL)

ORM: TypeORM (Entity-based approach)

Key Entities & Schemas:

1. User Table:

* id (UUID, Primary Key)

* email (VARCHAR(255), UNIQUE, NOT NULL)

* password (VARCHAR(255), NOT NULL - hashed)

* firstName (VARCHAR(100))

* lastName (VARCHAR(100))

* profilePictureUrl (TEXT, NULLABLE)

* role (ENUM: 'admin', 'user', 'guest', DEFAULT 'user')

* refreshToken (VARCHAR(255), NULLABLE - for JWT refresh)

* createdAt (TIMESTAMP, DEFAULT NOW())

* updatedAt (TIMESTAMP, DEFAULT NOW())

1. Project Table:

* id (UUID, Primary Key)

* name (VARCHAR(255), NOT NULL)

* description (TEXT, NULLABLE)

* status (ENUM: 'active', 'completed', 'on-hold', DEFAULT 'active')

* ownerId (UUID, Foreign Key -> User.id, NOT NULL)

* startDate (DATE, NULLABLE)

* dueDate (DATE, NULLABLE)

* createdAt (TIMESTAMP, DEFAULT NOW())

* updatedAt (TIMESTAMP, DEFAULT NOW())

1. Task Table:

* id (UUID, Primary Key)

* title (VARCHAR(255), NOT NULL)

* description (TEXT, NULLABLE)

* status (ENUM: 'todo', 'in-progress', 'done', 'blocked', DEFAULT 'todo')

* priority (ENUM: 'low', 'medium', 'high', DEFAULT 'medium')

* projectId (UUID, Foreign Key -> Project.id, NOT NULL)

* assigneeId (UUID, Foreign Key -> User.id, NULLABLE)

* reporterId (UUID, Foreign Key -> User.id, NOT NULL)

* dueDate (DATE, NULLABLE)

* createdAt (TIMESTAMP, DEFAULT NOW())

* updatedAt (TIMESTAMP, DEFAULT NOW())

1. Comment Table:

* id (UUID, Primary Key)

* content (TEXT, NOT NULL)

* taskId (UUID, Foreign Key -> Task.id, NOT NULL)

* authorId (UUID, Foreign Key -> User.id, NOT NULL)

* createdAt (TIMESTAMP, DEFAULT NOW())

* updatedAt (TIMESTAMP, DEFAULT NOW())

1. ProjectMember Table (Many-to-Many relationship between User and Project):

* userId (UUID, Foreign Key -> User.id, Primary Key)

* projectId (UUID, Foreign Key -> Project.id, Primary Key)

role (ENUM: 'member', 'viewer', 'admin', DEFAULT 'member') - project-specific role*

* joinedAt (TIMESTAMP, DEFAULT NOW())

1. Notification Table:

* id (UUID, Primary Key)

* userId (UUID, Foreign Key -> User.id, NOT NULL)

* type (VARCHAR(50), e.g., 'task_assigned', 'comment_added', 'project_update')

* message (TEXT, NOT NULL)

* isRead (BOOLEAN, DEFAULT FALSE)

* relatedEntityId (UUID, NULLABLE - e.g., taskId, projectId)

* createdAt (TIMESTAMP, DEFAULT NOW())

Relationships:

• One-to-Many:

* User has many Projects (owner).

* Project has many Tasks.

* User has many Tasks (assignee, reporter).

* Task has many Comments.

* User has many Comments.

* User has many Notifications.

• Many-to-Many:

* User and Project via ProjectMember table.

Database Migrations:

• TypeORM migrations will be used to manage schema changes, ensuring version control and consistency across environments.
• Initial migration script will create all described tables and relationships.

6. Authentication & Authorization Strategy

Authentication (JWT-based):

1. User Registration:

* Users provide email and password.

* Password is hashed using bcryptjs before storage.

* A new User record is created.

1. User Login:

* Users provide email and password.

* Password is compared with stored