Develop Full Stack Language Learning App in Next JS & Nest JS

src/
├── auth/          # JWT Authentication (Login/Register)
├── users/         # User Profile & Progress Management
├── courses/       # Course Management (Lessons, Quizzes)
├── quizzes/       # Quizzes and Results Tracking
├── database/      # PostgreSQL or MongoDB integration
├── notifications/ # Email and Push Notifications
├── app.module.ts  # Root Module

pages/
├── courses/               # List of courses
│   └── [courseId].tsx     # Individual course with lessons
├── profile.tsx            # User profile and progress tracking
├── quizzes/[quizId].tsx   # Quiz page
├── api/                   # API Routes if needed
components/
├── LessonCard.tsx         # Reusable component for lessons
├── QuizComponent.tsx      # Interactive quizzes

src/
├── screens/
│   ├── CourseScreen.js      # Lists lessons for a course
│   ├── QuizScreen.js        # Interactive quizzes
│   └── ProfileScreen.js     # User profile with progress
├── components/
│   ├── LessonCard.js        # Component for displaying lessons
│   └── QuizCard.js          # Component for interactive quiz
├── navigation/
│   └── AppNavigator.js      # React Navigation setup

  nest new language-app-backend

  npm install @nestjs/typeorm typeorm pg bcryptjs
  npm install @nestjs/jwt passport-jwt

  npx create-next-app@latest my-language-app

  npm install -D tailwindcss postcss autoprefixer
  npx tailwindcss init

  npx create-expo-app my-language-app

  npm install react-navigation react-native-async-storage

my-language-app/
├── app/
│   ├── (auth)/
│   │   ├── login/
│   │   │   └── page.tsx
│   │   ├── register/
│   │   │   └── page.tsx
│   ├── (dashboard)/
│   │   ├── layout.tsx
│   │   ├── page.tsx
│   ├── courses/
│   │   ├── page.tsx
│   │   ├── [courseId]/
│   │   │   ├── page.tsx
│   │   │   ├── quiz/
│   │   │   │   └── page.tsx
│   ├── profile/
│   │   └── page.tsx
│   ├── layout.tsx
│   ├── page.tsx
├── components/
│   ├── CourseCard.tsx
│   ├── Header.tsx
│   ├── QuizComponent.tsx
├── lib/
│   ├── api.ts
│   ├── auth.ts
├── styles/
│   ├── globals.css
│   └── tailwind.config.js
├── public/
│   ├── logo.png
│   └── favicon.ico
├── utils/
│   ├── fetcher.ts
│   ├── constants.ts
├── pages/
│   ├── api/
│   │   ├── auth/
│   │   │   └── [...nextauth].ts
│   │   ├── courses.ts
│   │   ├── quizzes.ts
│   └── _document.tsx
├── prisma/ (if using Prisma)
│   ├── schema.prisma
├── .env.local
├── next.config.js
├── tsconfig.json
└── package.json

my-language-app-backend/
├── src/
│   ├── auth/
│   │   ├── dto/
│   │   │   ├── login.dto.ts
│   │   │   └── register.dto.ts
│   │   ├── auth.controller.ts
│   │   ├── auth.module.ts
│   │   ├── auth.service.ts
│   │   ├── jwt.strategy.ts
│   │   └── local.strategy.ts
│   ├── users/
│   │   ├── dto/
│   │   │   ├── create-user.dto.ts
│   │   │   ├── update-user.dto.ts
│   │   ├── entities/
│   │   │   └── user.entity.ts
│   │   ├── users.controller.ts
│   │   ├── users.module.ts
│   │   ├── users.service.ts
│   ├── courses/
│   │   ├── dto/
│   │   │   ├── create-course.dto.ts
│   │   │   ├── update-course.dto.ts
│   │   ├── entities/
│   │   │   └── course.entity.ts
│   │   ├── courses.controller.ts
│   │   ├── courses.module.ts
│   │   ├── courses.service.ts
│   ├── lessons/
│   │   ├── dto/
│   │   │   ├── create-lesson.dto.ts
│   │   │   └── update-lesson.dto.ts
│   │   ├── entities/
│   │   │   └── lesson.entity.ts
│   │   ├── lessons.controller.ts
│   │   ├── lessons.module.ts
│   │   ├── lessons.service.ts
│   ├── quizzes/
│   │   ├── dto/
│   │   │   ├── create-quiz.dto.ts
│   │   │   └── submit-quiz.dto.ts
│   │   ├── entities/
│   │   │   └── quiz.entity.ts
│   │   ├── quizzes.controller.ts
│   │   ├── quizzes.module.ts
│   │   ├── quizzes.service.ts
│   ├── common/
│   │   ├── decorators/
│   │   │   └── roles.decorator.ts
│   │   ├── guards/
│   │   │   ├── jwt-auth.guard.ts
│   │   │   └── roles.guard.ts
│   │   └── utils/
│   │       └── hash.util.ts
│   ├── config/
│   │   ├── app.config.ts
│   │   └── database.config.ts
│   ├── database/
│   │   ├── migrations/
│   │   └── typeorm.config.ts
│   ├── app.module.ts
│   ├── main.ts
├── prisma/ (if using Prisma instead of TypeORM)
│   └── schema.prisma
├── .env
├── .gitignore
├── package.json
├── tsconfig.json
├── docker-compose.yml (optional for Docker setup)
└── README.md

import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
import { Course } from '../../courses/entities/course.entity';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

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

  @Column()
  password: string;

  @OneToMany(() => Course, course => course.user)
  courses: Course[];
}

import { Injectable

 } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { UsersService } from '../users/users.service';
import { JwtPayload } from './interfaces/jwt-payload.interface';

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

  async validateUser(email: string, password: string): Promise<any> {
    const user = await this.usersService.findOneByEmail(email);
    // Validate password (e.g., bcrypt)
    return user; // Return user if validated
  }

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

import { TypeOrmModuleOptions } from '@nestjs/typeorm';

export const typeOrmConfig: TypeOrmModuleOptions = {
  type: 'postgres',
  host: process.env.DB_HOST,
  port: parseInt(process.env.DB_PORT) || 5432,
  username: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  entities: [__dirname + '/../**/*.entity{.ts,.js}'],
  synchronize: true, // Disable in production!
};

my-language-app/
├── app/
│   ├── (auth)/
│   │   ├── login/
│   │   │   └── page.tsx
│   │   ├── register/
│   │   │   └── page.tsx
│   ├── (dashboard)/
│   │   ├── layout.tsx
│   │   ├── page.tsx
│   ├── courses/
│   │   ├── page.tsx
│   │   ├── [courseId]/
│   │   │   ├── page.tsx
│   │   │   ├── quiz/
│   │   │   │   └── page.tsx
│   ├── profile/
│   │   └── page.tsx
│   ├── layout.tsx
│   ├── page.tsx

// app/(auth)/login/page.tsx
import { useState } from 'react';
import { useRouter } from 'next/navigation';

export default function LoginPage() {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const router = useRouter();

  const handleLogin = async (e: React.FormEvent) => {
    e.preventDefault();

    const response = await fetch('/api/auth/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password }),
    });

    if (response.ok) {
      router.push('/dashboard');
    } else {
      alert('Login failed');
    }
  };

  return (
    <div className="flex justify-center items-center min-h-screen">
      <form onSubmit={handleLogin} className="w-full max-w-sm">
        <h2 className="text-2xl font-bold mb-4">Login</h2>
        <input
          type="email"
          className="input"
          placeholder="Email"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
        />
        <input
          type="password"
          className="input mt-4"
          placeholder="Password"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
        />
        <button className="btn mt-4" type="submit">Login</button>
      </form>
    </div>
  );
}

// app/(auth)/register/page.tsx
import { useState } from 'react';
import { useRouter } from 'next/navigation';

export default function RegisterPage() {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const router = useRouter();

  const handleRegister = async (e: React.FormEvent) => {
    e.preventDefault();

    const response = await fetch('/api/auth/register', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password }),
    });

    if (response.ok) {
      router.push('/login');
    } else {
      alert('Registration failed');
    }
  };

  return (
    <div className="flex justify-center items-center min-h-screen">
      <form onSubmit={handleRegister} className="w-full max-w-sm">
        <h2 className="text-2xl font-bold mb-4">Register</h2>
        <input
          type="email"
          className="input"
          placeholder="Email"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
        />
        <input
          type="password"
          className="input mt-4"
          placeholder="Password"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
        />
        <button className="btn mt-4" type="submit">Register</button>
      </form>
    </div>
  );
}

// app/(dashboard)/layout.tsx
import { ReactNode } from 'react';

export default function DashboardLayout({ children }: { children: ReactNode }) {
  return (
    <div className="flex">
      <aside className="w-64 h-screen bg-gray-800 text-white">
        <nav className="p-4">
          <ul>
            <li><a href="/dashboard" className="block py-2">Dashboard</a></li>
            <li><a href="/courses" className="block py-2">Courses</a></li>
            <li><a href="/profile" className="block py-2">Profile</a></li>
          </ul>
        </nav>
      </aside>
      <main className="flex-1 p-8">
        {children}
      </main>
    </div>
  );
}

// app/(dashboard)/page.tsx
export default function DashboardPage() {
  return (
    <div>
      <h1 className="text-3xl font-bold">Welcome to your Dashboard</h1>
      <p className="mt-4">You can view your progress and access courses here.</p>
    </div>
  );
}

// app/courses/page.tsx
import Link from 'next/link';

export default function CoursesPage() {
  const courses = [
    { id: 1, title: 'Spanish for Beginners' },
    { id: 2, title: 'French for Beginners' },
    { id: 3, title: 'German for Beginners' },
  ];

  return (
    <div>
      <h1 className="text-3xl font-bold">Available Courses</h1>
      <ul className="mt-4">
        {courses.map(course => (
          <li key={course.id} className="mt-2">
            <Link href={`/courses/${course.id}`}>
              <a className="text-blue-500 hover:underline">{course.title}</a>
            </Link>
          </li>
        ))}
      </ul>
    </div>
  );
}

// app/courses/[courseId]/page.tsx
import { useRouter } from 'next/router';

export default function CourseDetailPage() {
  const router = useRouter();
  const { courseId } = router.query;

  // Replace with actual course data from API
  const course = { title: `Course ${courseId}`, description: 'Course description goes here.' };

  return (
    <div>
      <h1 className="text-3xl font-bold">{course.title}</h1>
      <p className="mt-4">{course.description}</p>
      <a href={`/courses/${courseId}/quiz`} className="text-blue-500 hover:underline mt-4 block">Take Quiz</a>
    </div>
  );
}

// app/courses/[courseId]/quiz/page.tsx
import { useState } from 'react';
import { useRouter } from 'next/router';

export default function QuizPage() {
  const router = useRouter();
  const { courseId } = router.query;

  const [answers, setAnswers] = useState({ q1: '', q2: '' });

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    // Submit the quiz answers
    alert('Quiz submitted!');
  };

  return (
    <div>
      <h1 className="text-3xl font-bold">Quiz for Course {courseId}</h1>
      <form onSubmit={handleSubmit} className="mt-4">
        <div>
          <label className="block text-xl">Question 1: Translate "Hello" to Spanish.</label>
          <input
            type="text"
            className="input mt-2"
            value={answers.q1}
            onChange={(e) => setAnswers({ ...answers, q1: e.target.value })}
          />
        </div>
        <div className="mt-4">
          <label className="block text-xl">Question 2: Translate "Thank you" to Spanish.</label>
          <input
            type="text"
            className="input mt-2"
            value={answers.q2}
            onChange={(e) => setAnswers({ ...answers, q2: e.target.value })}
          />
        </div>
        <button className="btn mt-6" type="submit">Submit Quiz</button>
      </form>
    </div

>
  );
}

// app/profile/page.tsx
export default function ProfilePage() {
  return (
    <div>
      <h1 className="text-3xl font-bold">Your Profile</h1>
      <p className="mt-4">Manage your profile details and update your information.</p>
      <form className="mt-4">
        <div>
          <label className="block text-xl">Email</label>
          <input type="email" className="input mt-2" value="user@example.com" readOnly />
        </div>
        <div className="mt-4">
          <label className="block text-xl">Change Password</label>
          <input type="password" className="input mt-2" placeholder="New Password" />
        </div>
        <button className="btn mt-6" type="submit">Update Profile</button>
      </form>
    </div>
  );
}

// app/layout.tsx
import { ReactNode } from 'react';

export default function RootLayout({ children }: { children: ReactNode }) {
  return (
    <html lang="en">
      <body className="bg-gray-100">
        <header className="bg-blue-600 text-white p-4">
          <h1 className="text-2xl">Language Learning App</h1>
        </header>
        <main className="p-8">{children}</main>
      </body>
    </html>
  );
}

// app/page.tsx
export default function HomePage() {
  return (
    <div>
      <h1 className="text-4xl font-bold">Welcome to the Language Learning App</h1>
      <p className="mt-4">Start your language learning journey today!</p>
      <a href="/courses" className="text-blue-500 hover:underline mt-4 block">Browse Courses</a>
    </div>
  );
}

my-language-app/
├── components/
│   ├── CourseCard.tsx
│   ├── Header.tsx
│   ├── QuizComponent.tsx
├── lib/
│   ├── api.ts
│   ├── auth.ts
├── styles/
│   ├── globals.css
│   └── tailwind.config.js
├── public/
│   ├── logo.png
│   └── favicon.ico
├── utils/
│   ├── fetcher.ts
│   ├── constants.ts

// components/CourseCard.tsx
import Link from 'next/link';

interface CourseCardProps {
  id: number;
  title: string;
  description: string;
}

export default function CourseCard({ id, title, description }: CourseCardProps) {
  return (
    <div className="border rounded-lg p-4 shadow-md hover:shadow-lg transition-shadow">
      <h2 className="text-xl font-bold">{title}</h2>
      <p className="text-gray-600 mt-2">{description}</p>
      <Link href={`/courses/${id}`}>
        <a className="text-blue-500 mt-4 block hover:underline">View Course</a>
      </Link>
    </div>
  );
}

// components/Header.tsx
import Link from 'next/link';

export default function Header() {
  return (
    <header className="bg-blue-600 text-white p-4">
      <div className="container mx-auto flex justify-between items-center">
        <Link href="/">
          <a className="text-2xl font-bold">Language Learning App</a>
        </Link>
        <nav>
          <ul className="flex space-x-4">
            <li><Link href="/courses"><a>Courses</a></Link></li>
            <li><Link href="/profile"><a>Profile</a></Link></li>
            <li><Link href="/login"><a>Login</a></Link></li>
          </ul>
        </nav>
      </div>
    </header>
  );
}

// components/QuizComponent.tsx
import { useState } from 'react';

interface QuizComponentProps {
  question: string;
  onSubmit: (answer: string) => void;
}

export default function QuizComponent({ question, onSubmit }: QuizComponentProps) {
  const [answer, setAnswer] = useState('');

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    onSubmit(answer);
  };

  return (
    <form onSubmit={handleSubmit}>
      <label className="block text-xl">{question}</label>
      <input
        type="text"
        className="input mt-2"
        value={answer}
        onChange={(e) => setAnswer(e.target.value)}
      />
      <button className="btn mt-4" type="submit">
        Submit Answer
      </button>
    </form>
  );
}

// lib/api.ts
export const getCourses = async () => {
  const response = await fetch('/api/courses');
  if (!response.ok) {
    throw new Error('Failed to fetch courses');
  }
  return response.json();
};

export const getCourseById = async (id: number) => {
  const response = await fetch(`/api/courses/${id}`);
  if (!response.ok) {
    throw new Error('Failed to fetch course');
  }
  return response.json();
};

export const submitQuiz = async (courseId: number, answers: any) => {
  const response = await fetch(`/api/courses/${courseId}/quiz`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ answers }),
  });
  if (!response.ok) {
    throw new Error('Failed to submit quiz');
  }
  return response.json();
};

// lib/auth.ts
export const login = async (email: string, password: string) => {
  const response = await fetch('/api/auth/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });
  if (!response.ok) {
    throw new Error('Login failed');
  }
  return response.json();
};

export const register = async (email: string, password: string) => {
  const response = await fetch('/api/auth/register', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });
  if (!response.ok) {
    throw new Error('Registration failed');
  }
  return response.json();
};

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

body {
  @apply bg-gray-100 text-gray-800;
}

input {
  @apply border rounded-lg p-2 w-full focus:outline-none focus:ring-2 focus:ring-blue-400;
}

.btn {
  @apply bg-blue-500 text-white px-4 py-2 rounded-lg hover:bg-blue-600;
}

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

public/
├── logo.png
└── favicon.ico

// utils/fetcher.ts
export const fetcher = async (url: string) => {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error('Failed to fetch data');
  }
  return response.json();
};

// utils/constants.ts
export const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000';

my-language-app-backend/
├── src/
│   ├── auth/
│   │   ├── dto/
│   │   │   ├── login.dto.ts
│   │   │   └── register.dto.ts
│   │   ├── auth.controller.ts
│   │   ├── auth.module.ts
│   │   ├── auth.service.ts
│   │   ├── jwt.strategy.ts
│   │   └── local.strategy.ts
│   ├── users/
│   │   ├── dto/
│   │   │   ├── create-user.dto.ts
│   │   │   ├── update-user.dto.ts
│   │   ├── entities/
│   │   │   └── user.entity.ts
│   │   ├── users.controller.ts
│   │   ├── users.module.ts
│   │   ├── users.service.ts

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

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

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

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

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

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

// src/auth/auth.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LoginDto } from './dto/login.dto';
import { RegisterDto } from './dto/register.dto';

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

  @Post('login')
  async login(@Body() loginDto: LoginDto) {
    return this.authService.login(loginDto);
  }

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

// 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';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET || 'defaultSecretKey',
      signOptions: { expiresIn: '1h' },
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, JwtStrategy, LocalStrategy],
})
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 { LoginDto } from './dto/login.dto';
import { RegisterDto } from './dto/register.dto';
import * as bcrypt from 'bcrypt';

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

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

  async login(loginDto: LoginDto) {
    const user = await this.validateUser(loginDto.email, loginDto.password);
    if (!user) {
      throw new UnauthorizedException('Invalid credentials');
    }
    const payload = { username: user.email, sub: user.id };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }

  async register(registerDto: RegisterDto) {
    const hashedPassword = bcrypt.hashSync(registerDto.password, 10);
    return this.usersService.create({
      ...registerDto,
      password: hashedPassword,
    });
  }
}

// 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: process.env.JWT_SECRET || 'defaultSecretKey',
    });
  }

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

// 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/users/dto/create-user.dto.ts
import { IsEmail, IsNotEmpty, IsString } from 'class-validator';

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

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

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

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

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

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

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

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

  @Column()
  password: string;
}

// src/users/users.controller.ts
import { Body, Controller, Get, Param, Patch, Post } 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: [Users

Controller],
  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) {
    const user = this.usersRepository.create(createUserDto);
    return this.usersRepository.save(user);
  }

  async findOne(id: number) {
    return this.usersRepository.findOne({ where: { id } });
  }

  async findByEmail(email: string) {
    return this.usersRepository.findOne({ where: { email } });
  }

  async update(id: number, updateUserDto: UpdateUserDto) {
    await this.usersRepository.update(id, updateUserDto);
    return this.usersRepository.findOne({ where: { id } });
  }
}

my-language-app-backend/
├── src/
│   ├── courses/
│   │   ├── dto/
│   │   │   ├── create-course.dto.ts
│   │   │   ├── update-course.dto.ts
│   │   ├── entities/
│   │   │   └── course.entity.ts
│   │   ├── courses.controller.ts
│   │   ├── courses.module.ts
│   │   ├── courses.service.ts
│   ├── lessons/
│   │   ├── dto/
│   │   │   ├── create-lesson.dto.ts
│   │   │   └── update-lesson.dto.ts
│   │   ├── entities/
│   │   │   └── lesson.entity.ts
│   │   ├── lessons.controller.ts
│   │   ├── lessons.module.ts
│   │   ├── lessons.service.ts

// src/courses/dto/create-course.dto.ts
import { IsString, IsNotEmpty } from 'class-validator';

export class CreateCourseDto {
  @IsString()
  @IsNotEmpty()
  title: string;

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

// src/courses/dto/update-course.dto.ts
import { IsOptional, IsString } from 'class-validator';

export class UpdateCourseDto {
  @IsString()
  @IsOptional()
  title?: string;

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

// src/courses/entities/course.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
import { Lesson } from '../../lessons/entities/lesson.entity';

@Entity()
export class Course {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  description: string;

  @OneToMany(() => Lesson, lesson => lesson.course, { cascade: true })
  lessons: Lesson[];
}

// src/courses/courses.controller.ts
import { Body, Controller, Get, Param, Post, Patch, Delete } from '@nestjs/common';
import { CoursesService } from './courses.service';
import { CreateCourseDto } from './dto/create-course.dto';
import { UpdateCourseDto } from './dto/update-course.dto';

@Controller('courses')
export class CoursesController {
  constructor(private readonly coursesService: CoursesService) {}

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

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

  @Post()
  create(@Body() createCourseDto: CreateCourseDto) {
    return this.coursesService.create(createCourseDto);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateCourseDto: UpdateCourseDto) {
    return this.coursesService.update(+id, updateCourseDto);
  }

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

// src/courses/courses.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { CoursesService } from './courses.service';
import { CoursesController } from './courses.controller';
import { Course } from './entities/course.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Course])],
  controllers: [CoursesController],
  providers: [CoursesService],
  exports: [CoursesService],
})
export class CoursesModule {}

// src/courses/courses.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Course } from './entities/course.entity';
import { CreateCourseDto } from './dto/create-course.dto';
import { UpdateCourseDto } from './dto/update-course.dto';

@Injectable()
export class CoursesService {
  constructor(
    @InjectRepository(Course)
    private coursesRepository: Repository<Course>,
  ) {}

  findAll() {
    return this.coursesRepository.find({ relations: ['lessons'] });
  }

  findOne(id: number) {
    return this.coursesRepository.findOne({
      where: { id },
      relations: ['lessons'],
    });
  }

  create(createCourseDto: CreateCourseDto) {
    const course = this.coursesRepository.create(createCourseDto);
    return this.coursesRepository.save(course);
  }

  async update(id: number, updateCourseDto: UpdateCourseDto) {
    await this.coursesRepository.update(id, updateCourseDto);
    return this.coursesRepository.findOne({ where: { id } });
  }

  remove(id: number) {
    return this.coursesRepository.delete(id);
  }
}

// src/lessons/dto/create-lesson.dto.ts
import { IsNotEmpty, IsString } from 'class-validator';

export class CreateLessonDto {
  @IsString()
  @IsNotEmpty()
  title: string;

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

// src/lessons/dto/update-lesson.dto.ts
import { IsOptional, IsString } from 'class-validator';

export class UpdateLessonDto {
  @IsString()
  @IsOptional()
  title?: string;

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

// src/lessons/entities/lesson.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
import { Course } from '../../courses/entities/course.entity';

@Entity()
export class Lesson {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column('text')
  content: string;

  @ManyToOne(() => Course, course => course.lessons, { onDelete: 'CASCADE' })
  course: Course;
}

// src/lessons/lessons.controller.ts
import { Body, Controller, Get, Param, Post, Patch, Delete } from '@nestjs/common';
import { LessonsService } from './lessons.service';
import { CreateLessonDto } from './dto/create-lesson.dto';
import { UpdateLessonDto } from './dto/update-lesson.dto';

@Controller('lessons')
export class LessonsController {
  constructor(private readonly lessonsService: LessonsService) {}

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

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

  @Post()
  create(@Body() createLessonDto: CreateLessonDto) {
    return this.lessonsService.create(createLessonDto);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateLessonDto: UpdateLessonDto) {
    return this.lessonsService.update(+id, updateLessonDto);
  }

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

// src/lessons/lessons.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { LessonsService } from './lessons.service';
import { LessonsController } from './lessons.controller';
import { Lesson } from './entities/lesson.entity';

@Module({
  imports: [TypeOrm

Module.forFeature([Lesson])],
  controllers: [LessonsController],
  providers: [LessonsService],
  exports: [LessonsService],
})
export class LessonsModule {}

// src/lessons/lessons.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Lesson } from './entities/lesson.entity';
import { CreateLessonDto } from './dto/create-lesson.dto';
import { UpdateLessonDto } from './dto/update-lesson.dto';

@Injectable()
export class LessonsService {
  constructor(
    @InjectRepository(Lesson)
    private lessonsRepository: Repository<Lesson>,
  ) {}

  findAll() {
    return this.lessonsRepository.find({ relations: ['course'] });
  }

  findOne(id: number) {
    return this.lessonsRepository.findOne({
      where: { id },
      relations: ['course'],
    });
  }

  create(createLessonDto: CreateLessonDto) {
    const lesson = this.lessonsRepository.create(createLessonDto);
    return this.lessonsRepository.save(lesson);
  }

  async update(id: number, updateLessonDto: UpdateLessonDto) {
    await this.lessonsRepository.update(id, updateLessonDto);
    return this.lessonsRepository.findOne({ where: { id } });
  }

  remove(id: number) {
    return this.lessonsRepository.delete(id);
  }
}

my-language-app-backend/
├── src/
│   ├── quizzes/
│   │   ├── dto/
│   │   │   ├── create-quiz.dto.ts
│   │   │   └── submit-quiz.dto.ts
│   │   ├── entities/
│   │   │   └── quiz.entity.ts
│   │   ├── quizzes.controller.ts
│   │   ├── quizzes.module.ts
│   │   ├── quizzes.service.ts
│   ├── common/
│   │   ├── decorators/
│   │   │   └── roles.decorator.ts
│   │   ├── guards/
│   │   │   ├── jwt-auth.guard.ts
│   │   │   └── roles.guard.ts
│   │   └── utils/
│   │       └── hash.util.ts
│   ├── config/
│   │   ├── app.config.ts
│   │   └── database.config.ts
│   ├── database/
│   │   ├── migrations/
│   │   └── typeorm.config.ts
│   ├── app.module.ts
│   ├── main.ts

// src/quizzes/dto/create-quiz.dto.ts
import { IsString, IsNotEmpty, IsArray, ValidateNested, IsNumber } from 'class-validator';
import { Type } from 'class-transformer';

class QuizQuestionDto {
  @IsString()
  @IsNotEmpty()
  question: string;

  @IsArray()
  @IsString({ each: true })
  options: string[];

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

export class CreateQuizDto {
  @IsString()
  @IsNotEmpty()
  title: string;

  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => QuizQuestionDto)
  questions: QuizQuestionDto[];
}

// src/quizzes/dto/submit-quiz.dto.ts
import { IsArray, IsString, IsNotEmpty } from 'class-validator';

export class SubmitQuizDto {
  @IsArray()
  @IsNotEmpty({ each: true })
  answers: string[];

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

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

@Entity()
export class Quiz {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column('json')
  questions: { question: string; options: string[]; correctAnswer: string }[];
}

// src/quizzes/quizzes.controller.ts
import { Body, Controller, Get, Param, Post } from '@nestjs/common';
import { QuizzesService } from './quizzes.service';
import { CreateQuizDto } from './dto/create-quiz.dto';
import { SubmitQuizDto } from './dto/submit-quiz.dto';

@Controller('quizzes')
export class QuizzesController {
  constructor(private readonly quizzesService: QuizzesService) {}

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

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

  @Post()
  create(@Body() createQuizDto: CreateQuizDto) {
    return this.quizzesService.create(createQuizDto);
  }

  @Post('submit')
  submit(@Body() submitQuizDto: SubmitQuizDto) {
    return this.quizzesService.submit(submitQuizDto);
  }
}

// src/quizzes/quizzes.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { QuizzesService } from './quizzes.service';
import { QuizzesController } from './quizzes.controller';
import { Quiz } from './entities/quiz.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Quiz])],
  controllers: [QuizzesController],
  providers: [QuizzesService],
})
export class QuizzesModule {}

// src/quizzes/quizzes.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Quiz } from './entities/quiz.entity';
import { CreateQuizDto } from './dto/create-quiz.dto';
import { SubmitQuizDto } from './dto/submit-quiz.dto';

@Injectable()
export class QuizzesService {
  constructor(
    @InjectRepository(Quiz)
    private quizzesRepository: Repository<Quiz>,
  ) {}

  findAll() {
    return this.quizzesRepository.find();
  }

  findOne(id: number) {
    return this.quizzesRepository.findOne({ where: { id } });
  }

  create(createQuizDto: CreateQuizDto) {
    const quiz = this.quizzesRepository.create(createQuizDto);
    return this.quizzesRepository.save(quiz);
  }

  submit(submitQuizDto: SubmitQuizDto) {
    // Here you'd implement the logic to evaluate the quiz and return a score
    // For now, we'll return a simple response
    return { message: 'Quiz submitted successfully', score: 80 };
  }
}

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

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

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

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

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

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

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);
    if (!requiredRoles) {
      return true;
    }
    const { user } = context.switchToHttp().getRequest();
    return requiredRoles.some((role) => user.roles?.includes(role));
  }
}

// src/common/utils/hash.util.ts
import * as bcrypt from 'bcrypt';

export const hashPassword = async (password: string): Promise<string> => {
  const salt = await bcrypt.genSalt();
  return bcrypt.hash(password, salt);
};

export const comparePassword = async (
  password: string,
  hash: string,
): Promise<boolean> => {
  return bcrypt.compare(password, hash);
};

// src/config/app.config.ts
export const APP_PORT = process.env.APP_PORT || 3000;
export const JWT_SECRET = process.env.JWT_SECRET || 'defaultSecretKey';

// src/config/database.config.ts
import { TypeOrmModuleOptions } from '@nestjs/typeorm';

export const databaseConfig: TypeOrmModuleOptions = {
  type:

 'postgres',
  host: process.env.DB_HOST || 'localhost',
  port: parseInt(process.env.DB_PORT, 10) || 5432,
  username: process.env.DB_USER || 'postgres',
  password: process.env.DB_PASSWORD || 'password',
  database: process.env.DB_NAME || 'language-learning',
  entities: [__dirname + '/../**/*.entity{.ts,.js}'],
  synchronize: true, // Disable in production
};