Project Structure

As an application grows, each feature gets its own module. nest g resource creates the controller, service, module, DTOs and entity in one go, and for a REST API it also scaffolds CRUD endpoints.

nest g resource users

src/users/
├── dto/
│   ├── create-user.dto.ts
│   └── update-user.dto.ts
├── entities/
│   └── user.entity.ts
├── users.controller.spec.ts
├── users.controller.ts
├── users.module.ts
├── users.service.spec.ts
└── users.service.ts

By convention, file names follow <name>.<type>.ts in kebab case, and classes use PascalCase such as UsersController and UsersService. A module declares its own controllers and providers and lists in exports only the providers other modules need.

// src/users/users.module.ts
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 {}

The CLI adds UsersModule to the root module's imports automatically. Shared guards, interceptors and utilities often live in a folder such as src/common/.

Organizing an Express project

Because Express enforces no structure, teams decide for themselves. A common approach splits routers, middleware and business logic into folders, and keeps creating the app separate from listening on a port.

my-express-api/
├── src/
│   ├── routes/
│   │   └── users.js
│   ├── middleware/
│   │   └── error-handler.js
│   ├── services/
│   │   └── users-service.js
│   ├── app.js
│   └── server.js
└── package.json

app.js only builds and exports the app; server.js opens the port. Tests can then import app without binding to a port.

// src/app.js
const express = require("express");
const usersRouter = require("./routes/users");

const app = express();
app.use(express.json());
app.use("/users", usersRouter);

module.exports = app;

// src/server.js
const app = require("./app");

const port = process.env.PORT || 3000;
app.listen(port, () => console.log(`Listening on ${port}`));

Summary

• A Nest project centers on src/main.ts (entry point) and src/app.module.ts (root module).
• experimentalDecorators and emitDecoratorMetadata are required for decorators and dependency injection.
• Give each feature its own module; nest g resource generates the controller, service and DTOs together.
• Express leaves structure to you: separate routers, middleware and services, and split app from listen to make testing easy.