Products
Products
Video Hosting
Upload and manage your videos in a centralized video library.
Image Hosting
Upload and manage all your images in a centralized library.
Galleries
Choose from 100+templates to showcase your media in style.
Video Messaging
Record, and send personalized video messages.
CincoTube
Create your own community video hub your team, students or fans.
Pages
Create dedicated webpages to share your videos and images.
Live
Create dedicated webpages to share your videos and images.
For Developers
Video API
Build a unique video experience.
DeepUploader
Collect and store user content from anywhere with our file uploader.
Solutions
Solutions
Enterprise
Supercharge your business with secure, internal communication.
Townhall
Webinars
Team Collaboration
Learning & Development
Creative Professionals
Get creative with a built in-suite of editing and marketing tools.
eCommerce
Boost sales with interactive video and easy-embedding.
Townhall
Webinars
Team Collaboration
Learning & Development
eLearning & Training
Host and share course materials in a centralized portal.
Sales & Marketing
Attract, engage and convert with interactive tools and analytics.
"Cincopa helped my Enterprise organization collaborate better through video."
Book a Demo
Resources
Resources
Blog
Learn about the latest industry trends, tips & tricks.
Help Centre
Get access to help articles FAQs, and all things Cincopa.
Partners
Check out our valued list of partners.
Product Updates
Stay up-to-date with our latest greatest features.
Ebooks, Guides & More
Customer Stories
Hear how we've helped businesses succeed.
Boost Campaign Performance Through Video
Discover how to boost your next campaign by using video.
Download Now
Pricing
Watch a Demo
Demo
Login
Start Free Trial
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 .
Video Hosting
Image Hosting
Galleries
Video Messaging
CincoTube
Pages
Live
