Forem: Thor

📘 NestJS Blog Series – Series 1

Thor — Tue, 06 May 2025 19:09:36 +0000

🛠️ Bootstrapping a NestJS App & Understanding App Structure

✅ Getting Started with `nest new todoApp`

We create a new NestJS project using the CLI:

nest new todoApp

This sets up a clean TypeScript backend with:

A modular structure
TypeScript out of the box
Preconfigured build and test tools

📁 Project Structure Overview

After generating the app, you’ll see this:

src/
├── app.controller.ts
├── app.module.ts
├── app.service.ts
├── main.ts

🚀 `main.ts` – The Entry Point

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

🔍 What is `NestFactory`?

NestFactory is a helper class that bootstraps the NestJS application.
Under the hood, it sets up the HTTP server (based on Express by default).
You can swap it for Fastify if needed.

const app = await NestFactory.create(AppModule);

This creates an instance of the application using the root module AppModule.

💡 NestFactory vs Express

Feature	Express	NestJS (with NestFactory)
Architecture	Unopinionated, DIY	Modular, opinionated
Dependency Injection	Manual	Automatic
TypeScript Support	Optional	Built-in
CLI Tools	None	Powerful scaffolding via Nest CLI
Testing	Manual	Built-in tools and patterns

NestJS builds on top of Express, giving you a framework that's structured, testable, and scalable.

🧱 `AppModule` – The Root Module

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { HelloModule } from './hello/hello.module';

@Module({
  imports: [HelloModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

🧩 What’s a Module in NestJS?

A module is a class annotated with @Module()
It organizes code into cohesive blocks: controllers, services, other modules

🧩 A Feature Module Example – `HelloModule`

import { Module } from '@nestjs/common';
import { HelloController } from './hello.controller';
import { HelloService } from './hello.service';

@Module({
  controllers: [HelloController],
  providers: [HelloService],
  imports: [],
  exports: []
})
export class HelloModule {}

🧭 Explanation

controllers: Handle HTTP requests
providers: Services used by the controller or other providers
imports: Import other modules (e.g., DatabaseModule)
exports: Expose services to other modules if needed

🎮 Controller – Handling HTTP Requests

import { Controller, Get, Param, Query } from '@nestjs/common';
import { HelloService } from './hello.service';

@Controller('hello')
export class HelloController {
    constructor(private readonly helloService: HelloService) {}

    @Get()
    getHello(): string {
        return this.helloService.getHello();
    }

    @Get("/name/:username")
    getUser(@Param("username") username: string): string {
        return this.helloService.getHelloWithName(username);
    }

    @Get('query')
    getHelloUser(@Query("name") name: string): string {
        return this.helloService.getHelloWithName(name);
    }
}

📌 Key Concepts

@Controller('hello'): All routes start with /hello
@Get(): Handles GET request to /hello
@Param(): Gets URL parameter
@Query(): Gets query string param like /hello/query?name=John

🔐 Constructor Injection

constructor(private readonly helloService: HelloService) {}

This uses NestJS Dependency Injection to inject the HelloService. It’s how services are shared in NestJS.

⚙️ Service – Business Logic Layer

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

@Injectable()
export class HelloService {
    getHello(): string {
        return 'Hello nestjs';
    }

    getHelloWithName(name: string): string {
        return `Hello ${name} from nestjs`;
    }
}

💡 What is `@Injectable()`?

This tells NestJS that this class can be injected into other classes.
Think of it like @Service in Spring or a provider in Angular.

Would you like me to generate Series 2 now with a fully working TodoModule + DTO + in-memory storage?

🦀 Rust Series 3: Generics, Traits & Implementations

Thor — Sun, 06 Apr 2025 03:32:20 +0000

✨ Introduction

Welcome back to our Rust learning journey!

In our last post, we explored control flow, functions, and ownership. Today, we dive into three powerful concepts that make Rust both flexible and type-safe:

🚀 Generics, Traits, and Implementations

🔧 Generics in Rust

Generics let you write code that works with many different types while keeping Rust’s zero-cost abstraction promise.

// Generic function that works with any type implementing Add
fn sum_of_two_number<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

// Usage
let int_result = sum_of_two_number(20, 20);
let float_result = sum_of_two_number(20.20, 20.20);

👴 Without generics, you’d have to write separate functions:

fn sum_u32(a: u32, b: u32) -> u32 {
    a + b
}

fn sum_f32(a: f32, b: f32) -> f32 {
    a + b
}

📦 Structs & `impl` Blocks

You add functionality to types in Rust using impl.

struct Rect {
    width: u32,
    height: u32,
}

impl Rect {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

// Usage
let rect = Rect { width: 20, height: 30 };
println!("Area: {}", rect.area());

🧱 Generic Structs + Trait Bounds

Structs can be generic too, and we can add functionality using trait bounds.

struct RectWithGeneric<T> {
    width: T,
    height: T,
}

impl<T: std::ops::Add<Output = T> + Copy> RectWithGeneric<T> {
    fn area(&self) -> T {
        self.width + self.height
    }
}

// Usage
let float_rect = RectWithGeneric { width: 20.1, height: 20.2 };
let int_rect = RectWithGeneric { width: 200, height: 200 };

💡 Traits: Defining Shared Behavior

Traits are like interfaces in other languages — they define capabilities that types can implement.

// Display trait for printing
fn print<T: std::fmt::Display>(item: T) {
    println!("{}", item);
}

// Ord trait for comparison
fn max<T: Ord>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

Traits are used everywhere in Rust, including the standard library.

🌱 Real-World: Environment Variables

Here's a real-world use case: reading env vars safely.

use std::env;

// Safe error handling
match env::var("REDIS_INTERNAL") {
    Ok(val) => println!("{}", val),
    Err(_) => println!("Environment variable not found"),
}

// When you're sure it's set (be cautious)
let redis_value = env::var("REDIS_INTERNAL").unwrap();

✅ what you learnt

✅ Generics allow for type-safe and reusable code
✅ Traits define capabilities for types
✅ impl blocks add methods to structs
✅ Generic structs = power + flexibility
✅ Trait bounds like T: Add + Copy enforce required behavior

🔗 Resources

📘 Code examples:

github.com/ichiragkumar/rust-basics

🐦 Follow me for more:

https://x.com/imchiragkumar/

🦀 Rust Series 2: Control Flow, Functions, and Ownership

Thor — Mon, 31 Mar 2025 04:37:58 +0000

Rust is a powerful systems programming language that enforces memory safety without a garbage collector. In this post, we will explore control flow (conditionals & loops), functions, and ownership concepts (move vs. borrowing).

🔍 Conditionals in Rust

Rust provides if, else if, and else statements to control the program flow.

fn main() {
    println!("\n===== CONDITIONALS IN RUST =====");

    let is_user_logged_in = true;
    let is_user_paid = true;
    let is_admin = false;

    if is_user_logged_in {
        println!("User is logged in");
    }

    if is_admin {
        println!("Admin panel is accessible");
    } else {
        println!("Regular user dashboard");
    }

    if is_admin {
        println!("Welcome, Admin!");
    } else if is_user_paid && is_user_logged_in {
        println!("Welcome, Premium User!");
    } else if is_user_logged_in {
        println!("Welcome, Free User!");
    } else {
        println!("Please log in to continue");
    }

    let access_level = if is_admin {
        "admin"
    } else if is_user_paid {
        "premium"
    } else {
        "basic"
    };
    println!("Access level: {}", access_level);
}

🛠️ Loops in Rust

Rust supports different types of loops:

1. Infinite Loop (`loop`)

let mut counter = 0;
loop {
    println!("Counter is: {}", counter);
    counter += 1;
    if counter == 5 {
        break;
    }
}

2. Labeled Loops (`'label: loop`)

let result = 'counter_loop: loop {
    counter += 1;
    if counter == 10 {
        break 'counter_loop counter * 2;
    }
};
println!("Loop result: {}", result);

3. `while` Loop

let mut number = 1;
while number < 5 {
    println!("Number is: {}", number);
    number *= 2;
}

4. `for` Loop (Iterating over Ranges)

for i in 1..=5 {
    println!("i is: {}", i);
}

🔧 Functions in Rust

Functions help organize code into reusable logic blocks. Rust enforces explicit return types.

fn sum_of_two_numbers(num1: i32, num2: i32) -> i32 {
    num1 + num2
}

fn sum_of_numbers(n: i64) -> i64 {
    n * (n + 1) / 2
}

fn main() {
    println!("\n===== FUNCTIONS =====");

    let sum_result = sum_of_two_numbers(15, 27);
    println!("Sum of 15 and 27 is: {}", sum_result);

    let n = 1000;
    let sum_n = sum_of_numbers(n);
    println!("Sum of numbers from 1 to {} is: {}", n, sum_n);
}

🤖 Ownership, Borrowing, and String Handling in Rust

Rust prevents data races and use-after-free errors using ownership rules.

🔍 Example: Extracting Words from a Sentence

fn main() {
    let sentence = String::from("Hello rusty, welcome to world of rust");

    let first_word_from = get_first_word(&sentence);
    println!("First word from sentence is : {}", first_word_from);

    let first_letter_from = get_first_letter(&sentence);
    println!("First letter from sentence is : {}", first_letter_from);

    let return_asked_index = get_index_of(&sentence, 2);
    println!("Index of rust in sentence is : {}", return_asked_index);
}

fn get_first_word(sentence: &str) -> String {
    let mut ans = String::new();

    for char in sentence.chars() {
        if char == ' ' {
            break;
        }
        ans.push(char);
    }

    ans
}

fn get_first_letter(sentence: &str) -> String {
    sentence.chars().nth(0).unwrap().to_string()
}

fn get_index_of(sentence: &str, index: usize) -> String {
    if let Some(c) = sentence.chars().nth(index) {
        return c.to_string();
    }
    String::from("Not found")
}

Why Use `&str` Instead of `String`?

Rust has two main string types:

String (Heap-allocated, mutable)
&str (Borrowed, slice reference, immutable)

Using &str allows us to borrow data instead of moving it, which is essential for performance and memory safety.

Move vs. Borrowing in Rust

Move: When assigning a String to another variable, ownership transfers, making the original variable invalid.

  let s1 = String::from("Hello");
  let s2 = s1; // Moves ownership, s1 is no longer valid

Borrowing (&str): Allows a function to reference data without taking ownership.

  fn print_str(data: &str) {
      println!("Data: {}", data);
  }
  let s = String::from("Rust");
  print_str(&s); // Borrowing
  println!("Still valid: {}", s); // ✅ Works

Using borrowing (&str) ensures functions can use strings without transferring ownership.

🎉 Conclusion

In this blog, we covered:

Control Flow: if, else if, else, loops (loop, while, for).
Functions: How to define and call functions.
Ownership & Borrowing: Using &str to prevent data movement errors.

Rust's ownership model ensures memory safety without a garbage collector—a game-changer for performance and reliability! 🚀

Here's a closing section you can use for your technical blog:

🚀 Follow and Explore!

👉 Follow Chiragkumar on GitHub and X:

You can clone and use my repo to test all the examples covered in this blog!

🔗 GitHub – Star the repo and check out other cool projects! 🌟

🐦 X (Twitter) – Follow Chiragkumar to stay updated with my coding journey! 🧑‍💻

Happy coding! 😎

🦀 Rust Series 1: From 0 to 1

Thor — Fri, 28 Mar 2025 11:53:51 +0000

Welcome to Rust! In this series, we'll cover the basics of Rust programming, starting from installation and setup to writing and running your first program. We'll also cover key data types, variables, and basic operations with examples and edge cases.

✅ 1. Installing Rust

🛠️ Install Rust using `rustup`

rustup is the recommended way to install Rust as it manages updates and toolchains easily.

➡️ Steps to install:

Open your terminal.
Run the following command:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Follow the on-screen instructions.
- It will install:
  - rustc – The Rust compiler
  - cargo – The Rust package manager
  - rustup – The version manager

✅ Verify Installation

After installation, restart your terminal and run:

rustc --version
cargo --version

Example output:

rustc 1.76.0 (f9e8851be 2025-03-01)
cargo 1.76.0 (f9e8851be 2025-03-01)

🚀 2. Setting Up Your First Rust Project

➡️ Create a new Rust project

Use cargo to create a new project:

cargo new hello-rust

This creates a directory hello-rust with the following structure:

hello-rust
├── Cargo.toml   // Project configuration file
└── src
    └── main.rs  // Main code file

📝 3. Writing Your First Program

Open src/main.rs and write the following:

fn main() {
    println!("Hello, Rust!");
}

➡️ Run the program

Navigate to the project directory and run:

cargo run

✅ Output:

Hello, Rust!

🔢 4. Numbers in Rust

Rust has strict type-checking for numeric types:

➡️ Signed Integers (`i8`, `i16`, `i32`, `i64`, `i128`)

Signed integers can store negative values.
i32 is the default type for integers.

Example:

let x: i32 = -10;
let y: i32 = 20;
println!("Signed Integers: x = {}, y = {}", x, y);

➡️ Unsigned Integers (`u8`, `u16`, `u32`, `u64`, `u128`)

Unsigned integers store only positive values.

Example:

let x: u32 = 10;
let y: u32 = 20;
println!("Unsigned Integers: x = {}, y = {}", x, y);

➡️ Floating-Point Numbers (`f32`, `f64`)

f64 is the default type for floats.

Example:

let x: f32 = 10.5;
let y: f32 = 20.5;
println!("Floats: x = {}, y = {}", x, y);

✅ Edge Cases

Integer overflow example:

let x: u8 = 255;
let y = x + 1; // Causes overflow
println!("{}", y);

➡️ Output: thread 'main' panicked at overflow

Floating-point precision loss:

let x: f32 = 0.1 + 0.2;
println!("{}", x); // Output: 0.30000004

🔣 5. Booleans in Rust

Rust uses true and false for booleans.

Example:

let is_true: bool = true;
let is_false: bool = false;

if is_true && !is_false {
    println!("Both conditions are satisfied.");
} else {
    println!("Conditions are not satisfied.");
}

✅ Edge Cases:

Boolean used in if expression:

let condition = 1 > 2;
if condition {
    println!("True");
} else {
    println!("False");
}

🏷️ 6. Variables in Rust

Variables are immutable by default.
Use mut to make them mutable.

Example:

let x = 10; // immutable
let mut y = 20; // mutable

y = 30; // OK since it's mutable
println!("x = {}, y = {}", x, y);

✅ Edge Cases:

Trying to modify an immutable variable:

let x = 10;
x = 20; // Compile-time error

Shadowing example:

let x = 10;
let x = x + 20;
println!("{}", x); // Output: 30

🔡 7. Strings in Rust

Rust has two types of strings:

String – Heap-allocated and growable
&str – String slice (fixed size)

➡️ Example of `String`:

let greeting: String = String::from("Hello, Rust!");
println!("{}", greeting);

➡️ Example of `&str`:

let x: &str = "Hello";
let y: &str = "Rust";
println!("{} {}", x, y);

✅ Edge Cases:

String indexing is not allowed:

let s = String::from("hello");
println!("{}", s[0]); // Error: Rust strings are UTF-8

String length:

let s = String::from("hello");
println!("{}", s.len()); // Output: 5

Handling Option<char> when indexing:

let s = String::from("rust");
match s.chars().nth(2) {
    Some(c) => println!("Third character: {}", c),
    None => println!("No character at index"),
}

🪓 8. Match Statement

Example:

let x = 5;

match x {
    1 => println!("One"),
    2 => println!("Two"),
    3..=5 => println!("Three to Five"),
    _ => println!("Other"),
}

✅ Edge Cases:

Missing cases:

let x = 7;
match x {
    1 | 2 => println!("One or Two"),
    _ => println!("Other"),
}

📚 9. Functions in Rust

Example:

fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let result = add(5, 10);
    println!("Sum = {}", result);
}

✅ Edge Cases:

Mismatched return type:

fn add(x: i32, y: i32) -> i32 {
    x + y;
} // Error due to missing return statement without `;`

🏆 10. Full Example

fn main() {
    let x: i32 = 5;
    let y: i32 = 10;
    println!("Sum of {} and {} is {}", x, y, add(x, y));
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

➡️ Output:

Sum of 5 and 10 is 15

➡️ Clone the repo:

git clone https://github.com/ichiragkumar/rust-basics.git

➡️ Navigate to the project:

cd rust-basics

➡️ Run the project:

cargo run

➡️ Edit and Play Around:

Open src/main.rs in your editor (like VSCode) and start modifying it:

✅ Add new functions

✅ Test edge cases

✅ Break things to see how Rust handles it

🚀 Follow and Explore!

👉 Follow Chiragkumar on GitHub and X:

GitHub – Star the repo and check out other cool projects! 🌟
X (Twitter) – Stay updated with Chiragkumar's coding journey! 🧑‍💻

Forem: Thor

📘 NestJS Blog Series – Series 1

🛠️ Bootstrapping a NestJS App & Understanding App Structure

✅ Getting Started with nest new todoApp

📁 Project Structure Overview

🚀 main.ts – The Entry Point

🔍 What is NestFactory?

💡 NestFactory vs Express

🧱 AppModule – The Root Module

🧩 What’s a Module in NestJS?

🧩 A Feature Module Example – HelloModule

🧭 Explanation

🎮 Controller – Handling HTTP Requests

📌 Key Concepts

🔐 Constructor Injection

⚙️ Service – Business Logic Layer

💡 What is @Injectable()?

🦀 Rust Series 3: **Generics, Traits & Implementations**

✨ Introduction

🔧 Generics in Rust

📦 Structs & impl Blocks

🧱 Generic Structs + Trait Bounds

💡 Traits: Defining Shared Behavior

🌱 Real-World: Environment Variables

✅ what you learnt

🔗 Resources

🦀 Rust Series 2: Control Flow, Functions, and Ownership

🔍 Conditionals in Rust

🛠️ Loops in Rust

1. Infinite Loop (loop)

2. Labeled Loops ('label: loop)

3. while Loop

4. for Loop (Iterating over Ranges)

🔧 Functions in Rust

🤖 Ownership, Borrowing, and String Handling in Rust

🔍 Example: Extracting Words from a Sentence

Why Use &str Instead of String?

Move vs. Borrowing in Rust

🎉 Conclusion

🚀 Follow and Explore!

🦀 Rust Series 1: From 0 to 1

✅ 1. Installing Rust

🛠️ Install Rust using rustup

➡️ Steps to install:

✅ Verify Installation

🚀 2. Setting Up Your First Rust Project

➡️ Create a new Rust project

📝 3. Writing Your First Program

➡️ Run the program

🔢 4. Numbers in Rust

➡️ Signed Integers (i8, i16, i32, i64, i128)

➡️ Unsigned Integers (u8, u16, u32, u64, u128)

➡️ Floating-Point Numbers (f32, f64)

✅ Edge Cases

🔣 5. Booleans in Rust

🏷️ 6. Variables in Rust

🔡 7. Strings in Rust

➡️ Example of String:

➡️ Example of &str:

✅ Edge Cases:

🪓 8. Match Statement

📚 9. Functions in Rust

🏆 10. Full Example

➡️ Clone the repo:

➡️ Navigate to the project:

➡️ Run the project:

➡️ Edit and Play Around:

🚀 Follow and Explore!

✅ Getting Started with `nest new todoApp`

🚀 `main.ts` – The Entry Point

🔍 What is `NestFactory`?

🧱 `AppModule` – The Root Module

🧩 A Feature Module Example – `HelloModule`

💡 What is `@Injectable()`?

🦀 Rust Series 3: Generics, Traits & Implementations

📦 Structs & `impl` Blocks

1. Infinite Loop (`loop`)

2. Labeled Loops (`'label: loop`)

3. `while` Loop

4. `for` Loop (Iterating over Ranges)

Why Use `&str` Instead of `String`?

🛠️ Install Rust using `rustup`

➡️ Signed Integers (`i8`, `i16`, `i32`, `i64`, `i128`)

➡️ Unsigned Integers (`u8`, `u16`, `u32`, `u64`, `u128`)

➡️ Floating-Point Numbers (`f32`, `f64`)

➡️ Example of `String`:

➡️ Example of `&str`: