Why are the controller and service in separate files?

NestJS follows a layered design: controllers handle HTTP routing and the service holds business logic. Splitting them keeps the controller thin and lets you unit-test the service without spinning up the HTTP layer.

How does dependency injection work here?

The service is marked @Injectable and listed in the module's providers, and the controller receives it through its constructor. Nest's IoC container resolves and injects that single instance wherever it is requested.

What do the @Controller and @Get decorators do?

@Controller('users') sets the base route path, and method decorators like @Get(':id') or @Post() map HTTP verbs and sub-paths to handler methods. Nest reads these decorators to build the routing table at startup.

Why list the controller and provider in the module?

A module's controllers array tells Nest which request handlers to mount, and the providers array registers injectables. Without both, the routes would not be served and the service could not be injected.

Does this replace nest generate resource?

It produces the same shape as the Nest CLI's scaffolding for quick reference or environments without the CLI. For a full project you may still prefer nest g resource, which can also generate DTOs and entities.

NestJS Module Stub Builder

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

A wired-up NestJS feature module

A NestJS feature is three files that fit together: a service marked @Injectable, a controller that injects it and exposes routes, and a module that registers both. Writing the decorators, the constructor injection, and the CRUD handlers by hand is repetitive. This builder generates all three, correctly wired, from one resource name.

How it works

The tool derives class and path names from your resource (e.g. user → UsersController, UsersService, base path users). It emits three fenced blocks. The service is an @Injectable() class with findAll, findOne, create, update, and remove methods over an in-memory array as a placeholder. The controller is decorated @Controller('users'), injects the service via constructor(private readonly service: UsersService) {}, and maps @Get(), @Get(':id'), @Post(), @Patch(':id'), and @Delete(':id') to the service methods. The module is an @Module({ controllers: [...], providers: [...], exports: [...] }) that ties them together so it can be imported elsewhere.

Tips and example

Replace the in-memory array in the service with a repository (Prisma/TypeORM) injected the same way.
Add DTO classes plus a ValidationPipe so @Body() payloads are validated.
Export the service from the module if another module needs to inject it.

import { Module } from "@nestjs/common";
import { UsersController } from "./users.controller";
import { UsersService } from "./users.service";

@Module({
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}