Building a Scalable Event Hosting Platform with NestJS, TypeORM, and Modular Architecture

/your-project-name
│
├── /app                 # Main directory for Next.js App Router (used for routes and pages)
│   ├── /(event)         # Event-related routes grouped here
│   │   ├── create       # Event creation page
│   │   │   ├── page.tsx # Main page file for creating events
│   │   ├── [eventId]    # Dynamic route for a specific event's details
│   │   │   ├── page.tsx # Event details page
│   │   ├── live         # Page for live streaming
│   │   │   ├── page.tsx # Live streaming page
│   │   ├── list         # List of all events
│   │   │   ├── page.tsx # Event listing page
│   │   ├── qna          # Page for live Q&A during events
│   │       ├── page.tsx # Live Q&A page
│   │
│   ├── /(user)          # Group for user-related routes
│   │   ├── profile      # User profile page
│   │   │   ├── page.tsx # Profile page component
│   │   ├── login        # User login page
│   │   │   ├── page.tsx # Login page component
│   │   ├── register     # User registration page
│   │       ├── page.tsx # Registration page component
│   │
│   ├── layout.tsx       # Global layout for shared UI (header, footer, etc.)
│   ├── global.css       # Global CSS (where Tailwind's @import goes)
│   └── _app.tsx         # Custom App component for handling global state
│
├── /components          # Reusable UI components
│   ├── EventCard.tsx    # Card component for displaying event info
│   ├── Navbar.tsx       # Navigation bar component
│   ├── Footer.tsx       # Footer component
│   ├── Button.tsx       # Generic Button component
│   ├── Modal.tsx        # Modal component for popups
│   └── Loader.tsx       # Loader component for loading states
│
├── /hooks               # Custom React hooks
│   ├── useAuth.ts       # Hook for authentication management
│   ├── useEvent.ts      # Hook for fetching and managing event data
│   └── useStream.ts     # Hook for handling live stream interactions
│
├── /lib                 # Utilities and helper functions
│   ├── api.ts           # API calls to back-end services
│   └── validators.ts    # Validation functions for forms
│
├── /public              # Static assets like images, icons, and fonts
│   ├── /images          # Image assets for events, logos, etc.
│   ├── favicon.ico      # Favicon for the app
│   └── logo.png         # Application logo
│
├── /styles              # Additional global styles (if needed)
│   ├── tailwind.config.js # Tailwind CSS configuration file
│   ├── globals.css      # Global styles (optional, Tailwind CSS covers most)
│
├── /types               # TypeScript types
│   ├── event.ts         # Type definitions for event-related data
│   └── user.ts          # Type definitions for user data
│
├── next.config.js       # Next.js configuration file
├── tailwind.config.js   # Tailwind CSS configuration file
├── tsconfig.json        # TypeScript configuration
├── package.json         # Dependencies and scripts
├── .eslintrc.js         # ESLint configuration for linting
├── .prettierrc          # Prettier configuration for code formatting
└── .gitignore           # Files to be ignored by Git

/your-backend-project
│
├── /src                     # Main source folder for the backend
│   ├── /auth                # Module for authentication
│   │   ├── auth.controller.ts
│   │   ├── auth.module.ts
│   │   ├── auth.service.ts
│   │   ├── jwt.strategy.ts
│   │   ├── local.strategy.ts
│   │   ├── dto              # DTOs for request validation
│   │   │   ├── login.dto.ts
│   │   │   ├── register.dto.ts
│   │   ├── guards           # Guards for role-based access
│   │   │   ├── jwt-auth.guard.ts
│   │   │   ├── roles.guard.ts
│   │   ├── decorators       # Custom decorators like roles
│   │       ├── roles.decorator.ts
│   ├── /users               # User module for managing users
│   │   ├── users.controller.ts
│   │   ├── users.module.ts
│   │   ├── users.service.ts
│   │   ├── entities         # TypeORM entity for users
│   │   │   ├── user.entity.ts
│   │   ├── dto              # User-related DTOs
│   │       ├── create-user.dto.ts
│   │       ├── update-user.dto.ts
│   ├── /events              # Event module for managing events
│   │   ├── events.controller.ts
│   │   ├── events.module.ts
│   │   ├── events.service.ts
│   │   ├── entities         # TypeORM entity for events
│   │   │   ├── event.entity.ts
│   │   ├── dto              # Event-related DTOs
│   │       ├── create-event.dto.ts
│   │       ├── update-event.dto.ts
│   ├── /tickets             # Ticketing module for event tickets
│   │   ├── tickets.controller.ts
│   │   ├── tickets.module.ts
│   │   ├── tickets.service.ts
│   │   ├── entities         # TypeORM entity for tickets
│   │   │   ├── ticket.entity.ts
│   │   ├── dto              # DTOs for ticket-related operations
│   │       ├── create-ticket.dto.ts
│   │       ├── update-ticket.dto.ts
│   ├── /payments            # Payment module for managing transactions
│   │   ├── payments.controller.ts
│   │   ├── payments.module.ts
│   │   ├── payments.service.ts
│   │   ├── entities         # TypeORM entity for payments
│   │   │   ├── payment.entity.ts
│   │   ├── dto              # Payment-related DTOs
│   │       ├── create-payment.dto.ts
│   ├── /notifications       # Notifications module for email, SMS, and push notifications
│   │   ├── notifications.controller.ts
│   │   ├── notifications.module.ts
│   │   ├── notifications.service.ts
│   │   ├── dto              # Notification-related DTOs
│   │       ├── create-notification.dto.ts
│   ├── /database            # Database module for TypeORM configurations
│   │   ├── database.module.ts
│   │   ├── database.service.ts
│   │   ├── ormconfig.ts      # TypeORM configuration
│   ├── /common              # Shared utilities, guards, interceptors, and exceptions
│   │   ├── /filters         # Global exception filters
│   │   │   ├── all-exceptions.filter.ts
│   │   ├── /interceptors    # Interceptors for response transformation, logging, etc.
│   │   │   ├── transform.interceptor.ts
│   │   ├── /decorators      # Reusable decorators
│   │   │   ├── api-response.decorator.ts
│   │   ├── /pipes           # Global pipes for validation, etc.
│   │   │   ├── validation.pipe.ts
│   ├── app.module.ts        # Root application module
│   ├── main.ts              # Main entry point of the application
│
├── /test                    # Tests for the application
│   ├── /e2e                 # End-to-end tests
│   ├── /unit                # Unit tests
│
├── /config                  # Configuration files for different environments
│   ├── config.ts            # Configuration for database, security, etc.
├── .env                     # Environment variables
├── .eslintrc.js             # ESLint configuration for linting
├── .prettierrc              # Prettier configuration for code formatting
├── tsconfig.json            # TypeScript configuration
├── package.json             # Dependencies and scripts
├── README.md                # Project documentation
└── .gitignore               # Files and folders to ignore in Git

/app
├── /(event)
│   ├── create
│   │   └── page.tsx
│   ├── [eventId]
│   │   └── page.tsx
│   ├── live
│   │   └── page.tsx
│   ├── list
│   │   └── page.tsx
│   ├── qna
│       └── page.tsx

// /app/(event)/create/page.tsx
import React, { useState } from 'react';

const CreateEventPage: React.FC = () => {
  const [formData, setFormData] = useState({
    name: '',
    description: '',
    date: '',
    time: '',
    price: '',
  });

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
    const { name, value } = e.target;
    setFormData((prevData) => ({
      ...prevData,
      [name]: value,
    }));
  };

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    console.log('Event Data:', formData);
    // Call an API to create the event
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">Create New Event</h1>
      <form onSubmit={handleSubmit} className="space-y-4">
        <div>
          <label className="block">Event Name</label>
          <input
            name="name"
            type="text"
            className="w-full p-2 border rounded"
            value={formData.name}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Description</label>
          <textarea
            name="description"
            className="w-full p-2 border rounded"
            value={formData.description}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Date</label>
          <input
            name="date"
            type="date"
            className="w-full p-2 border rounded"
            value={formData.date}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Time</label>
          <input
            name="time"
            type="time"
            className="w-full p-2 border rounded"
            value={formData.time}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Price</label>
          <input
            name="price"
            type="number"
            className="w-full p-2 border rounded"
            value={formData.price}
            onChange={handleInputChange}
            required
          />
        </div>
        <button type="submit" className="bg-blue-500 text-white p-2 rounded">Create Event</button>
      </form>
    </div>
  );
};

export default CreateEventPage;

// /app/(event)/[eventId]/page.tsx
import { useRouter } from 'next/router';
import React from 'react';

const EventDetailsPage: React.FC = () => {
  const router = useRouter();
  const { eventId } = router.query; // Accessing eventId from the route

  // Fetch event details using eventId (replace with actual API call)
  const event = {
    id: eventId,
    name: 'Sample Event',
    description: 'This is a description of the event.',
    date: '2024-10-30',
    time: '14:00',
    price: 20,
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-3xl font-bold">{event.name}</h1>
      <p className="mt-2">{event.description}</p>
      <p className="mt-4">Date: {event.date}</p>
      <p className="mt-1">Time: {event.time}</p>
      <p className="mt-4">Price: ${event.price}</p>
      <button className="bg-green-500 text-white p-2 rounded mt-4">Buy Tickets</button>
    </div>
  );
};

export default EventDetailsPage;

// /app/(event)/live/page.tsx
import React from 'react';

const LiveStreamPage: React.FC = () => {
  // Placeholder: Replace with actual live stream integration
  const liveStreamUrl = 'https://www.example.com/livestream'; // Replace with actual stream URL

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-3xl font-bold">Live Event Stream</h1>
      <div className="mt-4">
        <iframe
          width="100%"
          height="500"
          src={liveStreamUrl}
          frameBorder="0"
          allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
          allowFullScreen
        ></iframe>
      </div>
    </div>
  );
};

export default LiveStreamPage;

// /app/(event)/list/page.tsx
import Link from 'next/link';
import React from 'react';

const EventListPage: React.FC = () => {
  // Placeholder: Replace with actual event list from API
  const events = [
    { id: '1', name: 'Event 1', date: '2024-11-01', price: 30 },
    { id: '2', name: 'Event 2', date: '2024-11-05', price: 20 },
  ];

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold">Upcoming Events</h1>
      <ul className="mt-4">
        {events.map((event) => (
          <li key={event.id} className="mb-4">
            <Link href={`/event/${event.id}`}>
              <a className="block p-4 border rounded hover:bg-gray-100">
                <h2 className="text-xl">{event.name}</h2>
                <p>Date: {event.date}</p>
                <p>Price: ${event.price}</p>
              </a>
            </Link>
          </li>
        ))}
      </ul>
    </div>
  );
};

export default EventListPage;

// /app/(event)/qna/page.tsx
import React, { useState } from 'react';

const QnAPage: React.FC = () => {
  const [question, setQuestion] = useState('');
  const [questions, setQuestions] = useState<string[]>([]);

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    setQuestions((prevQuestions) => [...prevQuestions, question]);
    setQuestion('');
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">Live Q&A</h1>
      <form onSubmit={handleSubmit} className="mb-6">
        <input
          type="text"
          className="w-full p-2 border rounded mb-2"
          placeholder="Ask your question"
          value={question}
          onChange={(e) => setQuestion(e.target.value)}
          required
        />
        <button type="submit" className="bg-blue-500 text-white p-2 rounded">Submit Question</button>
      </form>
      <ul>
        {questions.map((q, index) => (
          <li key={index} className="mb-2 border p-2 rounded">
            {q}
          </li>
        ))}
      </ul>
    </div>
  );
};

export default QnAPage;

/app
├── /(user)             # User-related routes
│   ├── profile         # User profile page
│   │   └── page.tsx    # Profile page component
│   ├── login           # User login page
│   │   └── page.tsx    # Login page component
│   ├── register        # User registration page
│       └── page.tsx    # Registration page component
│
├── layout.tsx          # Global layout for shared UI (header, footer, etc.)
├── global.css          # Global CSS (Tailwind CSS imports)
└── _app.tsx            # Custom App component for global state or context

// /app/(user)/profile/page.tsx
import React from 'react';

const ProfilePage: React.FC = () => {
  // Placeholder user data (fetch real user data via an API)
  const user = {
    name: 'John Doe',
    email: 'john.doe@example.com',
    joined: '2023-01-01',
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-3xl font-bold">User Profile</h1>
      <div className="mt-4">
        <p><strong>Name:</strong> {user.name}</p>
        <p><strong>Email:</strong> {user.email}</p>
        <p><strong>Joined:</strong> {user.joined}</p>
      </div>
      <button className="bg-blue-500 text-white p-2 mt-4 rounded">Edit Profile</button>
    </div>
  );
};

export default ProfilePage;

// /app/(user)/login/page.tsx
import React, { useState } from 'react';
import { useRouter } from 'next/router';

const LoginPage: React.FC = () => {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const router = useRouter();

  const handleLogin = (e: React.FormEvent) => {
    e.preventDefault();
    // Placeholder login logic (replace with API call)
    console.log('Logging in:', { email, password });
    router.push('/'); // Redirect to homepage after login
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">Login</h1>
      <form onSubmit={handleLogin} className="space-y-4">
        <div>
          <label className="block">Email</label>
          <input
            type="email"
            className="w-full p-2 border rounded"
            value={email}
            onChange={(e) => setEmail(e.target.value)}
            required
          />
        </div>
        <div>
          <label className="block">Password</label>
          <input
            type="password"
            className="w-full p-2 border rounded"
            value={password}
            onChange={(e) => setPassword(e.target.value)}
            required
          />
        </div>
        <button type="submit" className="bg-blue-500 text-white p-2 rounded">
          Login
        </button>
      </form>
      <p className="mt-4">
        Don't have an account?{' '}
        <a href="/user/register" className="text-blue-500">Register here</a>.
      </p>
    </div>
  );
};

export default LoginPage;

// /app/(user)/register/page.tsx
import React, { useState } from 'react';
import { useRouter } from 'next/router';

const RegisterPage: React.FC = () => {
  const [formData, setFormData] = useState({
    name: '',
    email: '',
    password: '',
  });
  const router = useRouter();

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const { name, value } = e.target;
    setFormData((prevData) => ({
      ...prevData,
      [name]: value,
    }));
  };

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    // Placeholder registration logic (replace with API call)
    console.log('Registering user:', formData);
    router.push('/user/login'); // Redirect to login page after registration
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">Register</h1>
      <form onSubmit={handleSubmit} className="space-y-4">
        <div>
          <label className="block">Name</label>
          <input
            name="name"
            type="text"
            className="w-full p-2 border rounded"
            value={formData.name}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Email</label>
          <input
            name="email"
            type="email"
            className="w-full p-2 border rounded"
            value={formData.email}
            onChange={handleInputChange}
            required
          />
        </div>
        <div>
          <label className="block">Password</label>
          <input
            name="password"
            type="password"
            className="w-full p-2 border rounded"
            value={formData.password}
            onChange={handleInputChange}
            required
          />
        </div>
        <button type="submit" className="bg-green-500 text-white p-2 rounded">
          Register
        </button>
      </form>
      <p className="mt-4">
        Already have an account?{' '}
        <a href="/user/login" className="text-blue-500">Login here</a>.
      </p>
    </div>
  );
};

export default RegisterPage;

// /app/layout.tsx
import React from 'react';

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="en">
      <body className="bg-gray-50 text-gray-900">
        <Header />
        <main className="min-h-screen">{children}</main>
        <Footer />
      </body>
    </html>
  );
}

const Header: React.FC = () => (
  <header className="bg-blue-500 text-white p-4">
    <div className="container mx-auto">
      <a href="/" className="text-xl font-bold">Event Hosting Platform</a>
      <nav className="mt-2">
        <a href="/user/profile" className="mr-4">Profile</a>
        <a href="/user/login">Login</a>
      </nav>
    </div>
  </header>
);

const Footer: React.FC = () => (
  <footer className="bg-gray-800 text-white p-4 mt-8">
    <div className="container mx-auto text-center">
      <p>&copy; 2024 Event Hosting Platform. All rights reserved.</p>
    </div>
  </footer>
);

/* /app/global.css */
@tailwind base;
@tailwind components;
@tailwind utilities;

/* Additional custom styles if needed */
body {
  font-family: 'Inter', sans-serif;
}

// /app/_app.tsx
import React from 'react';

export default function MyApp({ Component, pageProps }: any) {
  return (
    <Component {...pageProps} />
  );
}

// /components/EventCard.tsx
import React from 'react';

interface EventCardProps {
  name: string;
  description: string;
  date: string;
  price: number;
  imageUrl: string;
}

const EventCard: React.FC<EventCardProps> = ({ name, description, date, price, imageUrl }) => {
  return (
    <div className="max-w-sm rounded overflow-hidden shadow-lg">
      <img className="w-full h-48 object-cover" src={imageUrl} alt={name} />
      <div className="px-6 py-4">
        <h2 className="font-bold text-xl mb-2">{name}</h2>
        <p className="text-gray-700 text-base">{description}</p>
        <p className="text-gray-600 mt-2">Date: {date}</p>
        <p className="text-gray-600">Price: ${price}</p>
      </div>
    </div>
  );
};

export default EventCard;

// /components/Navbar.tsx
import React from 'react';

const Navbar: React.FC = () => {
  return (
    <nav className="bg-blue-500 text-white p-4">
      <div className="container mx-auto flex justify-between items-center">
        <a href="/" className="text-xl font-bold">Event Hosting Platform</a>
        <div>
          <a href="/user/profile" className="mr-4">Profile</a>
          <a href="/user/login" className="mr-4">Login</a>
        </div>
      </div>
    </nav>
  );
};

export default Navbar;

// /components/Footer.tsx
import React from 'react';

const Footer: React.FC = () => {
  return (
    <footer className="bg-gray-800 text-white text-center p-4 mt-8">
      <div className="container mx-auto">
        <p>&copy; 2024 Event Hosting Platform. All rights reserved.</p>
      </div>
    </footer>
  );
};

export default Footer;

// /components/Button.tsx
import React from 'react';

interface ButtonProps {
  label: string;
  onClick: () => void;
  className?: string;
}

const Button: React.FC<ButtonProps> = ({ label, onClick, className }) => {
  return (
    <button
      className={`bg-blue-500 text-white p-2 rounded ${className}`}
      onClick={onClick}
    >
      {label}
    </button>
  );
};

export default Button;

// /components/Modal.tsx
import React from 'react';

interface ModalProps {
  isOpen: boolean;
  title: string;
  children: React.ReactNode;
  onClose: () => void;
}

const Modal: React.FC<ModalProps> = ({ isOpen, title, children, onClose }) => {
  if (!isOpen) return null;

  return (
    <div className="fixed inset-0 flex items-center justify-center z-50">
      <div className="bg-white p-4 rounded shadow-lg">
        <h2 className="text-xl font-bold mb-2">{title}</h2>
        <div>{children}</div>
        <button
          className="bg-red-500 text-white p-2 rounded mt-4"
          onClick={onClose}
        >
          Close
        </button>
      </div>
      <div className="fixed inset-0 bg-black opacity-50" onClick={onClose}></div>
    </div>
  );
};

export default Modal;

// /components/Loader.tsx
import React from 'react';

const Loader: React.FC = () => {
  return (
    <div className="flex justify-center items-center">
      <div className="spinner-border animate-spin inline-block w-8 h-8 border-4 rounded-full border-t-transparent border-blue-500"></div>
    </div>
  );
};

export default Loader;

// /hooks/useAuth.ts
import { useState, useEffect } from 'react';

export const useAuth = () => {
  const [isAuthenticated, setIsAuthenticated] = useState(false);

  useEffect(() => {
    // Example: check localStorage or make an API call to verify authentication
    const token = localStorage.getItem('token');
    setIsAuthenticated(!!token);
  }, []);

  const login = (token: string) => {
    localStorage.setItem('token', token);
    setIsAuthenticated(true);
  };

  const logout = () => {
    localStorage.removeItem('token');
    setIsAuthenticated(false);
  };

  return { isAuthenticated, login, logout };
};

// /hooks/useEvent.ts
import { useState, useEffect } from 'react';
import { Event } from '../types/event';
import { fetchEvents } from '../lib/api';

export const useEvent = () => {
  const [events, setEvents] = useState<Event[]>([]);
  const [loading, setLoading] = useState<boolean>(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const loadEvents = async () => {
      try {
        const data = await fetchEvents();
        setEvents(data);
      } catch (err) {
        setError('Failed to load events');
      } finally {
        setLoading(false);
      }
    };

    loadEvents();
  }, []);

  return { events, loading, error };
};

// /hooks/useStream.ts
import { useState } from 'react';

export const useStream = () => {
  const [isStreaming, setIsStreaming] = useState(false);

  const startStream = () => {
    setIsStreaming(true);
    // Trigger actual live stream logic here
  };

  const stopStream = () => {
    setIsStreaming(false);
    // Stop live stream logic here
  };

  return { isStreaming, startStream, stopStream };
};

// /lib/api.ts
import { Event } from '../types/event';

const API_URL = 'https://api.example.com';

export const fetchEvents = async (): Promise<Event[]> => {
  const response = await fetch(`${API_URL}/events`);
  if (!response.ok) {
    throw new Error('Failed to fetch events');
  }
  return response.json();
};

export const loginUser = async (email: string, password: string): Promise<string> => {
  const response = await fetch(`${API_URL}/login`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });

  if (!response.ok) {
    throw new Error('Failed to log in');
  }

  const { token } = await response.json();
  return token;
};

// /lib/validators.ts
export const validateEmail = (email: string): boolean => {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
};

export const validatePassword = (password: string): boolean => {
  // Example validation: password must be at least 6 characters
  return password.length >= 6;
};

/public
├── /images
│   ├── event1.jpg
│   ├── event2.jpg
│   └── logo.png
├── favicon.ico

// /styles/tailwind.config.js
module.exports = {
  content: ['./app/**/*.{js,ts,jsx,tsx}', './components/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {},
  },
  plugins: [],
};

/* /styles/globals.css */
@tailwind base;
@tailwind components;
@tailwind utilities;

/* Additional global styles can go here */

// /types/event.ts
export interface Event {
  id: string;
  name: string;
  description: string;
  date: string;
  price: number;
  imageUrl: string;
}

// /types/user.ts
export interface User {


  id: string;
  name: string;
  email: string;
  joined: string;
}

/src
├── /auth
│   ├── auth.controller.ts
│   ├── auth.module.ts
│   ├── auth.service.ts
│   ├── jwt.strategy.ts
│   ├── local.strategy.ts
│   ├── dto
│   │   ├── login.dto.ts
│   │   ├── register.dto.ts
│   ├── guards
│   │   ├── jwt-auth.guard.ts
│   │   ├── roles.guard.ts
│   ├── decorators
│       ├── roles.decorator.ts
├── /users
│   ├── users.controller.ts
│   ├── users.module.ts
│   ├── users.service.ts
│   ├── entities
│   │   ├── user.entity.ts
│   ├── dto
│       ├── create-user.dto.ts
│       ├── update-user.dto.ts

// /src/auth/auth.controller.ts
import { Controller, Post, Body, UseGuards, Request } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LoginDto } from './dto/login.dto';
import { RegisterDto } from './dto/register.dto';
import { LocalAuthGuard } from './guards/local-auth.guard';
import { JwtAuthGuard } from './guards/jwt-auth.guard';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('login')
  @UseGuards(LocalAuthGuard)
  async login(@Request() req, @Body() loginDto: LoginDto) {
    return this.authService.login(req.user);
  }

  @Post('register')
  async register(@Body() registerDto: RegisterDto) {
    return this.authService.register(registerDto);
  }

  @UseGuards(JwtAuthGuard)
  @Post('profile')
  getProfile(@Request() req) {
    return req.user;
  }
}

// /src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { UsersModule } from '../users/users.module';
import { JwtStrategy } from './jwt.strategy';
import { LocalStrategy } from './local.strategy';
import { JwtAuthGuard } from './guards/jwt-auth.guard';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.register({
      secret: 'jwt_secret',  // Use environment variable for production
      signOptions: { expiresIn: '1d' },
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy, JwtStrategy, JwtAuthGuard],
})
export class AuthModule {}

// /src/auth/auth.service.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { UsersService } from '../users/users.service';
import { RegisterDto } from './dto/register.dto';
import { User } from '../users/entities/user.entity';

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService,
  ) {}

  async validateUser(email: string, pass: string): Promise<any> {
    const user = await this.usersService.findByEmail(email);
    if (user && user.password === pass) {
      const { password, ...result } = user;
      return result;
    }
    return null;
  }

  async login(user: any) {
    const payload = { email: user.email, sub: user.id };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }

  async register(registerDto: RegisterDto): Promise<User> {
    return this.usersService.create(registerDto);
  }
}

// /src/auth/jwt.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: 'jwt_secret', // Use environment variable for production
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, email: payload.email };
  }
}

// /src/auth/local.strategy.ts
import { Strategy } from 'passport-local';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { AuthService } from './auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private authService: AuthService) {
    super({ usernameField: 'email' });
  }

  async validate(email: string, password: string): Promise<any> {
    const user = await this.authService.validateUser(email, password);
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}

// /src/auth/dto/login.dto.ts
import { IsEmail, IsNotEmpty, MinLength } from 'class-validator';

export class LoginDto {
  @IsEmail()
  email: string;

  @IsNotEmpty()
  @MinLength(6)
  password: string;
}

// /src/auth/dto/register.dto.ts
import { IsEmail, IsNotEmpty, MinLength } from 'class-validator';

export class RegisterDto {
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;

  @IsNotEmpty()
  @MinLength(6)
  password: string;
}

// /src/auth/guards/jwt-auth.guard.ts
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

// /src/auth/guards/roles.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    return roles.includes(user.role);
  }
}

// /src/auth/decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

// /src/users/users.controller.ts
import { Controller, Get, Post, Body, Param, Patch } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.usersService.update(id, updateUserDto);
  }
}

// /src/users/users.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { User } from './entities/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

// /src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from

 '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { User } from './entities/user.entity';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private usersRepository: Repository<User>,
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    const user = this.usersRepository.create(createUserDto);
    return this.usersRepository.save(user);
  }

  async findOne(id: string): Promise<User> {
    return this.usersRepository.findOneBy({ id });
  }

  async findByEmail(email: string): Promise<User> {
    return this.usersRepository.findOneBy({ email });
  }

  async update(id: string, updateUserDto: UpdateUserDto): Promise<User> {
    await this.usersRepository.update(id, updateUserDto);
    return this.findOne(id);
  }
}

// /src/users/entities/user.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

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

  @Column()
  name: string;

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

  @Column()
  password: string;

  @Column({ default: 'user' })
  role: string;
}

// /src/users/dto/create-user.dto.ts
import { IsEmail, IsNotEmpty, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;

  @IsNotEmpty()
  @MinLength(6)
  password: string;
}

// /src/users/dto/update-user.dto.ts
import { IsOptional, MinLength } from 'class-validator';

export class UpdateUserDto {
  @IsOptional()
  name?: string;

  @IsOptional()
  @MinLength(6)
  password?: string;
}

/src
├── /events               # Event module
│   ├── events.controller.ts
│   ├── events.module.ts
│   ├── events.service.ts
│   ├── entities
│   │   ├── event.entity.ts
│   ├── dto
│       ├── create-event.dto.ts
│       ├── update-event.dto.ts
├── /tickets              # Ticket module
│   ├── tickets.controller.ts
│   ├── tickets.module.ts
│   ├── tickets.service.ts
│   ├── entities
│   │   ├── ticket.entity.ts
│   ├── dto
│       ├── create-ticket.dto.ts
│       ├── update-ticket.dto.ts

// /src/events/events.controller.ts
import { Controller, Get, Post, Body, Param, Patch, Delete } from '@nestjs/common';
import { EventsService } from './events.service';
import { CreateEventDto } from './dto/create-event.dto';
import { UpdateEventDto } from './dto/update-event.dto';

@Controller('events')
export class EventsController {
  constructor(private readonly eventsService: EventsService) {}

  @Post()
  create(@Body() createEventDto: CreateEventDto) {
    return this.eventsService.create(createEventDto);
  }

  @Get()
  findAll() {
    return this.eventsService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.eventsService.findOne(id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateEventDto: UpdateEventDto) {
    return this.eventsService.update(id, updateEventDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.eventsService.remove(id);
  }
}

// /src/events/events.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { EventsService } from './events.service';
import { EventsController } from './events.controller';
import { Event } from './entities/event.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Event])],
  controllers: [EventsController],
  providers: [EventsService],
})
export class EventsModule {}

// /src/events/events.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateEventDto } from './dto/create-event.dto';
import { UpdateEventDto } from './dto/update-event.dto';
import { Event } from './entities/event.entity';

@Injectable()
export class EventsService {
  constructor(
    @InjectRepository(Event)
    private eventsRepository: Repository<Event>,
  ) {}

  create(createEventDto: CreateEventDto): Promise<Event> {
    const event = this.eventsRepository.create(createEventDto);
    return this.eventsRepository.save(event);
  }

  findAll(): Promise<Event[]> {
    return this.eventsRepository.find();
  }

  async findOne(id: string): Promise<Event> {
    const event = await this.eventsRepository.findOneBy({ id });
    if (!event) {
      throw new NotFoundException(`Event with ID ${id} not found`);
    }
    return event;
  }

  async update(id: string, updateEventDto: UpdateEventDto): Promise<Event> {
    await this.eventsRepository.update(id, updateEventDto);
    return this.findOne(id);
  }

  async remove(id: string): Promise<void> {
    await this.findOne(id); // Ensure event exists
    await this.eventsRepository.delete(id);
  }
}

// /src/events/entities/event.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Event {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  name: string;

  @Column()
  description: string;

  @Column()
  date: string;

  @Column('decimal')
  price: number;

  @Column({ nullable: true })
  imageUrl: string;
}

// /src/events/dto/create-event.dto.ts
import { IsNotEmpty, IsString, IsDecimal, IsOptional } from 'class-validator';

export class CreateEventDto {
  @IsNotEmpty()
  @IsString()
  name: string;

  @IsNotEmpty()
  @IsString()
  description: string;

  @IsNotEmpty()
  date: string;

  @IsNotEmpty()
  @IsDecimal()
  price: number;

  @IsOptional()
  @IsString()
  imageUrl?: string;
}

// /src/events/dto/update-event.dto.ts
import { PartialType } from '@nestjs/mapped-types';
import { CreateEventDto } from './create-event.dto';

export class UpdateEventDto extends PartialType(CreateEventDto) {}

// /src/tickets/tickets.controller.ts
import { Controller, Get, Post, Body, Param, Patch, Delete } from '@nestjs/common';
import { TicketsService } from './tickets.service';
import { CreateTicketDto } from './dto/create-ticket.dto';
import { UpdateTicketDto } from './dto/update-ticket.dto';

@Controller('tickets')
export class TicketsController {
  constructor(private readonly ticketsService: TicketsService) {}

  @Post()
  create(@Body() createTicketDto: CreateTicketDto) {
    return this.ticketsService.create(createTicketDto);
  }

  @Get()
  findAll() {
    return this.ticketsService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.ticketsService.findOne(id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateTicketDto: UpdateTicketDto) {
    return this.ticketsService.update(id, updateTicketDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.ticketsService.remove(id);
  }
}

// /src/tickets/tickets.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TicketsService } from './tickets.service';
import { TicketsController } from './tickets.controller';
import { Ticket } from './entities/ticket.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Ticket])],
  controllers: [TicketsController],
  providers: [TicketsService],
})
export class TicketsModule {}

// /src/tickets/tickets.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateTicketDto } from './dto/create-ticket.dto';
import { UpdateTicketDto } from './dto/update-ticket.dto';
import { Ticket } from './entities/ticket.entity';

@Injectable()
export class TicketsService {
  constructor(
    @InjectRepository(Ticket)
    private ticketsRepository: Repository<Ticket>,
  ) {}

  create(createTicketDto: CreateTicketDto): Promise<Ticket> {
    const ticket = this.ticketsRepository.create(createTicketDto);
    return this.ticketsRepository.save(ticket);
  }

  findAll(): Promise<Ticket[]> {
    return this.ticketsRepository.find();
  }

  async findOne(id: string): Promise<Ticket> {
    const ticket = await this.ticketsRepository.findOneBy({ id });
    if (!ticket) {
      throw new NotFoundException(`Ticket with ID ${id} not found`);
    }
    return ticket;
  }

  async update(id: string, updateTicketDto: UpdateTicketDto): Promise<Ticket> {
    await this.ticketsRepository.update(id, updateTicketDto);
    return this.findOne(id);
  }

  async remove(id: string): Promise<void> {
    await this.findOne(id); // Ensure ticket exists
    await this.ticketsRepository.delete(id);
  }
}

// /src/tickets/entities/ticket.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
import { Event } from '../../events/entities/event.entity';

@Entity()
export class Ticket {
  @PrimaryGeneratedColumn('uuid')
  id: string

;

  @Column()
  seatNumber: string;

  @Column('decimal')
  price: number;

  @ManyToOne(() => Event, (event) => event.id)
  event: Event;
}

// /src/tickets/dto/create-ticket.dto.ts
import { IsNotEmpty, IsDecimal, IsString } from 'class-validator';

export class CreateTicketDto {
  @IsNotEmpty()
  @IsString()
  seatNumber: string;

  @IsNotEmpty()
  @IsDecimal()
  price: number;

  @IsNotEmpty()
  @IsString()
  eventId: string;
}

// /src/tickets/dto/update-ticket.dto.ts
import { PartialType } from '@nestjs/mapped-types';
import { CreateTicketDto } from './create-ticket.dto';

export class UpdateTicketDto extends PartialType(CreateTicketDto) {}

/src
├── /payments             # Payment module
│   ├── payments.controller.ts
│   ├── payments.module.ts
│   ├── payments.service.ts
│   ├── entities
│   │   ├── payment.entity.ts
│   ├── dto
│       ├── create-payment.dto.ts
├── /notifications        # Notification module
│   ├── notifications.controller.ts
│   ├── notifications.module.ts
│   ├── notifications.service.ts
│   ├── dto
│       ├── create-notification.dto.ts

// /src/payments/payments.controller.ts
import { Controller, Get, Post, Body, Param } from '@nestjs/common';
import { PaymentsService } from './payments.service';
import { CreatePaymentDto } from './dto/create-payment.dto';

@Controller('payments')
export class PaymentsController {
  constructor(private readonly paymentsService: PaymentsService) {}

  @Post()
  processPayment(@Body() createPaymentDto: CreatePaymentDto) {
    return this.paymentsService.processPayment(createPaymentDto);
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.paymentsService.findOne(id);
  }
}

// /src/payments/payments.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { PaymentsService } from './payments.service';
import { PaymentsController } from './payments.controller';
import { Payment } from './entities/payment.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Payment])],
  controllers: [PaymentsController],
  providers: [PaymentsService],
})
export class PaymentsModule {}

// /src/payments/payments.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreatePaymentDto } from './dto/create-payment.dto';
import { Payment } from './entities/payment.entity';

@Injectable()
export class PaymentsService {
  constructor(
    @InjectRepository(Payment)
    private paymentsRepository: Repository<Payment>,
  ) {}

  async processPayment(createPaymentDto: CreatePaymentDto): Promise<Payment> {
    // Placeholder logic for payment processing (integrate with a real payment provider like Stripe or PayPal)
    const payment = this.paymentsRepository.create(createPaymentDto);
    return this.paymentsRepository.save(payment);
  }

  async findOne(id: string): Promise<Payment> {
    const payment = await this.paymentsRepository.findOneBy({ id });
    if (!payment) {
      throw new NotFoundException(`Payment with ID ${id} not found`);
    }
    return payment;
  }
}

// /src/payments/entities/payment.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Payment {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  userId: string;

  @Column()
  eventId: string;

  @Column('decimal')
  amount: number;

  @Column()
  paymentMethod: string; // e.g., 'credit card', 'paypal'

  @Column()
  status: string; // e.g., 'pending', 'completed', 'failed'

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

// /src/payments/dto/create-payment.dto.ts
import { IsNotEmpty, IsDecimal } from 'class-validator';

export class CreatePaymentDto {
  @IsNotEmpty()
  userId: string;

  @IsNotEmpty()
  eventId: string;

  @IsNotEmpty()
  @IsDecimal()
  amount: number;

  @IsNotEmpty()
  paymentMethod: string; // e.g., 'credit card', 'paypal'
}

// /src/notifications/notifications.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { NotificationsService } from './notifications.service';
import { CreateNotificationDto } from './dto/create-notification.dto';

@Controller('notifications')
export class NotificationsController {
  constructor(private readonly notificationsService: NotificationsService) {}

  @Post()
  sendNotification(@Body() createNotificationDto: CreateNotificationDto) {
    return this.notificationsService.sendNotification(createNotificationDto);
  }
}

// /src/notifications/notifications.module.ts
import { Module } from '@nestjs/common';
import { NotificationsService } from './notifications.service';
import { NotificationsController } from './notifications.controller';

@Module({
  controllers: [NotificationsController],
  providers: [NotificationsService],
})
export class NotificationsModule {}

// /src/notifications/notifications.service.ts
import { Injectable } from '@nestjs/common';
import { CreateNotificationDto } from './dto/create-notification.dto';
import * as nodemailer from 'nodemailer'; // For email notifications (use an actual provider for SMS)

@Injectable()
export class NotificationsService {
  async sendNotification(createNotificationDto: CreateNotificationDto): Promise<any> {
    const { recipient, message, type } = createNotificationDto;

    if (type === 'email') {
      return this.sendEmail(recipient, message);
    }

    if (type === 'sms') {
      return this.sendSms(recipient, message);
    }

    if (type === 'push') {
      return this.sendPushNotification(recipient, message);
    }
  }

  private async sendEmail(recipient: string, message: string) {
    const transporter = nodemailer.createTransport({
      service: 'Gmail', // Use your actual email service provider here
      auth: {
        user: 'your-email@gmail.com',
        pass: 'your-email-password',
      },
    });

    const mailOptions = {
      from: 'your-email@gmail.com',
      to: recipient,
      subject: 'Notification',
      text: message,
    };

    return transporter.sendMail(mailOptions);
  }

  private async sendSms(recipient: string, message: string) {
    // Implement SMS sending logic (e.g., using Twilio)
    console.log(`Sending SMS to ${recipient}: ${message}`);
    return { success: true };
  }

  private async sendPushNotification(recipient: string, message: string) {
    // Implement push notification logic (e.g., using Firebase Cloud Messaging)
    console.log(`Sending push notification to ${recipient}: ${message}`);
    return { success: true };
  }
}

// /src/notifications/dto/create-notification.dto.ts
import { IsNotEmpty, IsEmail, IsIn } from 'class-validator';

export class CreateNotificationDto {
  @IsNotEmpty()
  @IsEmail()
  recipient: string; // Can be email or phone number depending on the type

  @IsNotEmpty()
  message: string;

  @IsNotEmpty()
  @IsIn(['email', 'sms', 'push'])
  type: string; // e.g., 'email', 'sms', 'push'
}

/src
├── /database               # Database module
│   ├── database.module.ts
│   ├── database.service.ts
│   ├── ormconfig.ts         # TypeORM configuration
├── /common                 # Shared utilities, guards, interceptors, and exceptions
│   ├── /filters            # Global exception filters
│   │   ├── all-exceptions.filter.ts
│   ├── /interceptors       # Interceptors for response transformation, logging, etc.
│   │   ├── transform.interceptor.ts
│   ├── /decorators         # Reusable decorators
│   │   ├── api-response.decorator.ts
│   ├── /pipes              # Global pipes for validation, etc.
│   │   ├── validation.pipe.ts
├── app.module.ts           # Root application module
├── main.ts                 # Main entry point of the application