Forem: Eduardo Calzone

Make Your TypeScript API Responses Safer with Zod (in seconds)

Eduardo Calzone — Mon, 16 Jun 2025 16:13:31 +0000

One of the most common problems we run into when trying to type our API responses—besides it being kind of tedious—is that we have zero control over when the API might change. And when it does... boom 💥 — your app can crash without warning.

The solution? Use the Zod library.

Zod lets you check your API responses at runtime, so you can make sure you're getting exactly what you expect—with the right types. No more silent type mismatches or weird crashes because the backend changed something without telling you.

🚀 Let’s See It in Action

Let’s say you’re calling a public API, like the Rick and Morty API, and you want to safely handle its response.

🔹 First, we hit the endpoint to get all the characters. 🎯

🔸 Next, we head over to Quicktype
Quicktype is a handy tool that turns raw JSON into ready-to-use TypeScript types. Super useful when working with API responses. ⚙️📦

There, we paste the JSON response from the characters endpoint into the left-hand panel.
Then, we select TypeScript with Zod on the right side to generate the corresponding schema. ⚡

🧪 Then, we drop the schema into our app and run a quick test to make sure everything works.

import * as z from "zod";


export const GenderSchema = z.enum([
    "Female",
    "Male",
    "unknown",
]);
export type Gender = z.infer<typeof GenderSchema>;


export const SpeciesSchema = z.enum([
    "Alien",
    "Human",
]);
export type Species = z.infer<typeof SpeciesSchema>;


export const StatusSchema = z.enum([
    "Alive",
    "Dead",
    "unknown",
]);
export type Status = z.infer<typeof StatusSchema>;

export const InfoSchema = z.object({
    "count": z.number(),
    "pages": z.number(),
    "next": z.string(),
    "prev": z.null(),
});
export type Info = z.infer<typeof InfoSchema>;

export const LocationSchema = z.object({
    "name": z.string(),
    "url": z.string(),
});
export type Location = z.infer<typeof LocationSchema>;

export const ResultSchema = z.object({
    "id": z.number(),
    "name": z.string(),
    "status": StatusSchema,
    "species": SpeciesSchema,
    "type": z.string(),
    "gender": GenderSchema,
    "origin": LocationSchema,
    "location": LocationSchema,
    "image": z.string(),
    "episode": z.array(z.string()),
    "url": z.string().url(),
    "created": z.coerce.date(),
});
export type Result = z.infer<typeof ResultSchema>;

export const RickAndMortyTypesSchema = z.object({
    "info": InfoSchema,
    "results": z.array(ResultSchema),
});
export type RickAndMortyTypes = z.infer<typeof RickAndMortyTypesSchema>;


async function fetchCharacters() {
  try {
    const res = await fetch("https://rickandmortyapi.com/api/character");

    if (!res.ok) {
      throw new Error(`HTTP error: ${res.status}`);
    }

    const json = await res.json();

    const parsed = RickAndMortyTypesSchema.safeParse(json);

    if (!parsed.success) {
      console.error("❌ Invalid API response:", parsed.error.format());
      return;
    }

    const data: RickAndMortyTypes = parsed.data;
    console.log("✅ Valid data:", data);
  } catch (err) {
    console.error("❌ Fetch failed:", err);
  }
}

fetchCharacters();

🚀 Now, the final test!
Let’s call the endpoint and validate the response using our new Zod schema. If everything works, we’ll get a fully typed, safe result — and if not, Zod will let us know! ✅⚠️

⚠️ We also introduce a deliberate error by setting name as a number instead of a string, so we can see Zod in action catching the issue. 🛑👀

✅ We observe the expected behavior, confirming that Zod validates our data correctly. 🎯

Source: Typescript Zod Validator

Happy coding! 🥳

Stop using console.log: Debug Smarter ⚡

Eduardo Calzone — Thu, 29 May 2025 18:19:41 +0000

Are you always hitting console.log like it's the only tool you’ve got?

Sure, it gets the job done—but did you know there are other console tricks that can make debugging way easier (and cooler)? Let’s give your dev life a little upgrade. 😎🛠️

Here’s a breakdown of the most useful console methods:

`console.info()` ℹ️

Print informational messages that are helpful but less critical.

console.info("Server started successfully");

`console.warn()` ⚠️

Show warning messages that alert you to potential issues.

console.warn("⚠️ Deprecated API used");

`console.error()` ❌

Display error messages to highlight failures or bugs.

console.error("❌ Failed to load user data");

`console.debug()` 🔍

Print debugging messages (may require enabling verbose mode in some browsers).
Same output as console.log, but with a few differences:

🆚 `console.log()` vs `console.debug()`

Feature	`console.log()` 📝	`console.debug()` 🔍
Purpose	General logging	Detailed debugging info
Visibility	Always visible	May be hidden (requires Verbose mode)
Severity level	Standard	Lower than `log`, filtered by default
Browser support	Visible in all tools	Sometimes hidden unless enabled
Use case	Track flow, show values	Deep inspection during debugging

Use console.debug() for cleaner logs and more control when debugging in depth.

`console.assert()` ✅

Prints a message only if the given condition is false.

console.assert(age >= 18, "🚫 Age must be 18 or older");

`console.count()` 🔢

Count the number of times this line has been executed with an optional label.

console.count("Button click");

`console.countReset()` 🔄

Reset the count for a specific label.

console.countReset("Button click");

`console.time()` ⏱️

Start a timer with a given label to measure how long an operation takes.

console.time("loadTime");
// code to measure
console.timeEnd("loadTime");

`console.group()` 🔗

Start a new console group to organize related messages.

console.group("User Details");
console.log("Name: Nina");
console.log("Age: 28");
console.groupEnd();

`console.table()` 📋

Display data as a formatted table for easier reading.

const users = [
  { name: "Nina", age: 28 },
  { name: "Leo", age: 35 },
];
console.table(users);

`console.trace()` 📣

Print a stack trace to see the path your code took to reach this point.

function start() {
  stepOne();
}

function stepOne() {
  stepTwo();
}

function stepTwo() {
  console.trace("Trace from stepTwo");
}

start();

Did you know console.log can print text with CSS styles? 🎨🖥️

console.log('%cThis text is red and big', 'color: red; font-size: 18px; font-weight: bold;');

Just add %c before the text, then pass your CSS styles as the second argument.

`console.clear()` 🧹

Clear all console output.

console.clear();

Happy coding! 🥳

Supercharge Your Deployments: GitHub Actions + Azure Web App CI/CD

Eduardo Calzone — Mon, 26 May 2025 20:47:34 +0000

📌 Note: This post is based on the source code used in my previous article
👉 Simple Email Sending API with .NET

🔄 What is CI/CD?

CI/CD stands for Continuous Integration and Continuous Delivery (or Continuous Deployment). It’s a set of modern DevOps practices that help teams deliver software faster, safer, and more frequently by automating the build, test, and deployment process.

🔧 Continuous Integration (CI)

CI is all about merging code early and often. Developers push changes to the main branch multiple times a day. Each push triggers automated builds and tests, helping catch bugs and integration issues before they grow into bigger problems.

Benefits:

✅ Catch errors early
✅ Keep the codebase stable
✅ Make collaboration easier

🚀 Continuous Delivery (CD)

CD ensures your app is always ready to deploy. Every change that passes CI is automatically pushed to a staging or test environment. Deploying to production is just one manual click away.

Benefits:

⚡ Faster release cycles
📉 Reduced deployment risks
🧪 Quick feedback from stakeholders

⚡ Continuous Deployment

This takes CD to the next level: every passing change goes straight to production—no manual steps required.

Benefits:

🔁 Real-time updates
🤖 Maximum automation
⏱️ Ultra-fast reaction to bugs or market needs

To pull this off, your test suite needs to be rock solid. Continuous Deployment is the endgame for teams aiming to ship confidently, quickly, and often.

⚙️ What is GitHub Actions?

GitHub Actions is a CI/CD (Continuous Integration and Continuous Delivery) tool built into GitHub. It lets you automate tasks like building, testing, and deploying your code every time you push to a repository.

🔧 What Can You Do With GitHub Actions?

✅ Run tests automatically on each commit or pull request
🚀 Deploy your app to cloud platforms (e.g., Azure, AWS, Heroku)
📦 Build and publish Docker images
🧹 Run code formatters, linters, or cleanup scripts
🧪 Set up custom workflows for any automation

🧠 Why Use It?

🔗 Fully integrated with GitHub

📈 Scales with your project

🙌 Community-driven (tons of reusable actions)

💸 Free minutes included with GitHub plans

If you’re already using GitHub to manage your code, GitHub Actions is a powerful and easy way to automate your entire dev lifecycle.

🛠️ Real-World CI/CD Example with Azure and GitHub

In the following step-by-step guide, we'll walk through a real-world scenario on how to implement a CI/CD pipeline in Azure for a web application hosted in a GitHub repository. These are the steps:

🚀 Create an Azure Web App

Go to https://portal.azure.com and create a new Azure Web App.

Before that, make sure to:

✅ Create a Subscription (if you don't already have one)
✅ Set up a Resource Group to organize your resources

Once these are ready, you can proceed with configuring your web app (choose runtime, region, and plan as needed).

⚙️ Enable Continuous Deployment

We chose to Enable Continuous Deployment. This allows us to select the GitHub repository we want to deploy from directly.

During this step:

🔗 You'll be prompted to authorize GitHub and select your repository and branch.
🔐 It's important to Enable Basic Authentication to allow Azure to access your GitHub repo securely.

Once completed, Azure will automatically pull and deploy changes from your repository whenever you push new commits.

🌐 Configure Access Settings

For the purposes of this tutorial, I selected Enable Public Access.

This allows anyone to access the web app via its public URL, which is useful for testing and demonstration.

⚠️ Note: In a production environment, you may want to restrict access using authentication, IP restrictions, or a private network setup.

💡 Extra Tip: Enable Application Insights

As an extra tip, you can enable Application Insights during setup.

Since our code uses the ILogger interface, this allows us to take full advantage of Azure's built-in monitoring and logging features.

With Application Insights, you’ll be able to:

🔍 Track requests, dependencies, and exceptions
📊 Analyze performance and response times
📈 Gain insights into user behavior and application usage

Enabling it now saves time later when debugging or optimizing your app.

✅ Final Step: Review and Create

Click on Review + Create to finalize the app setup.

Once the deployment is complete:

Go to your newly created Web App in the Azure Portal.
Add the necessary environment variables for your project.

🛠 These variables might include database connection strings, API keys, or other project-specific settings required at runtime.

📄 GitHub Actions Workflow File

After completing the deployment setup, a .yml file is automatically generated in your project’s GitHub repository.

This file defines your CI/CD pipeline and typically follows a structure like this:

name: Build and deploy ASP.Net Core app to Azure Web App - emailsenderapi

on:
  push:
    branches:
      - master
  workflow_dispatch:

jobs:
  build:
    runs-on: windows-latest
    permissions:
      contents: read #This is required for actions/checkout

    steps:
      - uses: actions/checkout@v4

      - name: Set up .NET Core
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.x'

      - name: Build with dotnet
        run: dotnet build --configuration Release
      - name: Run tests
        run: dotnet test --configuration Release --no-build --verbosity normal
      - name: dotnet publish
        run: dotnet publish -c Release -o "${{env.DOTNET_ROOT}}/myapp"

      - name: Upload artifact for deployment job
        uses: actions/upload-artifact@v4
        with:
          name: .net-app
          path: ${{env.DOTNET_ROOT}}/myapp

  deploy:
    runs-on: windows-latest
    needs: build
    environment:
      name: 'Production'
      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}

    steps:
      - name: Download artifact from build job
        uses: actions/download-artifact@v4
        with:
          name: .net-app

      - name: Deploy to Azure Web App
        id: deploy-to-webapp
        uses: azure/webapps-deploy@v3
        with:
          app-name: 'emailsenderapi'
          slot-name: 'Production'
          package: .
          publish-profile: ${{ secrets.AZUREAPPSERVICE_PUBLISHPROFILE }}

🚀 Testing the Deployed App

Now that the deployment is complete, it’s time to test the app and confirm everything is working as expected.

🧪 CI/CD Feedback in GitHub Actions

In GitHub Actions, we can visually track each step of the Build and Deploy process.

In our case, we can see that all 7 unit tests were executed successfully ✅.

This confirms that the application passed the testing phase before deployment.

❌ If any test had failed, the workflow would have been interrupted, and GitHub would have automatically notified us. This helps prevent broken code from being deployed to production.

You can view the full logs and outputs by clicking on each step within the GitHub Actions tab.

Happy Coding! 🥳

Set Up a MongoDB MCP Server in VS Code Like a Pro

Eduardo Calzone — Mon, 19 May 2025 19:53:44 +0000

🚀 What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open standard introduced by Anthropic that aims to simplify how AI applications—like chatbots, IDE assistants, or custom agents—connect with external tools, data sources, and systems.

🔌 Think of it like “USB for AI integrations”

Before USB, connecting devices meant dealing with dozens of ports and drivers. Similarly, integrating M different AI apps with N different tools used to require M × N custom integrations—a huge development burden.

MCP changes that to an M + N model:

Tool creators only need to build 1 MCP server per tool
App developers only need to build 1 MCP client per application

🧩 How it works

MCP follows a client-server architecture:

Hosts: AI applications the user interacts with (e.g., Claude, an IDE, a custom agent)
Clients: Reside within the host and manage a 1:1 connection to an MCP server
Servers: External programs exposing functionality to AI apps via a standard API

📚 MCP Servers expose 3 components:

Tools (model-controlled):

Functions the LLM can call to perform actions (e.g., calling a weather API)
Resources (app-controlled):

Data sources the model can read, similar to GET requests in a REST API

No heavy computation, no side effects
Prompts (user-controlled):

Predefined templates that help LLMs use tools/resources in the most effective way

This enables a modular, scalable ecosystem for AI integrations — with minimal duplication and maximum reuse.

🛠️ Configuring `mongodb-mcp-server` in VS Code

On the mongodb-mcp-server npm page, you'll find four different ways to run the server.

In this tutorial, we'll choose the simplest option — using a connection string directly in the mcp.json file.

Let's run the following command in your terminal:

npm i mongodb-mcp-server

Make sure you're using Node.js version 20 or higher. You can check your version with:

node -v

📁 Create the `.vscode/mcp.json` file

Inside your project's .vscode folder, create a file named mcp.json with the following content:

{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": [
        "-y",
        "mongodb-mcp-server",
        "--connectionString",
        "mongodb+srv://username:password@cluster.mongodb.net/myDatabase"
      ]
    }
  }
}

Once you've entered your MongoDB connection details, click Start to launch the server.

🚀 Installing GitHub Copilot Extensions

We will install the two GitHub Copilot extensions from the VS Code Marketplace:

GitHub Copilot – the core AI coding assistant.
GitHub Copilot Chat – enables chat-based interactions within your IDE.

🔑 Log in to GitHub Copilot

Then, log in to GitHub Copilot following the instructions provided after installation.

This will authenticate your GitHub account and activate Copilot features in your editor.

🧠 Using Agent Mode with MongoDB

Once you've selected Agent Mode, you can start using natural language to give high-level instructions to your MongoDB database.

For example, you can type prompts like:

"Show me all users who signed up last week"

"Add a new user with the username TestUser7"

The agent will translate these into MongoDB queries and execute them for you.

Let's see what we have in our database in the User collection:

💬 Running Our Instructions with Chat Copilot on MongoDB

Happy coding! 🥳

Simple Email Sending API with .NET

Eduardo Calzone — Sat, 17 May 2025 14:12:43 +0000

This project is a lightweight API built with .NET that enables sending emails through a dedicated endpoint. It follows a clean and minimal architecture using controllers, services, and dependency injection. The configuration is handled through appsettings, and error handling is in place to catch issues during the sending process. The API is ready for local testing and future expansion, such as adding authentication, scheduling, or support for attachments.

🔰 Step 0

Create a new project and select the project type "ASP.NET Core Web API"

The NuGet package dependencies used in this project are as follows:

MailKit
Microsoft.AspNetCore.OpenApi
Microsoft.OpenApi
Newtonsoft.Json
Swashbuckle.AspNetCore.Swagger
Swashbuckle.AspNetCore.SwaggerGen
Swashbuckle.AspNetCore.SwaggerUI

Project Structure Overview

The solution is organized following a clean and modular structure:

Controllers/ – Handles HTTP requests and delegates logic to services.

Models/ – Contains data transfer objects (DTOs) used for passing data.

Services/ – Implements the core logic for sending emails through SMTP.

Program.cs – Configures services, enables basic middleware like HTTPS redirection and Swagger, and sets up the application pipeline.

This layout keeps the responsibilities well-separated and makes the project easy to scale and maintain.

Let's Get Started

💻 Step 1 :

Create a simple model to represent the data sent from the contact form.

The EmailDto class includes three required fields:

To: the recipient's email address.
ContactName: the name of the person submitting the form.
Body: the actual message content.

These properties will be used when sending emails through the API.

namespace EmailSenderAPI.Models
{
    public class EmailDto
    {
        [Required]
        public string To { get; set; } = string.Empty;

        [Required]
        public string ContactName { get; set; } = string.Empty;

        [Required]
        public string Body { get; set; } = string.Empty;
    }
}

🔄 Step 2 :

Create an interface that defines the contract for the email service.
This interface contains the SendEmail method which will be implemented to handle email sending logic.

using EmailSenderAPI.Models;

namespace EmailSenderAPI.Services.EmailService
{
    public interface IEmailService
    {
        void SendEmail(EmailDto request);
    }
}

📧 Step 3:

Now let’s implement the logic to actually send the emails using MailKit.

In this step, you’ll create the EmailService class that fulfills the IEmailService contract.

This service does the following:

Sends a confirmation email to the user who filled out the form.
Sends the actual message to the business inbox.
Uses configuration values from appsettings.json (SMTP host, port, credentials).
Logs any errors using ILogger.

using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;
using MimeKit.Text;
using EmailSenderAPI.Models;
using Microsoft.Extensions.Logging;

namespace EmailSenderAPI.Services.EmailService
{
    public class EmailService(IConfiguration config, ILogger<EmailService> logger) : IEmailService
    {
        private readonly IConfiguration _config = config ?? throw new ArgumentNullException(nameof(config));
        private readonly ILogger<EmailService> _logger = logger ?? throw new ArgumentNullException(nameof(logger));

        // Sends both emails: one to the business and one to the customer
        public void SendEmail(EmailDto request)
        {
            ArgumentNullException.ThrowIfNull(request);

            try
            {
                // Send confirmation email to the user
                var confirmationEmail = CreateConfirmationEmail(request);
                SendEmailMessage(confirmationEmail);

                // Send original message to the business
                var businessEmail = CreateBusinessEmail(request);
                SendEmailMessage(businessEmail);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error sending email to {Recipient}", request.To);
                throw;
            }
        }

        // Email to the customer confirming receipt
        private MimeMessage CreateConfirmationEmail(EmailDto request)
        {
            var email = new MimeMessage();

            email.From.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.To.Add(MailboxAddress.Parse(request.To));
            email.Subject = "Thank you for your message";

            email.Body = new TextPart(TextFormat.Html)
            {
                Text = "<p>Thank you for your email. We will get in touch with you shortly.</p>"
            };

            return email;
        }

        // Email to the business with the user's message
        private MimeMessage CreateBusinessEmail(EmailDto request)
        {
            var email = new MimeMessage();

            email.From.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.To.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.Subject = $"New message from {request.ContactName}";

            email.Body = new TextPart(TextFormat.Html)
            {
                Text = $@"
                    <h2>New contact form submission</h2>
                    <p><strong>From:</strong> {request.ContactName} ({request.To})</p>
                    <p><strong>Message:</strong></p>
                    <p>{request.Body}</p>"
            };

            return email;
        }

        // Connects and sends the email
        private void SendEmailMessage(MimeMessage email)
        {
            using var smtp = new SmtpClient();

            var host = _config["EmailHost"];
            var port = _config.GetValue<int>("Port");
            var username = _config["EmailUsername"];
            var password = _config["EmailPassword"];

            if (string.IsNullOrWhiteSpace(host))
                throw new InvalidOperationException("EmailHost configuration is missing");
            if (port <= 0)
                throw new InvalidOperationException("Invalid Port configuration");
            if (string.IsNullOrWhiteSpace(username))
                throw new InvalidOperationException("EmailUsername configuration is missing");
            if (string.IsNullOrWhiteSpace(password))
                throw new InvalidOperationException("EmailPassword configuration is missing");

            smtp.Connect(host, port, SecureSocketOptions.StartTls);
            smtp.Authenticate(username, password);

            try
            {
                smtp.Send(email);
            }
            finally
            {
                smtp.Disconnect(true);
            }
        }
    }
}

📬 Step 4:

Let’s create a minimal controller to expose a POST endpoint that receives contact form data and triggers the email sending logic.

The controller:

Accepts POST requests to /api/email
Receives an EmailDto object from the body
Calls the SendEmail method of the injected service
Returns an HTTP 200 response on success

Here’s the code:

using System.Net;
using EmailSenderAPI.Models;
using EmailSenderAPI.Services.EmailService;
using Microsoft.AspNetCore.Mvc;

namespace EmailSenderAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmailController(IEmailService emailService) : ControllerBase
    {
        // Service for sending emails
        private readonly IEmailService _emailService = emailService;

        // POST api/email
        [HttpPost]
        public IActionResult SendEmail(EmailDto request)
        {
            // Call the service to send the email
            _emailService.SendEmail(request);

            // Return success response
            return Ok(new { message = "Email sent successfully" });
        }
    }
}

⚙️ Step 5:

Now let’s configure the application in Program.cs to:

Register necessary services (controllers, Swagger, HTTP client)
Register our custom EmailService
Set up the middleware pipeline for development and HTTPS redirection

Here’s the full code:

using EmailSenderAPI.Services.EmailService;
using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

// ------ Service Configuration ------
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo
    {
        Title = "EmailSenderAPI",
        Version = "v1",
        Description = "Email sending API"
    });
});

// Register custom services
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddHttpClient();

var app = builder.Build();

// ------ Middleware Pipeline ------
if (app.Environment.IsDevelopment())
{
    // Enable Swagger only in Development
    app.UseSwagger();
    app.UseSwaggerUI(); // Default endpoint: /swagger
}

app.UseHttpsRedirection();
app.MapControllers();
app.Run();

🛠️ Step 6:

To keep your email credentials and server details secure and easily manageable, add them to your appsettings.json file:

{
  "EmailHost": "smtp.example.com",
  "EmailUsername": "your@email.com",
  "EmailPassword": "yourEmailPassword",
  "Port": 587,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

✅ Note: Replace the placeholder values with your actual SMTP server, email address, and credentials.

These values are injected using IConfiguration in the EmailService class.

🚀 Now it’s time to test our email sender!

In Swagger, we will enter sample data to perform a test. (📸 Click to enlarge)

Successful test 🎉 We receive a 200 status code. (📸 Click to enlarge)

📩 Customer Email

Here we see the email that the customer who sent the inquiry would receive.

🏪 Business Email

Here we see the email that the business receives.

Source: https://github.com/educalok/EmailSenderAPI

How to Implement Redis Caching and Rate Limiting in Node.js

Eduardo Calzone — Sun, 20 Apr 2025 12:59:13 +0000

Overview

We’ll explore two important concepts:

🔄 Implementing Caching – We will use Redis Cloud, a managed Redis service, to temporarily store the results of API calls. This will simulate caching by allowing us to save and retrieve responses externally. When the same request is made again, we will quickly return the stored data instead of calling the external API again. This will reduce response time and improve performance.

🛡️ Protecting the API with IP Rate Limiting – To prevent abuse, we will implement a basic rate limiter that counts how many times a user (based on IP address) accesses the API across all its routes. If the number of requests exceeds the allowed limit within a certain time window, that IP will be temporarily blocked. In our example, users will be limited to 20 requests per hour. Once the time window resets, the user will be able to access the API again.

What is Redis? 🔍

Redis is an open-source, in-memory data structure store commonly used as a cache or message broker. It supports various data types, such as strings, hashes, lists, sets, and more. Redis is known for its high performance and low latency, making it ideal for scenarios where fast data access is required. It's often used to store temporary data, such as session information, frequently accessed API responses, and real-time analytics, reducing the load on databases and improving overall application performance.

How does Redis work? ⚙️

Redis operates as an in-memory data store, meaning it keeps all of its data in RAM rather than on disk, enabling sub-millisecond data access times. Redis supports different data structures like strings, hashes, lists, sets, sorted sets, and more. It works through key-value pairs where each key is associated with a value.

Data in Redis is stored persistently (optional) through mechanisms like snapshots (RDB) or append-only files (AOF) to disk, allowing it to recover data in case of failures. Redis uses an event-driven architecture and provides high availability and horizontal scaling options with features like replication and sharding, making it ideal for use cases that require low-latency data access and high-throughput performance, such as caching, session storage, and real-time analytics.

Step 0 🚀

In this tutorial, instead of installing Redis locally, we'll be using Redis Enterprise Cloud to create a Redis database. Redis Enterprise Cloud offers a managed service, allowing us to set up a Redis instance in the cloud without the need for local installation. We can easily get started with a free account.

As data source, we’ll use requests to the endpoint https://rickandmortyapi.com/api

We create an empty Node.js project and install the following dependencies:

pnpm add axios dotenv express redis

In the .env file, we add our Redis connection details:

REDIS_HOSTNAME =
REDIS_PORT =
REDIS_PASSWORD =
API_URL = https://rickandmortyapi.com/api/

Step 1 🛠️

We start by importing the necessary dependencies, defining constants like the port, rate limits, and cache expiration, and initializing both the Express app and the Redis client using environment variables.

const express = require('express');
const axios = require('axios');
const { createClient } = require('redis');
require('dotenv').config();

// App configuration
const PORT = process.env.PORT || 4000;
const RATE_LIMIT = 20;
const RATE_LIMIT_WINDOW = 3600; // 1 hour in seconds
const CACHE_EXPIRATION = 20; // Cache for 20 seconds

const app = express();

// Initialize Redis client using environment variables
const client = createClient({
  password: process.env.REDIS_PASSWORD,
  socket: {
    host: process.env.REDIS_HOSTNAME,
    port: process.env.REDIS_PORT
  }
});

// Log Redis errors
client.on('error', (err) => {
  console.error('Redis connection error:', err);
});

Step 2 🧱

Next, we add middleware for rate limiting and define a route to get character data. We use Redis to cache responses and return cached results when available.

// Apply rate limiter to all routes
app.use(limitRate);

// API route to fetch character data (cached using Redis)
app.get('/api/character', getCachedData);

/**
 * Redis caching logic
 * If data is found in Redis, return it.
 * Otherwise, fetch it from the external API and cache it.
 */
async function getCachedData(req, res) {
  try {
    const keyParam = 'character';

    // Check if data exists in Redis cache
    const cachedData = await client.get(keyParam);

    if (cachedData) {
      console.log(`Cache hit for ${keyParam}`);
      return res.json(JSON.parse(cachedData));
    }

    // If not cached, fetch data from external API
    console.log(`Cache miss for ${keyParam}, fetching from API`);
    const apiUrl = `${process.env.API_URL}${keyParam}`;
    const response = await axios.get(apiUrl);

    // Store the result in Redis with an expiration time
    await client.set(keyParam, JSON.stringify(response.data), {
      EX: CACHE_EXPIRATION
    });

    return res.json(response.data);
  } catch (error) {
    console.error('Error fetching data:', error);
    const statusCode = error.response?.status || 500;
    return res.status(statusCode).json({
      error: error.message,
      statusCode
    });
  }
}

/**
 * Middleware to limit the number of requests from each IP
 * Uses Redis to track request count within a time window
 */
async function limitRate(req, res, next) {
  try {
    // Get IP address
    const ip =
      req.headers['cf-connecting-ip'] ||
      (req.headers['x-forwarded-for'] || req.socket.remoteAddress || '')
        .split(',')[0]
        .trim();

    const rateKey = `rate:${ip}`;

    // Increment the request count for this IP
    const requests = await client.incr(rateKey);

    // Set expiration if this is the first request
    if (requests === 1) {
      await client.expire(rateKey, RATE_LIMIT_WINDOW);
    }

    console.log(`IP ${ip} - Request count: ${requests}`);

    // Block the request if the limit is exceeded
    if (requests > RATE_LIMIT) {
      return res.status(429).json({
        status: 'error',
        requestCount: requests,
        message: 'Rate limit exceeded. Please try again later.'
      });
    }

    // Allow request
    next();
  } catch (error) {
    console.error('Rate limiting error:', error);
    next(); // Fail-open: allow request if Redis fails
  }
}

Step 3 🔐

Finally, we connect to Redis, start the server, and handle graceful shutdown on termination.

/**
 * Connect to Redis and start the Express server
 */
async function startServer() {
  try {
    await client.connect();
    console.log('Connected to Redis successfully');

    app.listen(PORT, () => {
      console.log(`Server running at http://localhost:${PORT}`);
    });
  } catch (error) {
    console.error('Failed to start server:', error);
    process.exit(1);
  }
}

/**
 * Shutdown Redis connection
 */
process.on('SIGINT', async () => {
  try {
    await client.quit();
    console.log('Redis connection closed');
    process.exit(0);
  } catch (err) {
    console.error('Error shutting down:', err);
    process.exit(1);
  }
});

// Start server
startServer();

To provide a practical explanation, I’ve deployed our project to Render.
To avoid headaches, remember to upload the project's environment variables in the Settings section of Render and specify node src/index.js in the Start field.

First let's go to our endpoint set up to fetch all characters from the Rick and Morty API. We can see that it returns the corresponding data.

In our Redis database, the first part corresponds to the information saved after the first request to the API, with the key named "Character" (1). We can also see its corresponding TTL (Time to live) (2), originally set to 20 seconds, and finally the data (3). It is important to note that after 20 seconds, the key will automatically be deleted.

The second key/value corresponds to the IP from which we are making the request (1). We can also see its corresponding TTL (2) and the counter (3) indicating how many times we've accessed the endpoint—just once in this case.

Thanks to the console logs, we can more clearly see this situation in the Render terminal.

A while later, after several requests, we can see that the counter is at 6 and the data is coming from the API, since our request happened more than 20 seconds after the previous one. However, in requests 7 and 8, made shortly after, we can observe how the data is retrieved from Redis. On request 9, a minute later, we see it fetch the data from the external API once again.

As a final test, we perform more than 20 requests to see how our API blocks the IP from which we are making the calls.

We can also observe this from the terminal, where requests 21 and 22 did not hit the external API or our Redis database. Remember that we configured this block for 12 hours—once that time has passed, the IP key/value pair will be deleted, and the counter will reset to 1.

Source: https://github.com/educalok/nodejs-redis

Forem: Eduardo Calzone

Make Your TypeScript API Responses Safer with Zod (in seconds)

🚀 Let’s See It in Action

Stop using console.log: Debug Smarter ⚡

console.info() ℹ️

console.warn() ⚠️

console.error() ❌

console.debug() 🔍

🆚 console.log() vs console.debug()

console.assert() ✅

console.count() 🔢

console.countReset() 🔄

console.time() ⏱️

console.group() 🔗

console.table() 📋

console.trace() 📣

console.clear() 🧹

Supercharge Your Deployments: GitHub Actions + Azure Web App CI/CD

🔄 What is CI/CD?

🔧 Continuous Integration (CI)

🚀 Continuous Delivery (CD)

⚡ Continuous Deployment

⚙️ What is GitHub Actions?

🔧 What Can You Do With GitHub Actions?

🧠 Why Use It?

🛠️ Real-World CI/CD Example with Azure and GitHub

🚀 Create an Azure Web App

⚙️ Enable Continuous Deployment

🌐 Configure Access Settings

💡 Extra Tip: Enable Application Insights

✅ Final Step: Review and Create

📄 GitHub Actions Workflow File

🚀 Testing the Deployed App

🧪 CI/CD Feedback in GitHub Actions

Set Up a MongoDB MCP Server in VS Code Like a Pro

🚀 What is the Model Context Protocol (MCP)?

🔌 Think of it like “USB for AI integrations”

🧩 How it works

📚 MCP Servers expose 3 components:

🛠️ Configuring mongodb-mcp-server in VS Code

📁 Create the .vscode/mcp.json file

🚀 Installing GitHub Copilot Extensions

🔑 Log in to GitHub Copilot

🧠 Using Agent Mode with MongoDB

💬 Running Our Instructions with Chat Copilot on MongoDB

Happy coding! 🥳

Simple Email Sending API with .NET

🔰 Step 0

Project Structure Overview

Let's Get Started

💻 Step 1 :

🔄 Step 2 :

📧 Step 3:

📬 Step 4:

⚙️ Step 5:

🛠️ Step 6:

📩 Customer Email

🏪 Business Email

How to Implement Redis Caching and Rate Limiting in Node.js

Overview

What is Redis? 🔍

How does Redis work? ⚙️

Step 0 🚀

Step 1 🛠️

Step 2 🧱

Step 3 🔐

`console.info()` ℹ️

`console.warn()` ⚠️

`console.error()` ❌

`console.debug()` 🔍

🆚 `console.log()` vs `console.debug()`

`console.assert()` ✅

`console.count()` 🔢

`console.countReset()` 🔄

`console.time()` ⏱️

`console.group()` 🔗

`console.table()` 📋

`console.trace()` 📣

`console.clear()` 🧹

🛠️ Configuring `mongodb-mcp-server` in VS Code

📁 Create the `.vscode/mcp.json` file