DEV Community: FredAbod

Stop Dumping Everything in app.js — Express MVC for Beginners

FredAbod — Mon, 07 Sep 2026 20:50:41 +0000

Stop Dumping Everything in `app.js` — Express, Mongoose, and a Clean MVC Folder

So you built a CRUD API. It works. Postman is green. You are feeling like a backend engineer.

Then you open app.js.

Database connection. Schema. Create. Read. Update. Delete. Hello World. All in one file. Scrolling that thing feels like opening a WhatsApp group that never went on mute 😭

In this article I will take you step by step through how we split a student API into a folder structure that actually makes sense. Same app. Same MongoDB. Same routes. Just… not a crime scene anymore.

We are building (well, re-organising) a school student API with:

Express — the school gate
Mongoose — the person who talks to the records cupboard
MongoDB — the cupboard itself

By the end you will know why a request never talks to MongoDB directly, and what each of these files is for:

app.js
config/db.js
models/students.models.js
controllers/students.controller.js
routes/students.routes.js

Prerequisites

Make sure you have Node.js, npm, and MongoDB running on your machine.

I hope you already have a working Express + Mongoose CRUD 😉😉😉

If you don't… you have to 😎

This article is about structure, not "what is app.post".

If you are coming from my Prisma + PostgreSQL post, relax. Different database, same idea: don't put the whole school inside one office.

Let's Dive Right In

Step 1: The problem — one fat `app.js`

At first, one file is cute. You are learning. You paste a route, it works, you paste another, it also works. Life is good.

Then you add "get student by name". Then "get by email". Then update. Then delete. Then your friend asks "where is the schema again?" and you Ctrl+F through 200 lines like a detective.

That file is doing four jobs at once:

Starting the server
Connecting to MongoDB
Describing what a student looks like
Handling every request

That is like one person being the gatekeeper, the teacher, the registrar, and the person with the cupboard key. Possible? Yes. A good idea when the school grows? Absolutely not.

Step 2: Think of it like a school office

This is the whole article in one picture. A request walks through the building. It does not teleport into MongoDB.

  Client (Postman)
        │
        ▼
  app.js              ← front gate. "Are you speaking JSON? Cool. Students office is that way."
        │
        ▼
  routes              ← the list of doors. "Ah, POST /create-student. Clerk!"
        │
        ▼
  controllers         ← the clerk actually does the work
        │
        ▼
  models              ← the form every student must fill
        │
        ▼
  MongoDB             ← the cupboard. Writes Ada. Gives her an _id.
        │
        ▼
  back the same way to Postman

In words: the client never talks to MongoDB. It talks to Express. Express asks the router which door was knocked. The router calls a controller. The controller uses the Student model. The model talks to MongoDB. The answer travels back the same way.

If you remember only one sentence from this article, remember that one.

Step 3: Make the folders

From your project root:

mkdir config models controllers routes

Your project should look like this:

techySchoolApp/
├── app.js
├── config/
│   └── db.js
├── models/
│   └── students.models.js
├── controllers/
│   └── students.controller.js
└── routes/
    └── students.routes.js

Each folder has one job. If you catch yourself saving a student inside app.js again, slap your own hand. Gently. We are learning 😁

Step 4: The cupboard key — `config/db.js`

This file does one thing. Knock on MongoDB's door.

const mongoose = require("mongoose");

const databaseConnection = async () => {
  try {
    await mongoose.connect("mongodb://localhost:27017/techSchoolApp");
    console.log("Database connected successfully");
  } catch (error) {
    console.log("Database connection failed", error);
  }
};

module.exports = databaseConnection;

That's it. No routes. No schema. No "Student created successfully". Just the key.

Tiny gotcha: Mongoose will name the collection students (plural, lowercase), not "Student".

If you open Compass and look for a collection called Student, you will think the API is empty. It is not. You are just in the wrong cupboard 😅

Step 5: The form — `models/students.models.js`

Before we save Ada, we need a form that says what a student even is.

const mongoose = require("mongoose");

const studentSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String,
  phone: String,
  address: String,
  course: String,
  institution: String,
});

const Student = mongoose.model("Student", studentSchema);

module.exports = Student;

This file should not send res.json(...). It does not know HTTP. It only knows: "a student has a name, an age, an email…"

Think of it as the attendance register. The clerk (controller) fills it. The register itself does not talk to visitors at the gate.

Step 6: The clerk — `controllers/students.controller.js`

This is where the actual work lives. Unpack the request. Call the model. Send a reply.

I will show create + list first so you can test before we dump the whole file on you. Stretch your fingers later, not now 😉

const Student = require("../models/students.models");

const createStudent = async (req, res) => {
  const { name, age, email, phone, address, course, institution } = req.body;
  try {
    const student = new Student({
      name,
      age,
      email,
      phone,
      address,
      course,
      institution,
    });
    await student.save();
    return res
      .status(200)
      .json({ message: "Student created successfully", student });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

const getStudents = async (req, res) => {
  try {
    const students = await Student.find();
    return res
      .status(200)
      .json({ message: "Students fetched successfully", students });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

module.exports = { createStudent, getStudents };

See the pattern?

req comes in
we talk to Student
res goes out

The controller is allowed to know HTTP. The model is not. Don't mix them. Mixing them is how app.js got fat in the first place.

Step 7: The doors — `routes/students.routes.js`

Routes are a menu. They should be boring. Boring is good.

const express = require("express");
const router = express.Router();
const {
  createStudent,
  getStudents,
} = require("../controllers/students.controller");

router.post("/create-student", createStudent);
router.get("/get-students", getStudents);

module.exports = router;

Read that out loud: "when someone POSTs /create-student, call createStudent."

That is all a route file should say. If you start writing Student.find() in here, you have put the clerk at the door. Send them back to the office.

Step 8: The front gate — a slim `app.js`

Now app.js can finally be short. This is the whole point.

const express = require("express");
const databaseConnection = require("./config/db");
const studentsRoutes = require("./routes/students.routes");
const app = express();

const port = 4555;

app.use(express.json());

app.get("/", (req, res) => {
  res.send("Hello World");
});

app.use("/students", studentsRoutes);

app.listen(port, () => {
  databaseConnection();
  console.log(`Server is running on port ${port}`);
});

Three important lines, don't skip them:

express.json() — without this, req.body is undefined and you will save ghost students. Then you will blame Mongoose. It was you. It was always you 😭
app.use("/students", studentsRoutes) — this is the prefix. Your route file says /create-student, but the real URL is /students/create-student. I will say that again in a minute because this is the #1 "why is it 404" moment.
listen then connect DB — open the classroom, then unlock the cupboard.

Step 9: Don't forget the prefix 👏

Because the router is mounted at /students, every student door looks like this:

What you want	Method	Full URL	Clerk
Add a student	`POST`	`/students/create-student`	`createStudent`
Show everybody	`GET`	`/students/get-students`	`getStudents`
Show this one id	`GET`	`/students/get-student/:id`	`getStudentById`
Change this one	`PUT`	`/students/update-student/:id`	`updateStudent`
Find by exact name	`GET`	`/students/get-student-by-name`	`getStudentByName`
Find by email	`GET`	`/students/get-student-by-email`	`getStudentByEmail`
Remove this one	`DELETE`	`/students/delete-student/:id`	`deleteStudent`
Is the school open?	`GET`	`/`	Hello World

If you test POST /create-student and get 404, you did not break Express. You just went to the wrong door. The students office is down the hall: /students/...

Step 10: Stretch your fingers 😁😁

Now drop the rest of the clerks into the controller. Same pattern. Different door.

const getStudentById = async (req, res) => {
  const { id } = req.params;
  try {
    const student = await Student.findById(id);
    return res
      .status(200)
      .json({ message: "Student fetched successfully", student });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

const updateStudent = async (req, res) => {
  const { id } = req.params;
  const { name, age, email, phone, address, course, institution } = req.body;
  try {
    const student = await Student.findByIdAndUpdate(
      id,
      { name, age, email, phone, address, course, institution },
      { new: true },
    );
    return res
      .status(200)
      .json({ message: "Student updated successfully", student });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

const getStudentByName = async (req, res) => {
  const { name } = req.query;
  try {
    const student = await Student.find({ name });
    return res
      .status(200)
      .json({ message: "Student fetched successfully", student });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

const getStudentByEmail = async (req, res) => {
  const { email } = req.query;
  try {
    const student = await Student.find({ email });
    return res
      .status(200)
      .json({ message: "Student fetched successfully", student });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

const deleteStudent = async (req, res) => {
  const { id } = req.params;
  try {
    await Student.findByIdAndDelete(id);
    return res.status(200).json({ message: "Student deleted successfully" });
  } catch (error) {
    return res.status(500).json({ message: "Internal server error" });
  }
};

And hook them on the menu:

router.post("/create-student", createStudent);
router.get("/get-students", getStudents);
router.get("/get-student/:id", getStudentById);
router.get("/get-student-by-email", getStudentByEmail);
router.put("/update-student/:id", updateStudent);
router.get("/get-student-by-name", getStudentByName);
router.delete("/delete-student/:id", deleteStudent);

Notice the difference:

:id lives in req.params — it is part of the URL
name and email live in req.query — they come after ?

/get-student-by-name?name=Ada is not the same as /get-student-by-name/Ada. Query vs params. This will hunt you in your sleep until it clicks.

Step 11: One request, slowly — creating Ada

Let's walk Ada through the building. This is the part that makes the folders click.

Request: POST http://localhost:4555/students/create-student

{
  "name": "Ada",
  "age": 16,
  "email": "ada@school.com",
  "phone": "08012345678",
  "address": "Lagos",
  "course": "Computer Science",
  "institution": "Techy School"
}

Don't forget the header: Content-Type: application/json. That one line is why express.json() exists.

Now the walk:

  Postman
     │  JSON body + Content-Type
     ▼
  app.js
     │  express.json() turns the text into req.body
     │  path starts with /students → send to the router
     ▼
  students.routes.js
     │  POST /create-student  →  createStudent
     ▼
  students.controller.js
     │  pick name, age, email... out of req.body
     │  new Student({ ... })
     │  await student.save()
     ▼
  students.models.js
     │  checks the shape (name is String, age is Number...)
     ▼
  MongoDB  (techSchoolApp.students)
     │  writes one document, gives it an _id
     ▼
  back to the controller
     │  res.status(200).json({ message, student })
     ▼
  Postman sees Ada plus her _id 🎉

If anything breaks, ask: which floor did it die on?

404 → wrong door (routes / prefix)
req.body empty → gate did not parse JSON (express.json() or the header)
500 on save → cupboard / schema / Mongo not running
200 with student: null on get-by-id → valid-looking id, nobody home (that's a story for another day 👀)

Test GET /students/get-students next. You should see Ada in the list.

Step 12: Why we split it (so you don't undo it tomorrow)

Layer	File	Job	Should not do
App	`app.js`	Start server, JSON, mount routers	Know how to save a student
Routes	`routes/students.routes.js`	Map URL + method to a function	Talk to MongoDB
Controllers	`controllers/students.controller.js`	Read the request, call the model, reply	Own the Express app or the schema
Models	`models/students.models.js`	Shape of a student + Mongoose model	Send HTTP responses
Config	`config/db.js`	Connect to MongoDB	Define routes

Same idea as a school:

app.js is the front gate and the timetable
routes are the classroom doors
controllers are the teachers doing the work
models are the attendance register
db.js is the key to the records cupboard

When you want to add "get student by phone", you do not open app.js and start praying. You add a function in the controller, one line in the router, done. app.js does not even notice. That is the flex.

Before vs after

  BEFORE                              AFTER

  ┌─────────────────┐                 ┌─────────────────┐
  │     app.js      │                 │     app.js      │  start the school
  │  (everything)   │                 │  + express.json │
  │                 │                 │  + mount routes │
  │  connect DB     │                 └────────┬────────┘
  │  schema         │                          │
  │  all routes     │                          ▼
  │  all logic      │                 ┌─────────────────┐
  └─────────────────┘                 │     routes      │  the menu of doors
                                      └────────┬────────┘
                                               ▼
                                      ┌─────────────────┐
                                      │   controllers   │  the work happens here
                                      └────────┬────────┘
                                               ▼
                                      ┌─────────────────┐
                                      │     models      │  the student form
                                      └────────┬────────┘
                                               ▼
                                      ┌─────────────────┐
                                      │   config/db     │  the cupboard key
                                      └─────────────────┘

One file that does everything is a demo.

Folders that each do one thing is how you still like this project in two weeks.

Recap (say it with me)

The client talks to Express, not MongoDB.
Routes pick the door.
Controllers do the work.
Models describe the shape.
Config holds the cupboard key.
app.use("/students", ...) means every student URL starts with /students.
express.json() is not optional if you like req.body.

And that is a clean Express + Mongoose student API, without dumping the whole school into app.js.

Thank you for taking the time to read 🥰🥰

I hope this was helpful. Don't forget to drop a like and follow 😋😋

See you on the next one 🤗

CSharp-Basics

FredAbod — Wed, 28 Jan 2026 14:26:38 +0000

💻 CSharp-Basics

👩‍💻 This repository holds common C# syntax, concepts, and examples for beginners and intermediate developers. Whether you're coming from JavaScript, Python, or starting fresh, this guide will help you master C# fundamentals.

🖥️ System Requirements

Download and install the following software:

Software	Description	Download Link
.NET SDK	The runtime and compiler for C#	Download .NET
VS Code	Lightweight code editor	Download VS Code
C# Dev Kit	VS Code extension for C#	Get Extension

Alternative: Use Visual Studio Community (free, all-in-one IDE)

🚀 Getting Started

Fork and clone this repository
Open the folder in VS Code or Visual Studio
Open the terminal (Ctrl + ` in VS Code)
Run the examples: bash dotnet run
Edit Program.cs to uncomment different example methods
Repeat to explore each concept!

📚 TABLE OF CONTENTS

Section	Description
Introduction	What is C# and why learn it?
Variables	Storing and naming data
Data Types	Value types vs Reference types
Operators	Arithmetic, comparison, logical
Type Casting	Converting between types
Functions	Creating reusable code blocks
Arrays & Collections	Storing multiple values
Conditionals	Making decisions in code
Loops	Repeating code
Exception Handling	Handling errors gracefully
Classes	Object-oriented programming
Properties	Getters, setters, encapsulation
Inheritance	Extending classes
Interfaces	Defining contracts
Generics	Type-safe reusable code
LINQ	Querying data elegantly
Async/Await	Asynchronous programming
Calculator	Practical exercise

📖 Introduction

What is C#?

C# (pronounced "C-Sharp") is a modern, object-oriented programming language developed by Microsoft in 2000 as part of its .NET initiative. It was designed by Anders Hejlsberg (who also created Turbo Pascal and TypeScript).

Why Learn C#?

C# is one of the most versatile and in-demand programming languages:

Use Case	Technology	Examples
🌐 Web Development	ASP.NET Core	APIs, Web Apps, Microservices
🎮 Game Development	Unity	Mobile games, VR/AR, AAA titles
🖥️ Desktop Apps	WPF, WinForms, MAUI	Windows applications
📱 Mobile Apps	.NET MAUI, Xamarin	iOS and Android apps
☁️ Cloud Services	Azure Functions	Serverless, cloud-native apps
🤖 AI/ML	ML.NET	Machine learning models

C# vs JavaScript Comparison

If you're coming from JavaScript, here's a quick comparison:

Feature	JavaScript	C#
Typing	Dynamic (`let x = 5`)	Static (`int x = 5`)
Execution	Interpreted	Compiled
Semicolons	Optional	Required
Classes	Prototype-based	Class-based
Null handling	`null`/`undefined`	`null` only (with nullable types)

Your First C# Program

Every C# program starts with a Main method - this is the entry point where your program begins executing:

`csharp
using System; // Import the System namespace (like 'import' in JS)

namespace MyFirstApp // Namespace organizes your code (like a folder)
{
class Program // A class is a container for your code
{
static void Main(string[] args) // Entry point - program starts here
{
Console.WriteLine("Hello, World!"); // Print to console
}
}
}
`

Breaking it down:

using System; - Imports built-in functionality (like import in JS/Python)
namespace - Groups related classes together (prevents naming conflicts)
class - A blueprint/container for code and data
static void Main() - The entry point; static means no object needed, void means no return value
Console.WriteLine() - Prints text to the terminal

💡 Modern C# Tip: In .NET 6+, you can use "top-level statements" for simpler programs:

csharp Console.WriteLine("Hello, World!");

🔤 Variables

What is a Variable?

A variable is a named container that stores a value in your computer's memory. Think of it like a labeled box where you can put data and retrieve it later.

┌─────────────────┐ │ Variable: age │ ←── The label (name) ├─────────────────┤ │ 25 │ ←── The value stored inside └─────────────────┘

Declaring Variables in C

Unlike JavaScript, C# is statically typed - you must declare the type of data a variable will hold:

`csharp
// Syntax: type variableName = value;

string bunnyName = "Lucy"; // Text data (sequence of characters)
int age = 3; // Whole numbers (no decimals)
double weight = 2.5; // Decimal numbers (high precision)
bool isHappy = true; // True or false only

// Print all variables using string interpolation ($"...")
Console.WriteLine($"Name: {bunnyName}, Age: {age}, Weight: {weight}kg, Happy: {isHappy}");
// Output: Name: Lucy, Age: 3, Weight: 2.5kg, Happy: True
`

Why static typing?

✅ Catches errors at compile time (before running)
✅ Better IDE autocomplete and IntelliSense
✅ More efficient memory usage
✅ Self-documenting code

Variable Naming Rules

C# has strict rules for naming variables:

Rule	Valid ✅	Invalid ❌	Why?
Must start with letter or `_`	`name`, `_count`	`1name`	Numbers can't be first
Can contain letters, digits, `_`	`user1`, `total_count`	`user-name`	Hyphens not allowed
Case-sensitive	`Name` ≠ `name`	-	They're different variables
No reserved keywords	`myClass`	`class`, `int`	These are C# keywords

`csharp
// ✅ Valid variable names
string firstName = "Lucy";
string _privateField = "hidden";
int player1Score = 100;
string camelCaseIsPreferred = "yes";

// ❌ Invalid - these will cause compiler errors
// string 1stPlace = "Gold"; // Can't start with number
// string my-variable = "oops"; // Hyphens not allowed
// string class = "reserved"; // 'class' is a keyword
`

Naming Conventions

C# developers follow specific conventions:

Type	Convention	Example
Local variables	camelCase	`firstName`, `totalCount`
Class names	PascalCase	`BunnyManager`, `PlayerController`
Methods	PascalCase	`CalculateTotal()`, `GetUserName()`
Constants	UPPER_CASE or PascalCase	`MAX_SIZE`, `DefaultTimeout`
Private fields	_camelCase	`_connectionString`, `_logger`

var, const, and readonly

C# offers three important keywords for variable declaration:

`var` - Type Inference

The compiler automatically determines the type based on the assigned value:

`csharp
var name = "Lucy"; // Compiler infers: string
var age = 25; // Compiler infers: int
var price = 19.99; // Compiler infers: double
var isActive = true; // Compiler infers: bool

// var MUST be initialized - the compiler needs a value to infer the type
// var unknown; // ❌ Error: Implicitly-typed variables must be initialized
`

When to use var:

✅ When the type is obvious: var list = new List<string>();
✅ With LINQ queries: var results = users.Where(u => u.Age > 18);
❌ When it reduces readability: var x = GetData(); (what type is x?)

`const` - Compile-Time Constants

Values that are known at compile time and never change:

`csharp
const double PI = 3.14159265359; // Mathematical constant
const int MAX_PLAYERS = 100; // Game configuration
const string APP_NAME = "BunnyTracker"; // Application name

// Constants MUST be assigned at declaration
// const int laterValue; // ❌ Error

// Constants CANNOT be changed
// PI = 3.14; // ❌ Error: Cannot assign to const
`

Key points:

Value must be known at compile time
Implicitly static (shared across all instances)
Can only be primitive types or strings

`readonly` - Runtime Constants

Values set once at runtime (in declaration or constructor):

`csharp
public class GameConfig
{
// Can be set at declaration
public readonly DateTime CreatedAt = DateTime.Now;

// Or set in constructor
public readonly string ConnectionString;

public GameConfig(string connString)
{
    ConnectionString = connString;  // ✅ Can assign in constructor
}

public void TryChange()
{
    // ConnectionString = "new";  // ❌ Error: Cannot assign after construction
}

}
`

const vs readonly Summary:

Feature	`const`	`readonly`
When assigned	Compile time	Runtime (declaration or constructor)
Can use expressions	No	Yes (`= DateTime.Now`)
Memory	Stored in assembly	Stored in memory
Can be any type	Primitives/strings only	Any type

Variable Scope

Scope determines where a variable can be accessed in your code:

`csharp
class Program
{
// 1. CLASS-LEVEL (Field) - Accessible anywhere in the class
static string globalBunny = "Lucy";

static void Main()
{
    Console.WriteLine(globalBunny);  // ✅ Works - class-level scope

    // 2. METHOD-LEVEL (Local) - Only accessible within this method
    string localBunny = "Tom";
    Console.WriteLine(localBunny);   // ✅ Works - same method

    if (true)
    {
        // 3. BLOCK-LEVEL - Only accessible within these braces { }
        string blockBunny = "Molly";
        Console.WriteLine(blockBunny);   // ✅ Works - same block
        Console.WriteLine(localBunny);   // ✅ Works - outer scope
    }

    // Console.WriteLine(blockBunny);  // ❌ Error - out of scope!
}

static void AnotherMethod()
{
    Console.WriteLine(globalBunny);  // ✅ Works - class-level
    // Console.WriteLine(localBunny); // ❌ Error - different method
}

}
`

Scope Visualization:

┌─────────────────────────────────────────┐ │ Class Scope (globalBunny) │ │ ┌───────────────────────────────────┐ │ │ │ Method Scope (localBunny) │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ Block Scope (blockBunny) │ │ │ │ │ └─────────────────────────────┘ │ │ │ └───────────────────────────────────┘ │ └─────────────────────────────────────────┘

📝 Exercises

Basic: Create variables for your name (string), age (int), and height in meters (double). Print them.
Constants: Define a const for the speed of light (299792458 m/s) and use it in a calculation.
Scope: Create a method that demonstrates all three scope levels with different variables.

📊 Data Types

Understanding Data Types

Every piece of data in C# has a type that determines:

📦 How much memory it uses
🔢 What values it can hold
⚡ What operations you can perform

C# has two main categories:

┌─────────────────────────────────────────────────────┐ │ C# Data Types │ ├──────────────────────┬──────────────────────────────┤ │ VALUE TYPES │ REFERENCE TYPES │ │ (Stored in Stack) │ (Stored in Heap) │ ├──────────────────────┼──────────────────────────────┤ │ • int, long │ • string │ │ • float, double │ • arrays │ │ • decimal │ • classes │ │ • bool │ • interfaces │ │ • char │ • delegates │ │ • struct │ • object │ └──────────────────────┴──────────────────────────────┘

Value Types (Stored on Stack)

Value types store data directly in their memory location. When you copy a value type, you get a completely independent copy.

Numeric Types

`csharp
// INTEGER TYPES (whole numbers)
byte smallNumber = 255; // 0 to 255 (1 byte)
short shortNumber = 32767; // -32,768 to 32,767 (2 bytes)
int regularNumber = 2147483647; // Most common for integers (4 bytes)
long bigNumber = 9223372036854775807L; // Very large numbers (8 bytes)
// Note the 'L' suffix!

// FLOATING-POINT TYPES (decimals)
float price = 19.99f; // 7 digits precision (4 bytes)
// Note the 'f' suffix!
double distance = 3.14159265359; // 15-16 digits precision (8 bytes)
// Default for decimals
decimal money = 1000.50m; // 28-29 digits precision (16 bytes)
// Best for financial calculations!
// Note the 'm' suffix!
`

When to use which numeric type:

Type	Use Case	Example
`int`	Most counting/indexing	Loop counters, IDs, quantities
`long`	Very large numbers	File sizes, timestamps
`double`	Scientific calculations	Physics, graphics, general math
`decimal`	Money/financial	Prices, currency, accounting
`float`	Memory-constrained	Game development, large arrays

Boolean Type

Represents true or false only:

`csharp
bool isLoggedIn = true;
bool hasPermission = false;
bool isAdult = age >= 18; // Result of comparison

// Used in conditions
if (isLoggedIn && hasPermission)
{
Console.WriteLine("Access granted");
}
`

Character Type

Stores a single Unicode character:

`csharp
char letter = 'A'; // Single quotes for char!
char digit = '7';
char symbol = '$';
char emoji = '🐰'; // Unicode supported
char newLine = '\n'; // Escape character

// Common escape characters:
// \n = new line
// \t = tab
// \ = backslash
// \" = double quote
`

Reference Types (Stored on Heap)

Reference types store a reference (pointer) to the data's location in memory. Multiple variables can reference the same object.

String Type

A sequence of characters (text):

`csharp
string greeting = "Hello, World!";
string name = "Lucy";
string empty = ""; // Empty string
string nothing = null; // No string at all

// String concatenation (combining strings)
string fullGreeting = greeting + " My name is " + name;

// String interpolation (preferred - cleaner syntax)
string message = $"Hello, {name}! You have {5} new messages.";

// Verbatim strings (ignore escape characters)
string path = @"C:\Users\Lucy\Documents"; // No need to escape \

// Multi-line strings (C# 11+)
string json = """
{
"name": "Lucy",
"age": 3
}
""";
`

Important String Methods:

`csharp
string text = " Hello, World! ";

text.Length; // 17 (includes spaces)
text.ToUpper(); // " HELLO, WORLD! "
text.ToLower(); // " hello, world! "
text.Trim(); // "Hello, World!" (removes whitespace)
text.Contains("World"); // true
text.StartsWith(" H"); // true
text.Replace("World", "C#"); // " Hello, C#! "
text.Split(','); // [" Hello", " World! "]
text.Substring(2, 5); // "Hello"
`

Object Type

The base type of ALL types in C#. Any value can be stored in an object:

`csharp
object anything = "I'm a string";
anything = 42; // Now I'm an int
anything = true; // Now I'm a bool
anything = new DateTime(); // Now I'm a DateTime

// You need to cast back to use type-specific features
object boxed = 100;
int unboxed = (int)boxed; // Explicit cast required
`

Value vs Reference Types - The Key Difference

`csharp
// VALUE TYPES - Independent copies
int a = 10;
int b = a; // b gets a COPY of a's value
b = 20; // Changing b doesn't affect a
Console.WriteLine(a); // Still 10!
Console.WriteLine(b); // 20

// REFERENCE TYPES - Same object, multiple references
int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1; // arr2 points to SAME array as arr1
arr2[0] = 99; // Modifying through arr2...
Console.WriteLine(arr1[0]); // ...changes arr1 too! Output: 99
`

Visual Representation:

VALUE TYPES: REFERENCE TYPES: ┌─────┐ ┌─────┐ ┌─────┐ ┌─────────────┐ │ a=10│ │ b=20│ │arr1 │───▶│ {99, 2, 3} │ └─────┘ └─────┘ └─────┘ └─────────────┘ Independent copies ▲ ┌─────┐ │ │arr2 │─────────┘ └─────┘ Same object!

Nullable Types

By default, value types cannot be null. Use ? to make them nullable:

`csharp
// Regular value types - cannot be null
int age = 25;
// age = null; // ❌ Compile error!

// Nullable value types - CAN be null
int? nullableAge = null; // ✅ This is allowed
nullableAge = 25; // Can also hold regular values

// Checking for null
if (nullableAge.HasValue)
{
Console.WriteLine(nullableAge.Value); // 25
}

// Null-coalescing operator (??) - provide default if null
int displayAge = nullableAge ?? 0; // If null, use 0

// Null-coalescing assignment (??=) - assign only if null
nullableAge ??= 18; // Only assigns 18 if nullableAge is null

// Null-conditional operator (?.) - safe navigation
string? name = null;
int? length = name?.Length; // Returns null instead of crashing
`

📝 Exercises

Create variables for each numeric type and print their values.
Demonstrate the difference between value and reference types using arrays.
Use nullable types and null-coalescing operators to handle missing data.

➕ Operators

What are Operators?

Operators are symbols that perform operations on values (operands). C# has several categories of operators.

Arithmetic Operators

Perform mathematical calculations:

`csharp
int a = 10;
int b = 3;

// Basic operations
Console.WriteLine(a + b); // Addition: 13
Console.WriteLine(a - b); // Subtraction: 7
Console.WriteLine(a * b); // Multiplication: 30
Console.WriteLine(a / b); // Division: 3 (integer division!)
Console.WriteLine(a % b); // Modulus: 1 (remainder)

// ⚠️ Integer division truncates decimals!
Console.WriteLine(10 / 3); // 3 (not 3.33!)
Console.WriteLine(10.0 / 3); // 3.333... (use double for decimals)

// Increment and Decrement
int x = 5;
Console.WriteLine(x++); // Post-increment: prints 5, then x becomes 6
Console.WriteLine(++x); // Pre-increment: x becomes 7, then prints 7
Console.WriteLine(x--); // Post-decrement: prints 7, then x becomes 6
Console.WriteLine(--x); // Pre-decrement: x becomes 5, then prints 5
`

Comparison Operators

Compare values and return bool (true/false):

`csharp
int age = 25;
int limit = 18;

Console.WriteLine(age == limit); // Equal to: false
Console.WriteLine(age != limit); // Not equal to: true
Console.WriteLine(age > limit); // Greater than: true
Console.WriteLine(age < limit); // Less than: false
Console.WriteLine(age >= 18); // Greater than or equal: true
Console.WriteLine(age <= 30); // Less than or equal: true

// Comparing strings
string a = "hello";
string b = "Hello";
Console.WriteLine(a == b); // false (case-sensitive)
Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase)); // true
`

Logical Operators

Combine boolean expressions:

`csharp
bool isAdult = true;
bool hasLicense = false;
bool hasInsurance = true;

// AND (&&) - Both must be true
Console.WriteLine(isAdult && hasLicense); // false

// OR (||) - At least one must be true
Console.WriteLine(hasLicense || hasInsurance); // true

// NOT (!) - Reverses the value
Console.WriteLine(!isAdult); // false

// Complex conditions
bool canDrive = isAdult && hasLicense && hasInsurance;
bool needsHelp = !hasLicense || !hasInsurance;

// Short-circuit evaluation
// && stops if first is false (no need to check second)
// || stops if first is true (no need to check second)
`

Assignment Operators

Assign and modify values:

`csharp
int x = 10; // Basic assignment

x += 5; // Add and assign: x = x + 5 → 15
x -= 3; // Subtract and assign: x = x - 3 → 12
x *= 2; // Multiply and assign: x = x * 2 → 24
x /= 4; // Divide and assign: x = x / 4 → 6
x %= 4; // Modulus and assign: x = x % 4 → 2

// Also works with strings
string greeting = "Hello";
greeting += ", World!"; // "Hello, World!"
`

Ternary Operator

A shorthand for simple if-else:

`csharp
// Syntax: condition ? valueIfTrue : valueIfFalse

int age = 20;
string status = age >= 18 ? "Adult" : "Minor";
Console.WriteLine(status); // "Adult"

// Equivalent to:
string status2;
if (age >= 18)
status2 = "Adult";
else
status2 = "Minor";

// Can be nested (but avoid for readability)
string category = age < 13 ? "Child" : age < 20 ? "Teen" : "Adult";
`

Null-Related Operators

Handle null values safely:

`csharp
string? name = null;

// Null-coalescing (??) - provide default
string displayName = name ?? "Guest"; // "Guest"

// Null-coalescing assignment (??=)
name ??= "Default"; // Assigns only if name is null

// Null-conditional (?.) - safe member access
int? length = name?.Length; // null (doesn't crash!)
string? upper = name?.ToUpper();

// Null-forgiving (!) - tells compiler "I know this isn't null"
string definitelyNotNull = name!; // Use with caution!
`

🔄 Type Casting

What is Type Casting?

Type casting (or type conversion) is changing a value from one data type to another.

Implicit Casting (Automatic)

Happens automatically when converting to a larger/compatible type (no data loss):

`csharp
// Smaller → Larger (safe, no data loss)
int myInt = 100;
long myLong = myInt; // int → long (automatic)
float myFloat = myLong; // long → float (automatic)
double myDouble = myFloat; // float → double (automatic)

// Conversion hierarchy (implicit):
// byte → short → int → long → float → double
// ↓
// decimal
`

Explicit Casting (Manual)

Required when converting to a smaller type (potential data loss):

`csharp
// Larger → Smaller (may lose data!)
double myDouble = 9.78;
int myInt = (int)myDouble; // 9 (decimal part lost!)

long bigNumber = 1000L;
int smallerNumber = (int)bigNumber; // Works if value fits

// ⚠️ Overflow danger!
int tooBig = 300;
byte tooSmall = (byte)tooBig; // 44 (overflow - wraps around!)
`

Type Conversion Methods

For converting between incompatible types:

`csharp
// STRING → NUMBER
string ageText = "25";

// Method 1: Parse (throws if invalid)
int age1 = int.Parse(ageText); // 25
double price1 = double.Parse("19.99"); // 19.99

// Method 2: Convert class (handles null)
int age2 = Convert.ToInt32(ageText); // 25
int fromNull = Convert.ToInt32(null); // 0 (doesn't throw!)

// Method 3: TryParse (safest - doesn't throw)
if (int.TryParse(ageText, out int result))
{
Console.WriteLine($"Parsed: {result}"); // 25
}
else
{
Console.WriteLine("Invalid number");
}

// NUMBER → STRING
int number = 42;
string text1 = number.ToString(); // "42"
string text2 = Convert.ToString(number); // "42"
string text3 = $"{number}"; // "42" (interpolation)

// Formatting numbers as strings
double price = 1234.567;
Console.WriteLine(price.ToString("C")); // $1,234.57 (currency)
Console.WriteLine(price.ToString("F2")); // 1234.57 (2 decimals)
Console.WriteLine(price.ToString("N0")); // 1,235 (no decimals, with commas)
Console.WriteLine(price.ToString("P1")); // 123,456.7% (percentage)
`

🔧 Functions (Methods)

What is a Method?

A method (also called function) is a reusable block of code that performs a specific task. Methods help organize code and avoid repetition (DRY principle).

`csharp
// Method anatomy:
// [access modifier] [static?] [return type] MethodName([parameters])
// {
// // method body
// return value; // if return type isn't void
// }

public static int Add(int a, int b)
{
return a + b;
}
`

Method Declaration & Calling

`csharp
class Calculator
{
// Method with no parameters, no return value (void)
static void SayHello()
{
Console.WriteLine("Hello, World!");
}

// Method with parameters
static void Greet(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

// Method with return value
static int Add(int a, int b)
{
    return a + b;  // Must return an int
}

// Method with multiple parameters and return
static double CalculateArea(double width, double height)
{
    double area = width * height;
    return area;
}

static void Main()
{
    // Calling methods
    SayHello();                        // Hello, World!
    Greet("Lucy");                     // Hello, Lucy!

    int sum = Add(5, 3);               // sum = 8
    Console.WriteLine(sum);

    double area = CalculateArea(4.5, 3.0);  // area = 13.5
    Console.WriteLine($"Area: {area}");
}

}
`

Parameters: Default, Named, and Params

`csharp
// DEFAULT PARAMETERS - Optional with fallback values
static void CreateUser(string name, int age = 18, string role = "User")
{
Console.WriteLine($"{name}, {age} years old, Role: {role}");
}

CreateUser("Alice"); // Alice, 18 years old, Role: User
CreateUser("Bob", 25); // Bob, 25 years old, Role: User
CreateUser("Carol", 30, "Admin"); // Carol, 30 years old, Role: Admin

// NAMED PARAMETERS - Specify by name (any order)
CreateUser(role: "Moderator", name: "Dave"); // Dave, 18 years old, Role: Moderator

// PARAMS - Variable number of arguments
static int Sum(params int[] numbers)
{
int total = 0;
foreach (int num in numbers)
{
total += num;
}
return total;
}

Console.WriteLine(Sum(1, 2)); // 3
Console.WriteLine(Sum(1, 2, 3, 4, 5)); // 15
Console.WriteLine(Sum()); // 0 (no arguments)
`

Out, Ref, and In Parameters

`csharp
// OUT - Method MUST assign a value (returns multiple values)
static void GetMinMax(int[] numbers, out int min, out int max)
{
min = numbers.Min();
max = numbers.Max();
}

int[] data = { 5, 2, 8, 1, 9 };
GetMinMax(data, out int minimum, out int maximum);
Console.WriteLine($"Min: {minimum}, Max: {maximum}"); // Min: 1, Max: 9

// REF - Pass by reference (can read AND modify)
static void Double(ref int number)
{
number *= 2; // Modifies the original variable!
}

int value = 10;
Double(ref value);
Console.WriteLine(value); // 20 (original was modified!)

// IN - Pass by reference but READ-ONLY (for large structs)
static void PrintPoint(in Point p)
{
Console.WriteLine($"X: {p.X}, Y: {p.Y}");
// p.X = 10; // ❌ Error: cannot modify 'in' parameter
}
`

Expression-Bodied Methods

Shorter syntax for simple methods:

`csharp
// Traditional method
static int Square(int x)
{
return x * x;
}

// Expression-bodied (arrow syntax) - same result
static int Square(int x) => x * x;

// More examples
static string GetFullName(string first, string last) => $"{first} {last}";
static bool IsAdult(int age) => age >= 18;
static void Log(string message) => Console.WriteLine($"[LOG] {message}");
`

📦 Arrays and Collections

Arrays

An array is a fixed-size collection of elements of the same type:

`csharp
// Declaration and initialization
string[] bunnies = { "Lucy", "Tom", "Molly" }; // Shorthand
int[] numbers = new int[5]; // 5 zeros
double[] prices = new double[] { 9.99, 19.99, 29.99 }; // Explicit

// Accessing elements (0-indexed!)
Console.WriteLine(bunnies[0]); // "Lucy" (first element)
Console.WriteLine(bunnies[1]); // "Tom" (second element)
Console.WriteLine(bunnies[^1]); // "Molly" (last element - C# 8+)

// Modifying elements
bunnies[0] = "Peter"; // Replace "Lucy" with "Peter"

// Array properties
Console.WriteLine(bunnies.Length); // 3

// Iterating
for (int i = 0; i < bunnies.Length; i++)
{
Console.WriteLine($"Index {i}: {bunnies[i]}");
}

foreach (string bunny in bunnies)
{
Console.WriteLine(bunny);
}
`

Lists (Dynamic Arrays)

Lists can grow and shrink dynamically:

`csharp
using System.Collections.Generic;

// Creating lists
List bunnies = new List(); // Empty
List numbers = new List { 1, 2, 3, 4, 5 }; // With items
var names = new List { "Lucy", "Tom" }; // Using var

// Adding elements
bunnies.Add("Lucy"); // Add to end
bunnies.Add("Tom");
bunnies.Insert(0, "Peter"); // Insert at index 0

// Removing elements
bunnies.Remove("Tom"); // Remove by value (first occurrence)
bunnies.RemoveAt(0); // Remove by index
bunnies.Clear(); // Remove all

// Accessing elements
Console.WriteLine(names[0]); // "Lucy"
Console.WriteLine(names.Count); // 2

// Searching
bool hasLucy = names.Contains("Lucy"); // true
int index = names.IndexOf("Tom"); // 1
string? found = names.Find(n => n.StartsWith("L")); // "Lucy"

// Sorting
names.Sort(); // Alphabetical
names.Reverse(); // Reverse order
names.Sort((a, b) => b.CompareTo(a)); // Custom: descending
`

Dictionaries (Key-Value Pairs)

Store data as key-value pairs for fast lookup:

`csharp
// Creating dictionaries
Dictionary ages = new Dictionary();
var bunnyColors = new Dictionary
{
{ "Lucy", "White" },
{ "Tom", "Black" },
{ "Molly", "Brown" }
};

// Adding/updating
ages["Lucy"] = 3; // Add or update
ages.Add("Tom", 5); // Add only (throws if exists)
ages.TryAdd("Molly", 2); // Add only (returns false if exists)

// Accessing
string lucyColor = bunnyColors["Lucy"]; // "White"

// Safe access (avoid exceptions)
if (bunnyColors.TryGetValue("Tom", out string? color))
{
Console.WriteLine($"Tom is {color}");
}

// Checking existence
bool hasLucy = bunnyColors.ContainsKey("Lucy"); // true
bool hasGray = bunnyColors.ContainsValue("Gray"); // false

// Iterating
foreach (var pair in bunnyColors)
{
Console.WriteLine($"{pair.Key}: {pair.Value}");
}

// Or with deconstruction
foreach (var (name, bunnyColor) in bunnyColors)
{
Console.WriteLine($"{name} is {bunnyColor}");
}
`

❓ Conditional Statements

If-Else Statements

Make decisions based on conditions:

`csharp
int score = 85;

// Simple if
if (score >= 60)
{
Console.WriteLine("Passed!");
}

// If-else
if (score >= 60)
{
Console.WriteLine("Passed!");
}
else
{
Console.WriteLine("Failed!");
}

// If-else if-else (multiple conditions)
if (score >= 90)
{
Console.WriteLine("Grade: A");
}
else if (score >= 80)
{
Console.WriteLine("Grade: B");
}
else if (score >= 70)
{
Console.WriteLine("Grade: C");
}
else if (score >= 60)
{
Console.WriteLine("Grade: D");
}
else
{
Console.WriteLine("Grade: F");
}
`

Switch Statement

Better than multiple if-else for checking one value against many cases:

`csharp
string day = "Monday";

switch (day)
{
case "Monday":
case "Tuesday":
case "Wednesday":
case "Thursday":
case "Friday":
Console.WriteLine("Weekday");
break;
case "Saturday":
case "Sunday":
Console.WriteLine("Weekend!");
break;
default:
Console.WriteLine("Invalid day");
break;
}
`

Switch Expression (C# 8+)

Modern, concise syntax that returns a value:

`csharp
string day = "Monday";

string dayType = day switch
{
"Monday" or "Tuesday" or "Wednesday" or "Thursday" or "Friday" => "Weekday",
"Saturday" or "Sunday" => "Weekend!",
_ => "Invalid day" // _ is the default/discard pattern
};

Console.WriteLine(dayType);

// With pattern matching
int score = 85;
string grade = score switch
{
>= 90 => "A",
>= 80 => "B",
>= 70 => "C",
>= 60 => "D",
_ => "F"
};
`

Ternary Operator

One-line conditional expression:

`csharp
int age = 20;

// condition ? trueValue : falseValue
string status = age >= 18 ? "Adult" : "Minor";

// Can be nested (but avoid for readability)
string ticket = age < 12 ? "Child" : age < 65 ? "Adult" : "Senior";

// Null-conditional pattern
string? name = null;
string display = name ?? "Guest"; // Use "Guest" if null
`

🔁 Loops

For Loop

Best when you know how many iterations you need:

`csharp
// Basic for loop
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Iteration {i}"); // 0, 1, 2, 3, 4
}

// Counting backwards
for (int i = 10; i > 0; i--)
{
Console.WriteLine(i); // 10, 9, 8, ..., 1
}

// Stepping by 2
for (int i = 0; i <= 10; i += 2)
{
Console.WriteLine(i); // 0, 2, 4, 6, 8, 10
}

// Iterating array with index
string[] names = { "Lucy", "Tom", "Molly" };
for (int i = 0; i < names.Length; i++)
{
Console.WriteLine($"{i}: {names[i]}");
}
`

Foreach Loop

Best for iterating through collections:

`csharp
string[] bunnies = { "Lucy", "Tom", "Molly" };

foreach (string bunny in bunnies)
{
Console.WriteLine($"{bunny} is ready for checkup!");
}

// Works with any collection
List numbers = new() { 1, 2, 3, 4, 5 };
foreach (int num in numbers)
{
Console.WriteLine(num * 2);
}

// With dictionaries
Dictionary ages = new() { ["Lucy"] = 3, ["Tom"] = 5 };
foreach (var (name, age) in ages)
{
Console.WriteLine($"{name} is {age}");
}
`

While Loop

Continues while a condition is true:

`csharp
int count = 0;
while (count < 5)
{
Console.WriteLine($"Count: {count}");
count++;
}

// Reading until valid input
string input = "";
while (string.IsNullOrEmpty(input))
{
Console.Write("Enter your name: ");
input = Console.ReadLine() ?? "";
}
`

Do-While Loop

Runs at least once, then checks the condition:

`csharp
int number;
do
{
Console.Write("Enter a positive number: ");
number = int.Parse(Console.ReadLine() ?? "0");
} while (number <= 0);

Console.WriteLine($"You entered: {number}");
`

Break and Continue

Control loop flow:

`csharp
// BREAK - Exit the loop immediately
for (int i = 0; i < 10; i++)
{
if (i == 5) break; // Stop at 5
Console.WriteLine(i); // 0, 1, 2, 3, 4
}

// CONTINUE - Skip to next iteration
for (int i = 0; i < 5; i++)
{
if (i == 2) continue; // Skip 2
Console.WriteLine(i); // 0, 1, 3, 4
}
`

⚠️ Exception Handling

What are Exceptions?

Exceptions are errors that occur during program execution. Without handling, they crash your program!

Try-Catch-Finally

csharp try { // Code that might throw an exception int result = 10 / 0; // DivideByZeroException! } catch (DivideByZeroException ex) { // Handle specific exception Console.WriteLine($"Cannot divide by zero: {ex.Message}"); } catch (Exception ex) { // Handle any other exception Console.WriteLine($"An error occurred: {ex.Message}"); } finally { // ALWAYS runs (cleanup code) Console.WriteLine("Cleanup complete"); }

Common Exception Types

Exception	Cause
`NullReferenceException`	Accessing a null object
`IndexOutOfRangeException`	Array index out of bounds
`DivideByZeroException`	Division by zero
`FormatException`	Invalid format (e.g., parsing)
`ArgumentException`	Invalid argument passed
`InvalidOperationException`	Invalid operation for current state

Throwing Exceptions

`csharp
static void SetAge(int age)
{
if (age < 0)
{
throw new ArgumentException("Age cannot be negative", nameof(age));
}
if (age > 150)
{
throw new ArgumentOutOfRangeException(nameof(age), "Age is unrealistic");
}
// ... rest of logic
}

// Custom exceptions
public class InsufficientFundsException : Exception
{
public decimal Balance { get; }
public decimal Attempted { get; }

public InsufficientFundsException(decimal balance, decimal attempted)
    : base($"Insufficient funds. Balance: {balance:C}, Attempted: {attempted:C}")
{
    Balance = balance;
    Attempted = attempted;
}

}
`

🏗️ Classes and Objects

What is a Class?

A class is a blueprint for creating objects. It defines properties (data) and methods (behavior).

`csharp
public class Bunny
{
// Fields (private data)
private string name;
private int age;

// Properties (public access to data)
public string Name
{
    get { return name; }
    set { name = value; }
}

public int Age
{
    get { return age; }
    set { age = value >= 0 ? value : 0; }  // Validation!
}

// Constructor (initializes new objects)
public Bunny(string name, int age)
{
    this.name = name;
    this.age = age;
}

// Methods (behavior)
public void Speak()
{
    Console.WriteLine($"{Name} says: Squeak!");
}

// Static method (belongs to class, not instances)
public static void Info()
{
    Console.WriteLine("Bunnies are cute pets!");
}

}

// Using the class
Bunny lucy = new Bunny("Lucy", 3);
lucy.Speak(); // Lucy says: Squeak!
Console.WriteLine(lucy.Name); // Lucy

Bunny.Info(); // Static method - called on class
`

Auto-Properties (Simplified)

`csharp
public class Bunny
{
// Auto-implemented properties (compiler creates backing field)
public string Name { get; set; }
public int Age { get; set; }
public string Color { get; init; } // Can only set during initialization
public bool IsAdult => Age >= 1; // Computed property

// Constructor
public Bunny(string name, int age, string color)
{
    Name = name;
    Age = age;
    Color = color;
}

}

// Object initializer syntax
var bunny = new Bunny("Lucy", 3, "White");
// Or with object initializer
var bunny2 = new Bunny("Tom", 2, "Black") { Name = "Tommy" };
`

📋 Inheritance & Interfaces

Inheritance

Create new classes based on existing ones:

`csharp
// Base class
public class Animal
{
public string Name { get; set; }

public virtual void Speak()  // 'virtual' allows overriding
{
    Console.WriteLine("Some sound");
}

}

// Derived class
public class Bunny : Animal // Bunny inherits from Animal
{
public string Color { get; set; }

public override void Speak()  // Override base implementation
{
    Console.WriteLine($"{Name} says: Squeak!");
}

public void Hop() => Console.WriteLine($"{Name} is hopping!");

}

// Usage
Bunny bunny = new Bunny { Name = "Lucy", Color = "White" };
bunny.Speak(); // Lucy says: Squeak!
bunny.Hop(); // Lucy is hopping!
`

Interfaces

Define a contract that classes must implement:

`csharp
public interface IAnimal
{
string Name { get; set; }
void Speak();
void Move();
}

public class Bunny : IAnimal
{
public string Name { get; set; }
public void Speak() => Console.WriteLine($"{Name}: Squeak!");
public void Move() => Console.WriteLine($"{Name} hops!");
}

public class Dog : IAnimal
{
public string Name { get; set; }
public void Speak() => Console.WriteLine($"{Name}: Woof!");
public void Move() => Console.WriteLine($"{Name} runs!");
}

// Polymorphism - treat different types uniformly
IAnimal[] animals = { new Bunny { Name = "Lucy" }, new Dog { Name = "Max" } };
foreach (IAnimal animal in animals)
{
animal.Speak(); // Each uses its own implementation
}
`

🔍 LINQ

LINQ (Language Integrated Query) provides powerful data querying:

`csharp
using System.Linq;

var bunnies = new List
{
new Bunny { Name = "Lucy", Age = 3, Color = "White" },
new Bunny { Name = "Tom", Age = 5, Color = "Black" },
new Bunny { Name = "Molly", Age = 2, Color = "White" }
};

// WHERE - Filter
var whiteBunnies = bunnies.Where(b => b.Color == "White");

// SELECT - Transform
var names = bunnies.Select(b => b.Name); // ["Lucy", "Tom", "Molly"]

// ORDERBY - Sort
var byAge = bunnies.OrderBy(b => b.Age);

// FIRST / FIRSTORDEFAULT - Get first match
var oldest = bunnies.OrderByDescending(b => b.Age).First();
var baby = bunnies.FirstOrDefault(b => b.Age < 1); // null if not found

// AGGREGATE FUNCTIONS
int totalAge = bunnies.Sum(b => b.Age); // 10
double avgAge = bunnies.Average(b => b.Age); // 3.33
int count = bunnies.Count(b => b.Age > 2); // 2

// ANY / ALL
bool hasOld = bunnies.Any(b => b.Age > 4); // true
bool allWhite = bunnies.All(b => b.Color == "White"); // false
`

⏳ Async/Await

Handle asynchronous operations without blocking:

`csharp
using System.Net.Http;

// Async method declaration
public static async Task FetchDataAsync(string url)
{
using HttpClient client = new();
string result = await client.GetStringAsync(url);
return result;
}

// Calling async methods
public static async Task Main()
{
Console.WriteLine("Fetching data...");

string data = await FetchDataAsync("https://api.example.com/data");

Console.WriteLine($"Received: {data}");

}

// Parallel async operations
public static async Task FetchMultipleAsync()
{
var task1 = FetchDataAsync("https://api.example.com/users");
var task2 = FetchDataAsync("https://api.example.com/posts");

// Wait for all to complete
string[] results = await Task.WhenAll(task1, task2);

}
`

🧮 Calculator Exercise

`csharp
public class Calculator
{
public double Add(double x, double y) => x + y;
public double Subtract(double x, double y) => x - y;
public double Multiply(double x, double y) => x * y;
public double Divide(double x, double y) =>
y != 0 ? x / y : throw new DivideByZeroException();
public double Power(double x, double y) => Math.Pow(x, y);
public double Square(double x) => x * x;
public double SquareRoot(double x) => Math.Sqrt(x);
}

// Usage
var calc = new Calculator();
Console.WriteLine(calc.Add(5, 3)); // 8
Console.WriteLine(calc.Multiply(4, 7)); // 28
Console.WriteLine(calc.Power(2, 8)); // 256
`

📚 Resources

🤝 Contributing

Fork this repository
Create a new branch
Make your changes
Submit a pull request

⭐ Show Your Support

Give a ⭐ if this helped you!

Made with ❤️ for C# learners

🔥 7-week Node.js: Build & deploy real APIs! I’m Fredrick Abodunrin—Senior Backend Eng & instructor (5 cohorts, 40+ students). Early-bird ₦75K (3 spots!) 👉 https://forms.gle/uXUgfxLRFNNCmKXd9

FredAbod — Thu, 01 May 2025 19:03:19 +0000

🚀 Launch Your Backend Career with My 7-Week Node.js Course!

FredAbod ・ May 1

#webdev #beginners #tutorial #programming

🚀 Launch Your Backend Career with My 7-Week Node.js Course!

FredAbod — Thu, 01 May 2025 18:58:33 +0000

🚀 Launch Your Backend Career with My 7-Week Node.js Course!

Are you ready to go from zero to backend hero—with live coaching, real projects and one-on-one mentoring? I’m Fredrick Abodunrin, Senior Backend Engineer turned instructor, and I’ve distilled 5+ years of hands-on API & payment-infrastructure work into a structured, 7-week live course.

Why This Course?

Proven Track Record

• 5+ cohorts taught at Grazac Academy & Career Connect (EduTech)

• 40+ personal 1 : 1 students mentored—many now working as backend devs

• 50 000+ reads on my Dev.to articles demonstrating my teaching reach
End-to-End Curriculum

• Week 1: JavaScript essentials & async fundamentals

• Week 2: Advanced Promises, async/await & module patterns

• Week 3: Core Node.js (FS, HTTP, Event Loop) & npm mastery

• Week 4: Express.js + RESTful CRUD patterns

• Week 5: MongoDB persistence with Mongoose

• Week 6: Deploy anywhere: Heroku, Railway, Render + CI/CD basics

• Week 7: Polish your LinkedIn & GitHub + final 1 : 1 portfolio review
Live + Hands-On

• Twice-weekly 2-hour live labs

• Weekly office-hours Q&A

• Real deployable projects you’ll own
Bonus Profile Power-Ups

• Optimizing your LinkedIn headline, summary & posts

• Structuring your GitHub repos, READMEs & issues

• Clean commit messages & career networking tips

📅 Course Details & Pricing

Dates: 19 May – 7 July 2025
Duration: 7 weeks (14 live sessions + office hours)
Full Price: ₦150 000
🔥 Early-Bird: ₦75 000 for the first 5 registrations—you won’t find a deal like this anywhere else!

💬 What Graduates Say

“Fredrick’s mentorship at Grazac Academy turned me from a total beginner into someone confidently shipping APIs in 3 weeks.”

— Kehinde Olawale., Backend Developer @ TechFin

“I landed my first backend role after his 1 : 1 coaching—couldn’t recommend more!”

— Tobi Adeoke., Software Engineer @ InnovateX

🎯 Who Should Join?

Aspiring devs who want practical backend skills
Front-end engineers ready to own server-side logic
Career-changers aiming for high-demand Node.js roles
Anyone who learns best by building real apps—live!

🛠️ How to Register

Fill out the short form → https://forms.gle/uXUgfxLRFNNCmKXd9
Snag your ₦75 000 early-bird spot (only 5 available)
Join our WhatsApp community for instant announcements & peer support → https://chat.whatsapp.com/IKWYfnwv4eGLhcvQ7KebQu
Await your syllabus, pre-course checklist & payment instructions

📂 Learn More

🔗 Portfolio: https://beautiful-boluwatife-portfolio.lovable.app/

🔗 Dev.to Articles: Search “@fredrickabodunrin” for 50 K+ reads on modern backend topics

Don’t wait—seats are limited, and early-bird spots will vanish fast. Let’s build your backend expertise together!

[Boost]

FredAbod — Wed, 09 Apr 2025 17:54:45 +0000

FredAbod

Apr 9 '25

Building Your First Flask App: A Beginner's Guide

#programming #phyton #beginners #flask

6 min read

Building Your First Flask App: A Beginner's Guide

FredAbod — Wed, 09 Apr 2025 17:54:17 +0000

Building Your First Flask App: A Beginner's Guide

Flask is a lightweight and powerful web framework for Python. In this guide, we’ll walk you through building your first Flask app, complete with user authentication (signup and login). By the end, you’ll have a fully functional app running on your local machine.

Prerequisites

Before we start, make sure you have the following:

Python installed (version 3.7 or higher)
Basic knowledge of Python
A code editor (e.g., VS Code)
MySQL installed locally or access to a MySQL database
A willingness to learn (and maybe some coffee ☕)

Step 1: Setting Up Your Environment

Install Flask: lask is a tool that helps us build websites using Python. To install it, open your terminal and run:

   pip install flask flask-mysqldb werkzeug

Create Your Project Directory: Think of this as creating a folder where all your files will live. Run:

   mkdir myfirstFlaskApp
   cd myfirstFlaskApp

Set Up Your Database: Create a MySQL database named myDB and a table named user:

   CREATE DATABASE myDB;
   USE myDB;
   CREATE TABLE user (
       id INT AUTO_INCREMENT PRIMARY KEY,
       username VARCHAR(100) UNIQUE,
       password VARCHAR(255)
   );

Step 2: Writing the Flask App

Create a file named app.py and add the following code:

from flask import Flask, render_template, request, flash, redirect, url_for, session
from flask_mysqldb import MySQL
from werkzeug.security import generate_password_hash, check_password_hash

app = Flask(__name__)

# MySQL Config
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = 'your_mysql_password'
app.config['MYSQL_DB'] = 'myDB'
mysql = MySQL(app)

app.secret_key = 'your_secret_key'

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/signup', methods=['GET', 'POST'])
def signup():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        hashed_password = generate_password_hash(password)

        try:
            cur = mysql.connection.cursor()
            cur.execute("INSERT INTO user (username, password) VALUES (%s, %s)", (username, hashed_password))
            mysql.connection.commit()
            cur.close()
            flash('Registration successful!', 'success')
            return redirect(url_for('login'))
        except:
            flash('Registration failed! Username might already exist.', 'error')
    return render_template('signup.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']

        cur = mysql.connection.cursor()
        cur.execute("SELECT * FROM user WHERE username = %s", [username])
        user = cur.fetchone()
        cur.close()

        if user and check_password_hash(user[2], password):
            session['username'] = username
            flash('Welcome back, {}!'.format(username), 'success')
            return redirect(url_for('home'))
        else:
            flash('Invalid username or password', 'danger')
    return render_template('login.html')

if __name__ == '__main__':
    app.run(debug=True)

Step 3: Creating the HTML Templates

Homepage (templates/index.html):

   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>Home Page</title>
       <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
   </head>
   <body>
       <div class="container mt-5">
           {% with messages = get_flashed_messages(with_categories=true) %}
               {% if messages %}
                   {% for category, message in messages %}
                       <div class="alert alert-{{ category }}">{{ message }}</div>
                   {% endfor %}
               {% endif %}
           {% endwith %}
           <div class="text-center">
               <h1>Welcome to My Flask App</h1>
               <p>This is the homepage.</p>
               <div class="btn-group">
                   <a href="/signup" class="btn btn-primary">Signup</a>
                   <a href="/login" class="btn btn-success">Login</a>
               </div>
           </div>
       </div>
   </body>
   </html>

Signup Page (templates/signup.html):

   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>Signup</title>
       <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
   </head>
   <body>
       <div class="container mt-5">
           {% with messages = get_flashed_messages() %}
               {% if messages %}
                   {% for message in messages %}
                       <div class="alert alert-info">{{ message }}</div>
                   {% endfor %}
               {% endif %}
           {% endwith %}
           <h2>Signup</h2>
           <form method="POST">
               <div class="form-group">
                   <label for="username">Username</label>
                   <input type="text" class="form-control" id="username" name="username" required>
               </div>
               <div class="form-group">
                   <label for="password">Password</label>
                   <input type="password" class="form-control" id="password" name="password" required>
               </div>
               <button type="submit" class="btn btn-primary">Register</button>
           </form>
       </div>
   </body>
   </html>

Login Page (templates/login.html):

   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>Login</title>
       <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
   </head>
   <body>
       <div class="container mt-5">
           {% with messages = get_flashed_messages() %}
               {% if messages %}
                   {% for message in messages %}
                       <div class="alert alert-info">{{ message }}</div>
                   {% endfor %}
               {% endif %}
           {% endwith %}
           <h2>Login</h2>
           <form method="POST">
               <div class="form-group">
                   <label for="username">Username</label>
                   <input type="text" class="form-control" id="username" name="username" required>
               </div>
               <div class="form-group">
                   <label for="password">Password</label>
                   <input type="password" class="form-control" id="password" name="password" required>
               </div>
               <button type="submit" class="btn btn-primary">Login</button>
           </form>
       </div>
   </body>
   </html>

Step 4: Running Your App

Open your terminal and navigate to the project directory:

   cd myfirstFlaskApp

Run the app:

   python app.py

Open your browser and go to http://127.0.0.1:5000.

Code Explanation

from flask import Flask, render_template, request, flash, redirect, url_for, session

Flask: This is the main tool we use to create the app.
render_template: Helps us show HTML pages to the user.
request: Lets us get data (like username and password) from forms.
flash: Displays messages like "Signup successful!" or "Login failed."
redirect and url_for: Help us move the user to another page.
session: Stores information about the user (like if they’re logged in).

from flask_mysqldb import MySQL
from werkzeug.security import generate_password_hash, check_password_hash

MySQL: Connects our app to the database.
generate_password_hash: Turns passwords into a secret code (hash) for security.
check_password_hash: Checks if a password matches its secret code.

Setting Up the App

app = Flask(__name__)

This creates the Flask app.

app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = 'your_mysql_password'
app.config['MYSQL_DB'] = 'myDB'
mysql = MySQL(app)

Here, we tell Flask how to connect to the database:

MYSQL_HOST: The address of the database (usually localhost for local machines).
MYSQL_USER and MYSQL_PASSWORD: The username and password for the database.
MYSQL_DB: The name of the database (myDB).

app.secret_key = 'your_secret_key'

This is a secret key that Flask uses to keep things secure (like flash messages and sessions).

Homepage Route

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/'): This tells Flask to show the homepage when someone visits /.
render_template('index.html'): Displays the index.html file.

Signup Route

@app.route('/signup', methods=['GET', 'POST'])
def signup():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        hashed_password = generate_password_hash(password)

methods=['GET', 'POST']: Allows the page to handle form submissions.
request.form['username']: Gets the username from the form.
generate_password_hash(password): Turns the password into a secret code.

        try:
            cur = mysql.connection.cursor()
            cur.execute("INSERT INTO user (username, password) VALUES (%s, %s)", (username, hashed_password))
            mysql.connection.commit()
            cur.close()
            flash('Registration successful!', 'success')
            return redirect(url_for('login'))
        except:
            flash('Registration failed! Username might already exist.', 'error')

cur.execute: Adds the username and hashed password to the database.
flash: Shows a success or error message.
redirect(url_for('login')): Sends the user to the login page.

Login Route

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']

request.form['username'] and request.form['password']: Get the username and password from the form.

        cur = mysql.connection.cursor()
        cur.execute("SELECT * FROM user WHERE username = %s", [username])
        user = cur.fetchone()
        cur.close()

cur.execute: Searches the database for the username.
cur.fetchone(): Gets the user’s data (if it exists).

        if user and check_password_hash(user[2], password):
            session['username'] = username
            flash('Welcome back, {}!'.format(username), 'success')
            return redirect(url_for('home'))
        else:
            flash('Invalid username or password', 'danger')

check_password_hash(user[2], password): Checks if the password matches the secret code.
session['username']: Stores the username in the session (to remember the user).
flash: Shows a success or error message.

Running the App

if __name__ == '__main__':
    app.run(debug=True)

This starts the app. The debug=True makes it easier to find errors.

Conclusion

Congratulations! 🎉 You’ve built your first Flask app with user authentication. This app can serve as a foundation for more advanced projects. Keep experimenting and happy coding!
Don't Forget To Drop A Like❤️

[Boost]

FredAbod — Thu, 27 Mar 2025 12:56:11 +0000

Understanding a NestJS Authentication App for an Express.js Developer

FredAbod ・ Mar 27

#programming #express #beginners #javascript

Building a NestJS Authentication API with MongoDB and JWT: A Step-by-Step Guide

FredAbod — Thu, 27 Mar 2025 12:41:34 +0000

Building a NestJS Authentication API with MongoDB and JWT: A Step-by-Step Guide

Authentication is a critical part of any application. In this guide, we’ll build a complete authentication system using NestJS, MongoDB, and JWT. We'll cover everything from setting up the project to implementing authentication routes and securing them with guards.

Prerequisites

Node.js and npm installed
Basic understanding of NestJS
MongoDB installed locally or access to a MongoDB cloud instance
A willingness to learn (and maybe some coffee ☕)

To install the NestJS CLI globally, run:

npm install -g @nestjs/cli

Verify the installation:

nest --version

Step 1: Initialize the Project

Create a new NestJS project:

nest new auth-app
cd auth-app

Install the required dependencies:

npm install @nestjs/mongoose mongoose @nestjs/jwt @nestjs/passport passport-jwt bcryptjs
npm install --save-dev @types/bcryptjs @types/passport-jwt

Setting Up MongoDB

Step 2: Configure MongoDB Connection
NestJS provides the @nestjs/mongoose package to integrate MongoDB. Let’s set up the connection.

Create a DatabaseModule:

nest generate module database

Configure the connection in database.module.ts:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    MongooseModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        uri: configService.get<string>('DATABASE_URL'),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class DatabaseModule {}

Add the DATABASE_URL to your .env file:

DATABASE_URL=mongodb://localhost/nest-auth

Creating the User Module

Step 3: Define the User Schema

Generate the User module:

nest generate module users
nest generate service users
nest generate controller users

Create the User schema in user.schema.ts:

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type UserDocument = User & Document;

@Schema({ timestamps: true })
export class User {
  @Prop({ required: true, unique: true })
  username: string;

  @Prop({ required: true })
  password: string;

  @Prop({ required: true, unique: true })
  email: string;

  @Prop({ default: null })
  refreshToken: string;
}

export const UserSchema = SchemaFactory.createForClass(User);

Update the UsersModule to include the schema:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { User, UserSchema } from './schemas/user.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])],
  providers: [UsersService],
  controllers: [UsersController],
  exports: [UsersService],
})
export class UsersModule {}

Implementing Authentication

Step 4: Create the Auth Module

Generate the Auth module:

nest generate module auth
nest generate service auth
nest generate controller auth

Configure JWT and Passport in auth.module.ts:

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { UsersModule } from '../users/users.module';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET || 'fallback-secret',
      signOptions: { expiresIn: '15m' },
    }),
  ],
  providers: [AuthService, JwtStrategy],
  controllers: [AuthController],
})
export class AuthModule {}

Add the JWT_SECRET to your .env file:

JWT_SECRET=your_jwt_secret_key_here

Step 5: Implement the Auth Service
The AuthService handles the business logic for authentication.

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { UsersService } from '../users/users.service';
import * as bcrypt from 'bcryptjs';

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService,
  ) {}

  async validateUser(username: string, password: string): Promise<any> {
    const user = await this.usersService.findOne(username);
    if (!user) {
      throw new UnauthorizedException('Invalid credentials');
    }

    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      throw new UnauthorizedException('Invalid credentials');
    }

    const { password: _, ...result } = user.toObject();
    return result;
  }

  async login(user: any) {
    const payload = { username: user.username, sub: user._id };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }

  async register(username: string, email: string, password: string) {
    const hashedPassword = await bcrypt.hash(password, 10);
    return this.usersService.create(username, email, hashedPassword);
  }
}

Step 6: Implement the Auth Controller
The AuthController defines the authentication routes.

import { Controller, Post, Body, UseGuards, Get, Request } from '@nestjs/common';
import { AuthService } from './auth.service';
import { JwtAuthGuard } from './jwt-auth.guard';
import { LoginDto, RegisterDto } from '../common/dto/auth.dto';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  @Post('login')
  async login(@Body() loginDto: LoginDto) {
    const user = await this.authService.validateUser(loginDto.username, loginDto.password);
    return this.authService.login(user);
  }

  @Post('register')
  async register(@Body() registerDto: RegisterDto) {
    return this.authService.register(registerDto.username, registerDto.email, registerDto.password);
  }

  @UseGuards(JwtAuthGuard)
  @Get('profile')
  getProfile(@Request() req) {
    return req.user;
  }
}

Step 7: Secure Routes with Guards
Create a JWT Guard in jwt-auth.guard.ts:

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

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

Implement the JWT Strategy in jwt.strategy.ts:

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: process.env.JWT_SECRET || 'fallback-secret',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

Conclusion

In this guide, we built a complete authentication system using NestJS, MongoDB, and JWT. We covered everything from setting up the project to implementing secure routes with guards. This setup can serve as a foundation for more advanced features like role-based access control, email verification, and password reset functionality.
Don't Forget to Like and Follow❤️❤️
Here's the GitHub Repo for reference Nest-Auth-App
If You're coming from express.js no worries(●'◡'●) I Gat you, Check out my article on Understanding a NestJS Authentication App for an Express.js Developer

Happy coding! 🎉

Understanding a NestJS Authentication App for an Express.js Developer

FredAbod — Thu, 27 Mar 2025 12:38:48 +0000

Understanding a NestJS Authentication App for an Express.js Developer

If you're coming from the world of Express.js, where everything is a bit more "manual" and you have to wire up routes, middleware, and controllers yourself, NestJS might feel like stepping into a world where everything is pre-organized for you. Think of it as moving from a DIY furniture kit to a fully furnished apartment. Let’s break down this NestJS authentication app and compare it to how you’d typically build a basic CRUD app in Express.js.

The Entry Point

Express.js:
In Express, you’d typically start with an app.js or server.js file where you initialize the app, set up middleware, and define routes.

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

app.use(express.json());

app.get('/', (req, res) => {
  res.send('Hello World!');
});

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

NestJS:
In NestJS, the entry point is main.ts. It’s where the app is bootstrapped, and global configurations like middleware or pipes are applied.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
      transform: true,
    }),
  );

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

Comparison:

In Express, you manually set up middleware like body-parser.
In NestJS, you use decorators and global pipes like ValidationPipe to handle validation and transformation automatically.

Routing

Express.js:
In Express, you define routes directly in your app.js or split them into route files.

const express = require('express');
const router = express.Router();

router.get('/users', (req, res) => {
  res.send('Get all users');
});

router.post('/users', (req, res) => {
  res.send('Create a user');
});

module.exports = router;

NestJS:
In NestJS, routes are defined in controllers using decorators like @Controller, @Get, and @Post.

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

@Controller('users') // Base route: /users
export class UsersController {
  @Get()
  getAllUsers() {
    return 'Get all users';
  }

  @Post()
  createUser(@Body() body: any) {
    return `Create a user with data: ${JSON.stringify(body)}`;
  }
}

Comparison:

In Express, routes are functions tied to HTTP methods (app.get, app.post).
In NestJS, routes are methods in a class, and decorators define the HTTP method and path.

Middleware

Express.js:
Middleware in Express is a function that processes requests before they reach the route handler.

const logger = (req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
};

app.use(logger);

NestJS:
Middleware in NestJS is similar but is implemented as a class or function and applied globally or to specific routes.

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

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    console.log(`${req.method} ${req.url}`);
    next();
  }
}

Comparison:

In Express, middleware is just a function.
In NestJS, middleware can be a class, giving it more structure and reusability.

Controllers and Services

Express.js:
In Express, you might handle everything in the route handler itself or split logic into separate files.

app.post('/auth/register', async (req, res) => {
  const { username, password } = req.body;
  // Hash password, save user to DB, etc.
  res.send('User registered');
});

NestJS:
In NestJS, controllers handle the routes, but the actual logic is moved to services for better separation of concerns.

// auth.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  @Post('register')
  async register(@Body() body: any) {
    return this.authService.register(body.username, body.password);
  }
}

// auth.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AuthService {
  async register(username: string, password: string) {
    // Hash password, save user to DB, etc.
    return 'User registered';
  }
}

Comparison:

In Express, you might mix route handling and business logic in the same file.
In NestJS, controllers handle routing, and services handle business logic, making the code more modular and testable.

Database Integration

Express.js:
In Express, you’d use an ORM like Mongoose directly in your route handlers or a separate model file.

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
  username: String,
  password: String,
});

const User = mongoose.model('User', UserSchema);

app.post('/auth/register', async (req, res) => {
  const user = new User(req.body);
  await user.save();
  res.send('User registered');
});

NestJS:
In NestJS, you use @nestjs/mongoose to define schemas and inject models into services.

// user.schema.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class User extends Document {
  @Prop({ required: true })
  username: string;

  @Prop({ required: true })
  password: string;
}

export const UserSchema = SchemaFactory.createForClass(User);

// users.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './schemas/user.schema';

@Injectable()
export class UsersService {
  constructor(@InjectModel(User.name) private userModel: Model<User>) {}

  async create(username: string, password: string) {
    const user = new this.userModel({ username, password });
    return user.save();
  }
}

Comparison:

In Express, you directly use Mongoose models in your route handlers.
In NestJS, models are injected into services, keeping the code cleaner and more testable.

Authentication

Express.js:
In Express, you’d use middleware like passport or manually validate JWT tokens.

const jwt = require('jsonwebtoken');

const authMiddleware = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).send('Unauthorized');

  try {
    const decoded = jwt.verify(token, 'secret');
    req.user = decoded;
    next();
  } catch {
    res.status(401).send('Unauthorized');
  }
};

app.get('/protected', authMiddleware, (req, res) => {
  res.send(`Hello ${req.user.username}`);
});

NestJS:
In NestJS, you use guards and strategies to handle authentication.

// jwt.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: 'secret',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

// jwt-auth.guard.ts
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

// auth.controller.ts
@UseGuards(JwtAuthGuard)
@Get('protected')
getProtected(@Request() req) {
  return `Hello ${req.user.username}`;
}

Comparison:

In Express, you manually validate tokens in middleware.
In NestJS, guards and strategies handle authentication, making it more reusable and declarative.

Validation

Express.js:
In Express, you’d use a library like joi or manually validate inputs.

const Joi = require('joi');

const schema = Joi.object({
  username: Joi.string().required(),
  password: Joi.string().min(8).required(),
});

app.post('/auth/register', (req, res) => {
  const { error } = schema.validate(req.body);
  if (error) return res.status(400).send(error.details[0].message);

  res.send('User registered');
});

NestJS:
In NestJS, validation is built-in using class-validator and class-transformer.

import { IsString, MinLength } from 'class-validator';

export class RegisterDto {
  @IsString()
  username: string;

  @IsString()
  @MinLength(8)
  password: string;
}

// auth.controller.ts
@Post('register')
async register(@Body() registerDto: RegisterDto) {
  return this.authService.register(registerDto.username, registerDto.password);
}

Comparison:

In Express, you manually validate inputs using libraries.
In NestJS, validation is declarative and tied to DTOs (Data Transfer Objects).

Final Thoughts 😊

NestJS is like Express.js on steroids. It takes care of a lot of boilerplate and enforces a clean, modular structure. While Express gives you the freedom to do things your way, NestJS provides a framework that guides you toward best practices.

If Express is a blank canvas, NestJS is a paint-by-numbers kit. Both let you create beautiful art, but NestJS ensures you stay within the lines. And hey, who doesn’t like a little structure in their life? 🎨😉😂😉🎨

You can check out my article on Building a NestJS Authentication API with MongoDB and JWT: A Step-by-Step Guide

Building a Full-Stack CRUD Application with Express.js, MySQL, and Sequelize

FredAbod — Thu, 20 Mar 2025 10:17:52 +0000

Building a Full-Stack CRUD Application with Express.js, MySQL, and Sequelize

Introduction to MySQL and Sequelize ORM: A Complete Guide for Node.js Developers

In today's data-driven world, building robust database applications is essential for developers. MySQL remains one of the most popular relational database systems, and Sequelize provides an elegant Node.js ORM to interact with it. In this comprehensive tutorial, we'll build a complete CRUD (Create, Read, Update, Delete) application using Express.js, MySQL, and Sequelize from scratch.

Prerequisites

Node.js and npm installed on your system
MySQL installed and running
Basic understanding of JavaScript and Express.js
A cup of coffee (coding is always better with caffeine)

Let's dive into building our application!

Setting Up MySQL for Our Project

Before we start coding, you'll need MySQL installed and running on your system.

Step 1: Install MySQL

If you haven't installed MySQL yet, download it from the official website and follow the installation instructions for your operating system.

Step 2: Create a Database

Open your MySQL terminal or MySQL Workbench and run:

CREATE DATABASE crud_db;

That's it! Sequelize will handle creating our tables automatically.

Building Our Application Step by Step

Step 1: Initialize Your Node.js Project

Create a new directory and initialize a Node.js project:

mkdir sequelize-crud
cd sequelize-crud
npm init -y

Step 2: Install Required Dependencies

npm install express mysql2 sequelize dotenv
npm install --save-dev nodemon

Step 3: Create Environment Variables

Create a .env file to store your database credentials:

DB_NAME=crud_db
DB_USER=root
DB_PASSWORD=1234Asdf?
DB_HOST=localhost
DB_DIALECT=mysql
PORT=3500

Step 4: Set Up Sequelize

Create a directory for configuration files:

mkdir config

Now let's create the Sequelize configuration file. This file will handle connecting to the MySQL database and setting up the Sequelize instance.

Create config/database.js:

const { Sequelize } = require('sequelize');
require('dotenv').config();

const sequelize = new Sequelize(
  process.env.DB_NAME,
  process.env.DB_USER,
  process.env.DB_PASSWORD,
  {
    host: process.env.DB_HOST,
    dialect: process.env.DB_DIALECT,
    logging: false,
  }
);

const connectDB = async () => {
  try {
    await sequelize.authenticate();
    console.log('Database connection has been established successfully.');
    await sequelize.sync({ alter: true });
    console.log('All models were synchronized successfully.');
  } catch (error) {
    console.error('Unable to connect to the database:', error);
    process.exit(1);
  }
};

module.exports = { sequelize, connectDB };

Step 5: Define Models

Create a directory for models:

mkdir models

Create models/User.js:

const { DataTypes } = require('sequelize');
const { sequelize } = require('../config/database');

const User = sequelize.define('User', {
  id: {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  },
  name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isEmail: true,
    },
  },
  age: {
    type: DataTypes.INTEGER,
    allowNull: true,
  }
}, {
  tableName: 'users',
  timestamps: true,
});

module.exports = User;

Step 6: Create Controllers

Create a directory for controllers:

mkdir controllers

Create controllers/userController.js:

const User = require('../models/user');

// Create a new user
exports.createUser = async (req, res) => {
  try {
    const { name, email, age } = req.body;

    const user = await User.create({
      name,
      email,
      age
    });

    res.status(201).json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
};

// Get all users
exports.getAllUsers = async (req, res) => {
  try {
    const users = await User.findAll();

    res.status(200).json({
      success: true,
      count: users.length,
      data: users
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
};

// Get a single user by ID
exports.getUserById = async (req, res) => {
  try {
    const user = await User.findByPk(req.params.id);

    if (!user) {
      return res.status(404).json({
        success: false,
        error: 'User not found'
      });
    }

    res.status(200).json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
};

// Update a user
exports.updateUser = async (req, res) => {
  try {
    const user = await User.findByPk(req.params.id);

    if (!user) {
      return res.status(404).json({
        success: false,
        error: 'User not found'
      });
    }

    const { name, email, age } = req.body;

    await user.update({
      name: name || user.name,
      email: email || user.email,
      age: age || user.age
    });

    res.status(200).json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
};

// Delete a user
exports.deleteUser = async (req, res) => {
  try {
    const user = await User.findByPk(req.params.id);

    if (!user) {
      return res.status(404).json({
        success: false,
        error: 'User not found'
      });
    }

    await user.destroy();

    res.status(200).json({
      success: true,
      data: {}
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
};

Step 7: Set Up Routes

Create a directory for routes:

mkdir routes

Create routes/userRoutes.js:

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

// Create a new user
router.post('/', userController.createUser);

// Get all users
router.get('/', userController.getAllUsers);

// Get a single user
router.get('/:id', userController.getUserById);

// Update a user
router.put('/:id', userController.updateUser);

// Delete a user
router.delete('/:id', userController.deleteUser);

module.exports = router;

Step 8: Create the Express Server

Create server.js:

const express = require('express');
const { connectDB } = require('./config/database');
const userRoutes = require('./routes/userRoutes');
require('dotenv').config();

// Initialize Express app
const app = express();

// Connect to database
connectDB();

// Middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/users', userRoutes);

// Home route
app.get('/', (req, res) => {
  res.send('Welcome to User CRUD API with Express, MySQL, and Sequelize');
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Step 9: Run the Application

Start the application using nodemon:

npx nodemon server.js

Your CRUD application is now up and running! You can use tools like Postman to test the API endpoints.

Folder Structure

Here's the final folder structure of our project:

sequelize-crud/
├── config/
│   └── database.js
├── controllers/
│   └── userController.js
├── models/
│   └── User.js
├── routes/
│   └── userRoutes.js
├── .env
├── package.json
├── server.js

Conclusion

In this tutorial, we built a full-stack CRUD application using Express.js, MySQL, and Sequelize. We covered setting up the project, defining models, creating controllers, and setting up routes. With this foundation, you can expand the application further by adding authentication, validation, and more features.
Don't forget to drop a like ❤️😉❤️
Happy coding!

How to Build a High-Performance Redis-Powered Node.js Application: A 2025 Step-by-Step Guide

FredAbod — Tue, 04 Mar 2025 15:59:19 +0000

Building a Redis-Powered Node.js Application: A Step-by-Step Guide

Redis is like that one friend who always seems to remember everything instantly. It's an in-memory data store that can significantly speed up your applications by reducing the need to repeatedly query your database. In this article, we'll build a Node.js Express application with Redis caching from scratch, explaining each step along the way.

Prerequisites

Node.js and npm installed
Basic understanding of Express.js
A sense of humor (optional, but recommended)

Let's Get Right Into It

Installing Redis on Windows

Since Redis wasn't built with Windows in mind (they're not exactly on speaking terms), we need to use Windows Subsystem for Linux (WSL).

Step 1: Install WSL

Open PowerShell with administrator privileges and run:

wsl --install

This command installs WSL with Ubuntu. You might need to restart your computer, so save any cat videos you're watching for later.

Step 2: Set Up Ubuntu

After restart, a terminal will open asking you to create a username and password. Choose something memorable, unlike that "secure" password with 17 special characters you created last week and already forgot.

Step 3: Install Redis on Ubuntu

In your WSL terminal:

sudo apt-get update
sudo apt-get install redis-server

Step 4: Start Redis Server

sudo service redis-server start

To verify Redis is working:

redis-cli ping

If it responds with "PONG," congratulations! Redis is running. If not, well, we've all been there. Try restarting the service or check for error messages.

Building Our Application Step by Step

Step 1: Initialize Your Node.js Project

Create a new directory and initialize a Node.js project:

mkdir redis-test
cd redis-test
npm init -y

Step 2: Install Required Dependencies

npm install express mongoose dotenv redis

Step 3: Create Environment Variables

Create a .env file:

PORT=4000
MONGODB_URI=mongodb://localhost:27017/students-db
REDIS_URL=redis://localhost:6379

Step 4: Set Up Redis Connection

Create a directory for configuration files:

mkdir config

Now let's create the Redis connection file. This file will handle connecting to Redis and provide fallback functionality if Redis is unavailable.

Create config/redis.js:

const redis = require('redis');

// Create a Redis client with connection to Redis server
const createRedisClient = async () => {
  try {
    // Create Redis client
    const client = redis.createClient({
      url: process.env.REDIS_URL || 'redis://localhost:6379'
    });

    // Setup event handlers
    client.on('error', (err) => {
      console.error('Redis Error:', err);
    });

    client.on('connect', () => {
      console.log('Redis connected');
    });

    client.on('reconnecting', () => {
      console.log('Redis reconnecting...');
    });

    client.on('end', () => {
      console.log('Redis connection closed');
    });

    // Connect to Redis
    await client.connect();

    return client;
  } catch (err) {
    console.error('Failed to create Redis client:', err);

    // Return a mock client that stores data in memory as fallback
    console.log('Using in-memory fallback for Redis');

    const mockStorage = {};

    return {
      get: async (key) => mockStorage[key] || null,
      set: async (key, value, options) => {
        mockStorage[key] = value;
        // Handle expiration if EX option provided
        if (options && options.EX) {
          setTimeout(() => {
            delete mockStorage[key];
          }, options.EX * 1000);
        }
        return 'OK';
      },
      del: async (key) => {
        if (mockStorage[key]) {
          delete mockStorage[key];
          return 1;
        }
        return 0;
      },
      keys: async (pattern) => {
        const regex = new RegExp('^' + pattern.replace('*', '.*') + '$');
        return Object.keys(mockStorage).filter(key => regex.test(key));
      },
      // Add other Redis commands as needed for your application
      hSet: async () => 'OK',
      hGetAll: async () => ({}),
      zAdd: async () => 1,
      zRange: async () => [],
      zRem: async () => 1,
      exists: async () => 0
    };
  }
};

module.exports = { createRedisClient };

This setup gives us a robust Redis client that:

Connects to our Redis server
Handles errors and reconnection attempts
Provides a fallback in-memory implementation if Redis is unavailable

Step 5: Create Main Application File

Now, let's create our main application file, building it step by step:

Create app.js:

// Load environment variables
require('dotenv').config();

// Import required packages
const express = require('express');
const mongoose = require('mongoose');
const { createRedisClient } = require('./config/redis');

// Initialize express app
const app = express();
const port = process.env.PORT || 4000;

// Global Redis client
let redisClient;

// Connect to databases and start server
async function startServer() {
  try {
    // Connect to Redis
    redisClient = await createRedisClient();

    // Connect to MongoDB
    await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/students-db');
    console.log('MongoDB connected');

    // Start express server
    app.listen(port, () => {
      console.log(`Student CRUD API running on port ${port}`);
    });
  } catch (err) {
    console.error('Failed to initialize connections:', err);
    process.exit(1);
  }
}

Step 6: Create Student Model

Add this code to your app.js:

// Student Schema
const studentSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    trim: true,
    lowercase: true
  },
  grade: {
    type: String,
    required: true,
    trim: true
  },
  age: {
    type: Number,
    required: true,
    min: 5
  },
  subjects: [{
    type: String,
    trim: true
  }],
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// Student Model
const Student = mongoose.model('Student', studentSchema);

// Middleware
app.use(express.json());

Step 7: Create Caching Middleware

This is where the magic happens. Let's add our caching middleware to app.js:

// Cache middleware
const cacheData = (expireTime = 3600) => {
  return async (req, res, next) => {
    // Skip caching for non-GET requests
    if (req.method !== 'GET') {
      return next();
    }

    // Create a cache key based on the full URL
    const cacheKey = `students:${req.originalUrl}`;

    try {
      // Check if cache exists
      const cachedData = await redisClient.get(cacheKey);

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

      console.log(`Cache miss for ${cacheKey}`);

      // If not in cache, continue but modify res.json
      res.originalJson = res.json;
      res.json = function(data) {
        // Store in cache before sending response
        redisClient.set(cacheKey, JSON.stringify(data), { EX: expireTime })
          .catch(err => console.error('Redis cache error:', err));

        // Continue with the original response
        return res.originalJson(data);
      };

      next();
    } catch (err) {
      console.error('Cache middleware error:', err);
      next();
    }
  };
};

Let's break down what this middleware does:

It only applies to GET requests because we don't typically want to cache modifications
It creates a unique cache key based on the URL
It checks if the data for that URL is already in Redis
- If found, it returns the cached data immediately (cache hit)
- If not found, it modifies the response to save the data to Redis before sending it (cache miss)

Step 8: Create Cache Invalidation Function

Next, we need a way to clear the cache when data changes:

// Clear cache helper
const clearCache = async (pattern) => {
  try {
    const keys = await redisClient.keys(pattern);
    if (keys.length > 0) {
      console.log(`Clearing cache keys matching: ${pattern}`);
      await Promise.all(keys.map(key => redisClient.del(key)));
    }
  } catch (err) {
    console.error('Error clearing cache:', err);
  }
};

This function finds all Redis keys matching a pattern (like students:/api/students*) and deletes them, ensuring that when data changes, cached versions are cleared.

Step 9: Create API Routes with Caching

Now let's implement our API routes with Redis caching:

// Routes with caching
// 1. Get all students
app.get('/api/students', cacheData(60), async (req, res) => {
  try {
    const students = await Student.find({});
    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 2. Get student by ID
app.get('/api/students/:id', cacheData(60), async (req, res) => {
  try {
    const student = await Student.findById(req.params.id);
    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }
    res.json(student);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

Notice how we're applying the cacheData(60) middleware to our GET routes? This means the data will be cached for 60 seconds. After that, a fresh copy will be retrieved from MongoDB.

Step 10: Create Routes That Invalidate Cache

When data changes, we need to invalidate our cache:

// 3. Create student
app.post('/api/students', async (req, res) => {
  try {
    const student = new Student(req.body);
    await student.save();

    // Clear the list cache when a new student is added
    await clearCache('students:/api/students*');

    res.status(201).json(student);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 4. Update student
app.put('/api/students/:id', async (req, res) => {
  try {
    const student = await Student.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );

    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }

    // Clear both specific and list caches
    await Promise.all([
      clearCache(`students:/api/students/${req.params.id}`),
      clearCache('students:/api/students*')
    ]);

    res.json(student);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 5. Delete student
app.delete('/api/students/:id', async (req, res) => {
  try {
    const student = await Student.findByIdAndDelete(req.params.id);

    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }

    // Clear both specific and list caches
    await Promise.all([
      clearCache(`students:/api/students/${req.params.id}`),
      clearCache('students:/api/students*')
    ]);

    res.json({ message: 'Student deleted successfully' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

In each of these routes, we call clearCache() after modifying data to ensure users always see the most up-to-date information.

Step 11: Add More Advanced Routes

Let's add some more routes to show how we can cache filtered data:

// 6. Search students by name or email (with caching)
app.get('/api/students/search/:query', cacheData(30), async (req, res) => {
  try {
    const query = req.params.query;
    const students = await Student.find({
      $or: [
        { name: { $regex: query, $options: 'i' } },
        { email: { $regex: query, $options: 'i' } }
      ]
    });

    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 7. Get students by grade (with caching)
app.get('/api/students/grade/:grade', cacheData(60), async (req, res) => {
  try {
    const students = await Student.find({ grade: req.params.grade });
    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

We're using a shorter cache duration (30 seconds) for search results since they might change more frequently.

Step 12: Add Error Handler and Start the Server

Finally, let's add an error handler and start the server:

// Error handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

// Start the server
startServer();

module.exports = app;

Testing the Application

Now that we've built our application, let's test its caching capabilities:

Start your server:

   node app.js

Create a new student:

   curl -X POST http://localhost:4000/api/students -H "Content-Type: application/json" -d '{"name":"John Doe","email":"john@example.com","grade":"A","age":15,"subjects":["Math","Science"]}'

Get all students (first request - cache miss):

   curl http://localhost:4000/api/students

You should see "Cache miss" in your console.

Get all students again (second request - cache hit):

   curl http://localhost:4000/api/students

You should see "Cache hit" in your console and notice the response comes back much faster!

Update a student, then get all students again to see cache invalidation in action:

   curl -X PUT http://localhost:4000/api/students/[student-id] -H "Content-Type: application/json" -d '{"name":"John Smith"}'
   curl http://localhost:4000/api/students

You should see "Cache miss" again since the cache was cleared.

The Benefits of Redis Caching

Blistering Speed: Redis operations happen in microseconds, while database queries can take milliseconds or more. That might not seem like much, but it adds up when you have thousands of users.
Reduced Database Load: Your database server can focus on important write operations instead of handling the same read requests over and over.
Scalable Architecture: By implementing Redis, you're already preparing your application for growth. As traffic increases, your caching layer will help maintain performance.
Improved User Experience: Faster response times lead to happier users. Nobody likes waiting for a website to load.

Common Redis Caching Pitfalls to Avoid

Caching Everything: Some data changes too frequently or is too personalized to benefit from caching.
Incorrect Cache Invalidation: Failing to clear the cache when data changes leads to stale data being served to users.
Using Too Long Expiration Times: Find the right balance between cache hits and data freshness.
Not Handling Redis Failures: Always have a fallback plan, like our in-memory cache replacement.

Conclusion

We've just built a complete Node.js application with Redis caching! By strategically implementing caching for our read operations and carefully invalidating the cache when data changes, we've created a system that can deliver fast responses while maintaining data accuracy.

Remember that caching isn't a silver bullet - it's a tool that, when used properly, can significantly improve your application's performance. Start with conservative cache durations and adjust based on your specific use case and data volatility.

As the wise computer science saying goes: "There are only two hard things in Computer Science: cache invalidation and naming things." Now you're well equipped to handle at least one of them!

Happy coding!

Complete Code

For reference, here's the complete app.js file we built throughout this tutorial:

require('dotenv').config();
const express = require('express');
const mongoose = require('mongoose');
const { createRedisClient } = require('./config/redis');

// Initialize express app
const app = express();
const port = process.env.PORT || 4000;

// Global Redis client
let redisClient;

// Connect to databases and start server
async function startServer() {
  try {
    // Connect to Redis
    redisClient = await createRedisClient();

    // Connect to MongoDB
    await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/students-db');
    console.log('MongoDB connected');

    // Start express server
    app.listen(port, () => {
      console.log(`Student CRUD API running on port ${port}`);
    });
  } catch (err) {
    console.error('Failed to initialize connections:', err);
    process.exit(1);
  }
}

// Student Schema
const studentSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    trim: true,
    lowercase: true
  },
  grade: {
    type: String,
    required: true,
    trim: true
  },
  age: {
    type: Number,
    required: true,
    min: 5
  },
  subjects: [{
    type: String,
    trim: true
  }],
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// Student Model
const Student = mongoose.model('Student', studentSchema);

// Middleware
app.use(express.json());

// Cache middleware
const cacheData = (expireTime = 3600) => {
  return async (req, res, next) => {
    // Skip caching for non-GET requests
    if (req.method !== 'GET') {
      return next();
    }

    // Create a cache key based on the full URL
    const cacheKey = `students:${req.originalUrl}`;

    try {
      // Check if cache exists
      const cachedData = await redisClient.get(cacheKey);

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

      console.log(`Cache miss for ${cacheKey}`);

      // If not in cache, continue but modify res.json
      res.originalJson = res.json;
      res.json = function(data) {
        // Store in cache before sending response
        redisClient.set(cacheKey, JSON.stringify(data), { EX: expireTime })
          .catch(err => console.error('Redis cache error:', err));

        // Continue with the original response
        return res.originalJson(data);
      };

      next();
    } catch (err) {
      console.error('Cache middleware error:', err);
      next();
    }
  };
};

// Clear cache helper
const clearCache = async (pattern) => {
  try {
    const keys = await redisClient.keys(pattern);
    if (keys.length > 0) {
      console.log(`Clearing cache keys matching: ${pattern}`);
      await Promise.all(keys.map(key => redisClient.del(key)));
    }
  } catch (err) {
    console.error('Error clearing cache:', err);
  }
};

// Routes with caching
// 1. Get all students
app.get('/api/students', cacheData(60), async (req, res) => {
  try {
    const students = await Student.find({});
    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 2. Get student by ID
app.get('/api/students/:id', cacheData(60), async (req, res) => {
  try {
    const student = await Student.findById(req.params.id);
    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }
    res.json(student);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 3. Create student
app.post('/api/students', async (req, res) => {
  try {
    const student = new Student(req.body);
    await student.save();

    // Clear the list cache when a new student is added
    await clearCache('students:/api/students*');

    res.status(201).json(student);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 4. Update student
app.put('/api/students/:id', async (req, res) => {
  try {
    const student = await Student.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );

    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }

    // Clear both specific and list caches
    await Promise.all([
      clearCache(`students:/api/students/${req.params.id}`),
      clearCache('students:/api/students*')
    ]);

    res.json(student);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 5. Delete student
app.delete('/api/students/:id', async (req, res) => {
  try {
    const student = await Student.findByIdAndDelete(req.params.id);

    if (!student) {
      return res.status(404).json({ message: 'Student not found' });
    }

    // Clear both specific and list caches
    await Promise.all([
      clearCache(`students:/api/students/${req.params.id}`),
      clearCache('students:/api/students*')
    ]);

    res.json({ message: 'Student deleted successfully' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 6. Search students by name or email (with caching)
app.get('/api/students/search/:query', cacheData(30), async (req, res) => {
  try {
    const query = req.params.query;
    const students = await Student.find({
      $or: [
        { name: { $regex: query, $options: 'i' } },
        { email: { $regex: query, $options: 'i' } }
      ]
    });

    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 7. Get students by grade (with caching)
app.get('/api/students/grade/:grade', cacheData(60), async (req, res) => {
  try {
    const students = await Student.find({ grade: req.params.grade });
    res.json(students);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Error handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

// Start the server
startServer();

module.exports = app;

And the complete redis.js file:

const redis = require('redis');

// Create a Redis client with connection to Redis server
const createRedisClient = async () => {
  try {
    // Create Redis client
    const client = redis.createClient({
      url: process.env.REDIS_URL || 'redis://localhost:6379'
    });

    // Setup event handlers
    client.on('error', (err) => {
      console.error('Redis Error:', err);
    });

    client.on('connect', () => {
      console.log('Redis connected');
    });

    client.on('reconnecting', () => {
      console.log('Redis reconnecting...');
    });

    client.on('end', () => {
      console.log('Redis connection closed');
    });

    // Connect to Redis
    await client.connect();

    return client;
  } catch (err) {
    console.error('Failed to create Redis client:', err);

    // Return a mock client that stores data in memory as fallback
    console.log('Using in-memory fallback for Redis');

    const mockStorage = {};

    return {
      get: async (key) => mockStorage[key] || null,
      set: async (key, value, options) => {
        mockStorage[key] = value;
        // Handle expiration if EX option provided
        if (options && options.EX) {
          setTimeout(() => {
            delete mockStorage[key];
          }, options.EX * 1000);
        }
        return 'OK';
      },
      del: async (key) => {
        if (mockStorage[key]) {
          delete mockStorage[key];
          return 1;
        }
        return 0;
      },
      keys: async (pattern) => {
        const regex = new RegExp('^' + pattern.replace('*', '.*') + '$');
        return Object.keys(mockStorage).filter(key => regex.test(key));
      },
      // Add other Redis commands as needed for your application
      hSet: async () => 'OK',
      hGetAll: async () => ({}),
      zAdd: async () => 1,
      zRange: async () => [],
      zRem: async () => 1,
      exists: async () => 0
    };
  }
};

module.exports = { createRedisClient };

Node.js Debugging Made Easy! Unlock key tools: Node Inspector, VS Code debugger, and efficient logging. Level up your code fast—explore my guide now! 🚀 #Nodejs #Debugging #CodingTools #TechTips

FredAbod — Tue, 25 Feb 2025 15:38:52 +0000

Essential Debugging Tools for Node.js

FredAbod ・ Feb 25

#webdev #node #javascript #beginners

DEV Community: FredAbod

Stop Dumping Everything in app.js — Express MVC for Beginners

Stop Dumping Everything in app.js — Express, Mongoose, and a Clean MVC Folder

Prerequisites

Let's Dive Right In

Step 1: The problem — one fat app.js

Step 2: Think of it like a school office

Step 3: Make the folders

Step 4: The cupboard key — config/db.js

Step 5: The form — models/students.models.js

Step 6: The clerk — controllers/students.controller.js

Step 7: The doors — routes/students.routes.js

Step 8: The front gate — a slim app.js

Step 9: Don't forget the prefix 👏

Step 10: Stretch your fingers 😁😁

Step 11: One request, slowly — creating Ada

Step 12: Why we split it (so you don't undo it tomorrow)

Before vs after

Recap (say it with me)

CSharp-Basics

💻 CSharp-Basics

🖥️ System Requirements

🚀 Getting Started

📚 TABLE OF CONTENTS

📖 Introduction

What is C#?

Why Learn C#?

C# vs JavaScript Comparison

Your First C# Program

🔤 Variables

What is a Variable?

Declaring Variables in C

Variable Naming Rules

Naming Conventions

var, const, and readonly

var - Type Inference

const - Compile-Time Constants

readonly - Runtime Constants

Variable Scope

📝 Exercises

📊 Data Types

Understanding Data Types

Value Types (Stored on Stack)

Numeric Types

Boolean Type

Character Type

Reference Types (Stored on Heap)

String Type

Object Type

Value vs Reference Types - The Key Difference

Nullable Types

📝 Exercises

➕ Operators

What are Operators?

Arithmetic Operators

Comparison Operators

Logical Operators

Assignment Operators

Ternary Operator

Null-Related Operators

🔄 Type Casting

What is Type Casting?

Implicit Casting (Automatic)

Explicit Casting (Manual)

Type Conversion Methods

🔧 Functions (Methods)

What is a Method?

Method Declaration & Calling

Parameters: Default, Named, and Params

Out, Ref, and In Parameters

Expression-Bodied Methods

📦 Arrays and Collections

Arrays

Lists (Dynamic Arrays)

Dictionaries (Key-Value Pairs)

❓ Conditional Statements

If-Else Statements

Switch Statement

Switch Expression (C# 8+)

Ternary Operator

Stop Dumping Everything in `app.js` — Express, Mongoose, and a Clean MVC Folder

Step 1: The problem — one fat `app.js`

Step 4: The cupboard key — `config/db.js`

Step 5: The form — `models/students.models.js`

Step 6: The clerk — `controllers/students.controller.js`

Step 7: The doors — `routes/students.routes.js`

Step 8: The front gate — a slim `app.js`

`var` - Type Inference

`const` - Compile-Time Constants

`readonly` - Runtime Constants