Forem: codingKrills

I Self-Hosted a Scalable Live Video Infrastructure in 10 Minutes (And You Can Too) 🚀🎥

codingKrills — Sun, 12 Apr 2026 22:50:43 +0000

I Self-Hosted a Scalable Live Video Infrastructure in 10 Minutes (And You Can Too) 🚀🎥

Hook: Forget expensive Zoom APIs or complex Twilio setups. I just deployed a production-ready LiveKit server with Ingress (OBS support) and Egress (Recording) on a basic VPS. Here is exactly how I did it without losing my mind.

The "Why" 🧐

Building video apps is usually a nightmare. You have to deal with STUN/TURN servers, SSL certificates, and UDP port ranges. Enter LiveKit: an open-source, high-performance WebRTC stack that handles the heavy lifting.

I’m going to show you how to turn a fresh Ubuntu VPS into a powerhouse for video calls, livestreams, and recordings.

Phase 1: The "Clean Slate" Script 🧹

Before we start, we need a clean Docker environment. No ghost containers, no dangling images. I used this "Nuclear Cleanup" script:

!/bin/bash# Stop everything, delete everything, restart the engine

docker stop $(docker ps -aq) 2>/dev/null
docker system prune -a --volumes -f
sudo systemctl restart docker

Run chmod +x clean.sh && ./clean.sh and boom—you’re starting from zero.

Phase 2: The DNS Magic Trick 🪄

If you use Cloudflare, this is where 90% of people fail.

Create two A records: ://yourdomain.com and ://yourdomain.com.
CRITICAL: Switch the Proxy status to Grey Cloud (DNS Only).

Pro-Tip: WebRTC needs raw UDP traffic. Cloudflare's orange cloud (HTTP proxy) will kill your video stream instantly.

Phase 3: Launching the Generator 🚀

We don't write config files manually; we let LiveKit’s interactive wizard do it.

sudo docker run --rm -it -v$PWD:/output livekit/generate

The Choices I Made:

Components: Server + Ingress (for OBS/RTMP) + Egress (for Recording).
SSL: Let's Encrypt (Free and automatic).
Redis: Bundled (Keep it simple).

This generated a folder with a livekit.yaml and a magical init_script.sh.

Phase 4: Opening the Gates (Firewall) 🛡️

You can't have a party if the doors are locked. We need to open specific ports for WebRTC to breathe:

TCP for signals, UDP for the actual video data

sudo ufw allow 80,443,7881,1935/tcp
sudo ufw allow 3478,7885,50000:60000/udp

Phase 5: The "One Command" Deployment ⚡

Navigate into your generated folder and let it rip:

cd ://yourdomain.com
sudo chmod +x init_script.sh
sudo ./init_script.sh

Once you see livekit-server: Up, you officially own your own video infrastructure.

Phase 6: How to Connect (The Code) 💻

Connecting your frontend is surprisingly easy. Use the livekit-client SDK:

import { Room } from 'livekit-client';
const room = new Room();await room.connect('wss://://yourdomain.com', 'YOUR_TOKEN');await room.localParticipant.enableCameraAndMicrophone();

The Verdict 🏆

In under 15 minutes, we have:
✅ End-to-end encrypted video calls.
✅ RTMP Ingress (You can stream from OBS directly to your server).
✅ Egress (Save meetings directly to S3 or local storage).
✅ Auto-scaling capabilities.

Stop paying for minutes. Start owning your stack.

What are you building next? Video games? Remote surgery apps? Virtual classrooms? Let me know in the comments! 👇

webdev #javascript #docker #openSource #webrtc

⚔️ Kafka vs RabbitMQ vs SQS vs BullMQ — Stop Guessing, Choose the Right One (2026 Guide)

codingKrills — Tue, 07 Apr 2026 13:17:40 +0000

⚔️ Kafka vs RabbitMQ vs SQS vs BullMQ — Stop Guessing, Choose the Right One (2026 Guide)

❌ Using the wrong messaging system will silently kill your scalability.
✅ Choosing the right one will make your system fast, resilient, and future-proof.

If you're building microservices, background jobs, or real-time systems… this is one decision you cannot afford to get wrong.

🧠 TL;DR (Save This)

Use Case	Pick
Microservices communication	🐰 RabbitMQ
Real-time analytics / streaming	🧠 Kafka
AWS serverless apps	☁️ SQS
Node.js background jobs	⚡ BullMQ

📡 The 4 Systems Explained

🐰 RabbitMQ — The Reliable Workhorse

🔹 What it is:

A traditional message broker that routes messages via exchanges → queues.

🔹 Best for:

Microservices communication
Task queues
Reliable processing

🔹 Example:

User signs up → event sent → email + notification services consume it

🧠 Apache Kafka — The Scale Monster

🔹 What it is:

A distributed event streaming platform that stores events as logs.

🔹 Best for:

Real-time analytics
Event sourcing
High-scale systems

🔹 Example:

Tracking millions of user clicks → analytics dashboard in real-time

☁️ Amazon SQS — The Managed Simplicity

🔹 What it is:

A fully managed queue service by AWS.

🔹 Best for:

Serverless architectures
AWS-based systems

🔹 Example:

Lambda → SQS → Worker → Process job

⚡ BullMQ — The Developer Favorite

🔹 What it is:

A Redis-based queue system built for Node.js.

🔹 Best for:

Background jobs
Simple async processing

🔹 Example:

Upload file → queue job → process in background

⚔️ The Real Differences (No BS Table)

Feature	RabbitMQ 🐰	Kafka 🧠	SQS ☁️	BullMQ ⚡
Type	Broker	Streaming	Managed Queue	Job Queue
Throughput	Medium	🔥 Extremely High	High	Medium
Complexity	Medium	😵 High	😌 Low	😌 Low
Scaling	Good	🚀 Massive	Auto	Limited
Replay Events	❌	✅	❌	❌
Setup	Self-hosted	Complex cluster	Managed	Redis needed

✅ Pros & Cons (Straight Talk)

🐰 RabbitMQ

✅ Pros:

Flexible routing (fanout, topic, direct)
Strong reliability (ACK, DLQ, retries)
Perfect for microservices

❌ Cons:

Lower throughput than Kafka
Needs infrastructure setup

🧠 Kafka

✅ Pros:

Massive throughput (millions/sec)
Event replay (game-changer)
Horizontal scalability

❌ Cons:

Hard to learn & manage
Overkill for most apps

☁️ SQS

✅ Pros:

Fully managed (no ops)
Highly durable
Easy AWS integration

❌ Cons:

Limited flexibility
Vendor lock-in

⚡ BullMQ

✅ Pros:

Super easy setup
Fast (Redis-based)
Perfect for Node.js devs

❌ Cons:

Not for large distributed systems
Limited advanced features

🔥 Real-World Use Cases (This is What Matters)

💡 E-commerce App

Order processing → 🐰 RabbitMQ
Analytics pipeline → 🧠 Kafka
Email queue → ⚡ BullMQ
AWS infra → ☁️ SQS

💡 Your System (Quotation + AI + OTP)

OTP → ⚡ BullMQ / 🐰 RabbitMQ
Notifications → ⚡ BullMQ
Quotation processing → 🐰 RabbitMQ
AI + analytics → 🧠 Kafka

🚨 Common Mistakes (Avoid These)

❌ Using Kafka for simple queues
❌ Using BullMQ for distributed systems
❌ Ignoring retries & DLQ
❌ Tight coupling between services

🧠 Decision Framework (Think Like a Senior Engineer)

Ask yourself:

Do I need event replay? → Kafka
Do I need reliable task processing? → RabbitMQ
Am I on AWS only? → SQS
Is this just background jobs in Node.js? → BullMQ

💣 Hard Truth

Most systems don’t fail because of code…
They fail because of wrong architecture decisions.

🚀 Final Takeaway

RabbitMQ = Reliable messaging
Kafka = High-scale streaming
SQS = Managed simplicity
BullMQ = Developer-friendly queues

👉 Pick based on use case, not hype

🧠 TL;DR (Again)

Don’t choose tools because they’re popular.
Choose them because they fit your problem.

🔥 Want More Like This?

If this helped you, I can write next:

⚔️ Kafka vs RabbitMQ deep dive (real production scenarios)
🧱 Full microservices architecture (NestJS + Kafka + Redis)
☸️ Deploy everything on Kubernetes

👉 Comment “PART 2” and I’ll drop it 😄

🚀 NestJS Microservices with RabbitMQ, Retries & DLQ — Production Setup That Actually Scales.

codingKrills — Tue, 07 Apr 2026 13:09:55 +0000

🚀 NestJS Microservices with RabbitMQ, Retries & DLQ — Production Setup That Actually Scales

❌ Stop building fragile microservices that silently fail.
✅ Start building systems that retry, recover, and scale automatically.

If you're using NestJS and not handling failures, retries, and dead-letter queues (DLQ) properly… your system will break in production. Period.

In this guide, I’ll show you a battle-tested architecture using NestJS + RabbitMQ with:

🔁 Retries
💀 Dead Letter Queues (DLQ)
⚡ Event-driven communication
🧱 Scalable microservices

🧠 What You’ll Build

A real-world system with services like:

authentication
rbac
quotation
packages
generate-quotation-pdf
generate-quotation-ai
subscription-plans
user-subscriptions
notifications
send-otp

🏗️ Architecture Overview

API Gateway → RabbitMQ → Microservices (Consumers)

👉 No direct service-to-service calls
👉 Fully async & decoupled

📁 Monorepo Structure

nestjs-microservices/
│
├── apps/
│   ├── api-gateway/
│   ├── authentication/
│   ├── rbac/
│   ├── quotation/
│   ├── packages/
│   ├── generate-quotation-pdf/
│   ├── generate-quotation-ai/
│   ├── subscription-plans/
│   ├── user-subscriptions/
│   ├── notifications/
│   └── send-otp/
│
├── libs/
│   ├── rabbitmq/
│   ├── common/
│   ├── dto/
│   ├── config/
│   └── utils/

👉 Clean separation = easy scaling

📡 Messaging Setup (Core Idea)

Instead of this ❌

await this.authService.validateUser();

We do this ✅

this.client.send('auth.validate', payload);

👉 Async, scalable, resilient

⚙️ RabbitMQ Configuration (DLQ + Retry)

ClientsModule.register([
  {
    name: 'RABBITMQ_SERVICE',
    transport: Transport.RMQ,
    options: {
      urls: [process.env.RABBITMQ_URL],
      queue: 'main_queue',
      queueOptions: {
        durable: true,
        deadLetterExchange: 'dlx',
        deadLetterRoutingKey: 'dlq',
      },
    },
  },
]);

🔁 Retry Mechanism (The Secret Sauce)

Main Queue → Retry Queue (TTL) → Main Queue → DLQ

Retry Queue Example:

{
  queue: 'quotation_retry',
  queueOptions: {
    messageTtl: 5000,
    deadLetterRoutingKey: 'quotation_queue',
  },
}

👉 If a job fails → wait 5s → retry automatically

💀 Dead Letter Queue (DLQ)

When retries fail:

@EventPattern('quotation.dlq')
handleFailed(data: any) {
  console.error('DLQ Message:', data);
}

👉 No silent failures anymore 🔥

📤 Producer Example

@Injectable()
export class QuotationProducer {
  constructor(@Inject('RABBITMQ_SERVICE') private client: ClientProxy) {}

  createQuotation(data: any) {
    return this.client.emit('quotation.create', data);
  }
}

📥 Consumer Example

@EventPattern('quotation.create')
async handle(data: any, context: RmqContext) {
  const channel = context.getChannelRef();
  const message = context.getMessage();

  try {
    await this.service.process(data);
    channel.ack(message);
  } catch (e) {
    channel.nack(message, false, false); // goes to DLQ
  }
}

⚡ Event-Driven Wins

Traditional API	Event-Driven
Tight coupling ❌	Loose coupling ✅
Blocking ❌	Async ✅
Hard to scale ❌	Horizontally scalable ✅

🔥 Real Use Cases

📩 send-otp → async SMS
📄 generate-quotation-pdf → heavy processing
🤖 generate-quotation-ai → AI calls
🔔 notifications → emails, push

👉 Your API stays FAST ⚡

🧠 Production Best Practices

✅ Use idempotency keys
✅ Add correlation IDs
✅ Monitor DLQ actively
✅ Scale consumers independently
✅ Separate queues per service
✅ Validate DTOs strictly

🐳 Bonus: Run Everything with Docker

rabbitmq:
  image: rabbitmq:3-management
  ports:
    - "5672:5672"
    - "15672:15672"

👉 Access dashboard → http://localhost:15672

💣 Hard Truth

If your system doesn’t handle failure… it’s already broken.

🚀 Final Takeaway

Build microservices that don’t just “work”… but recover, retry, and scale automatically.

🧠 TL;DR

Use NestJS + RabbitMQ
Prefer event-driven architecture
Implement retries + DLQ
Scale consumers independently
Never ignore failures

🔥 Want More?

If this helped you, I can next show:

☸️ Kubernetes deployment (auto-scaling microservices)
📊 Monitoring with Prometheus + Grafana
🔐 Full auth + API Gateway setup

Just comment: “PART 2” 👇

🚨 Stop Writing Messy API Calls in Next.js — Do This Instead (Production-Grade Setup)

codingKrills — Tue, 31 Mar 2026 21:57:28 +0000

Let me be brutally honest.

Most Next.js codebases I’ve reviewed lately are a complete mess when it comes to API handling:

useEffect everywhere
API calls inside components
No caching
Broken auth (random logouts 🤡)
Copy-pasted logic across files

And the worst part?

👉 These apps work… until they scale.

⚠️ The Problem Nobody Talks About

Frontend devs focus a lot on UI…

But ignore architecture.

Meanwhile, backend engineers:

design layers
enforce contracts
optimize performance

👉 Frontend?
"Just fetch it bro" 😅

💡 So I Built This Instead

A production-grade API layer using modern tools:

🧱 Stack

Next.js (App Router)
Axios (client-side)
TanStack Query (API state)
Zustand (global state)
Zod (validation)
React Hook Form (forms)
JWT Auth (with refresh token rotation)

🧠 Architecture Overview

[ UI Components ]
        ↓
[ Custom Hooks (React Query) ]
        ↓
[ Services Layer ]
        ↓
[ Axios / Fetch Layer ]
        ↓
[ NestJS Backend ]

👉 Clean separation = scalable system

🔥 Step 1: STOP Calling APIs in Components

❌ Bad

useEffect(() => {
  fetch("/api/users").then(...)
}, [])

✅ Good (Service Layer)

// services/user.service.ts
export const getUsers = async () => {
  const res = await api.get("/users");
  return res.data;
};

👉 Your components should NEVER know how APIs work.

⚡ Step 2: React Query = Game Changer

Using TanStack Query:

const { data, isLoading } = useQuery({
  queryKey: ["users"],
  queryFn: getUsers,
});

What you get for free:

🚀 caching
🔁 retries
⚡ background refetch
📊 pagination support

👉 This replaces Redux (for API state)

🧩 Step 3: Axios with Interceptors (REAL AUTH)

// lib/api.ts
import axios from "axios";

export const api = axios.create({
  baseURL: process.env.NEXT_PUBLIC_API_URL,
  withCredentials: true,
});

🔐 Token Handling (IMPORTANT)

Flow:

Request → 401 → Refresh Token → Retry Request

Interceptor:

api.interceptors.response.use(
  res => res,
  async (error) => {
    if (error.response.status === 401) {
      const newToken = await refreshToken();
      error.config.headers.Authorization = `Bearer ${newToken}`;
      return api(error.config);
    }
    return Promise.reject(error);
  }
);

👉 This is what separates amateur apps vs production apps

🧠 Step 4: Zustand (Keep It Simple)

Using Zustand:

import { create } from "zustand";

export const useAuthStore = create((set) => ({
  user: null,
  token: null,
  setAuth: (data) => set(data),
  logout: () => set({ user: null, token: null }),
}));

✔ no boilerplate
✔ super fast
✔ perfect with React Query

🛡️ Step 5: Zod = No More API Surprises

Using Zod:

const userSchema = z.object({
  id: z.string(),
  name: z.string(),
});

Why this matters:

Without validation:

Backend changes → frontend silently breaks 😬

With Zod:
✔ strict validation
✔ type safety
✔ safer production

🧾 Step 6: Forms That Don’t Lag

Using React Hook Form:

const { register, handleSubmit } = useForm();

<form onSubmit={handleSubmit(onSubmit)}>
  <input {...register("email")} />
</form>

✔ minimal re-renders
✔ clean integration with Zod
✔ better UX

📁 Step 7: Folder Structure (This is KEY)

/src
  /lib
    api.ts
    fetcher.ts
  /services
    auth.service.ts
    user.service.ts
  /hooks
    useApiQuery.ts
    useApiMutation.ts
  /store
    auth.store.ts
  /schemas
    user.schema.ts

👉 This is what makes your app scalable after 6+ months.

🧠 Step 8: Custom Hooks = Clean UI

export const useApiQuery = (key, fn) => {
  return useQuery({
    queryKey: key,
    queryFn: fn,
  });
};

Now in UI:

const { data } = useApiQuery(["users"], getUsers);

👉 Clean AF.

📊 Diagram: Full Flow

[Component]
   ↓
[useApiQuery]
   ↓
[Service Layer]
   ↓
[Axios Instance]
   ↓
[Interceptor]
   ↓
[NestJS API]

💥 The Real Difference

Before:

messy code
duplicated logic
no caching
auth bugs

After:

scalable architecture
centralized API logic
automatic caching
seamless auth flow

⚠️ Controversial Take

If you're still using useEffect for API calls in 2025…

You're writing legacy code.

Yeah, I said it.

🧠 Final Thoughts

Frontend is no longer “just UI”.

It’s:

data orchestration
caching strategy
auth handling
performance optimization

👉 Treat it like backend architecture.

🚀 Want This Setup Instantly?

I created a Cursor AI command that generates this entire architecture automatically.

Drop a comment: "setup"
I’ll share it with you 👇

🔥 Tags

nextjs #nestjs #reactquery #zustand #webdev #typescript #frontend #fullstack #javascript

🚀 Want the full setup?

I’ve created a Cursor AI command that generates this entire architecture automatically.

Comment “setup” and I’ll share it 👇

RESTful API Design: Complete Guide to Best Practices, Architecture, and Real-World Examples (2026).

codingKrills — Tue, 17 Mar 2026 22:19:02 +0000

Modern software systems rely heavily on APIs to connect web apps, mobile apps, and backend services. Among various API architectures, RESTful APIs remain the most widely used standard for building scalable backend systems.

If you are building backend services using Node.js, Python, Java, or any modern framework, understanding REST API design principles and best practices is essential for creating maintainable and scalable applications.

In this complete guide, we will explore:

What RESTful APIs are
REST architecture principles
Best practices for REST API design
Real-world API examples
HTTP methods and status codes
API versioning and pagination
Security and authentication

By the end of this article, you will understand how to design production-ready REST APIs used by companies like Stripe, GitHub, and Shopify.

What is a RESTful API?

A RESTful API (Representational State Transfer API) is a web service architecture that allows communication between clients and servers using standard HTTP protocols.

REST was introduced by Roy Fielding in 2000 in his doctoral dissertation and has since become the foundation of modern web APIs.

A REST API exposes resources through URLs and allows clients to interact with them using HTTP methods such as:

GET
POST
PUT
PATCH
DELETE

Example REST API endpoints:

GET    /users
POST   /users
GET    /users/123
PATCH  /users/123
DELETE /users/123

Each endpoint represents a resource, and the HTTP method determines the action performed.

Why REST APIs Are So Popular

REST APIs have become the industry standard because they provide several advantages:

1. Simplicity

REST uses standard HTTP protocols, making it easy to implement and understand.

2. Scalability

Stateless architecture allows REST APIs to scale horizontally across multiple servers.

3. Flexibility

REST APIs can be consumed by:

Web applications
Mobile apps
Microservices
IoT devices

4. Language Independence

REST APIs can be built using any programming language:

Node.js
Java
Python
Go
Ruby
PHP

Core Principles of REST Architecture

A well-designed REST API follows several architectural constraints.

1. Client-Server Separation

The client and server operate independently.

The client handles:

User interface
User interactions

The server handles:

Business logic
Database operations
Authentication

Example architecture:

Frontend: React / Next.js
Backend: Node.js API
Database: MongoDB / PostgreSQL

This separation allows teams to develop frontend and backend independently.

2. Stateless Communication

REST APIs are stateless, meaning the server does not store client session information.

Each request must contain all necessary information.

Example request:

GET /orders
Authorization: Bearer TOKEN

Benefits:

Better scalability
Simpler infrastructure
Improved reliability

3. Resource-Based URLs

REST APIs organize data as resources.

Examples of resources:

Users
Products
Orders
Posts
Comments

Each resource is represented by a URL.

Examples:

/users
/products
/orders
/comments

Important rule:

Always use nouns instead of verbs in URLs.

Bad example:

/createUser
/updateOrder
/deleteProduct

Correct REST design:

POST   /users
PATCH  /orders/:id
DELETE /products/:id

HTTP Methods in REST APIs

REST APIs use HTTP verbs to define actions.

HTTP Method	Purpose
GET	Retrieve resources
POST	Create a resource
PUT	Replace a resource
PATCH	Update partially
DELETE	Remove a resource

Example:

Create a user:

POST /users

Request body:

{
  "name": "Pulkit Singh",
  "email": "pulkit@email.com"
}

Response:

201 Created

REST API Status Codes

Proper status codes help clients understand API responses.

Code	Meaning
200	Success
201	Resource created
204	No content
400	Bad request
401	Unauthorized
403	Forbidden
404	Resource not found
500	Server error

Example response:

HTTP/1.1 200 OK

{
  "success": true,
  "data": {
    "id": "123",
    "name": "Pulkit Singh"
  }
}

Designing RESTful Endpoints

Below is a typical REST API design for a blog platform.

Posts API

GET     /api/v1/posts
GET     /api/v1/posts/:id
POST    /api/v1/posts
PATCH   /api/v1/posts/:id
DELETE  /api/v1/posts/:id

Comments API

GET     /api/v1/posts/:postId/comments
POST    /api/v1/posts/:postId/comments

Users API

GET     /api/v1/users
POST    /api/v1/users
GET     /api/v1/users/:id

Filtering, Sorting, and Pagination

REST APIs should support query parameters to filter and paginate data.

Example pagination:

GET /products?page=2&limit=20

Sorting example:

GET /products?sort=price

Filtering example:

GET /products?category=electronics

Typical paginated response:

{
  "data": [...],
  "pagination": {
    "page": 2,
    "limit": 20,
    "total": 200
  }
}

Pagination is critical for performance when dealing with large datasets.

API Versioning

APIs evolve over time. Versioning prevents breaking existing clients.

Recommended format:

/api/v1/users
/api/v2/users

Benefits of versioning:

Backward compatibility
Safe feature upgrades
Easier API maintenance

Consistent Response Structure

Consistency improves developer experience.

Success response:

{
  "success": true,
  "message": "Users fetched successfully",
  "data": [...]
}

Error response:

{
  "success": false,
  "error": "User not found"
}

Authentication and Security

REST APIs must secure endpoints using authentication mechanisms.

Common methods include:

JWT Authentication

Authorization: Bearer TOKEN

OAuth 2.0

Used by platforms such as Google and GitHub.

API Keys

Used by many SaaS APIs.

Security best practices:

Validate all inputs
Implement rate limiting
Use HTTPS
Sanitize request data

Example REST API Implementation (Node.js)

Example Express routes:

router.get("/users", getUsers);
router.get("/users/:id", getUser);
router.post("/users", createUser);
router.patch("/users/:id", updateUser);
router.delete("/users/:id", deleteUser);

Example controller:

export const getUsers = async (req, res) => {
  const users = await User.find();

  res.json({
    success: true,
    data: users
  });
};

REST API Best Practices

To design scalable REST APIs, follow these guidelines:

Use nouns in URLs
Use HTTP methods correctly
Always return proper status codes
Implement pagination
Version your APIs
Maintain consistent response structures
Secure APIs with authentication
Validate request payloads
Document APIs using Swagger/OpenAPI
Implement rate limiting

Common REST API Design Mistakes

Avoid these common mistakes when designing APIs:

Using verbs in endpoint URLs
Not using proper HTTP status codes
Returning inconsistent response formats
Ignoring pagination
Lack of versioning
Over-nesting resources

Fixing these issues ensures your API remains maintainable and scalable.

Conclusion

RESTful APIs remain the backbone of modern web applications. By following REST architecture principles, using proper HTTP methods, implementing pagination, and maintaining consistent responses, developers can build APIs that scale efficiently and provide an excellent developer experience.

Whether you're building a startup product, SaaS platform, or microservices architecture, mastering REST API design will significantly improve your backend development skills.

If you follow the practices described in this guide, your APIs will be clean, scalable, secure, and easy to integrate for developers worldwide.

VIBE CODE !

codingKrills — Sun, 16 Nov 2025 20:37:45 +0000

TypeORM + PostgresQL

codingKrills — Fri, 26 Sep 2025 10:22:57 +0000

TypeORM with NestJS & PostgreSQL – Guide

1. Installation & Setup

npm install --save @nestjs/typeorm typeorm pg

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './users/user.entity';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'yourpassword',
      database: 'testdb',
      entities: [User],
      synchronize: true,
    }),
    UsersModule,
  ],
})
export class AppModule {}

2. Defining Entities

@Entity()
export class User {
  @PrimaryGeneratedColumn() id: number;
  @Column({ unique: true }) email: string;
  @Column() name: string;
  @Column({ nullable: true }) age: number;
  @CreateDateColumn() createdAt: Date;
  @UpdateDateColumn() updatedAt: Date;
  @OneToMany(() => Post, post => post.user)
  posts: Post[];
}

@Entity()
export class Post {
  @PrimaryGeneratedColumn() id: number;
  @Column() title: string;
  @Column({ type: 'text' }) content: string;
  @ManyToOne(() => User, user => user.posts)
  user: User;
}

3. Repositories & Services

@Injectable()
export class UsersService {
  constructor(@InjectRepository(User) private usersRepo: Repository<User>) {}

  findAll() { return this.usersRepo.find({ relations: ['posts'] }); }
  findOne(id: number) { return this.usersRepo.findOne({ where: { id }, relations: ['posts'] }); }
  create(userData: Partial<User>) { const user = this.usersRepo.create(userData); return this.usersRepo.save(user); }
  update(id: number, userData: Partial<User>) { return this.usersRepo.update(id, userData); }
  remove(id: number) { return this.usersRepo.delete(id); }
}

4. Controller Example

@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}

  @Get() getAll() { return this.usersService.findAll(); }
  @Get(':id') getOne(@Param('id') id: number) { return this.usersService.findOne(id); }
  @Post() create(@Body() userData: Partial<User>) { return this.usersService.create(userData); }
  @Put(':id') update(@Param('id') id: number, @Body() userData: Partial<User>) { return this.usersService.update(id, userData); }
  @Delete(':id') remove(@Param('id') id: number) { return this.usersService.remove(id); }
}

5. Query Examples

// QueryBuilder
const users = await this.usersRepo.createQueryBuilder('user')
  .leftJoinAndSelect('user.posts', 'post')
  .where('user.age > :age', { age: 25 })
  .orderBy('user.name', 'ASC')
  .getMany();

// Raw SQL
const result = await this.usersRepo.query('SELECT * FROM "user" WHERE age > $1', [25]);

6. Relationships in TypeORM

OneToOne: User → Profile
OneToMany / ManyToOne: User → Posts
ManyToMany: Posts ↔ Tags

@ManyToMany(() => Tag, tag => tag.posts)
@JoinTable()
tags: Tag[];

7. Transactions

await this.dataSource.transaction(async (manager) => {
  await manager.update(User, { id: 1 }, { age: 30 });
  await manager.update(Post, { id: 5 }, { title: 'Updated' });
});

8. Migrations

npx typeorm migration:generate -n CreateUsers
npx typeorm migration:run
npx typeorm migration:revert

9. Indexes & Constraints

@Column({ unique: true }) email: string;
@Column({ nullable: true }) username: string;
@Index('idx_user_email')
@Column() email: string;

10. Advanced Tips

Use QueryBuilder for complex queries with joins, pagination, filtering.
Avoid N+1 problems with leftJoinAndSelect.
Use transactions for multi-table operations.
Use migrations in production, not synchronize: true.
Combine with Redis caching for heavy reads.
Use DTOs + ValidationPipe for input validation.

Nestjs Questions & Answeres.

codingKrills — Fri, 26 Sep 2025 10:03:00 +0000

NestJS Interview Questions & Answers

1. What is NestJS and why use it?

NestJS is a progressive Node.js framework built on TypeScript for
building scalable and maintainable server-side applications. It
provides modularity, dependency injection, and decorators, making it
structured like Angular.

2. What are modules in NestJS?

A module is a container for a feature (controllers, providers, services).
Every NestJS app has at least one root module (AppModule).
Helps in organizing code into modular, reusable units.

3. What are controllers in NestJS?

Controllers handle incoming HTTP requests and return responses.\
Defined with @Controller() decorator and route handlers with @Get(),
@Post(), etc.

4. What are providers/services in NestJS?

Services (providers) hold business logic.
They can be injected into controllers or other providers using dependency injection.
Decorated with @Injectable().

5. What is Dependency Injection in NestJS?

A design pattern where classes request dependencies from the framework
rather than creating them manually.\
Example: Injecting UsersService into UsersController instead of
instantiating it.

6. What are decorators in NestJS?

Special functions that add metadata.\
Examples:\

@Controller() -- marks a class as controller\
@Get() -- maps a GET request\
@Injectable() -- makes a service available for DI

7. What are pipes in NestJS?

Pipes are used for validation and transformation.
Example: ValidationPipe automatically validates DTOs against class validators.

8. What are interceptors in NestJS?

Interceptors can transform requests/responses, log execution time, handle caching, etc.
Example: LoggingInterceptor to measure API execution time.

9. What are guards in NestJS?

Guards control authorization.
Example: AuthGuard checks if the user is authenticated before accessing a route.

10. What are filters in NestJS?

Exception filters catch unhandled exceptions and format error responses.
Example: HttpExceptionFilter to customize error messages.

11. What is Middleware in NestJS?

Middleware runs before route handlers.
Used for logging, authentication, parsing, etc.
Example: app.use(LoggerMiddleware)

12. How does NestJS handle database integration?

Via TypeORM, Sequelize, Prisma, or Mongoose.
Use repositories or models injected into services to interact with DB.

13. What are DTOs in NestJS?

DTO = Data Transfer Object.
Defines the shape of data received or sent.
Used with validation decorators like @IsString(), @IsEmail().

14. What is the difference between `forRoot()` and `forFeature()` in modules?

forRoot() → used in the root module to configure a module globally (e.g., database connection).
forFeature() → used in feature modules to register entities or repositories.

15. How does NestJS support Microservices?

Provides @nestjs/microservices package.
Supports TCP, Redis, Kafka, RabbitMQ, NATS, and gRPC.
Uses message-based communication instead of HTTP.

16. What is the difference between `@Module()` imports, providers, controllers, and exports?

imports → modules to import\
controllers → handle requests\
providers → services/business logic\
exports → services to share with other modules

17. How does NestJS handle authentication?

Using Passport.js strategy integration (@nestjs/passport).
JWT-based authentication is most common.
Guard + Strategy pattern (JwtAuthGuard).

18. What is the lifecycle of a request in NestJS?

Middleware → Guards → Interceptors (before) → Pipes → Controller →
Service → Interceptors (after) → Response → Filters (if error).

19. What is the difference between Monorepo and Microservice architecture in NestJS?

Monorepo: All apps/services in a single repo with shared code.
Microservice: Independent services communicating via events/messages.
NestJS supports both.

20. How do you implement caching in NestJS?

Use @nestjs/cache-manager or Redis.
Example: CacheInterceptor to cache responses.
Can also use manual caching with cacheManager.set() and cacheManager.get().

MySQL Queries

codingKrills — Tue, 23 Sep 2025 16:40:19 +0000

PostgreSQL Important Queries for 5+ Years Experience

1. Database Basics

\l  -- Show all databases
\c dbname;  -- Connect to a database
\dt;  -- Show all tables in current schema
\d tablename;  -- Show table structure

2. CRUD Operations

INSERT INTO users (name, email, age) VALUES ('Pulkit', 'pulkit@example.com', 28);
SELECT * FROM users;
UPDATE users SET age = 29 WHERE id = 1;
DELETE FROM users WHERE id = 1;

3. Filtering & Sorting

SELECT * FROM orders WHERE status = 'completed' ORDER BY created_at DESC;
SELECT * FROM products WHERE price BETWEEN 100 AND 500;
SELECT * FROM users WHERE id IN (1,2,3);
SELECT * FROM customers WHERE name LIKE 'Pul%';

4. Joins

-- Inner Join
SELECT u.name, o.id, o.amount FROM users u INNER JOIN orders o ON u.id = o.user_id;

-- Left Join
SELECT u.name, o.id FROM users u LEFT JOIN orders o ON u.id = o.user_id;

-- Right Join
SELECT u.name, o.id FROM users u RIGHT JOIN orders o ON u.id = o.user_id;

-- Full Join
SELECT u.name, o.id FROM users u FULL JOIN orders o ON u.id = o.user_id;

-- Cross Join
SELECT * FROM users CROSS JOIN roles;

5. Grouping & Aggregations

SELECT status, COUNT(*) FROM orders GROUP BY status;
SELECT user_id, COUNT(*) as total_orders FROM orders GROUP BY user_id HAVING COUNT(*) > 5;

6. Subqueries

SELECT name FROM users WHERE id IN (SELECT user_id FROM orders WHERE amount > 500);
SELECT name, (SELECT COUNT(*) FROM orders o WHERE o.user_id = u.id) as total_orders FROM users u;

7. Common Table Expressions (CTEs)

WITH recent_orders AS (
  SELECT * FROM orders WHERE created_at > NOW() - INTERVAL '30 days'
)
SELECT * FROM recent_orders WHERE status = 'completed';

WITH RECURSIVE employee_hierarchy AS (
  SELECT id, manager_id, name FROM employees WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.manager_id, e.name
  FROM employees e
  INNER JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT * FROM employee_hierarchy;

8. Window Functions

SELECT id, user_id, amount, RANK() OVER (PARTITION BY user_id ORDER BY amount DESC) as rank FROM orders;
SELECT user_id, amount, SUM(amount) OVER (PARTITION BY user_id ORDER BY created_at) as running_total FROM orders;

9. Indexes

CREATE INDEX idx_users_email ON users(email);
CREATE UNIQUE INDEX idx_unique_username ON users(username);
CREATE INDEX idx_active_users ON users(last_login) WHERE active = true;
DROP INDEX idx_users_email;

10. Constraints

ALTER TABLE users ADD CONSTRAINT users_pkey PRIMARY KEY (id);
ALTER TABLE orders ADD CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users(id);
ALTER TABLE users ADD CONSTRAINT unique_email UNIQUE (email);
ALTER TABLE products ADD CONSTRAINT check_price CHECK (price > 0);

11. Transactions

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

BEGIN;
DELETE FROM orders WHERE id = 100;
ROLLBACK;

12. Advanced Queries

INSERT INTO users (id, name, email) VALUES (1, 'Pulkit', 'pulkit@example.com')
ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email;

SELECT data->>'name' as username FROM users_json WHERE data->>'role' = 'admin';
SELECT * FROM posts WHERE tags @> ARRAY['nestjs'];

13. Performance Tools

EXPLAIN SELECT * FROM orders WHERE user_id = 5;
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 5;
SELECT * FROM pg_stat_activity;

14. User & Role Management

CREATE USER devuser WITH PASSWORD 'password';
GRANT ALL PRIVILEGES ON DATABASE mydb TO devuser;
REVOKE ALL PRIVILEGES ON DATABASE mydb FROM devuser;

15. Backup & Restore

pg_dump -U username dbname > backup.sql
psql -U username dbname < backup.sql

Pro Tip: Focus on CRUD, joins, aggregation, CTEs, window functions, indexing, transactions, and JSON operations for interviews and high-scale applications.

MongoDB Queries

codingKrills — Tue, 23 Sep 2025 16:40:03 +0000

S3 uploads

codingKrills — Tue, 23 Sep 2025 16:39:47 +0000

How to set up SSH on a new MacBook (M1) and connect to GitHub

codingKrills — Sat, 06 Sep 2025 09:29:26 +0000

TL;DR (what you'll do)

Check for existing SSH keys.
Create a new ed25519 SSH key (recommended).
Add the key to the ssh-agent and macOS Keychain.
Add the public key to your GitHub account.
Configure ~/.ssh/config so your key loads automatically.
Test the connection and switch existing repos to SSH.

Why SSH?

SSH lets your Mac authenticate with GitHub without typing your username/password (or a PAT) for every git push. It's secure, fast, and the standard for developers.

1) Check for existing keys

Open Terminal and run:

ls -al ~/.ssh

If the folder doesn't exist or you don't see id_ed25519/id_rsa, you're clear to create a new key. If you see keys you still want to keep, note their names.

2) Generate a new key (use `ed25519` if possible)

ed25519 is modern and compact. Replace the email with your GitHub email:

ssh-keygen -t ed25519 -C "your_email@example.com"

When prompted for a file to save the key, press Enter to accept the default (~/.ssh/id_ed25519) unless you want multiple keys. Add a passphrase for an extra layer of security (recommended), or press Enter to leave it empty.

If ed25519 isn’t supported on your system, use RSA:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

3) Start the ssh-agent and add your key

Start the agent in your shell session:

eval "$(ssh-agent -s)"

Then add your new private key to the agent and (on macOS) save the passphrase in the Keychain so you won't need to enter it repeatedly.

# On macOS Monterey (12.0) and later (Apple's ssh-add):
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# On older macOS versions (pre-Monterey) you can use:
ssh-add -K ~/.ssh/id_ed25519

# Fallback (simple add, no keychain behaviour):
ssh-add ~/.ssh/id_ed25519

If ssh-add --apple-use-keychain fails (e.g. ssh-add: illegal option -- apple-use-keychain), you're probably using a non-Apple ssh-add (Homebrew’s OpenSSH). Check which binary is being used with which ssh-add and use /usr/bin/ssh-add --apple-use-keychain ~/.ssh/id_ed25519 or remove/adjust the Homebrew version.

4) Configure `~/.ssh/config` so macOS automatically uses your key

Create or edit ~/.ssh/config and add these lines (this makes the ssh-agent use your key and use Keychain on macOS):

Host github.com
  HostName github.com
  User git
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519

This is especially helpful if you have multiple keys or want passphrases remembered.

5) Copy the public key and add it to GitHub

Copy the public key to clipboard (macOS):

pbcopy < ~/.ssh/id_ed25519.pub

Or display it for manual copy:

cat ~/.ssh/id_ed25519.pub

Then in GitHub: Settings → SSH and GPG keys → New SSH key. Give it a descriptive title (e.g. MacBook-M1) and paste the key.

6) Test the connection

Run:

ssh -T git@github.com

On success you'll see something like:

Hi <your-username>! You've successfully authenticated, but GitHub does not provide shell access.

If you see Permission denied (publickey), continue to the troubleshooting section below.

7) Switch an existing repo to SSH (if needed)

Inside your repo:

git remote -v
# to check current remote, if it shows https, switch it to ssh:
git remote set-url origin git@github.com:USERNAME/REPO.git

Or clone using SSH:

git clone git@github.com:USERNAME/REPO.git

Troubleshooting

ssh-add: illegal option -- apple-use-keychain

Cause: ssh-add installed from Homebrew (or another source) doesn't include Apple's --apple-use-keychain flag.
Fix: Run which ssh-add to see which binary is being used. Apple's ssh-add lives at /usr/bin/ssh-add. Call it directly or remove/adjust the PATH for the Homebrew ssh. See the ssh-add --apple-use-keychain behaviour in man ssh-add if necessary.

Permission denied (publickey)

Common causes:
- The private key wasn't loaded to the agent. Run ssh-add -l to list loaded keys.
- Wrong file permissions on ~/.ssh or key files. Fix with:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

You added the wrong public key to GitHub (copy/paste error). Re-copy with pbcopy < ~/.ssh/id_ed25519.pub.
The remote is still using HTTPS — check with git remote -v.

Verbose debug output
Run a verbose SSH attempt to see what key is being offered:

ssh -vT git@github.com

Multiple GitHub accounts (personal vs work)
If you need separate keys for different accounts, create two keys:

# personal
ssh-keygen -t ed25519 -C "personal@example.com" -f ~/.ssh/id_ed25519_personal

# work
ssh-keygen -t ed25519 -C "work@example.com" -f ~/.ssh/id_ed25519_work

Then add them to your ~/.ssh/config:

# Personal
Host github-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_personal
  AddKeysToAgent yes
  UseKeychain yes

# Work
Host github-work
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_work
  AddKeysToAgent yes
  UseKeychain yes

Use the host alias when cloning or setting remotes, for example:

git clone git@github-personal:yourusername/yourrepo.git
# or set remote
git remote set-url origin git@github-work:yourorg/repo.git

Extra notes for Apple Silicon (M1) users

Homebrew installs on M1 use /opt/homebrew by default; this can install a different ssh/ssh-add under /opt/homebrew/bin which may not support Apple-specific flags. If you face issues with --apple-use-keychain, check which ssh-add and use /usr/bin/ssh-add when necessary.
zsh is the default shell on modern macOS. Add ssh-add --apple-load-keychain ~/.ssh/id_ed25519 2>/dev/null or the ssh-add --apple-use-keychain command to your ~/.zshrc if you want keys to load automatically after login.

# Setup SSH & GitHub on macOS (M1)

## Steps

1. Check for existing keys:

   ```

bash
   ls -al ~/.ssh

Generate an ED25519 key (replace email):


bash
   ssh-keygen -t ed25519 -C "your_email@example.com"

Start ssh-agent and add key (macOS):


bash
   eval "$(ssh-agent -s)"
   ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Add the following to ~/.ssh/config:


text
   Host github.com
     HostName github.com
     User git
     AddKeysToAgent yes
     UseKeychain yes
     IdentityFile ~/.ssh/id_ed25519

Copy the public key and add it to GitHub Settings → SSH and GPG keys:


bash
   pbcopy < ~/.ssh/id_ed25519.pub

Test connection:


bash
   ssh -T git@github.com

Switch an existing repo to SSH:


bash
   git remote set-url origin git@github.com:USERNAME/REPO.git

Troubleshooting tips

ssh-add --apple-use-keychain not found: run which ssh-add and ensure you're using /usr/bin/ssh-add (Apple’s version).
Permission denied (publickey): check ssh-add -l, ssh -vT git@github.com, and file permissions.




---

# Final checklist (quick)
- [ ] Generated a key: `~/.ssh/id_ed25519`
- [ ] Added key to ssh-agent & Keychain
- [ ] Pasted public key into GitHub
- [ ] Confirmed `ssh -T git@github.com` succeeds
- [ ] Updated repo remotes to SSH

---