DEV Community: FredAbod

Stop Multiplying by 100 - Handle Money Amounts Safely in TypeScript for Beginners

FredAbod — Sat, 07 Nov 2026 12:23:47 +0000

So you added payments to your app.

The checkout button works. Paystack opens. Your test card goes through.

You wrote amount * 100 somewhere and moved on with your life, feeling like a fintech engineer. 😎

Then one day:

A customer pays ₦1,150.15 and your code sends 115015.00000000001 to the provider. 👀
A refund is one kobo short and finance wants a "quick call".
Your company expands to Japan and a ¥500 order is charged as ¥50,000. 😭😭

Nobody hacked you. Nobody broke the provider. It was you. It was always you 😭

In this article we will fix money handling properly, step by step, in Express and TypeScript. No * 100 anywhere. Not even one. 😁

The coin-counting cashier 🪙

Picture a cashier at a busy market stall. You hand her a ₦1,000 note. She does not write "1,000 naira" in her book. She writes it in kobo, the smallest coin: 100000. Why? Because coins are whole numbers. You can't have half a coin. Whole numbers never get "almost right".

That's exactly how payment providers work. Every provider is a cashier who only counts coins.

But here is the twist: every cashier has her own counting rule.

Paystack's cashier wants every amount in the subunit of the currency. NGN 100 is sent as 10000.
Stripe's cashier wants the currency's minor unit. USD 10.99 is 1099. But Japanese yen has no smaller coin (Stripe calls it a "zero-decimal currency"), so ¥500 is just 500. Multiply it by 100 and you have charged someone ¥50,000.
Some currencies have three decimal places. The Kuwaiti dinar (KWD) has three decimal places, so KWD 1.250 is 1250.
And my favourite: Paystack's docs say the West African CFA franc (XOF) has no subunit, but you must still multiply by 100. Same currency, different cashier, different rule. 🙃

So amount * 100 is not a rule. It's a coincidence that happens to work for naira and dollars.

Here's the plan for today:

Customer types "1150.15"
        │
        ▼
 ┌──────────────────┐
 │  toMinor()       │  string → whole number of coins (no floats!)
 └──────────────────┘
        │
        ├──► Our notebook (DB):   { amountMinor: 115015, currency: "NGN" }
        │
        └──► Provider adapter:    paystackAmount() / stripeAmount()
                                  (each cashier's own rule)

Prerequisites

Node.js 22 (I ran everything on Node 22)
Basic Express knowledge (routes, req.body, res.json)
Basic TypeScript (types, functions)
curl or Postman

No Paystack or Stripe account needed. We will build the exact amount each provider expects and stop right before the network call, so you can run everything locally without API keys. In a real app you'd pass that number to the provider's API.

Let's Dive Right In 😁😁

Step 0: Watch it break first — `src/float-bug.ts`

Before we fix anything, let's see the bug with our own eyes. This file does one thing: embarrass JavaScript.

// Run this once and watch your confidence leave your body.
console.log(19.99 * 100);             // 1998.9999999999998
console.log(1150.15 * 100);           // 115015.00000000001
console.log(Math.floor(4.35 * 100));  // 434, one kobo gone
console.log(500 * 100);               // 50000, fine for NGN, wrong for JPY on Stripe

Run it later (after setup) with npm run bug and you'll see:

1998.9999999999998
115015.00000000001
434
50000

Why? JavaScript numbers are floating point. 19.99 can't be stored exactly in binary, so it's stored as something very close to 19.99. Multiply it and the tiny error shows up.

Math.round() would "fix" 19.99, but now you are rounding money silently and hoping. Hope is not a payment strategy.
Math.floor(4.35 * 100) gives 434. One kobo just vanished. Do that across thousands of transactions and someone will notice. Probably finance. Probably on a Friday. 😅

The real fix: never let money be a float in the first place. Treat the amount as a string, split it at the dot, and glue the digits together.

Step 1: Set up the project

mkdir money-minor-units && cd money-minor-units
npm init -y
npm i express@5
npm i -D typescript @types/express @types/node
mkdir -p src/money src/providers src/routes

I used Express 5.3.0 and TypeScript 7.0.2.

Now the package.json. The important bits are "type": "module" and the scripts:

{
  "name": "money-minor-units",
  "version": "1.0.0",
  "description": "",
  "main": "dist/server.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/server.js",
    "bug": "node dist/float-bug.js",
    "test": "node --test \"dist/**/*.test.js\""
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^5.3.0"
  },
  "devDependencies": {
    "@types/express": "^5.0.6",
    "@types/node": "^26.6.6",
    "typescript": "^7.0.2"
  },
  "type": "module"
}

And tsconfig.json, with strict on, because we are adults now:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "nodenext",
    "moduleResolution": "nodenext",
    "rootDir": "src",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}

Step 2: The cashier's cheat sheet — `src/money/currencies.ts`

This file does one thing: it remembers how many decimal places each currency has.

// How many digits come after the decimal point for each currency.
// NGN 2 (kobo), JPY 0 (no subunit), KWD 3.
export const CURRENCY_DECIMALS = {
  NGN: 2,
  GHS: 2,
  KES: 2,
  ZAR: 2,
  USD: 2,
  EUR: 2,
  GBP: 2,
  JPY: 0,
  KWD: 3,
  XOF: 0,
} as const;

export type Currency = keyof typeof CURRENCY_DECIMALS;

export function isCurrency(code: string): code is Currency {
  return Object.hasOwn(CURRENCY_DECIMALS, code);
}

as const makes TypeScript treat the keys as exact values, so Currency becomes "NGN" | "GHS" | ... | "XOF". Typos like "NGM" get caught.
isCurrency() is a type guard. After it returns true, TypeScript knows the string is a real Currency.
Only add a currency after you've checked it. Don't guess. Guessing is how ¥500 becomes ¥50,000.

Step 3: Counting coins without floats — `src/money/toMinor.ts`

This is the heart of the article. Read it slowly. 👀

export class MoneyError extends Error {}

// "19.99" + 2 decimals -> 1999
// "500"   + 0 decimals -> 500
// "1.25"  + 3 decimals -> 1250
export function toMinor(amount: string, decimals: number): number {
  const match = /^(\d+)(?:\.(\d+))?$/.exec(amount.trim());
  if (!match) {
    throw new MoneyError(`"${amount}" is not a valid amount`);
  }

  const whole = match[1]!;
  const fraction = match[2] ?? "";

  if (fraction.length > decimals) {
    throw new MoneyError(
      `"${amount}" has ${fraction.length} decimal places, this currency allows ${decimals}`
    );
  }

  const minor = Number(whole + fraction.padEnd(decimals, "0"));

  if (!Number.isSafeInteger(minor)) {
    throw new MoneyError(`"${amount}" is too large`);
  }
  return minor;
}

// 1999 + 2 decimals -> "19.99"
export function fromMinor(minor: number, decimals: number): string {
  if (decimals === 0) return String(minor);
  const digits = String(minor).padStart(decimals + 1, "0");
  return `${digits.slice(0, -decimals)}.${digits.slice(-decimals)}`;
}

Let's walk through toMinor("1150.15", 2):

The regex splits it: whole = "1150", fraction = "15".
"15".padEnd(2, "0") is still "15".
Glue them: "1150" + "15" = "115015".
Number("115015") = 115015. A clean whole number. No multiplication ever happened. 🎉

And for toMinor("1.25", 3) (KWD): "25".padEnd(3, "0") becomes "250", so we get "1" + "250" = 1250.

Three important lines, don't skip them:

fraction.length > decimals throws. "10.999" dollars is not a real amount, so we reject it instead of quietly rounding. Silent rounding is how kobo disappear.
The regex only allows digits and one dot. So "-5", "1e3" and "" are all rejected. (Refunds should be their own operation, not a negative charge.)
Number.isSafeInteger() makes sure the number is small enough for JavaScript to store exactly.

fromMinor() goes the other way for display: 1999 with 2 decimals becomes "19.99", and 5 becomes "0.05" thanks to padStart.

Step 4: Paystack's cashier — `src/providers/paystack.ts`

Each provider gets its own small file. This one knows Paystack's rule and nothing else.

import { MoneyError, toMinor } from "../money/toMinor.js";

const PAYSTACK_CURRENCIES = ["NGN", "GHS", "KES", "ZAR", "USD", "XOF"] as const;
type PaystackCurrency = (typeof PAYSTACK_CURRENCIES)[number];

function isPaystackCurrency(code: string): code is PaystackCurrency {
  return (PAYSTACK_CURRENCIES as readonly string[]).includes(code);
}

// Paystack wants every amount in the subunit, i.e. x100.
// XOF has no subunit, but Paystack still wants x100,
// so we only allow whole XOF amounts.
export function paystackAmount(amount: string, currency: string): number {
  if (!isPaystackCurrency(currency)) {
    throw new MoneyError(`Paystack does not support ${currency} in this app`);
  }
  if (currency === "XOF" && amount.includes(".")) {
    throw new MoneyError("XOF amounts must be whole numbers");
  }
  return toMinor(amount, 2);
}

Paystack's API docs say amounts must be sent "in the subunit of that currency", so NGN 100 goes out as 10000.
For XOF, Paystack's docs say there is no subunit but you must still multiply by 100, and that this doesn't mean the amount can have a fractional part. So we accept only whole XOF and send toMinor(amount, 2): XOF 5000 becomes 500000.
Notice there is still no * 100. We reuse toMinor, which glues strings.

Step 5: Stripe's cashier — `src/providers/stripe.ts`

Same idea, different rule.

import { CURRENCY_DECIMALS } from "../money/currencies.js";
import { MoneyError, toMinor } from "../money/toMinor.js";

// Only the currencies this app has checked against Stripe's docs.
const STRIPE_CURRENCIES = ["USD", "EUR", "GBP", "JPY"] as const;
type StripeCurrency = (typeof STRIPE_CURRENCIES)[number];

function isStripeCurrency(code: string): code is StripeCurrency {
  return (STRIPE_CURRENCIES as readonly string[]).includes(code);
}

// Stripe wants the currency's minor unit:
// USD 10.99 -> 1099, JPY 500 -> 500 (zero-decimal).
export function stripeAmount(amount: string, currency: string): number {
  if (!isStripeCurrency(currency)) {
    throw new MoneyError(`Stripe does not support ${currency} in this app`);
  }
  return toMinor(amount, CURRENCY_DECIMALS[currency]);
}

Stripe's docs say all API requests expect amount in the currency's minor unit, and give the example: 1099 to charge 10.99 USD, 10 to charge 10 JPY.
So for Stripe we use the real decimals from our cheat sheet: USD has 2, JPY has 0.
I only listed four currencies on purpose. Stripe has special cases for some currencies (for example ISK and UGX, which its docs say must be sent with two extra zeros for backward compatibility). If you add a currency, read Stripe's currencies page for it first. Slap your own hand if you skip that. Gently. 😅

Step 6: The checkout counter — `src/routes/checkout.ts`

This is where everything meets. The route does two separate things: decide what we store, and decide what the provider gets.

import { Router } from "express";
import { CURRENCY_DECIMALS, isCurrency } from "../money/currencies.js";
import { MoneyError, fromMinor, toMinor } from "../money/toMinor.js";
import { paystackAmount } from "../providers/paystack.js";
import { stripeAmount } from "../providers/stripe.js";

export const checkoutRouter = Router();

checkoutRouter.post("/checkout", (req, res) => {
  const { amount, currency, provider } = req.body ?? {};

  if (typeof amount !== "string") {
    res.status(400).json({ error: 'amount must be a string like "19.99"' });
    return;
  }
  if (typeof currency !== "string" || !isCurrency(currency)) {
    res.status(400).json({ error: "unknown currency" });
    return;
  }

  try {
    // 1. What WE store: integer minor units + currency code.
    const decimals = CURRENCY_DECIMALS[currency];
    const amountMinor = toMinor(amount, decimals);

    // 2. What the PROVIDER wants: their own rules.
    let providerAmount: number;
    if (provider === "paystack") {
      providerAmount = paystackAmount(amount, currency);
    } else if (provider === "stripe") {
      providerAmount = stripeAmount(amount, currency);
    } else {
      res.status(400).json({ error: "provider must be paystack or stripe" });
      return;
    }

    // In real life you would call the provider here with providerAmount.
    // This tutorial stops before the network call (no real API keys).
    res.json({
      stored: { amountMinor, currency },
      provider,
      providerAmount,
      display: `${currency} ${fromMinor(amountMinor, decimals)}`,
    });
  } catch (err) {
    if (err instanceof MoneyError) {
      res.status(400).json({ error: err.message });
      return;
    }
    throw err;
  }
});

typeof amount !== "string" rejects 19.99 sent as a JSON number. Once it's a number, it's already a float, and the damage is done before your code even runs. Ask your frontend to send "19.99".
stored is what goes into your database: an integer plus the currency code. Always both. 1999 alone means nothing. Is it naira? Yen? Dinar? 🤷🏽‍♂️
providerAmount is computed by the provider adapter. For NGN on Paystack they happen to match. For XOF on Paystack they don't (5000 stored, 500000 sent). That's exactly why we keep them apart.

Step 7: Wire it up — `src/app.ts` and `src/server.ts`

This file does one thing: create the app.

import express from "express";
import { checkoutRouter } from "./routes/checkout.js";

export const app = express();

app.use(express.json());
app.use(checkoutRouter);

And this one does one thing: start it.

import { app } from "./app.js";

const PORT = Number(process.env.PORT ?? 3000);

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

That's it. Build and start:

npm run build
npm start

Server running on http://localhost:3000

Step 8: Let's poke it with curl 🧪

A normal naira payment, the one that used to give us 115015.00000000001:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":"1150.15","currency":"NGN","provider":"paystack"}'

{
  "stored": {
    "amountMinor": 115015,
    "currency": "NGN"
  },
  "provider": "paystack",
  "providerAmount": 115015,
  "display": "NGN 1150.15"
}

Clean 115015. No float drama. 🥰

The Japanese customer, on Stripe:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":"500","currency":"JPY","provider":"stripe"}'

{
  "stored": {
    "amountMinor": 500,
    "currency": "JPY"
  },
  "provider": "stripe",
  "providerAmount": 500,
  "display": "JPY 500"
}

¥500 is 500. Not 50,000. The customer keeps their money and you keep your job. 😋

XOF on Paystack, where the stored amount and provider amount are different:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":"5000","currency":"XOF","provider":"paystack"}'

{
  "stored": {
    "amountMinor": 5000,
    "currency": "XOF"
  },
  "provider": "paystack",
  "providerAmount": 500000,
  "display": "XOF 5000"
}

Now the bad inputs. Too many decimals:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":"10.999","currency":"USD","provider":"stripe"}'

{
  "error": "\"10.999\" has 3 decimal places, this currency allows 2"
}

Amount sent as a number instead of a string:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":19.99,"currency":"NGN","provider":"paystack"}'

{
  "error": "amount must be a string like \"19.99\""
}

A currency we never checked for that provider:

curl -X POST http://localhost:3000/checkout \
  -H "Content-Type: application/json" \
  -d '{"amount":"1.25","currency":"KWD","provider":"stripe"}'

{
  "error": "Stripe does not support KWD in this app"
}

Every wrong input gets a clear 400 instead of a wrong charge. That's the whole point.

Step 9: Tests, because money deserves tests — `src/money/toMinor.test.ts`

We use Node's built-in test runner, so there's nothing extra to install.

import { test } from "node:test";
import assert from "node:assert/strict";
import { toMinor, fromMinor, MoneyError } from "./toMinor.js";
import { paystackAmount } from "../providers/paystack.js";
import { stripeAmount } from "../providers/stripe.js";

test("NGN 19.99 becomes 1999 kobo, not 1998.9999999999998", () => {
  assert.equal(toMinor("19.99", 2), 1999);
});

test("NGN 4.35 becomes 435, no kobo goes missing", () => {
  assert.equal(toMinor("4.35", 2), 435);
});

test("JPY 500 stays 500", () => {
  assert.equal(toMinor("500", 0), 500);
});

test("KWD 1.25 becomes 1250", () => {
  assert.equal(toMinor("1.25", 3), 1250);
});

test("too many decimals is rejected, not silently rounded", () => {
  assert.throws(() => toMinor("10.999", 2), MoneyError);
  assert.throws(() => toMinor("500.5", 0), MoneyError);
});

test("garbage is rejected", () => {
  assert.throws(() => toMinor("-5", 2), MoneyError);
  assert.throws(() => toMinor("1e3", 2), MoneyError);
  assert.throws(() => toMinor("", 2), MoneyError);
});

test("fromMinor goes back the other way", () => {
  assert.equal(fromMinor(1999, 2), "19.99");
  assert.equal(fromMinor(5, 2), "0.05");
  assert.equal(fromMinor(1250, 3), "1.250");
  assert.equal(fromMinor(500, 0), "500");
});

test("provider rules", () => {
  assert.equal(paystackAmount("100", "NGN"), 10000);
  assert.equal(paystackAmount("5000", "XOF"), 500000);
  assert.throws(() => paystackAmount("50.5", "XOF"), MoneyError);
  assert.equal(stripeAmount("10.99", "USD"), 1099);
  assert.equal(stripeAmount("500", "JPY"), 500);
});

npm run build
npm test

Trimmed output:

ok 1 - NGN 19.99 becomes 1999 kobo, not 1998.9999999999998
ok 2 - NGN 4.35 becomes 435, no kobo goes missing
ok 3 - JPY 500 stays 500
ok 4 - KWD 1.25 becomes 1250
ok 5 - too many decimals is rejected, not silently rounded
ok 6 - garbage is rejected
ok 7 - fromMinor goes back the other way
ok 8 - provider rules
# tests 8
# pass 8
# fail 0

All green, and these tests actually check exact values. If an AI agent (or a tired you at 1am) ever "fixes" a failing money test by changing assert.equal to something looser, reject that change. 😤

Before vs after

Before:

const amount = req.body.amount * 100; // 🙈

Floats sneak in: 1150.15 * 100 is 115015.00000000001.
Math.floor silently loses kobo.
Wrong for zero-decimal currencies like JPY on Stripe.
Wrong for three-decimal currencies like KWD.
One line, spread across 14 files, that nobody wants to touch.

After:

The amount arrives as a string and never becomes a float.
toMinor() turns it into a whole number by gluing digits, not multiplying.
The database stores { amountMinor, currency }, always together.
Each provider has its own small adapter with its own rule.
Bad input fails loudly with a 400, before any money moves.

Why we do it this way

At Prooval I built payment flows on Stripe, Paystack and Fincra. Once you have more than one provider, you stop thinking "multiply by 100" and start thinking "what does this provider expect for this currency?". Keeping one shared toMinor() plus one tiny adapter per provider means adding a new provider is one new file, not a search-and-replace across the codebase.

A few extra tips for when you go further:

Store integers in the database, with a separate currency column. Never a float column for money.
Check the provider's minimum amounts. Paystack's docs list a minimum per currency (₦50.00 for NGN at the time of writing), so validate that before you call the API.
Do maths on integers only. Adding two minor amounts is safe. Splitting 1000 kobo three ways is not as simple as it looks, but that's a story for another article. 😁

Recap (say it with me)

Payment providers count in coins (minor units), not notes. 🪙
Each provider has its own rule. * 100 is a coincidence, not a rule.
Money arrives as a string, never a float.
toMinor() glues digits; it doesn't multiply.
Store { amountMinor, currency } together, always.
One small adapter per provider.
Reject bad amounts loudly. Never round silently.

GitHub repo: https://github.com/FredAbod/stop-multiplying-by-100-money-amounts-typescript-code

Sources I checked while writing this:

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

Thank you for taking the time to read 🥰🥰

See you on the next one 🤗

[Boost]

FredAbod — Sat, 31 Oct 2026 08:25:56 +0000

FredAbod

Oct 31

Stop Trusting Every Webhook - Verify Paystack Signatures in Express for Beginners

#node #typescript #webdev #beginners

14 min read

Stop Trusting Every Webhook - Verify Paystack Signatures in Express for Beginners

FredAbod — Sat, 31 Oct 2026 08:25:33 +0000

So you added Paystack to your app.

The checkout pops up. The test card goes through. Your webhook route logs charge.success.

You mark the order as paid, you push to production, and you go to bed feeling like a payments engineer. 😎

Now, quick question.

What stops anybody on the internet from sending this to your server?

curl -X POST https://your-api.com/webhooks/paystack \
  -H "Content-Type: application/json" \
  -d '{"event":"charge.success","data":{"reference":"order_001","amount":500000}}'

If your answer is "nothing"... then congratulations, you just built a free ₦5,000 voucher machine. 😭😭

Your webhook URL is just a URL. Anyone who finds it can POST to it. So in this article we are going to fix that, step by step:

Check that the webhook really came from Paystack (the signature)
Do it on the raw body, because that's where most people get stuck
Ignore the same event if it shows up twice
Ask Paystack directly before we give anybody value

The Estate Gate Analogy 🏘️

Picture an estate in Lagos with a gate and a security man. Let's call him Baba Gate.

A delivery man walks up and says: "Paystack sent me. The customer in Flat 3 has paid. Release their goods."

A lazy Baba Gate just opens the gate. Anyone can say "Paystack sent me".

A good Baba Gate does four things:

Checks the stamp on the letter. Paystack signs every letter with a stamp only Paystack and you can make (your secret key).
Checks the stamp against the original letter. Not a photocopy. Not a version someone retyped neatly. The original.
Checks his logbook. "Did I already let this same delivery in this morning?"
Calls the office to confirm. "Did Flat 3 really pay ₦5,000?"

Hold on to Baba Gate. He is the whole article. 😁

Prerequisites

Node.js 18 or newer (we use the built-in fetch)
Basic Express knowledge (routes, middleware)
A little TypeScript (if you've read my Express + TypeScript post, you're good)
A Paystack account is optional. I'll explain below.

Honest note: in this tutorial we fake the Paystack side so you can run everything on your laptop. We sign our own test webhooks with a practice secret, and the "call the office" step uses a small fake ledger instead of the real Verify Transaction API. When you are ready, one environment variable switches it to the real API.

Let's Dive Right In 😁😁

mkdir paystack-webhook-guard && cd paystack-webhook-guard
npm init -y
npm i express@5
npm i -D typescript @types/express @types/node

Here is where we're going:

paystack-webhook-guard/
├── src/
│   ├── config.ts
│   ├── app.ts
│   ├── server.ts
│   ├── routes/
│   │   └── webhook.ts
│   ├── services/
│   │   ├── paystack.ts
│   │   └── paymentHandler.ts
│   ├── store/
│   │   └── orderStore.ts
│   └── utils/
│       └── verifySignature.ts
├── scripts/
│   ├── send-webhook.ts
│   └── why-raw.ts
├── package.json
└── tsconfig.json

And the flow, Baba Gate style:

Paystack ──POST──▶ /webhooks/paystack
                     │
                     ▼
           express.raw()  → keep the ORIGINAL letter (Buffer)
                     │
                     ▼
           check x-paystack-signature  ──✗──▶ 401, gate stays shut
                     │ ✓
                     ▼
           JSON.parse + reply 200 quickly
                     │
                     ▼
           logbook: seen this event?  ──yes──▶ skip
                     │ no
                     ▼
           call Paystack: verify reference, amount, currency
                     │ ✓
                     ▼
           mark order as paid 🎉

Step 0: The boring setup — `tsconfig.json` and `package.json`

Nobody claps for config files, but they are holding the house up.

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "rootDir": ".",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src", "scripts"]
}

Add these scripts to your package.json:

"scripts": {
  "build": "tsc --strict",
  "start": "node dist/src/server.js",
  "webhook": "node dist/scripts/send-webhook.js"
}

That's it. strict is on, because we are adults now. 😅

Step 1: Baba Gate's secret — `src/config.ts`

This file does one thing. It reads your secret key and refuses to start without it.

export const config = {
  port: Number(process.env.PORT ?? 4000),
  paystackSecret: process.env.PAYSTACK_SECRET_KEY ?? "",
  // true = pretend to be Paystack's Verify Transaction API (for local practice)
  mockPaystack: process.env.PAYSTACK_MOCK !== "false",
};

if (!config.paystackSecret) {
  throw new Error("PAYSTACK_SECRET_KEY is missing. Put it in your environment.");
}

Your Paystack secret key is what Paystack uses to stamp the letters. Never put it in your frontend. Never commit it.
PAYSTACK_MOCK is on by default so you can practise without hitting the real API.

Step 2: Checking the stamp — `src/utils/verifySignature.ts`

Paystack's webhook docs say every webhook comes with an x-paystack-signature header, and that header is an HMAC SHA512 signature of the payload, signed with your secret key.

In plain English: Paystack takes the exact body it's sending you, mixes it with your secret key, and produces a long hex string. We do the same mixing on our side. If our string matches theirs, the letter is real.

import crypto from "node:crypto";

export function isValidPaystackSignature(
  rawBody: Buffer,
  signature: string | undefined,
  secret: string
): boolean {
  if (!signature) return false;

  const expected = crypto
    .createHmac("sha512", secret)
    .update(rawBody)
    .digest("hex");

  const expectedBuf = Buffer.from(expected, "utf8");
  const receivedBuf = Buffer.from(signature, "utf8");

  // timingSafeEqual throws if the lengths differ, so check first
  if (expectedBuf.length !== receivedBuf.length) return false;

  return crypto.timingSafeEqual(expectedBuf, receivedBuf);
}

Three important lines, don't skip them:

.update(rawBody) — we hash the raw bytes, not a JavaScript object. (Step 4 explains why this matters so much.)
crypto.timingSafeEqual — a normal === can stop early on the first different character, and that timing difference is information an attacker can measure. timingSafeEqual compares in constant time.
The length check — timingSafeEqual throws a RangeError if the two buffers have different lengths. I tested it: Input buffers must have the same byte length. So if someone sends x-paystack-signature: lol, we return false instead of crashing.

Step 3: The estate records — `src/store/orderStore.ts`

We need somewhere to keep orders and a logbook of events we've already handled. For this tutorial, it's a Map and a Set in memory.

export type OrderStatus = "pending" | "paid";

export interface Order {
  reference: string;
  amount: number; // in kobo (100 kobo = ₦1)
  currency: "NGN";
  status: OrderStatus;
}

// In-memory for this tutorial. In real life: your database.
const orders = new Map<string, Order>([
  ["order_001", { reference: "order_001", amount: 500000, currency: "NGN", status: "pending" }],
  ["order_002", { reference: "order_002", amount: 250000, currency: "NGN", status: "pending" }],
]);

// Our logbook of events we have already handled
const processedEvents = new Set<string>();

export const orderStore = {
  find(reference: string): Order | undefined {
    return orders.get(reference);
  },
  markPaid(reference: string): void {
    const order = orders.get(reference);
    if (order) order.status = "paid";
  },
  // Returns false if we've seen this key before
  claimEvent(key: string): boolean {
    if (processedEvents.has(key)) return false;
    processedEvents.add(key);
    return true;
  },
  releaseEvent(key: string): void {
    processedEvents.delete(key);
  },
};

Amounts are in kobo. Paystack works with the subunit of the currency, so ₦5,000 is 500000. Mix this up and someone pays ₦50 for a ₦5,000 order. 🙃
claimEvent is Baba Gate's logbook. First time we see a key, we write it down and return true. Second time, false.

In production this is your database. More on that at the end.

Step 4: The original letter, not a photocopy — `src/routes/webhook.ts`

This is the heart of the whole thing. 👀

Most Express apps have this line at the top of app.js:

app.use(express.json());

It reads the request body, parses it, and gives you a nice object in req.body. Lovely for normal routes. Terrible for webhooks.

Why? Because once Express has parsed the body, the original bytes are gone. To check the signature you'd have to do JSON.stringify(req.body) and hope it comes out byte for byte the same as what Paystack sent.

To be fair, Paystack's own docs example does exactly that, and it works when the re-built string happens to match the original exactly. But "happens to match" is not a payments strategy. 😅 Stripe's docs say it plainly: they need the raw body for signature verification, and any change to it makes verification fail.

Don't believe me? Here's a tiny script that signs the same data in three slightly different "shapes":

// Same data, different bytes = different signature
import crypto from "node:crypto";

const secret = "sk_test_practice_only";
const sign = (s: string) => crypto.createHmac("sha512", secret).update(s).digest("hex").slice(0, 16);

const raw = '{"event":"charge.success","data":{"reference":"order_001","amount":500000}}';
const rawWithSpaces = '{ "event": "charge.success", "data": { "reference": "order_001", "amount": 500000 } }';
const rawEscaped = '{"event":"charge.success","data":{"reference":"order\\/001","amount":500000}}';

for (const original of [raw, rawWithSpaces, rawEscaped]) {
  const rebuilt = JSON.stringify(JSON.parse(original));
  console.log(sign(original) === sign(rebuilt) ? "✅ match" : "❌ MISMATCH", "|", original);
}

npx tsc --strict && node dist/scripts/why-raw.js

Output:

✅ match | {"event":"charge.success","data":{"reference":"order_001","amount":500000}}
❌ MISMATCH | { "event": "charge.success", "data": { "reference": "order_001", "amount": 500000 } }
❌ MISMATCH | {"event":"charge.success","data":{"reference":"order\/001","amount":500000}}

Same data. One extra space, or one escaped /, and the stamp no longer matches. That's the photocopy problem: Baba Gate is comparing the stamp against a retyped letter.

So we tell Express: for this one route, don't parse anything, just give me the raw bytes.

import express, { Router, Request, Response } from "express";
import { config } from "../config";
import { isValidPaystackSignature } from "../utils/verifySignature";
import { handlePaystackEvent, PaystackEvent } from "../services/paymentHandler";

const router = Router();

router.post(
  "/paystack",
  express.raw({ type: "application/json" }),
  (req: Request, res: Response) => {
    // 1. We must have the raw bytes, not a parsed object
    if (!Buffer.isBuffer(req.body)) {
      console.error("Webhook body is not raw. Is express.json() running before this route?");
      res.sendStatus(400);
      return;
    }

    // 2. Check the stamp
    const signature = req.get("x-paystack-signature");
    if (!isValidPaystackSignature(req.body, signature, config.paystackSecret)) {
      res.sendStatus(401);
      return;
    }

    // 3. Only now do we read the letter
    let event: PaystackEvent;
    try {
      event = JSON.parse(req.body.toString("utf8")) as PaystackEvent;
    } catch {
      res.sendStatus(400);
      return;
    }

    // 4. Say "received" fast, then do the work
    res.sendStatus(200);
    handlePaystackEvent(event).catch((err) =>
      console.error("Failed to process webhook:", err)
    );
  }
);

export default router;

Let's walk through it:

express.raw({ type: "application/json" }) gives us req.body as a Buffer. We must set type, because by default express.raw() only handles application/octet-stream, and Paystack sends JSON.
The Buffer.isBuffer check catches the classic mistake (see Step 6). If some other parser got there first, we fail loudly instead of silently rejecting every real webhook.
We verify before we JSON.parse. Never read a letter you haven't confirmed is real.
We reply 200 before the slow work. Paystack's docs say to acknowledge the event before running long tasks, because a slow handler can time out and count as a failure. And failures get retried: in live mode, every 3 minutes for the first 4 tries, then hourly for the next 72 hours. Which leads us nicely to...

Step 5: The logbook and the phone call — `src/services/paystack.ts` and `src/services/paymentHandler.ts`

Retries mean the same event can arrive more than once. Stripe's docs say the same about their webhooks, and recommend logging the event IDs you've processed and skipping ones you've already seen. Paystack's "Verify Payments" page also tells you to confirm you haven't already delivered value for a transaction, especially if you use webhooks.

Also: a valid stamp proves the letter came from Paystack. It doesn't hurt to call the office and confirm the details match your order before you release goods. Paystack's Verify Transaction endpoint is GET https://api.paystack.co/transaction/verify/:reference with your secret key as a Bearer token.

First, the "phone call":

import { config } from "../config";

export interface VerifyResponse {
  status: boolean;
  message: string;
  data: {
    status: string; // "success", "failed", "abandoned", ...
    reference: string;
    amount: number; // subunit, e.g. kobo
    currency: string;
  };
}

// Pretend Paystack's records, used only when PAYSTACK_MOCK is on
const mockLedger: Record<string, VerifyResponse["data"]> = {
  order_001: { status: "success", reference: "order_001", amount: 500000, currency: "NGN" },
  order_002: { status: "success", reference: "order_002", amount: 100, currency: "NGN" },
};

export async function verifyTransaction(reference: string): Promise<VerifyResponse> {
  if (config.mockPaystack) {
    const data = mockLedger[reference];
    if (!data) return { status: false, message: "Transaction reference not found", data: { status: "failed", reference, amount: 0, currency: "NGN" } };
    return { status: true, message: "Verification successful", data };
  }

  const res = await fetch(
    `https://api.paystack.co/transaction/verify/${encodeURIComponent(reference)}`,
    { headers: { Authorization: `Bearer ${config.paystackSecret}` } }
  );
  return (await res.json()) as VerifyResponse;
}

With PAYSTACK_MOCK on, we answer from mockLedger. Notice order_002 in the fake ledger says 100 kobo. That's on purpose. We'll use it to see what happens when the numbers don't agree. 😋
With PAYSTACK_MOCK=false, it calls the real endpoint with your key.

Now the handler, where Baba Gate makes his final decision:

import { orderStore } from "../store/orderStore";
import { verifyTransaction } from "./paystack";

export interface PaystackEvent {
  event: string;
  data: { reference: string; amount: number; currency: string; status: string };
}

export async function handlePaystackEvent(event: PaystackEvent): Promise<void> {
  if (event.event !== "charge.success") {
    console.log(`Ignoring event: ${event.event}`);
    return;
  }

  const { reference } = event.data;
  const key = `${event.event}:${reference}`;

  // Have we let this visitor in before?
  if (!orderStore.claimEvent(key)) {
    console.log(`Duplicate event ${key}, skipping`);
    return;
  }

  try {
    const order = orderStore.find(reference);
    if (!order) {
      console.warn(`No order for reference ${reference}`);
      return;
    }
    if (order.status === "paid") {
      console.log(`Order ${reference} already paid`);
      return;
    }

    // Don't trust the letter alone. Call Paystack and ask.
    const check = await verifyTransaction(reference);
    const ok =
      check.status === true &&
      check.data.status === "success" &&
      check.data.amount === order.amount &&
      check.data.currency === order.currency;

    if (!ok) {
      console.warn(`Verification failed for ${reference}`, check.data);
      return;
    }

    orderStore.markPaid(reference);
    console.log(`✅ Order ${reference} marked as paid`);
  } catch (err) {
    orderStore.releaseEvent(key); // let a retry try again
    throw err;
  }
}

We only care about charge.success here. Everything else is politely ignored.
event + reference is our logbook key. Same event, same reference, second time? Skip.
We claim the key before the await. If two copies arrive at the same moment, only one gets past the logbook.
We check status, amount and currency against our own order. Not the webhook's numbers. Ours.
If something crashes, releaseEvent removes the key so a future retry can try again.

Step 6: Order matters — `src/app.ts` and `src/server.ts`

Remember that app.use(express.json()) line? Here is where most bugs are born.

import express from "express";
import webhookRoutes from "./routes/webhook";
import { orderStore } from "./store/orderStore";

const app = express();

// Webhooks FIRST, before any JSON parser touches the body
app.use("/webhooks", webhookRoutes);

// Everybody else can have parsed JSON
app.use(express.json());

app.get("/orders/:reference", (req, res) => {
  const order = orderStore.find(req.params.reference);
  if (!order) {
    res.status(404).json({ message: "Order not found" });
    return;
  }
  res.json(order);
});

export default app;

The webhook router is mounted before express.json().

If you flip them, express.json() reads the body first. Then express.raw() sees the body has already been handled and does nothing, so req.body is an object, not a Buffer. I tested this exact mistake on purpose and our guard caught it:

Webhook body is not raw. Is express.json() running before this route?
status 400

Without that check you'd just get mysterious 401s on every real webhook and spend your Saturday blaming Paystack. It wasn't Paystack. It was you. It was always you 😭

And the server file is short:

import app from "./app";
import { config } from "./config";

app.listen(config.port, () => {
  console.log(`Server running on http://localhost:${config.port} (mock Paystack: ${config.mockPaystack})`);
});

Step 7: Pretend to be Paystack — `scripts/send-webhook.ts`

We need someone to knock on the gate. This script builds a charge.success payload, stamps it with the same secret, and POSTs it. Exactly what Paystack does, minus the money. 😁

// Pretend to be Paystack: sign a payload with your secret and POST it.
import crypto from "node:crypto";

const secret = process.env.PAYSTACK_SECRET_KEY ?? "";
const url = process.env.WEBHOOK_URL ?? "http://localhost:4000/webhooks/paystack";
const reference = process.argv[2] ?? "order_001";
const amount = Number(process.argv[3] ?? 500000);

const body = JSON.stringify({
  event: "charge.success",
  data: { reference, amount, currency: "NGN", status: "success" },
});

const signature = crypto.createHmac("sha512", secret).update(body).digest("hex");

fetch(url, {
  method: "POST",
  headers: { "Content-Type": "application/json", "x-paystack-signature": signature },
  body,
}).then((res) => console.log(`Webhook for ${reference} -> ${res.status}`));

Let's Test It 🧪

Build and start the server:

npm run build
export PAYSTACK_SECRET_KEY=sk_test_practice_only
npm start

In a second terminal (export the same PAYSTACK_SECRET_KEY there too):

1. A real, signed webhook

npm run -s webhook -- order_001 500000
curl -s localhost:4000/orders/order_001

Webhook for order_001 -> 200
{"reference":"order_001","amount":500000,"currency":"NGN","status":"paid"}

Server log: ✅ Order order_001 marked as paid 🎉

2. The same webhook again (a retry)

npm run -s webhook -- order_001 500000

Webhook for order_001 -> 200

Server log: Duplicate event charge.success:order_001, skipping. We still reply 200, so Paystack stops retrying, but we don't deliver twice. Baba Gate checked his logbook. 🥰

3. A forged signature

BODY='{"event":"charge.success","data":{"reference":"order_002","amount":250000,"currency":"NGN","status":"success"}}'

curl -s -o /dev/null -w "%{http_code}\n" -X POST localhost:4000/webhooks/paystack \
  -H "Content-Type: application/json" \
  -H "x-paystack-signature: iamdefinitelypaystack" \
  -d "$BODY"

Leave out the header completely and you also get 401.

4. A real signature, but someone changed the amount

SIG=$(printf '%s' "$BODY" | openssl dgst -sha512 -hmac "$PAYSTACK_SECRET_KEY" | awk '{print $NF}')
TAMPERED=$(echo "$BODY" | sed 's/250000/2500/')

curl -s -o /dev/null -w "%{http_code}\n" -X POST localhost:4000/webhooks/paystack \
  -H "Content-Type: application/json" \
  -H "x-paystack-signature: $SIG" \
  -d "$TAMPERED"

The stamp was real, but the letter changed after stamping. Gate stays shut. 💪

5. Valid signature, but Paystack's records disagree

This one uses a body with extra spaces too, just to prove raw-body hashing doesn't care about formatting:

PRETTY='{ "event": "charge.success", "data": { "reference": "order_002", "amount": 250000, "currency": "NGN", "status": "success" } }'
SIG=$(printf '%s' "$PRETTY" | openssl dgst -sha512 -hmac "$PAYSTACK_SECRET_KEY" | awk '{print $NF}')

curl -s -o /dev/null -w "%{http_code}\n" -X POST localhost:4000/webhooks/paystack \
  -H "Content-Type: application/json" \
  -H "x-paystack-signature: $SIG" \
  -d "$PRETTY"

curl -s localhost:4000/orders/order_002

200
{"reference":"order_002","amount":250000,"currency":"NGN","status":"pending"}

The signature passed (even with all those spaces), but our fake Paystack ledger says only 100 kobo was paid, not 250000. So the order stays pending and the server logs Verification failed for order_002. Baba Gate called the office, and the office said "no o". 😂

Before vs After

	Before 😬	After 😎
Who can mark an order paid	Anyone with curl	Only letters stamped with your secret
Body used for the signature	Re-built with `JSON.stringify`	The raw bytes Paystack sent
Comparing signatures	`===`	`timingSafeEqual` with a length check
Retries / duplicates	Customer gets value twice	Logbook skips it
Amount check	Trust the webhook	Ask Paystack, compare with your own order
Slow work	Inside the request, risking timeouts	Reply 200 first, then process

Why we do it this way (and what changes in production)

This is pretty much the same shape I use for real payment flows. At Prooval, where I built the backend from scratch, we take payments through Stripe, Paystack and Fincra, and every one of them comes down to the same Baba Gate questions: is this really from the provider, have I seen it before, and do the numbers match?

A few things you should upgrade before real money flows through this:

Use your database for the logbook. An in-memory Set is wiped on every restart and isn't shared between servers. Save processed events in a table with a unique index on the key, so if two servers race, the database lets only one insert win.
Move the slow work to a queue. Right now we res.sendStatus(200) and then process in the same Node process. If the server dies in between, that event is gone, because Paystack already got its 200. A job queue (I wrote about BullMQ on LinkedIn recently) or at least a "received events" table you can replay fixes this.
Lock down the route. Paystack also publishes the IP addresses it sends webhooks from, so you can whitelist them as an extra layer. Check their webhook docs for the current list.
Switch the mock off. Set PAYSTACK_MOCK=false and use your real test secret key. The verifyTransaction function will call the real endpoint.

Recap (say it with me) 🗣️

A webhook URL is public. Anyone can POST to it.
Paystack signs every webhook with HMAC SHA512 of the body, using your secret key, in x-paystack-signature.
Hash the raw body (express.raw({ type: "application/json" })), not JSON.stringify(req.body).
Mount the webhook route before express.json().
Compare with timingSafeEqual, and check lengths first.
Reply 200 fast, then do the work.
The same event can come more than once. Keep a logbook.
Before giving value, verify the transaction and compare amount and currency with your order.

Baba Gate would be proud. 🫡

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

If you've been burned by a webhook bug before, tell me about it in the comments. I promise not to laugh. Too much. 😅

Thank you for taking the time to read 🥰🥰

See you on the next one 🤗

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

DEV Community: FredAbod

Stop Multiplying by 100 - Handle Money Amounts Safely in TypeScript for Beginners

The coin-counting cashier 🪙

Prerequisites

Let's Dive Right In 😁😁

Step 0: Watch it break first — src/float-bug.ts

Step 1: Set up the project

Step 2: The cashier's cheat sheet — src/money/currencies.ts

Step 3: Counting coins without floats — src/money/toMinor.ts

Step 4: Paystack's cashier — src/providers/paystack.ts

Step 5: Stripe's cashier — src/providers/stripe.ts

Step 6: The checkout counter — src/routes/checkout.ts

Step 7: Wire it up — src/app.ts and src/server.ts

Step 8: Let's poke it with curl 🧪

Step 9: Tests, because money deserves tests — src/money/toMinor.test.ts

Before vs after

Why we do it this way

Recap (say it with me)

[Boost]

Stop Trusting Every Webhook - Verify Paystack Signatures in Express for Beginners

Stop Trusting Every Webhook - Verify Paystack Signatures in Express for Beginners

The Estate Gate Analogy 🏘️

Prerequisites

Let's Dive Right In 😁😁

Step 0: The boring setup — tsconfig.json and package.json

Step 1: Baba Gate's secret — src/config.ts

Step 2: Checking the stamp — src/utils/verifySignature.ts

Step 3: The estate records — src/store/orderStore.ts

Step 4: The original letter, not a photocopy — src/routes/webhook.ts

Step 5: The logbook and the phone call — src/services/paystack.ts and src/services/paymentHandler.ts

Step 6: Order matters — src/app.ts and src/server.ts

Step 7: Pretend to be Paystack — scripts/send-webhook.ts

Let's Test It 🧪

Before vs After

Why we do it this way (and what changes in production)

Recap (say it with me) 🗣️

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

Step 0: Watch it break first — `src/float-bug.ts`

Step 2: The cashier's cheat sheet — `src/money/currencies.ts`

Step 3: Counting coins without floats — `src/money/toMinor.ts`

Step 4: Paystack's cashier — `src/providers/paystack.ts`

Step 5: Stripe's cashier — `src/providers/stripe.ts`

Step 6: The checkout counter — `src/routes/checkout.ts`

Step 7: Wire it up — `src/app.ts` and `src/server.ts`

Step 9: Tests, because money deserves tests — `src/money/toMinor.test.ts`

Step 0: The boring setup — `tsconfig.json` and `package.json`

Step 1: Baba Gate's secret — `src/config.ts`

Step 2: Checking the stamp — `src/utils/verifySignature.ts`

Step 3: The estate records — `src/store/orderStore.ts`

Step 4: The original letter, not a photocopy — `src/routes/webhook.ts`

Step 5: The logbook and the phone call — `src/services/paystack.ts` and `src/services/paymentHandler.ts`

Step 6: Order matters — `src/app.ts` and `src/server.ts`

Step 7: Pretend to be Paystack — `scripts/send-webhook.ts`

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