NestJS
Cheatsheet

src/
  main.ts                     bootstrap
  setup.ts                    prefix, versioning, Swagger
  app.module.ts               root module, global enhancers
  config/                     env.schema.ts, app.config.ts
  auth/                       module, controller, service, guard
  tasks/                      module, controller, service, model
    dto/                      create, update, list query
  common/                     decorators, filters, guards,
                              interceptors, middleware, pipes
  database/                   TypeORM entity, module, repository
test/                         unit and e2e specs

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module.js';
import { configureApp } from './setup.js';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  configureApp(app);
  app.enableShutdownHooks();             // call onApplicationShutdown on SIGTERM and SIGINT
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

import { Module } from '@nestjs/common';
import { TasksController } from './tasks.controller.js';
import { TasksService } from './tasks.service.js';
import { clockProvider, TASKS_LIMIT } from '../common/clock.provider.js';

@Module({
  controllers: [TasksController],
  providers: [
    TasksService,                                // shorthand for { provide: TasksService, useClass: TasksService }
    clockProvider,                               // useFactory behind a Symbol token
    { provide: TASKS_LIMIT, useValue: 100 },     // useValue behind a string token
  ],
  exports: [TasksService],                       // modules that import TasksModule can inject it
})
export class TasksModule {}

import { MiddlewareConsumer, Module, NestModule, ValidationPipe } from '@nestjs/common';
import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
import { ConfigModule } from '@nestjs/config';
import { appConfig } from './config/app.config.js';
import { envSchema } from './config/env.schema.js';
import { AuthModule } from './auth/auth.module.js';
import { TasksModule } from './tasks/tasks.module.js';
import { AuthGuard } from './auth/auth.guard.js';
import { RolesGuard } from './common/guards/roles.guard.js';
import { HttpErrorFilter } from './common/filters/http-error.filter.js';
import { LoggingInterceptor } from './common/interceptors/logging.interceptor.js';
import { RequestIdMiddleware } from './common/middleware/request-id.middleware.js';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true, load: [appConfig], validationSchema: envSchema }),
    AuthModule,
    TasksModule,
  ],
  providers: [
    // Global enhancers registered as providers, so they can inject dependencies
    { provide: APP_PIPE, useValue: new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }) },
    { provide: APP_GUARD, useClass: AuthGuard },
    { provide: APP_GUARD, useClass: RolesGuard },
    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
    { provide: APP_FILTER, useClass: HttpErrorFilter },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(RequestIdMiddleware).forRoutes('*path');
  }
}

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import type { ConfigType } from '@nestjs/config';
import { appConfig } from '../config/app.config.js';
import { AuthController } from './auth.controller.js';
import { AuthService } from './auth.service.js';

@Module({
  imports: [
    // A dynamic module, configured from another provider at startup
    JwtModule.registerAsync({
      global: true,
      inject: [appConfig.KEY],
      useFactory: (app: ConfigType<typeof appConfig>) => ({
        secret: app.jwtSecret,
        signOptions: { expiresIn: '15m' },
      }),
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService],
})
export class AuthModule {}

import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Patch, Post, Query, StandardSchemaValidationPipe, UseInterceptors } from '@nestjs/common';
import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
import { TasksService } from './tasks.service.js';
import { CreateTaskDto } from './dto/create-task.dto.js';
import { UpdateTaskDto } from './dto/update-task.dto.js';
import { listTasksQuery, type ListTasksQuery } from './dto/list-tasks.query.js';
import { ParseIdPipe } from '../common/pipes/parse-id.pipe.js';
import { CurrentUser } from '../common/decorators/current-user.decorator.js';
import { AdminOnly } from '../common/decorators/roles.decorator.js';
import { EnvelopeInterceptor } from '../common/interceptors/envelope.interceptor.js';

@ApiTags('tasks')
@ApiBearerAuth()
@UseInterceptors(EnvelopeInterceptor)
@Controller({ path: 'tasks', version: '1' })          // /api/v1/tasks
export class TasksController {
  constructor(private readonly tasks: TasksService) {}  // injected by its type

  @Get()                                                // GET /api/v1/tasks?status=open&page=1
  findAll(@Query({ schema: listTasksQuery, pipes: [StandardSchemaValidationPipe] }) query: ListTasksQuery) {
    return this.tasks.findAll(query);
  }

  @Get(':id')                                           // GET /api/v1/tasks/1
  findOne(@Param('id', ParseIdPipe) id: number) {
    return this.tasks.findOne(id);
  }

  @Post()                                               // POST /api/v1/tasks, 201 by default
  create(@Body() dto: CreateTaskDto, @CurrentUser('sub') userId: string) {
    return this.tasks.create(dto, userId);
  }

  @Patch(':id')
  update(@Param('id', ParseIdPipe) id: number, @Body() dto: UpdateTaskDto) {
    return this.tasks.update(id, dto);
  }

  @Delete(':id')
  @AdminOnly()
  @HttpCode(HttpStatus.NO_CONTENT)                      // 204 with an empty body
  remove(@Param('id', ParseIdPipe) id: number) {
    this.tasks.remove(id);
  }
}

import { Provider } from '@nestjs/common';

// Tokens for things that are not classes
export const CLOCK = Symbol('CLOCK');
export const TASKS_LIMIT = 'TASKS_LIMIT';

export interface Clock {
  now(): string;
}

// useFactory: build the value with code, optionally injecting other providers
export const clockProvider: Provider = {
  provide: CLOCK,
  useFactory: (): Clock => ({ now: () => new Date().toISOString() }),
};

import { ConflictException, Inject, Injectable, Logger, NotFoundException, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
import type { ConfigType } from '@nestjs/config';
import { appConfig } from '../config/app.config.js';
import { CLOCK, TASKS_LIMIT, type Clock } from '../common/clock.provider.js';
import { CreateTaskDto } from './dto/create-task.dto.js';
import { UpdateTaskDto } from './dto/update-task.dto.js';
import type { ListTasksQuery } from './dto/list-tasks.query.js';
import { Task, TaskStatus } from './task.model.js';

@Injectable()
export class TasksService implements OnModuleInit, OnApplicationShutdown {
  private readonly logger = new Logger(TasksService.name);
  private tasks: Task[] = [];
  private nextId = 1;

  constructor(
    @Inject(appConfig.KEY) private readonly config: ConfigType<typeof appConfig>,
    @Inject(CLOCK) private readonly clock: Clock,
    @Inject(TASKS_LIMIT) private readonly limit: number,
  ) {}

  onModuleInit() {
    this.create({ title: 'Read the NestJS docs' }, 'u_1');
    this.logger.log(`Seeded ${this.tasks.length} task, limit ${this.limit}`);
  }

  onApplicationShutdown(signal?: string) {
    this.logger.log(`Shutting down on ${signal}, tasks in memory: ${this.tasks.length}`);
  }

  findAll({ status, page }: ListTasksQuery) {
    const size = this.config.pageSize;
    const rows = this.tasks.filter((t) => !status || t.status === status);
    return { page, total: rows.length, items: rows.slice((page - 1) * size, page * size) };
  }

  findOne(id: number): Task {
    const task = this.tasks.find((t) => t.id === id);
    if (!task) throw new NotFoundException(`Task ${id} not found`);
    return task;
  }

  create(dto: CreateTaskDto, ownerId: string): Task {
    if (this.tasks.length >= this.limit) throw new ConflictException('Task limit reached');
    const task: Task = {
      id: this.nextId++,
      title: dto.title,
      status: dto.status ?? TaskStatus.Open,
      priority: dto.priority ?? 3,
      ownerId,
      createdAt: this.clock.now(),
    };
    this.tasks.push(task);
    return task;
  }

  update(id: number, dto: UpdateTaskDto): Task {
    return Object.assign(this.findOne(id), dto);
  }

  remove(id: number): void {
    this.findOne(id);
    this.tasks = this.tasks.filter((t) => t.id !== id);
  }
}

import { ApiProperty } from '@nestjs/swagger';
import { IsEnum, IsInt, IsOptional, IsString, Length, Max, Min } from 'class-validator';
import { TaskStatus } from '../task.model.js';

export class CreateTaskDto {
  @ApiProperty({ example: 'Write the NestJS cheatsheet' })
  @IsString()
  @Length(3, 80)
  title!: string;

  @ApiProperty({ enum: TaskStatus, required: false })
  @IsOptional()
  @IsEnum(TaskStatus)
  status?: TaskStatus;

  @ApiProperty({ minimum: 1, maximum: 5, default: 3, required: false })
  @IsOptional()
  @IsInt()
  @Min(1)
  @Max(5)
  priority?: number;
}

import { PartialType, OmitType } from '@nestjs/swagger';
import { CreateTaskDto } from './create-task.dto.js';

// Every field optional, validators and docs copied from CreateTaskDto
export class UpdateTaskDto extends PartialType(CreateTaskDto) {}

// Mapped types compose: everything except title, all optional
export class UpdateStatusDto extends PartialType(OmitType(CreateTaskDto, ['title'] as const)) {}

import { z } from 'zod';

// Nest 12: a Standard Schema can validate a parameter directly
export const listTasksQuery = z.object({
  status: z.enum(['open', 'in_progress', 'done']).optional(),
  page: z.coerce.number().int().min(1).default(1),
});

export type ListTasksQuery = z.infer<typeof listTasksQuery>;

import { ArgumentMetadata, BadRequestException, Injectable, PipeTransform } from '@nestjs/common';

// A pipe transforms or rejects one argument before the handler runs
@Injectable()
export class ParseIdPipe implements PipeTransform<unknown, number> {
  transform(value: unknown, meta: ArgumentMetadata): number {
    const id = Number(value);
    if (!Number.isInteger(id) || id < 1) {
      throw new BadRequestException(`${meta.data} must be a positive integer`);
    }
    return id;
  }
}

import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus, Logger } from '@nestjs/common';
import type { Request, Response } from 'express';

// @Catch() with no arguments catches everything
@Catch()
export class HttpErrorFilter implements ExceptionFilter {
  private readonly logger = new Logger(HttpErrorFilter.name);

  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const req = ctx.getRequest<Request>();
    const res = ctx.getResponse<Response>();

    const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
    const body = exception instanceof HttpException ? exception.getResponse() : 'Internal server error';
    const message = typeof body === 'string' ? body : (body as { message: string | string[] }).message;

    if (status >= 500) this.logger.error(exception);
    res.status(status).json({ statusCode: status, message, path: req.url, requestId: req.headers['x-request-id'] });
  }
}

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Role } from '../common/decorators/roles.decorator.js';

export interface JwtUser {
  sub: string;
  email: string;
  role: Role;
}

// Demo users; a real app reads them from the database with hashed passwords
const USERS = [
  { sub: 'u_1', email: 'shree@example.com', password: 'secret', role: Role.Admin },
  { sub: 'u_2', email: 'ana@example.com', password: 'secret', role: Role.User },
];

@Injectable()
export class AuthService {
  constructor(private readonly jwt: JwtService) {}

  async login(email: string, password: string) {
    const user = USERS.find((u) => u.email === email && u.password === password);
    if (!user) throw new UnauthorizedException('Invalid credentials');
    const payload: JwtUser = { sub: user.sub, email: user.email, role: user.role };
    return { accessToken: await this.jwt.signAsync(payload) };
  }
}

import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';
import { IS_PUBLIC } from '../common/decorators/public.decorator.js';
import type { JwtUser } from './auth.service.js';

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly jwt: JwtService, private readonly reflector: Reflector) {}

  async canActivate(ctx: ExecutionContext): Promise<boolean> {
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC, [ctx.getHandler(), ctx.getClass()]);
    if (isPublic) return true;

    const req = ctx.switchToHttp().getRequest();
    const [scheme, token] = (req.headers.authorization ?? '').split(' ');
    if (scheme !== 'Bearer' || !token) throw new UnauthorizedException('Missing bearer token');

    try {
      req.user = await this.jwt.verifyAsync<JwtUser>(token);   // later steps read request.user
      return true;
    } catch {
      throw new UnauthorizedException('Invalid or expired token');
    }
  }
}

import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Roles } from '../decorators/roles.decorator.js';
import type { JwtUser } from '../../auth/auth.service.js';

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

  canActivate(ctx: ExecutionContext): boolean {
    // The handler's metadata wins, then the controller's
    const required = this.reflector.getAllAndOverride(Roles, [ctx.getHandler(), ctx.getClass()]);
    if (!required?.length) return true;

    const user: JwtUser | undefined = ctx.switchToHttp().getRequest().user;
    if (user && required.includes(user.role)) return true;
    throw new ForbiddenException(`Requires role: ${required.join(', ')}`);
  }
}

import { CallHandler, ExecutionContext, Injectable, Logger, NestInterceptor } from '@nestjs/common';
import { Observable, tap } from 'rxjs';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  private readonly logger = new Logger('HTTP');

  intercept(ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
    const { method, url } = ctx.switchToHttp().getRequest();
    const started = Date.now();
    // Code before next.handle() runs before the handler; tap() runs after it
    return next.handle().pipe(
      tap(() => this.logger.log(`${method} ${url} ${Date.now() - started}ms`)),
    );
  }
}

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { map, Observable, timeout } from 'rxjs';

export interface Envelope<T> {
  data: T;
  meta: { requestId: string | undefined };
}

// Reshape every successful response, and fail handlers slower than 5 seconds
@Injectable()
export class EnvelopeInterceptor<T> implements NestInterceptor<T, Envelope<T>> {
  intercept(ctx: ExecutionContext, next: CallHandler<T>): Observable<Envelope<T>> {
    const requestId = ctx.switchToHttp().getRequest().headers['x-request-id'];
    return next.handle().pipe(
      timeout(5000),
      map((data) => ({ data, meta: { requestId } })),
    );
  }
}

import { Injectable, NestMiddleware } from '@nestjs/common';
import type { NextFunction, Request, Response } from 'express';
import { randomUUID } from 'node:crypto';

// Middleware runs first, before guards, with the raw request and response
@Injectable()
export class RequestIdMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const id = (req.headers['x-request-id'] as string | undefined) ?? randomUUID().slice(0, 8);
    req.headers['x-request-id'] = id;
    res.setHeader('x-request-id', id);
    next();
  }
}

export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(RequestIdMiddleware).forRoutes('*path');
  }
}

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import type { JwtUser } from '../../auth/auth.service.js';

// @CurrentUser() gives the whole user, @CurrentUser('sub') one field
export const CurrentUser = createParamDecorator(
  (field: keyof JwtUser | undefined, ctx: ExecutionContext) => {
    const user: JwtUser = ctx.switchToHttp().getRequest().user;
    return field ? user[field] : user;
  },
);

import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC = 'isPublic';
export const Public = () => SetMetadata(IS_PUBLIC, true);

import { applyDecorators } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { ApiBearerAuth, ApiForbiddenResponse } from '@nestjs/swagger';

export enum Role {
  User = 'user',
  Admin = 'admin',
}

// A typed metadata decorator: @Roles([Role.Admin])
export const Roles = Reflector.createDecorator<Role[]>();

// applyDecorators bundles several decorators into one
export function AdminOnly() {
  return applyDecorators(Roles([Role.Admin]), ApiBearerAuth(), ApiForbiddenResponse({ description: 'Admins only' }));
}

import { z } from 'zod';

// Any Standard Schema library works here: Zod, Valibot, ArkType
export const envSchema = z.object({
  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
  PORT: z.coerce.number().int().default(3000),
  JWT_SECRET: z.string().min(16, 'JWT_SECRET must be at least 16 characters'),
  PAGE_SIZE: z.coerce.number().int().min(1).max(100).default(20),
});

import { registerAs } from '@nestjs/config';

// A namespaced, typed slice of config: inject it with @Inject(appConfig.KEY)
export const appConfig = registerAs('app', () => ({
  name: 'tasks-api',
  jwtSecret: process.env.JWT_SECRET!,
  pageSize: Number(process.env.PAGE_SIZE ?? 20),
}));

import { Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
import { TaskStatus } from '../tasks/task.model.js';

@Entity('tasks')
export class TaskEntity {
  @PrimaryGeneratedColumn()
  id!: number;

  @Column({ length: 80 })
  title!: string;

  @Index()
  @Column({ type: 'enum', enum: TaskStatus, default: TaskStatus.Open })
  status!: TaskStatus;

  @Column({ default: 3 })
  priority!: number;

  @Column()
  ownerId!: string;

  @CreateDateColumn()
  createdAt!: Date;
}

import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TaskEntity } from './task.entity.js';
import { TasksRepository } from './tasks.repository.js';

@Module({
  imports: [
    // forRootAsync: read the connection settings from config at startup
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'postgres',
        url: config.getOrThrow<string>('DATABASE_URL'),
        autoLoadEntities: true,     // pick up every entity registered with forFeature
        synchronize: false,         // use migrations in every shared environment
      }),
    }),
    TypeOrmModule.forFeature([TaskEntity]),   // makes Repository<TaskEntity> injectable here
  ],
  providers: [TasksRepository],
  exports: [TasksRepository],
})
export class DatabaseModule {}

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { DataSource, Repository } from 'typeorm';
import { TaskEntity } from './task.entity.js';
import { TaskStatus } from '../tasks/task.model.js';

@Injectable()
export class TasksRepository {
  constructor(
    @InjectRepository(TaskEntity) private readonly repo: Repository<TaskEntity>,
    private readonly dataSource: DataSource,
  ) {}

  async page(status: TaskStatus | undefined, page: number, size: number) {
    const [items, total] = await this.repo.findAndCount({
      where: status ? { status } : {},
      order: { createdAt: 'DESC' },
      skip: (page - 1) * size,
      take: size,
    });
    return { page, total, items };
  }

  create(data: Pick<TaskEntity, 'title' | 'ownerId'>) {
    return this.repo.save(this.repo.create(data));
  }

  // Both writes commit together or not at all
  async moveAll(fromOwner: string, toOwner: string) {
    return this.dataSource.transaction(async (manager) => {
      const result = await manager.update(TaskEntity, { ownerId: fromOwner }, { ownerId: toOwner });
      await manager.query('INSERT INTO audit_log (action) VALUES ($1)', [`move ${fromOwner} to ${toOwner}`]);
      return result.affected ?? 0;
    });
  }
}

onModuleInit() {
  this.create({ title: 'Read the NestJS docs' }, 'u_1');
  this.logger.log(`Seeded ${this.tasks.length} task, limit ${this.limit}`);
}

onApplicationShutdown(signal?: string) {
  this.logger.log(`Shutting down on ${signal}, tasks in memory: ${this.tasks.length}`);
}

import { INestApplication, VersioningType } from '@nestjs/common';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

// Shared by main.ts and the e2e tests, so both run the same app
export function configureApp(app: INestApplication) {
  app.setGlobalPrefix('api');                              // every route starts with /api
  app.enableVersioning({ type: VersioningType.URI });      // /api/v1/...
  app.enableCors();

  const config = new DocumentBuilder().setTitle('Tasks API').setVersion('1.0').addBearerAuth().build();
  SwaggerModule.setup('docs', app, () => SwaggerModule.createDocument(app, config));
  return app;
}

import { beforeEach, describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { NotFoundException } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { TasksService } from '../src/tasks/tasks.service.js';
import { appConfig } from '../src/config/app.config.js';
import { CLOCK, TASKS_LIMIT } from '../src/common/clock.provider.js';

describe('TasksService', () => {
  let service: TasksService;

  beforeEach(async () => {
    // A small module with only what the service needs, every dependency faked
    const moduleRef = await Test.createTestingModule({
      providers: [
        TasksService,
        { provide: appConfig.KEY, useValue: { pageSize: 2 } },
        { provide: CLOCK, useValue: { now: () => '2026-01-01T00:00:00.000Z' } },
        { provide: TASKS_LIMIT, useValue: 3 },
      ],
    }).compile();
    service = moduleRef.get(TasksService);
  });

  it('creates a task with default status and priority', () => {
    const task = service.create({ title: 'Ship it' }, 'u_1');
    assert.deepEqual(task, {
      id: 1, title: 'Ship it', status: 'open', priority: 3, ownerId: 'u_1', createdAt: '2026-01-01T00:00:00.000Z',
    });
  });

  it('throws NotFoundException for a missing id', () => {
    assert.throws(() => service.findOne(42), NotFoundException);
  });

  it('pages with the configured page size', () => {
    ['a', 'b', 'c'].forEach((title) => service.create({ title }, 'u_1'));
    assert.equal(service.findAll({ page: 1 }).items.length, 2);
    assert.equal(service.findAll({ page: 2 }).items.length, 1);
  });
});

import { after, before, describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { INestApplication } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { AppModule } from '../src/app.module.js';
import { configureApp } from '../src/setup.js';
import { CLOCK } from '../src/common/clock.provider.js';

describe('Tasks API (e2e)', () => {
  let app: INestApplication;
  let token: string;

  before(async () => {
    const moduleRef = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(CLOCK)                       // swap one provider, keep the rest real
      .useValue({ now: () => '2026-01-01T00:00:00.000Z' })
      .compile();
    app = configureApp(moduleRef.createNestApplication({ logger: false }));
    await app.init();

    const res = await request(app.getHttpServer())
      .post('/api/v1/auth/login')
      .send({ email: 'shree@example.com', password: 'secret' });
    token = res.body.accessToken;
  });

  after(() => app.close());

  it('rejects requests without a token', async () => {
    await request(app.getHttpServer()).get('/api/v1/tasks').expect(401);
  });

  it('creates a task', async () => {
    const res = await request(app.getHttpServer())
      .post('/api/v1/tasks')
      .auth(token, { type: 'bearer' })
      .send({ title: 'From the e2e test', priority: 5 })
      .expect(201);
    assert.equal(res.body.data.createdAt, '2026-01-01T00:00:00.000Z');
  });

  it('validates the body', async () => {
    const res = await request(app.getHttpServer())
      .post('/api/v1/tasks')
      .auth(token, { type: 'bearer' })
      .send({ title: 'x' })
      .expect(400);
    assert.deepEqual(res.body.message, ['title must be longer than or equal to 3 characters']);
  });
});

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "skipLibCheck": true,
    "rootDir": ".",
    "outDir": "dist",
    "sourceMap": true
  },
  "include": ["src", "test"]
}