@nestjs/common#Controller TypeScript Examples

@Controller('api')
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
  @Get('token/:token')
  async getToken(
    @Param('token') ftToken: string,
    @Res({ passthrough: true }) res: Response,
  ) {
    const token = await this.appService.getToken(ftToken);
    res.cookie('w_auth', token);
  }
}

@Controller()
export class ApiController {
	constructor(private readonly consul: ConsulService<ConfigInterface>) {
	}

	async testConfig() {
		return this.consul.configs;
	}

	async setConfig(value: string) {
		return this.consul.set<ITest>('am-cli/test', {
			valueNum: 1,
			valuesString: value
		});
	}

	async getConfig() {
		return this.consul.get<ITest>('am-cli/test');
	}

	async deleteConfig() {
		return this.consul.delete('am-cli/test');
	}
}

@Controller()
/**
 * Generic NestJS app controller.
 */
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Post()
  /**
   * Handle data received as a mock Kinesis event.
   */
  handleData(@Body() data: OsDocumentData, @Query('print') print: string): Promise<OpenSearchBulkResult> {
    return this.appService.handleKinesisEvent(data, print === 'true');
  }
}

@Controller()
export class ApplicationController {
  constructor(private readonly appService: ApplicationService) {}

  @Get('/ping')
  ping(): string {
    return 'pong';
  }

  @Get('/users')
  async fetchAll(): Promise<User[]> {
    return this.appService.fetchAll();
  }
}

@Controller('')
@ApiTags('')
export class HealthController {
  constructor(private readonly appService: HealthService) {}

  @Get('/health')
  @ApiOperation({ description: 'health check' })
  healthCheck(@Res() res: Response) {
    const result: string = this.appService.sendOk();

    return res.status(HttpStatus.OK).send(result);
  }
}

@Controller()
export class StatusController {
  constructor(private readonly statusService: StatusService) {}

  @Get()
  getStatus(): string {
    return this.statusService.getStatus();
  }

  @Get('version')
  getVersion(): Dictionary<string> {
    return this.statusService.getVersion();
  }
}

@Controller()
export class AppController {
  constructor(private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('auth/login')
  async login(@Request() req: Express.Request) {
    return this.authService.login(req.user);
  }

  @Post('auth/register')
  async register(@Body() body: Partial<UserEntity>) {
    try {
      const salt = await genSalt(10);
      const { password, ...reset } = body;
      const u: Partial<UserEntity> = {
        salt,
        ...reset,
        password: hashSync(password, salt),
        role: Roles.user,
      };
      const user = await this.authService.register(u);
      const logedInUser = await this.authService.login(user);
      delete logedInUser.password;
      delete logedInUser.salt;
      return logedInUser;
    } catch (error) {
      throw error;
    }
  }
}

@Controller()
export default class AppController {
  constructor(private readonly appService: AppService) {}

  @ApiOkResponse({ description: 'Returns you Hello world!' })
  @Get()
  sayHello(): string {
    return this.appService.getHello();
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('/status')
  @ApiResponse({ status: 200, type: AppStatus })
  appStatus(): string {
    return this.appService.appStatus();
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(@Query('name') name = 'World'): Promise<string> {
    return this.appService.getHello(name);
  }
}

@Controller('health')
export class HealthController {
  constructor(
    private readonly eventStoreHealthIndicator: EventStoreHealthIndicator,
  ) {}

  @Get()
  @HealthCheck()
  public async healthCheck(): Promise<HealthIndicatorResult> {
    return this.eventStoreHealthIndicator.check();
  }
}

@Controller(routesV1.version)
export class CreateUserHttpController {
  constructor(private readonly commandBus: CommandBus) {}

  @Post(routesV1.user.root)
  @ApiOperation({ summary: 'Create a user' })
  @ApiResponse({
    status: HttpStatus.OK,
    type: IdResponse,
  })
  @ApiResponse({
    status: HttpStatus.CONFLICT,
    description: UserAlreadyExistsError.message,
  })
  @ApiResponse({
    status: HttpStatus.BAD_REQUEST,
  })
  async create(@Body() body: CreateUserRequest): Promise<IdResponse> {
    const command = new CreateUserCommand(body);

    const result: Result<
      ID,
      UserAlreadyExistsError
    > = await this.commandBus.execute(command);

    // Deciding what to do with a Result (similar to Rust matching)
    // if Ok we return a response with an id
    // if Error decide what to do with it depending on its type
    return match(result, {
      Ok: id => new IdResponse(id.value),
      Err: error => {
        if (error instanceof UserAlreadyExistsError)
          throw new ConflictException(error.message);
        throw error;
      },
    });
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  public getHello(): string {
    return this.appService.getHello();
  }

  @Post()
  public postHello(@Body() testBody: Hello): string {
    return testBody.hello;
  }
}

/**
 * Base controller backend-api app
 */
@Controller()
export class AppController {
  /**
   * Return welcome string
   */
  @Get()
  getData() {
    return {message: 'Welcome to backend/api!'}
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getData() {
    return this.appService.getData();
  }
}

@Controller()
export class DataStoreController {
  constructor(private readonly service: DataStoreService) {}

  @Get('wizard')
  async getWizard(@Query('id') id: string): Promise<Wizard> {
    return await this.service.getWizard(id);
  }
}

@Controller()
@ApiTags('app')
export class AppController {
  constructor(
    private readonly appService: AppService,
    private readonly appServiceV2: PurseSavingService,
    /**
     * This is deprecated in typeorm for now,
     * but the DataSource object still not injectable in Nest.js,
     * because of that we should use deprecated [Connection] until [DataSource]
     * will be injectable
     */
    private readonly connection: Connection,
  ) {
  }

  @Post('transfer')
  @ApiResponse({
    type: TransferOperationResultDto,
  })
  async makeRemittanceWithTransaction(@Body() remittanceDto: TransferParamsDTO) {
    return this.connection.transaction(manager => {
      return this.appService.withTransaction(manager)/* <-- this is interesting new thing */.makeTransfer(remittanceDto.userIdFrom, remittanceDto.userIdTo, remittanceDto.sum, remittanceDto.withError);
    });
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Post('/file')
  @UseInterceptors(
    FileInterceptor('file', {
      storage: diskStorage({
        destination: './uploads',
        filename: (req, file, callback) => {
          const uniqueSuffix =
            Date.now() + '-' + Math.round(Math.random() * 1e9);
          const ext = extname(file.originalname);
          const filename = `${uniqueSuffix}${ext}`;
          callback(null, filename);
        },
      }),
    }),
  )
  handleUpload(@UploadedFile() file: Express.Multer.File) {
    console.log('file', file);
    return 'File upload API';
  }
}

@Controller('/')
export class AuthController {
  private host: string;
  constructor(
    private readonly authService: AuthService,
    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger
  ) {
    this.host = process.env.CLIENT_HOST || 'http://localhost:3001';
  }

  @UseInterceptors(MorganInterceptor('combined'))
  @Get('/github')
  @UseGuards(AuthGuard('github'))
  async github() {
    return;
  }

  @UseInterceptors(MorganInterceptor('combined'))
  @UseFilters(GithubAuthExceptionFilter)
  @Get('/github/callback')
  @UseGuards(AuthGuard('github'))
  async githubCallback(@Req() request: Request, @Res() response: Response) {
    const user: AuthUser = request.user as AuthUser;
    this.logger.log({
      level: 'info',
      message: `receive login callback from github account_id=${user.account.id}`
    });
    const token = await this.authService.prepareToken(user);
    response.redirect(301, `${this.host}?token=${token}`);
  }
}

@Controller("events/l")
export class TodoListEventsController {
  constructor(
    @Inject(AUTHENTICATOR)
    private readonly authenticator: Authenticator,
    private readonly todoListEvents: TodoListEventsConsumer
  ) {}

  @Sse("/:todoListId")
  async getEvents(@Param("todoListId") todoListId: string) {
    const currentUser = await this.authenticator.currentUser();
    const heartbeat$ = interval(30_000).pipe(
      map(() => ({ type: "heartbeat", data: "_" }))
    );

    const updates$ = this.todoListEvents.events.pipe(
      filter(
        (event) =>
          event.todoListId === todoListId &&
          event.sessionId !== currentUser.sessionId
      ),
      map((event) => ({ type: "update", data: event.type } as MessageEvent))
    );

    return merge(heartbeat$, updates$);
  }
}

@Controller('')
export class AppController {
  private readonly logger = new Logger(AppController.name);

  @ApiExcludeEndpoint()
  @Get()
  @Redirect('/api/docs')
  getDocs() {
    this.logger.log('Redirecting to /api/docs');
  }
}

@Controller()
export class UserQueriesController {
  constructor(private readonly userQueriesService: UserQueriesService) {}

  @GrpcMethod('IdentityService', 'getUsers')
  getProducts({ pager, order, filters }) {
    return this.userQueriesService.getUsers(pager, order, filters)
  }
}

@Controller()
export class UsersController {
  constructor(@Inject('UsersService') private readonly usersService: UsersService, private readonly logger: PinoLogger) {
    logger.setContext(UsersController.name)
  }

  @GrpcMethod('UsersService', 'findAll')
  async findAll(query: Query): Promise<UserServiceQueryResult> {
    this.logger.info('UsersController#findAll.call', query)

    const result: Array<User> = await this.usersService.findAll({
      attributes: !isEmpty(query.attributes) ? query.attributes : undefined,
      where: !isEmpty(query.where) ? JSON.parse(query.where) : undefined,
      order: !isEmpty(query.order) ? JSON.parse(query.order) : undefined,
      offset: query.offset ? query.offset : 0,
      limit: query.limit ? query.limit : 25
    })

    this.logger.info('UsersController#findAll.result', result)

    return { data: result }
  }

  @GrpcMethod('UsersService', 'count')
  async count(query: Query): Promise<Count> {
    this.logger.info('UsersController#count.call', query)

    const count: number = await this.usersService.count({
      where: !isEmpty(query.where) ? JSON.parse(query.where) : undefined
    })

    this.logger.info('UsersController#count.result', count)

    return { count }
  }
}

@Controller('test')
export class TestController {
    @Recaptcha()
    submit(): void {}

    @Recaptcha({response: req => req.body.customRecaptchaField})
    submitOverridden(): void {}

    @SetRecaptchaOptions({action: 'TestOptions', score: 0.5})
    @UseGuards(GoogleRecaptchaGuard)
    submitWithSetRecaptchaOptionsDecorator(): void {}
}

@Controller()
@ApiTags("Health-Check")
export class AppController {
  constructor(private readonly appService: AppService) { }

  @Get()
  getHello(): string {
    return this.appService.getWelcome();
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getStatus(): { status: number; body: string } {
    return this.appService.getStatus()
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  @ExceptTracing()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('error')
  getError(@Tracing() tracing: TracingData): never {
    Logger.log({ getError: tracing });
    throw new NotImplementedException();
  }

  @Get('sum')
  execute(): Observable<number> {
    return this.appService.execute();
  }

  @UseInterceptors(TracingInterceptor)
  @MessagePattern({ cmd: 'echoMessage' })
  echoMessage(
    @Tracing() tracing: TracingData,
    @Payload() message: string,
  ): string {
    Logger.log({ echoMessage: tracing });
    return message;
  }
}

@Controller()
export class AppController {
  @Get('version')
  reportVersion() {
    return { version: process.env.npm_package_version };
  }

  @Get()
  home() {
    return { status: 'ok' };
  }
}