TILs - Fueling Curiosity, One Insight at a Time

At Codemancers, we believe every day is an opportunity to grow. This section is where our team shares bite-sized discoveries, technical breakthroughs and fascinating nuggets of wisdom we've stumbled upon in our work.

Published
Author
user-image
Puneeth kumar
System Analyst
Using emit in NestJS

In NestJS, event-based communication can be implemented using @nestjs/event-emitter package, which is built on top of eventemitter2 . It's particularly useful for decoupling the parts of our application — for example, sending notifications, logging, or triggering async jobs after certain actions.

How to use it?

• Install the necessary package:

Code

npm install --save @nestjs/event-emitter


• Register the module in the app:

Code

// app.module.ts
import { EventEmitterModule } from '@nestjs/event-emitter';

@Module({
  imports: [
    EventEmitterModule.forRoot(),
  ],
})
export class AppModule {}


• Emit an event from anywhere in the app:

Code

// user.service.ts
import { EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class UserService {
  constructor(private eventEmitter: EventEmitter2) {}

  async createUser(userDto: CreateUserDto) {
    const user = await this.userRepository.save(userDto);
    
    this.eventEmitter.emit('user.created', user); // 🔥

    return user;
  }
}


• Handle the event using a listener:

Code

// user.listener.ts
import { OnEvent } from '@nestjs/event-emitter';

@Injectable()
export class UserListener {
  @OnEvent('user.created')
  handleUserCreatedEvent(payload: any) {
    console.log('User created!', payload);
    // Trigger welcome email, analytics, etc.
  }
}


Why use emits?

✅ Decouples the core logic from side-effects
✅ Makes it easier to add/remove behaviours like notifications, logging
✅ Encourages modular architecture

#CCT1JMA0Z #nestJs #event_based_communication
Published
Author
user-image
Sudeep Hipparge
Difference Between jest.fn() and jest.spyOn() in Jest

🧪 While writing tests in Jest, I came across two commonly used utilities: jest.fn() and jest.spyOn(). They may seem similar, but they serve different purposes:

🔹 jest.fn()
• Creates a new mock function from scratch
• Ideal when you want to replace a function with a mock implementation entirely
• Commonly used to inject mocked dependencies in unit tests

Code

const mockFn = jest.fn();
mockFn('arg'); 
expect(mockFn).toHaveBeenCalledWith('arg');


🔹 jest.spyOn()
• Spies on an existing method of an object
• Allows you to observe calls to the method or mock its implementation, while retaining the original object structure

Code

const obj = {
  greet: () => 'Hello',
};

const spy = jest.spyOn(obj, 'greet');
obj.greet();
expect(spy).toHaveBeenCalled();


👉 Use jest.fn() when creating mocks from scratch.
👉 Use jest.spyOn() to observe or override existing methods.

#jest #CCT1JMA0Z #testing
Published
Author
user-image
Puneeth kumar
System Analyst
Recover Lost Data in PostgreSQL

Most SQL databases, like PostgreSQL, let us restore the database to a specific point in time — this is called Point-In-Time Recovery (PITR). PostgreSQL makes this possible using something called the Write-Ahead Log (WAL).

The WAL keeps a log of every change made to the database, like adding, updating, or deleting the data. Each of these log has a unique ID called as Log Sequence Number (LSN). This allows PostgreSQL to rebuild the database exactly as it was at any moment in the past.

However, PostgreSQL doesn’t keep these logs forever. A background process automatically removes old WAL files when they’re no longer needed to save space.

#postgreSQL #databases
Published
Author
user-image
Sudeep Hipparge
How to Revoke (Undo) a Git Rebase

If you’ve run a git rebase and need to undo it due to issues, here’s a simple way to revert back:

1.Check your reflog to find the commit before rebase started:

Code

git reflog


Look for the commit hash just before the rebase (usually marked with rebase started).

2.Reset your branch back to that commit:

Code

git reset --hard <commit-hash>


This will reset your branch to the exact state before the rebase.

Important:
• Use git reset --hard with caution, as it will discard any uncommitted changes.
#Git
Published
Author
user-image
Sudeep Hipparge
React Query

✅ It simplifies data fetching, caching, syncing, and updating — without manually managing loading or error states.
Here’s a small snippet I worked on today:


JavaScript

import { useQuery } from '@tanstack/react-query';
import axios from 'axios';

const fetchOrganisations = async () => {
  const { data } = await axios.get('/api/organisations');
  return data;
};

const Users = () => {
  const { data, isLoading, error } = useQuery(['organisations'], fetchOrganisations);

  if (isLoading) return <p>Loading...</p>;
  if (error) return <p>Error fetching organisations</p>;

  return (
    <ul>
      {data.map(organisation => (
        <li key={organisation.id}>{organisation.name}</li>
      ))}
    </ul>
  );
};


💡 What I love:
• Built-in caching
• Automatic background refetching
• Easy-to-use API with powerful features
#CCT1JMA0Z #FrontendDevelopment
Published
Author
user-image
Sudeep Hipparge
Typescript as const turns everything into readonly.


TypeScript

const user = {
  role: 'admin',
} as const;

user.role = 'editor'; // ❌ Error: Cannot assign to 'role' because it is a read-only property.


💡 as const is great for making values literal and immutable — useful in Redux, Enums, etc.

#Typescript #CCT1JMA0Z
Published
Author
user-image
Sudeep Hipparge
JavaScript: Object.groupBy()

Grouping data used to be messy — relying on Array.reduce() with verbose logic. But JavaScript's new Object.groupBy() method has made things incredibly elegant and easy!

With just one line, you can group array items based on any property.
It’s clean, readable, and production-friendly.

📌 Example:


JavaScript

const products = [
  { name: "T-shirt", category: "clothes", price: 50 },
  { name: "Apple", category: "food", price: 5 },
  { name: "Shoes", category: "clothes", price: 35 },
  { name: "Orange", category: "food", price: 7.5 },
  { name: "Blueberry", category: "food", price: 4.5 }
];

const grouped = Object.groupBy(products, product => product.category);

console.log(grouped);


💡 Output:


Code

{
  clothes: [
    { name: "T-shirt", category: "clothes", price: 50 },
    { name: "Shoes", category: "clothes", price: 35 }
  ],
  food: [
    { name: "Apple", category: "food", price: 5 },
    { name: "Orange", category: "food", price: 7.5 },
    { name: "Blueberry", category: "food", price: 4.5 }
  ]
}


✅ Cleaner. ✅ Less boilerplate. ✅ Much easier to read.

#CCT1JMA0Z #WebDevelopment
Published
Author
user-image
Vaibhav Yadav
Senior System Analyst
Using Makefile for tedious commands

A Makefile can be used to automate a commands, simplifying the execution process. Here’s a concise example:


Code

.PHONY: run-script

# Target to run a long command
run-script:
    @echo "Running a long command..."
    sleep 5  # Simulate a long-running command
    @echo "Command completed."


Running the Makefile
1. Create a Makefile: Save the above content as Makefile in your project directory.
2. Run Make: In your terminal, navigate to the project directory and execute:

Code

make run-script


Benefits
• Simplicity: Easily run a long command without remembering the syntax.
• Automation: Reduces manual effort and potential errors.
#cli #automation #makefile #commands
Published
Author
user-image
Sudeep Hipparge
💡 Why is [] == ![] true in JavaScript?

It all comes down to type coercion and how JavaScript evaluates expressions using the == (abstract equality) operator.

Here’s the breakdown:
![] evaluates to false because an empty array is truthy, and the ! operator negates it.
So the expression becomes: [] == false
When comparing an object (like[]) to a boolean with==, JavaScript converts both sides to numbers:
+[] → 0
+false → 0
So:

JavaScript

[] == ![]  
=> [] == false  
=> +[] == +false  
=> 0 == 0  
=> true


✅ Hence, [] == ![] evaluates to true.

#CCT1JMA0Z
Published
Author
user-image
Adithya Hebbar
System Analyst
How Dependency Injection Works in NestJS

NestJS uses Dependency Injection (DI) to manage the creation and lifecycle of classes like services, repositories, and providers. It leverages TypeScript's metadata to resolve dependencies automatically.

🚀 How It Works:

• Declare Providers: Services and other classes are marked with @Injectable() to make them available for dependency injection. They are then registered as providers in a module.

TypeScript

// user.service.ts
@Injectable()
export class UserService {
  getUsers() {
    return ['Alice', 'Bob'];
  }
}


• Register Providers in a Module

Code

// user.module.ts
@Module({
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}


• Use the Service via Constructor Injection

Code

// user.controller.ts
@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  findAll() {
    return this.userService.getUsers();
  }
}


NestJS reads the constructor types and injects the required instances for you. No manual instantiation needed!

✅ Benefits:
• Decouples components
• Simplifies testing with mocks
• Promotes cleaner, modular code

#nestjs #dependencyinjection #typescript

Showing page 5 of 83

Your competitors are already using AI.
The question is how fast you want to unlock the value?

Don't know where to start?

AI is everywhere but it's unclear which investments will actually move your metrics and which are expensive experiments.

Your data isn't ready

Most AI projects fail at the data layer. Pipelines, quality, access all need work before LLMs can deliver value.

Internal teams are stretched

Your engineers are shipping product. They don't have capacity to also become AI specialists with production-grade experience.

Legacy systems block everything

Aging, undocumented codebases make AI integration slow, risky, and expensive. They need to move first.

Don't Worry. We've got you covered.

Start with the audit.

Book a free discovery call →