DEV Community: Shyam Tala

How I Accidentally Deleted My Project Environments and Used VS Code’s Timeline to Save the Day

Shyam Tala — Thu, 20 Mar 2025 05:28:37 +0000

Yesterday, in a moment of sheer genius (read: foolishness), I accidentally deleted my project’s .env file. No big deal, right? Just check the bin folder and restore it. Except… it wasn’t there. My .env had vanished into the void.

Cue panic mode. 😱

The Panic: Googling My Way to Nowhere

I did what any developer would do: I Googled. I read blogs, Stack Overflow threads, and even watched a few YouTube tutorials. But nothing worked. My environments were lost in the digital abyss, and I was starting to accept my fate.

Then, like a glimmer of hope, I remembered something: VS Code’s Timeline feature.

The Savior: VS Code’s Timeline

For those who don’t know, VS Code’s Timeline is like a time machine for your files. It shows you the history of changes, and you can restore previous versions with a single click. I opened the Timeline, scrolled through the history, and there they were—my precious environments, waiting to be resurrected.

I clicked “Restore,” and just like that, my environments were back. Crisis averted.

Lessons Learned (The Easy Way):

Backup Everything: This incident taught me the importance of backups. Whether it’s a simple copy-paste or an automated system, always have a backup plan.
VS Code Timeline is a Game-Changer: If you’re not using this feature, you’re missing out. It’s like having an undo button for your entire project.
Think Twice, Delete Once: That delete button is dangerous. Always double-check before you hit it.
Stay Calm and Google On: When things go wrong, take a deep breath and start searching for solutions. The answer might be closer than you think.

Final Thoughts

Next time you delete something important, don’t lose hope. Your savior might be just a few clicks away. And with that, I close this chapter of The Lost & Found Dev Files Saga.

Stay safe, and may your .env files always be recoverable! 🚀

How to Manage Multiple GitHub Accounts on macOS (Like an IT Moonlighter) 🌙💻

Shyam Tala — Mon, 17 Mar 2025 05:51:46 +0000

Juggling Work and Side Projects Without GitHub Drama

So, you’re living the double life—full-time dev by day, side-hustle coding wizard by night. Managing multiple GitHub accounts can feel like having two secret identities. If you’ve ever accidentally committed work code with your personal account or vice versa, you know the pain. 😅

But don’t worry! With SSH keys and a little Git magic, you can seamlessly switch between accounts like a pro. Let’s set things up!

1. Generate SSH Keys for Each GitHub Account 🔑

Think of SSH keys as the ID badges for your GitHub accounts. You need separate badges for work and personal projects.

Open your terminal and run:

# Personal GitHub account
ssh-keygen -t ed25519 -C "personal@email.com" -f ~/.ssh/personal

# Work GitHub account
ssh-keygen -t ed25519 -C "work@email.com" -f ~/.ssh/work

What’s Happening Here?

-t ed25519: Uses a secure encryption type (your digital badge).
-C "email": Tags the key with your email.
-f ~/.ssh/filename: Saves the keys separately.

Congrats! You now have two sets of SSH keys:

~/.ssh/personal (for personal repos)
~/.ssh/work (for work repos)

2. Configure SSH to Know Who’s Who 🎭

Now, let’s teach SSH when to use which key. Open the SSH config file:

sudo nano ~/.ssh/config

Add this:

# Personal GitHub account
Host github.com-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/personal

# Work GitHub account
Host github.com-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/work

Breakdown:

Host: Custom alias (makes switching easy).
IdentityFile: Tells SSH which key to use.
HostName: Points to GitHub.

Save the file (Ctrl + O, Enter, then Ctrl + X) and update permissions:

chmod 600 ~/.ssh/config

Now SSH knows when to wear the "personal" badge and when to wear the "work" badge. ✅

3. Add Your SSH Keys to GitHub 🔗

You need to introduce these SSH keys to GitHub (so it lets you in).

Run:

cat ~/.ssh/personal.pub  # Copy this key for personal GitHub
cat ~/.ssh/work.pub      # Copy this key for work GitHub

Go to GitHub > Settings > SSH and GPG keys → Click New SSH key, paste it in, and save.

Repeat for both accounts. Now GitHub knows who you are! 🎉

4. Test Your SSH Connection 🛠️

Let’s confirm everything is working:

ssh -T git@github.com-personal
ssh -T git@github.com-work

If you see "Hi username! You’ve successfully authenticated", you’re good to go!

5. Set Up Git to Use the Right Account 📝

Now, let’s make sure Git commits are using the correct account.

Step 1: Edit Your Global Git Config

Run:

sudo nano ~/.gitconfig

Add:

[includeIf "gitdir:~/personal/"]
    path = ~/.gitconfig-personal

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

This tells Git to use different configs based on the project folder.

Step 2: Create Account-Specific Configs

For personal:

echo -e "[user]\n    name = Your Personal Name\n    email = personal@email.com" > ~/.gitconfig-personal

For work:

echo -e "[user]\n    name = Your Work Name\n    email = work@email.com" > ~/.gitconfig-work

Now, when you’re in ~/personal/, Git uses personal@email.com, and in ~/work/, it switches to work@email.com. 🚀

6. Cloning and Pushing Without Headaches 🔄

Always use the right SSH alias when cloning repositories:

# Personal repos
git clone git@github.com-personal:username/repo.git

# Work repos
git clone git@github.com-work:username/repo.git

Already cloned the repo? Update the remote:

git remote set-url origin git@github.com-personal:username/repo.git

Now you’ll never push personal code to work or vice versa by mistake. 😎

7. Apply Configuration Locally

To apply the configuration for a specific repository, you can use the following command inside the project directory:

git config --local include.path ~/.gitconfig-personal

8. Troubleshooting Common Issues 🛑

SSH Connection Fails? ❌

Run:

ssh-add ~/.ssh/personal
ssh-add ~/.ssh/work

Test again: ssh -T git@github.com-personal

Git Using the Wrong Email? 🤦‍♂️

Check:

git config user.email

Fix it:

git config user.email "correct@email.com"

Now your commits will always be tied to the right account.

Conclusion 🎉

That’s it! Now you can switch between GitHub accounts effortlessly—just like balancing your 9-to-5 and your moonlight coding gigs. 🌙💼

No more “oops, wrong account” commits. Just smooth sailing between personal and work projects. Happy coding! 🚀

JavaScript Closures Explained with a Crazy Grandfather’s Treasure 🏴‍☠️💰

Shyam Tala — Mon, 17 Mar 2025 05:15:23 +0000

Imagine you have a crazy rich grandfather (let's call him Grandpa Closure) who is very protective of his treasure. 💎

Grandpa’s Rule:

“You can see the treasure, you can use the treasure, but you can’t steal the key to my vault!” 😤

So, he locks up his wealth in a secret underground vault and only gives you a helper (a butler named getTreasure()) to access it.

JavaScript Version of Grandpa Closure’s Vault

function GrandpaClosure() {
    let treasure = "💰 100kg of Gold & a Flying Car 🚗✨";  // Secret wealth

    return function getTreasure() {
        return `Here’s your inheritance: ${treasure}`;
    };
}

// You (the grandchild) get access to the treasure through the butler
const grandchild = GrandpaClosure();

console.log(grandchild()); // Here’s your inheritance: 💰 100kg of Gold & a Flying Car 🚗✨

// But you can’t directly access Grandpa's vault!
console.log(grandchild.treasure); // Undefined 😭
console.log(typeof treasure); // Undefined 😵

What Just Happened? 🤯

GrandpaClosure() runs and creates the secret treasure (variable) inside it.
It returns a function (getTreasure), which acts like a butler that remembers where the vault is.
Even though GrandpaClosure() is finished, the getTreasure() function still remembers the treasure.
But you can’t directly access treasure because it’s locked inside the function scope.

That’s Closure! 🎉

The butler (getTreasure()) remembers the treasure but doesn’t give you the vault key!

Can I Ask Grandpa to Add More Gold? 🧐

Nope! He doesn’t trust you that much! 😂 You only get read access, but let’s say Grandpa decides:

"Okay, you can add more to the treasure, but only through a secret code!"

Now, we modify the code:

function GrandpaClosure() {
    let treasure = "💰 100kg of Gold & a Flying Car 🚗✨";

    return {
        getTreasure: function() {
            return `Here’s your inheritance: ${treasure}`;
        },
        addGold: function(amount) {
            treasure += ` + ${amount} Gold`;
            return `Gold added! New total: ${treasure}`;
        }
    };
}

// You get access to the butler’s functions, not the vault!
const grandchild = GrandpaClosure();

console.log(grandchild.getTreasure()); // Here’s your inheritance: 💰 100kg of Gold & a Flying Car 🚗✨
console.log(grandchild.addGold("50kg")); // Gold added! New total: 💰 100kg of Gold & a Flying Car 🚗✨ + 50kg Gold
console.log(grandchild.getTreasure()); // Here’s your inheritance: 💰 100kg of Gold & a Flying Car 🚗✨ + 50kg Gold

Moral of the Story? 🤓

Closures are like Grandpa’s Secret Vault – Some things remain private but can still be accessed indirectly.
You can retrieve treasure, but you can’t steal it! – You get access to functions that remember the variables, but you can’t directly change them.
Closures help protect your JavaScript code – Just like Grandpa protects his wealth from greedy grandkids! 😂

Final Thought

Next time someone asks you what a closure is, just tell them:

"It’s like having a Grandpa who hides all his money in a secret vault, only lets you take a peek through a butler, and won’t let you touch the key!"

That’s closures in JavaScript! 🎩💰💎🚀

🚀 Introducing rate-bouncer: A Powerful Rate Limiting Middleware for Node.js

Shyam Tala — Tue, 11 Mar 2025 12:45:25 +0000

Introduction

In today's fast-paced digital world, APIs are the backbone of web applications, enabling seamless data exchange. However, APIs are vulnerable to abuse, such as Denial-of-Service (DoS) attacks, excessive bot traffic, and accidental request floods. To combat these challenges, rate limiting is essential. This is where rate-bouncer comes into play! 🎯

rate-bouncer is a lightweight and flexible rate-limiting middleware for Node.js, designed to protect your API from excessive requests while ensuring legitimate users have a smooth experience.

Why Use `rate-bouncer`? 🤔

✅ Prevents API Abuse: Stops malicious bots and excessive traffic from overwhelming your server.
✅ Customizable: Offers global and per-route configurations, allowing fine-tuned control.
✅ Lightweight & Fast: Minimal footprint with in-memory storage for quick lookups.
✅ Easy Integration: Works effortlessly with Express and similar frameworks.
✅ Automatic Cleanup: Optimizes memory usage by periodically removing old request data.

Getting Started 🚀

Installation

You can install rate-bouncer using npm:

npm install rate-bouncer

Basic Usage

Setting up rate-bouncer in an Express app is straightforward:

const express = require("express");
const { setGlobalRateLimitConfig, rateLimitConfig } = require("rate-bouncer");

const app = express();

// Set global rate limit (applies to all routes unless overridden)
setGlobalRateLimitConfig({
  duration: 15 * 60 * 1000, // 15 minutes
  maxRequests: 100, // Max 100 requests per 15 minutes
  startCleanupInterval: 50000, // Cleanup interval (optional)
});

// Apply rate limiter globally
app.use(rateLimitConfig());

app.get("/api/data", (req, res) => {
  res.send("This route is protected by rate limiting.");
});

app.listen(3000, () => console.log("Server running on port 3000"));

Advanced Configuration ⚙️

Per-Route Customization

Override global settings for specific routes when needed:

app.get(
  "/api/special",
  rateLimitConfig({ duration: 10 * 60 * 1000, maxRequests: 50 }),
  (req, res) => {
    res.send("Limited to 50 requests per 10 minutes.");
  }
);

Disabling Rate Limiting

Need to exclude certain routes? Simply disable rate limiting:

app.get("/api/open", rateLimitConfig({ disabled: true }), (req, res) => {
  res.send("This route has no rate limit.");
});

Handling Exceeded Limits ⚠️

When a user exceeds the allowed request count, they receive a 429 Too Many Requests response:

{
  "message": "Too many requests",
  "retryAfter": "10.0 seconds"
}

Best Practices for Using `rate-bouncer` 🔥

Choose the Right Limits: Set appropriate request limits based on your API's needs.
Use Different Limits for Different Routes: Critical routes may need stricter limits than public endpoints.
Combine with Authentication: Rate limiting works best when combined with authentication and IP-based restrictions.
Monitor Traffic: Regularly check logs to fine-tune rate limits based on real-world usage.

Conclusion 🎯

Rate limiting is a crucial defense against API abuse and traffic overloads. rate-bouncer makes it incredibly easy to implement rate limiting in Node.js applications with minimal setup and maximum flexibility. By integrating this lightweight middleware, you can protect your API, enhance security, and provide a smooth user experience.

Give rate-bouncer a try today! 🚀

👉 Check it out on GitHub: rate-bouncer

Happy coding! 💻🔥

Global Error Handling in Express.js: Best Practices

Shyam Tala — Mon, 10 Mar 2025 07:07:16 +0000

Error handling is a crucial part of any backend application. In Express.js, an error can occur due to various reasons such as invalid user input, database failures, or unexpected issues in the application logic. To ensure a smooth user experience and maintainability, implementing a global error handler is essential.

In this blog, we will explore what a global error handler is, how to implement it in Express.js, and best practices to follow.

📌 What is Global Error Handling in Express.js?

In Express.js, middleware functions are executed in a sequence, and errors can propagate through them. A global error handler is a special middleware function that:

✅ Catches errors from any part of the application.

✅ Prevents the app from crashing due to unhandled errors.

✅ Provides consistent error responses.

✅ Helps in debugging and logging.

By defining a centralized error handler, we can manage all application errors in one place.

🛠 How to Implement a Global Error Handler in Express.js

Step 1: Basic Express App Setup

First, create a basic Express server.

const express = require("express");
const app = express();

// Middleware to parse JSON
app.use(express.json());

// Sample Route
app.get("/", (req, res) => {
  throw new Error("Something went wrong!");
});

// Start the server
app.listen(3000, () => console.log("Server running on port 3000"));

At this stage, if an error occurs in a route, Express will return a default HTML error response. We need a custom global error handler to return structured JSON responses.

Step 2: Define a Global Error Handler Middleware

An error-handling middleware must have four parameters: (err, req, res, next).

// Global Error Handling Middleware
app.use((err, req, res, next) => {
  console.error(err.stack); // Log the error

  res.status(500).json({
    success: false,
    message: err.message || "Internal Server Error",
  });
});

🔹 Important: The global error handler must be defined after all routes; otherwise, it won’t work.

🔄 Throwing and Handling Errors in Express.js

1️⃣ Synchronous Errors

Simply throwing an error inside a route will be caught by the error handler:

app.get("/sync-error", (req, res) => {
  throw new Error("Synchronous error occurred!");
});

2️⃣ Asynchronous Errors

For async functions, always pass the error to next(err):

app.get("/async-error", async (req, res, next) => {
  try {
    await someAsyncOperation();
  } catch (err) {
    next(err); // Pass the error to the global handler
  }
});

🚀 Enhancing the Global Error Handler

Handling Different Error Types

You can customize responses based on error types:

app.use((err, req, res, next) => {
  let statusCode = err.status || 500;
  let message = err.message || "Internal Server Error";

  if (err.name === "ValidationError") {
    statusCode = 400;
    message = "Invalid data provided";
  }

  res.status(statusCode).json({
    success: false,
    error: message,
  });
});

Creating a Custom Error Class

To make error handling even cleaner, define a custom error class:

class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
  }
}

Now, you can throw errors like this:

app.get("/custom-error", (req, res, next) => {
  return next(new AppError("Resource not found", 404));
});

Modify the error handler to handle this class:

app.use((err, req, res, next) => {
  res.status(err.statusCode || 500).json({
    success: false,
    message: err.message,
  });
});

⚡ Using `express-async-errors` for Cleaner Async Error Handling

Instead of manually wrapping async functions in try-catch, install express-async-errors:

npm install express-async-errors

Then import it in your server.js:

require("express-async-errors");

Now, async errors will automatically be passed to the global handler:

app.get("/async-error", async (req, res) => {
  const data = await someAsyncOperation(); // No try-catch needed
  res.json(data);
});

🚨 Common Mistakes to Avoid

❌ Defining the Error Handler Before Routes

Error handlers must be defined after all routes.

❌ Wrong Order:

app.use((err, req, res, next) => { /* Error Handler */ }); // ❌
app.get("/", (req, res) => { throw new Error("Test Error"); });

✅ Correct Order:

app.get("/", (req, res) => { throw new Error("Test Error"); });
app.use((err, req, res, next) => { /* Error Handler */ }); // ✅

❌ Not Logging Errors for Debugging

Always log errors for debugging:

console.error(err.stack);

❌ Not Handling Different Error Types

Handle validation errors separately for better responses.

🎯 Best Practices for Global Error Handling

✅ Keep the error handler at the bottom of the middleware stack.

✅ Use a custom error class for cleaner error handling.

✅ Log errors to a file or a monitoring service (e.g., Winston, Sentry).

✅ Handle validation errors differently from server errors.

✅ Use express-async-errors to avoid repetitive try-catch blocks.

🎉 Conclusion

A well-implemented global error handler in Express.js ensures that your application is robust, maintains a good user experience, and makes debugging easier. By following best practices, handling different error types, and using custom error classes, you can create a clean and maintainable error-handling mechanism.

🔹 Now you’re ready to handle errors like a pro in your Express.js apps! 🚀

🚀 Introducing Git Styler: Make Your Git Commits Cleaner and Faster!

Shyam Tala — Fri, 07 Mar 2025 11:49:46 +0000

Tired of messy commit messages? Keeping a clean Git history is crucial for collaboration, but writing well-structured commit messages every time can be a hassle. Enter Git Styler – a CLI tool that simplifies commit message styling and enforces structure effortlessly. 🚀

Why Git Styler? 🤔

Writing commit messages manually can lead to inconsistencies like:

Unclear or unformatted commit messages
Inconsistent use of emojis or prefixes
No standard format for different types of commits

Git Styler solves this by providing easy-to-use commands for well-structured commits, following conventional commit formats.

🌟 Features

✅ Predefined commit types with appropriate emojis 📦 🐛 ♻️ 📖

✅ Shortcut commands for quick commits (e.g., gfeat, gfix, grel, etc.)

✅ Automatic git push after committing changes

✅ Color-coded logs for better visibility

✅ No extra configuration needed – works out of the box!

🚀 Installation

Git Styler should be installed globally so that commands are available system-wide.

npm install -g git-styler

⚠️ Avoid local installation (npm install git-styler), as the commands won't be recognized outside the project.

📌 How It Works

Git Styler introduces easy-to-remember commands for different commit types. Here are some examples:

Command	Emoji	Type
`gfeat`	📦	NEW (Feature)
`gimp`	👌	IMPROVE (Enhancement)
`gfix`	🐛	FIX (Bug Fix)
`gdoc`	📖	DOC (Documentation)
`gtest`	🤖	TEST (Testing)
`gbreak`	‼️	BREAKING (Breaking Change)
`grel`	🦄	RELEASE (Release)
`gref`	♻️	REFACTOR (Refactor Code)

✨ Usage Examples

1️⃣ Standard Commit

Instead of writing:

git add . && git commit -m "Added a new authentication module" && git push

Simply run:

gfeat "Added a new authentication module"

🔹 This automatically formats the commit as:

git commit -m "📦 NEW: Added a new authentication module"

2️⃣ Releasing a New Version

grel "Version 1.0.0 release"

👉 This runs:

git commit -m "🦄 RELEASE: Version 1.0.0 release" && git push

🔍 Debugging & Help

If you run into any issues, check available commands with:

git-styler --help

🛠️ How Git Styler Works Under the Hood

Git Styler is built using:

Commander.js – For handling CLI commands
child_process – To execute Git commands
path module – For script detection

The tool intercepts Git commands and ensures they follow a structured format before committing. No extra configuration is needed! 🎉

📢 Spread the Word!

If you find Git Styler useful, please star the GitHub repo and share it with your team! ⭐

GitHub Repo

🚀 Start making your commit history cleaner today!

npm install -g git-styler

Let me know what you think in the comments! Happy coding! 🎉

DEV Community: Shyam Tala

How I Accidentally Deleted My Project Environments and Used VS Code’s Timeline to Save the Day

The Panic: Googling My Way to Nowhere

The Savior: VS Code’s Timeline

Lessons Learned (The Easy Way):

Final Thoughts

How to Manage Multiple GitHub Accounts on macOS (Like an IT Moonlighter) 🌙💻

Juggling Work and Side Projects Without GitHub Drama

1. Generate SSH Keys for Each GitHub Account 🔑

What’s Happening Here?

2. Configure SSH to Know Who’s Who 🎭

Breakdown:

3. Add Your SSH Keys to GitHub 🔗

4. Test Your SSH Connection 🛠️

5. Set Up Git to Use the Right Account 📝

Step 1: Edit Your Global Git Config

Step 2: Create Account-Specific Configs

6. Cloning and Pushing Without Headaches 🔄

7. Apply Configuration Locally

8. Troubleshooting Common Issues 🛑

SSH Connection Fails? ❌

Git Using the Wrong Email? 🤦‍♂️

Conclusion 🎉

JavaScript Closures Explained with a Crazy Grandfather’s Treasure 🏴‍☠️💰

Grandpa’s Rule:

JavaScript Version of Grandpa Closure’s Vault

What Just Happened? 🤯

Can I Ask Grandpa to Add More Gold? 🧐

Moral of the Story? 🤓

Final Thought

🚀 Introducing rate-bouncer: A Powerful Rate Limiting Middleware for Node.js

Introduction

Why Use rate-bouncer? 🤔

Getting Started 🚀

Installation

Basic Usage

Advanced Configuration ⚙️

Per-Route Customization

Disabling Rate Limiting

Handling Exceeded Limits ⚠️

Best Practices for Using rate-bouncer 🔥

Conclusion 🎯

Global Error Handling in Express.js: Best Practices

📌 What is Global Error Handling in Express.js?

🛠 How to Implement a Global Error Handler in Express.js

Step 1: Basic Express App Setup

Step 2: Define a Global Error Handler Middleware

🔄 Throwing and Handling Errors in Express.js

1️⃣ Synchronous Errors

2️⃣ Asynchronous Errors

🚀 Enhancing the Global Error Handler

Handling Different Error Types

Creating a Custom Error Class

⚡ Using express-async-errors for Cleaner Async Error Handling

🚨 Common Mistakes to Avoid

❌ Defining the Error Handler Before Routes

❌ Not Logging Errors for Debugging

❌ Not Handling Different Error Types

🎯 Best Practices for Global Error Handling

🎉 Conclusion

🚀 Introducing Git Styler: Make Your Git Commits Cleaner and Faster!

Why Git Styler? 🤔

🌟 Features

🚀 Installation

📌 How It Works

✨ Usage Examples

1️⃣ Standard Commit

2️⃣ Releasing a New Version

🔍 Debugging & Help

🛠️ How Git Styler Works Under the Hood

📢 Spread the Word!

Why Use `rate-bouncer`? 🤔

Best Practices for Using `rate-bouncer` 🔥

⚡ Using `express-async-errors` for Cleaner Async Error Handling