Final project: Bookstore REST API

Course project: Bookstore REST API

You have reached the end of the NestJS Complete course. In this final lesson you will consolidate everything you have learned by reviewing the complete architecture of the Bookstore REST API and adding the remaining features to make it production-ready.

What you have built

Over the previous 15 lessons, you built a NestJS application with:

Complete project structure

bookstore-api/
  src/
    auth/
      dto/
        login.dto.ts
        register.dto.ts
        refresh-token.dto.ts
      decorators/
        current-user.decorator.ts
        public.decorator.ts
        roles.decorator.ts
      guards/
        auth.guard.ts
        roles.guard.ts
        ws-auth.guard.ts
      strategies/
        jwt.strategy.ts
      user.entity.ts
      auth.controller.ts
      auth.module.ts
      auth.service.ts
    books/
      dto/
        create-book.dto.ts
        update-book.dto.ts
        book-response.dto.ts
        paginated-books.dto.ts
      book.entity.ts
      books.controller.ts
      books.controller.spec.ts
      books.module.ts
      books.service.ts
      books.service.spec.ts
    authors/
      author.entity.ts
      authors.controller.ts
      authors.module.ts
      authors.service.ts
    categories/
      category.entity.ts
      categories.controller.ts
      categories.module.ts
      categories.service.ts
    orders/
      dto/
        create-order.dto.ts
      entities/
        order.entity.ts
        order-item.entity.ts
      orders.controller.ts
      orders.module.ts
      orders.service.ts
    notifications/
      notifications.gateway.ts
      notifications.module.ts
    shared/
      filters/
        http-exception.filter.ts
      interceptors/
        logging.interceptor.ts
        transform.interceptor.ts
      shared.module.ts
    config/
      app.config.ts
      database.config.ts
      jwt.config.ts
    migrations/
      001-CreateAuthorsTable.ts
      002-CreateBooksTable.ts
      003-CreateCategoriesTable.ts
      004-CreateBookCategoriesJunction.ts
      005-CreateUsersTable.ts
      006-CreateOrdersTable.ts
    app.module.ts
    main.ts
  test/
    books.e2e-spec.ts
    auth.e2e-spec.ts
  datasource.ts
  nest-cli.json
  .env.development
  .env.production

The AppModule

The root module wires everything together:

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      load: [appConfig, databaseConfig, jwtConfig],
      validationSchema: envValidationSchema,
    }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'postgres',
        host: config.getOrThrow('database.host'),
        port: config.getOrThrow('database.port'),
        username: config.getOrThrow('database.username'),
        password: config.getOrThrow('database.password'),
        database: config.getOrThrow('database.name'),
        autoLoadEntities: true,
        synchronize: false,
        migrationsRun: true,
        migrations: [__dirname + '/migrations/*.js'],
      }),
    }),
    ThrottlerModule.forRoot([{ ttl: 60000, limit: 100 }]),
    EventEmitterModule.forRoot({ wildcard: true }),
    BooksModule,
    AuthorsModule,
    CategoriesModule,
    AuthModule,
    OrdersModule,
    NotificationsModule,
    SharedModule,
  ],
})
export class AppModule {}

Global providers in main.ts

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const config = app.get(ConfigService);

  app.setGlobalPrefix(config.get('app.apiPrefix', 'api'));

  app.enableCors({
    origin: config.get<string>('app.corsOrigin', '*'),
    credentials: true,
  });

  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
      transform: true,
      transformOptions: { enableImplicitConversion: true },
    }),
  );

  app.useGlobalInterceptors(
    new ClassSerializerInterceptor(app.get(Reflector)),
    new LoggingInterceptor(),
    new TransformInterceptor(),
  );

  app.useGlobalFilters(new AllExceptionsFilter());

  // Swagger only in non-production
  if (config.get('app.env') !== 'production') {
    const swaggerConfig = new DocumentBuilder()
      .setTitle('Bookstore API')
      .setVersion('1.0')
      .addBearerAuth()
      .build();
    const document = SwaggerModule.createDocument(app, swaggerConfig);
    SwaggerModule.setup('api/docs', app, document, {
      swaggerOptions: { persistAuthorization: true },
    });
  }

  // Enable graceful shutdown hooks
  app.enableShutdownHooks();

  const port = config.get<number>('app.port', 3000);
  await app.listen(port);
  console.log(`Bookstore API running on port ${port}`);
}

API endpoints summary

Authentication:
  POST   /api/auth/register       → Register new user
  POST   /api/auth/login          → Login (returns JWT)
  POST   /api/auth/refresh        → Refresh access token
  POST   /api/auth/logout         → Revoke refresh token
  GET    /api/auth/me             → Get current user profile

Books:
  GET    /api/books               → List with pagination
  GET    /api/books/search        → Full-text search
  GET    /api/books/:id           → Get by ID
  POST   /api/books               → Create (admin/author)
  PATCH  /api/books/:id           → Update (admin/author)
  DELETE /api/books/:id           → Soft delete (admin)

Authors:
  GET    /api/authors             → List all authors
  GET    /api/authors/:id         → Get author with books
  POST   /api/authors             → Create (admin)
  PATCH  /api/authors/:id         → Update (admin)

Categories:
  GET    /api/categories          → List all categories
  POST   /api/categories          → Create (admin)

Orders:
  GET    /api/orders              → My orders
  POST   /api/orders              → Place an order
  GET    /api/orders/:id          → Order details

Health:
  GET    /api/health              → Health check (DB + memory)

What to build next

Now that you have a solid NestJS foundation, here are the natural next steps for the bookstore project:

File uploads — Use @nestjs/platform-express with Multer to upload book cover images, store them on AWS S3 or Cloudinary.

Caching — Add a Redis cache layer with @nestjs/cache-manager for frequently accessed endpoints like book listings.

Background jobs — Use @nestjs/bull with Redis for processing tasks asynchronously: sending order confirmation emails, resizing uploaded images, generating sales reports.

Full-text search — Integrate PostgreSQL's tsvector or Elasticsearch for more powerful book search capabilities.

Microservices — Split the monolith into microservices using NestJS's @nestjs/microservices package with TCP or RabbitMQ transport.

GraphQL — Add a GraphQL layer alongside the REST API using @nestjs/graphql and apollo-server.

Congratulations on completing the NestJS Complete course! You now have the skills to build production-grade backend APIs with TypeScript, TypeORM, authentication, real-time features, documentation, and a comprehensive test suite.