Introduction to NestJS: A Progressive Node.js Framework

NestJS is a modular Node.js framework built with TypeScript. It provides a structured architecture using decorators, dependency injection, and metadata-driven programming. The design organizes components for complex applications such as video streaming platforms. Modules, controllers, and providers are isolated for maintainability and testability.

Key Features

NestJS uses TypeScript and Node.js to build scalable, maintainable applications. It structures code with modules, applies metadata using decorators, and manages dependencies through a built-in injection system. It standardizes routing, validation, testing, and communication in both monolithic and distributed systems.

Dependency Injection (DI)

NestJS implements an inversion-of-control (IoC) container for managing dependencies. Providers (services, repositories, etc.) are injected into classes via constructors, reducing tight coupling. The DI system resolves dependencies automatically, ensuring testability and maintainability.

import { Injectable } from '@nestjs/common';

@Injectable()

export class UsersService {

private users = [];

findAll() {

return this.users;

}

}

Explanation:

• Imports the Injectable decorator from NestJS.

• Declares and exports the UsersService class.

Decorator-Driven Development

Decorators define metadata for classes and methods, streamlining routing, middleware, and validation. For instance, @Controller(), @Get(), and @Post() simplify REST API creation:

import { Controller, Get } from '@nestjs/common';

@Controller('users')

export class UsersController {

constructor(private usersService: UsersService) {}

@Get()

findAll() {

return this.usersService.findAll();

}

}

Explanation:

• Imports Controller and Get decorators from NestJS core.
• Controller defines an HTTP route handler class.
• Get maps HTTP GET requests to method handlers.

Microservices Support

NestJS natively supports microservices with transporters like TCP, Redis, MQTT, and gRPC. The @MessagePattern() decorator handles event-based communication:

import { Controller } from '@nestjs/common';

import { MessagePattern } from '@nestjs/microservices';

@Controller()

export class MathController {

@MessagePattern({ cmd: 'sum' })

accumulate(data: number[]): number {

return (data || []).reduce((a, b) => a + b);

}

}

Explanation:

• Controller: Marks the class as a NestJS controller.
• MessagePattern: Defines message-based route handlers for microservice contexts (e.g., TCP, Redis, Kafka).
• Defines and exports the MathController class.

GraphQL Integration

NestJS provides support for GraphQL via @nestjs/graphql. Resolvers and mutations are defined using decorators:

import { Resolver, Query, Args } from '@nestjs/graphql';

@Resolver('User')

export class UsersResolver {

@Query(() => [User])

async users() {

return this.usersService.findAll();

}

}

Explanation:

• Declares this class as a GraphQL resolver for the User type.
• Routes GraphQL operations targeting User fields to methods in this class.

WebSockets & Real-Time Communication

The framework includes @nestjs/websockets for WebSocket gateways, enabling bidirectional event-based communication.

import { WebSocketGateway, SubscribeMessage } from '@nestjs/websockets';

@WebSocketGateway()

export class EventsGateway {

@SubscribeMessage('message')

handleMessage(client: any, payload: string): string {

return 'Message received: ' + payload;

}

}

Explanation:

• Declares and exports the EventsGateway class.

• handleMessage(...) processes the 'message' event.

Video-Centric Concepts in NestJS

NestJS supports video-focused functionality through modules, decorators, and built-in utilities. Core features include byte-range streaming, multipart file uploads using interceptors, metadata handling via DTOs, and access control using guards and pipes.

Video Streaming with Byte-Range Support

NestJS supports partial content delivery (HTTP 206) for efficient video streaming. The StreamableFile class and range headers enable adaptive bitrate streaming and seekable playback.

import { Controller, Get, Param, Headers, Header } from '@nestjs/common';

import { createReadStream, statSync } from 'fs';

import { join } from 'path';

import { StreamableFile } from '@nestjs/common';

@Controller('videos')

export class VideoController {

@Get('stream/:filename')

@Header('Accept-Ranges', 'bytes') // Enables range requests

async streamVideo(

@Param('filename') filename: string,

@Headers() headers: { range?: string },

) {

const videoPath = join(__dirname, 'assets', filename);

const { size } = statSync(videoPath);

if (headers.range) {

const CHUNK_SIZE = 10 ** 6; // 1MB chunks

const start = Number(headers.range.replace(/\D/g, ''));

const end = Math.min(start + CHUNK_SIZE, size - 1);

const stream = createReadStream(videoPath, { start, end });

return new StreamableFile(stream, {

disposition: `inline; filename="${filename}"`,

type: 'video/mp4',

length: end - start + 1,

});

}

return new StreamableFile(createReadStream(videoPath));

}

}

Explanation

• A NestJS wrapper around Node.js Readable streams.
• Optimizes memory-efficient delivery of large files such as video streams.
• Extracts the Range header from incoming requests.

File Uploads with Validation

NestJS integrates with Multer for handling multipart/form-data uploads. Custom interceptors enforce file size limits and MIME-type validation.

import {

Post,

UploadedFile,

UseInterceptors,

Body,

Controller

} from '@nestjs/common';

import { FileInterceptor } from '@nestjs/platform-express';

import { diskStorage } from 'multer';

import { extname } from 'path';

@Controller('videos')

export class VideoController {

@Post('upload')

@UseInterceptors(

FileInterceptor('video', {

storage: diskStorage({

destination: './uploads',

filename: (req, file, cb) => {

const uniqueName = Date.now() + extname(file.originalname);

cb(null, uniqueName);

},

}),

limits: { fileSize: 1024 * 1024 * 1024 }, // 1GB max

fileFilter: (req, file, cb) => {

if (file.mimetype.startsWith('video/')) cb(null, true);

else cb(new Error('Only video files allowed!'), false);

},

}),

)

async uploadVideo(

@UploadedFile() file: Express.Multer.File,

@Body() metadata: { title: string; description: string },

) {

return {

message: 'Video uploaded successfully!',

filename: file.filename,

metadata,

};

}

}

Explanation

• Middleware that extracts multipart/form-data file uploads.
• Registers the uploaded file under req.file for controller access.

Video Processing with Queues (Bull + Redis)

NestJS integrates with Bull and Redis to offload video processing tasks such as transcoding to background queues. Queues handle workload distribution and async execution outside the request-response cycle. Jobs are added to the queue with parameters like video ID and output formats, enabling scalable and non-blocking media workflows.

import { Injectable } from '@nestjs/common';

import { InjectQueue } from '@nestjs/bull';

import { Queue } from 'bull';

@Injectable()

export class VideoService {

constructor(@InjectQueue('video') private videoQueue: Queue) {}

async transcodeVideo(videoId: string) {

await this.videoQueue.add('transcode', {

videoId,

formats: ['720p', '1080p', '4K'],

});

}

}

Explanation

• Injects a Bull queue instance named 'video' into the class.
• Connects to a Redis-backed job queue configured for background processing.

WebSockets for Real-Time Notifications

NestJS uses WebSocket gateways to enable real-time client communication. Events such as video processing completion can trigger server-side messages using `@SubscribeMessage` handlers. The `WebSocketServer` instance emits status updates to subscribed clients over Socket.IO, allowing instant notification delivery.

import { WebSocketGateway, SubscribeMessage, WebSocketServer } from '@nestjs/websockets';

import { Server } from 'socket.io';

@WebSocketGateway()

export class VideoGateway {

@WebSocketServer()

server: Server;

@SubscribeMessage('video_processed')

handleProcessed(client: any, payload: { videoId: string }) {

this.server.emit(`video_${payload.videoId}`, { status: 'completed' });

}

}

Explanation

• Registers the class as a WebSocket gateway.
• Initializes a WebSocket server and binds it to the application context.
• Binds a method to handle messages for a specific client-side event name.