@Get('/v2/:key')
@HttpCode(HttpStatus.OK)
async getContentFromCacheByKey(
  @Param('key') key: string,
): Promise<GenericRedisResponse> {
  const result = await this.cacheService.get(key);
  if (!result) {
    throw new NotFoundException(`There is no key ${key} in cache`);
  }
  return result;
}

@Post('/v2/:key')
@HttpCode(HttpStatus.NO_CONTENT)
async getContentFromCacheByKey(
  @Param('key') key: string,
  @Body() body: GenericRedisBody,
): Promise<void> {
    await this.cacheService.set(key, body.data, body.ex, body.validFor);
}

// pages/api/user.ts
class User {
  // GET /api/user
  @Get()
  async fetchUser(@Query('id') id: string) {
    const user = await DB.findUserById(id);
    if (!user) {
      throw new NotFoundException('User not found.');
    }
    return user;
  }
  // POST /api/user
  @Post()
  @HttpCode(201)
  async createUser(@Body(ValidationPipe) body: CreateUserDto) {
    return await DB.createUser(body.email);
  }
}
export default createHandler(User);

export default async (req: NextApiRequest, res: NextApiResponse) => {
  if (req.method === 'GET') {
    const user = await DB.findUserById(req.query.id);
    if (!user) {
      return res.status(404).json({
        statusCode: 404,
        message: 'User not found'
      })
    }
    return res.json(user);
  } else if (req.method === 'POST') {
    // Very primitive e-mail address validation.
    if (!req.body.email || (req.body.email && !req.body.email.includes('@'))) {
      return res.status(400).json({
        statusCode: 400,
        message: 'Invalid e-mail address.'
      })
    }
    const user = await DB.createUser(req.body.email);
    return res.status(201).json(user);
  }
  res.status(404).json({
    statusCode: 404,
    message: 'Not Found'
  });
}

@SetHeader('Content-Type', 'text/plain')
class UserHandler {
  @Get()
  users(@Header('Referer') referer: string) {
    return `Your referer is ${referer}`;
  }
  @Get('/json')
  @SetHeader('Content-Type', 'application/json')
  users(@Header('Referer') referer: string) {
    return { referer };
  }
}

import { IsNotEmpty, IsEmail } from 'class-validator';
export class CreateUserDTO {
  @IsEmail()
  email: string;
  @IsNotEmpty()
  fullName: string;
}

@Get('/users')
@Query('isActive', ParseBooleanPipe({ nullable: true })) isActive?: boolean

@Get('/users/:userId')
@Param('userId', ParseNumberPipe) userId: string,

const JwtAuthGuard = createMiddlewareDecorator(
  (req: NextApiRequest, res: NextApiResponse, next: NextFunction) => {
    if (!validateJwt(req)) {
      throw new UnauthorizedException();
      // или
      return next(new UnauthorizedException());
    }
    next();
  }
);
class SecureHandler {
  @Get()
  @JwtAuthGuard() // здесь используется объявленный ранее обработчик
  public securedData(): string {
    return 'Secret data';
  }
}

@UseMiddleware(() => ...)
class User {
// ...

import { Catch } from '@storyofams/next-api-decorators';
function exceptionHandler(
  error: unknown,
  req: NextApiRequest,
  res: NextApiResponse
) {
  const message = error instanceof Error ? error.message : 'An unknown error occurred.';
  res.status(200).json({ success: false, error: message });
}
@Catch(exceptionHandler)
class Events {
  @Get()
  public events() {
    return 'Our events';
  }
}