DEV Community: 𝙹𝚒𝚋𝚛āʾī𝚕 ⚡

🚀 Best NestJS Package for Filtering and Pagination

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Tue, 10 Jun 2025 22:13:08 +0000

First lets install this incredible package

Installation

npm install nestjs-paginate

Now our Endpoint should look something like that

http://localhost:3000/cats?limit=5&page=2&sortBy=color:DESC&search=i&filter.age=$gte:3&select=id,name,color,age

And the result should look like that

{
  "data": [
    {
      "id": 4,
      "name": "George",
      "color": "white",
      "age": 3
    },
    {
      "id": 5,
      "name": "Leche",
      "color": "white",
      "age": 6
    },
    {
      "id": 2,
      "name": "Garfield",
      "color": "ginger",
      "age": 4
    },
    {
      "id": 1,
      "name": "Milo",
      "color": "brown",
      "age": 5
    },
    {
      "id": 3,
      "name": "Kitty",
      "color": "black",
      "age": 3
    }
  ],
  "meta": {
    "itemsPerPage": 5,
    "totalItems": 12,
    "currentPage": 2,
    "totalPages": 3,
    "sortBy": [["color", "DESC"]],
    "search": "i",
    "filter": {
      "age": "$gte:3"
    }
  },
  "links": {
    "first": "http://localhost:3000/cats?limit=5&page=1&sortBy=color:DESC&search=i&filter.age=$gte:3",
    "previous": "http://localhost:3000/cats?limit=5&page=1&sortBy=color:DESC&search=i&filter.age=$gte:3",
    "current": "http://localhost:3000/cats?limit=5&page=2&sortBy=color:DESC&search=i&filter.age=$gte:3",
    "next": "http://localhost:3000/cats?limit=5&page=3&sortBy=color:DESC&search=i&filter.age=$gte:3",
    "last": "http://localhost:3000/cats?limit=5&page=3&sortBy=color:DESC&search=i&filter.age=$gte:3"
  }
}

Now lets find how to set up our code

The Entity

import { Column, Entity } from 'typeorm';

@Entity()
export class CommodityEntity extends AbstractSharedEntity {
  @Column({ length: 500 })
  name: string;

  @Column({ length: 50 })
  icon: string;
}

The Controller

...
import { Paginate, PaginateQuery } from 'nestjs-paginate';
...


  async findAll(@Query() where: any, @Paginate() query: PaginateQuery) {
    return await this.commodityService.findAll(query);
  }

...

The Service

...
import { FilterOperator, FilterSuffix, PaginateQuery, paginate } from 'nestjs-paginate';
...


  public async findAll(query: PaginateQuery): Promise<any> {
    return paginate(query, this.commodityRepository.getRepository(), {
      sortableColumns: ['id', 'created_at'],
      nullSort: 'last',
      withDeleted: !!query?.filter?.deleted_at,
      searchableColumns: ['name'],
      select: ['name', 'icon', 'created_at', 'isActive', 'deleted_at'],
      filterableColumns: {
        name: [FilterOperator.CONTAINS, FilterOperator.EQ],
        isActive: [FilterOperator.EQ],
        deleted_at: [FilterSuffix.NOT, FilterOperator.NULL],
      },
    });
  }


...

Creating a Dynamic service for NestJS and mongoose

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Mon, 30 Oct 2023 13:14:21 +0000

Building a big application in NestJs require a lot of pieces of code to be repeated, so to make it DRY, i implemented in my business' a Dynamic service that help me create crud services easily.

This is the CRUD service

import { Model, Document, FilterQuery } from 'mongoose';
import { WhereDto } from '../dto/where.dto';
import { IResponseDto } from '../dto/response.dto';
import { MongoError } from 'typeorm';
import {
  ArgumentsHost,
  Catch,
  ExceptionFilter,
  InternalServerErrorException,
} from '@nestjs/common';

@Catch(MongoError)
export class CrudService<T extends Document> implements ExceptionFilter {
  catch(exception: typeof MongoError, host: ArgumentsHost) {}

  constructor(private model: Model<T>) {}

  PAGE: number = 0;
  PAGE_SIZE: number = 5;
  WHERE: WhereDto;

  /**
   * Find all records that match the given conditions.
   *
   * @param {WhereDto} where - The conditions to match.
   * @return {Promise<IResponseDto<T>>} A promise that resolves to the response DTO.
   */
  async findAll(where: WhereDto): Promise<IResponseDto<T>> {
    console.log(where);

    this.PAGE = where.page;
    this.WHERE = where;

    delete where.page;

    const objectsCount = await this.model.count(where);
    const pageCount = Math.ceil(objectsCount / this.PAGE_SIZE);

    const data = await this.model
      .find(where)
      .skip((this.PAGE - 1) * this.PAGE_SIZE)
      .limit(this.PAGE_SIZE);

    const pagination = {
      page: this.PAGE,
      pageSize: this.PAGE_SIZE,
      pageCount: pageCount,
      total: objectsCount,
    };

    return {
      data: data,
      meta: {
        pagination: pagination,
      },
    };
  }

  /**
   * Creates a new document in the database.
   *
   * @param {Partial<T>} data - The data to be used to create the document.
   * @return {Promise<T>} The newly created document.
   */
  async create(data: Partial<T>): Promise<T> {
    console.log('in create');

    try {
      const doc = new this.model(data);
      return doc.save();
    } catch (e) {
      throw new InternalServerErrorException(
        'Error occurred while fetching data from MongoDB.',
        e,
      );
    }
  }

  /**
   * Finds a single record by its id.
   *
   * @param {string} id - The id of the record to find.
   * @return {Promise<IResponseDto<T> | null>} A promise that resolves to the found record or null.
   */
  async findOne(id: string): Promise<IResponseDto<T> | null> {
    const result = await this.model.findById(id).exec();
    if (result) {
      // if we want to keep the result as find all as array
      const dataArray: T[] = [result]; // Convert the result to an array
      return {
        data: result,
        msg: 'SUCCESS',
      };
    } else {
      return {
        msg: 'SUCCESS',
      };
    }
  }
  /**
   * Updates a document in the database with the given id and data.
   *
   * @param {string} id - The id of the document to update.
   * @param {Partial<T>} data - The data to update the document with.
   * @return {Promise<T | null>} A promise that resolves to the updated document, or null if not found.
   */
  async update(id: string, data: Partial<T>): Promise<T | null> {
    return this.model.findByIdAndUpdate(id, data, { new: true }).exec();
  }

  /**
   * Removes a document from the model by its ID.
   *
   * @param {string} id - The ID of the document to remove.
   * @return {Promise<T | null>} A promise that resolves to the removed document,
   * or null if no document was found with the given ID.
   */
  async remove(id: string): Promise<T | null> {
    return this.model.findByIdAndRemove(id).exec();
  }
}

Lets say that there is a country crud and i want to implement it in my CountryService

import { Inject, Injectable } from '@nestjs/common';
import { CreateCountryDto } from './dto/create-country.dto';
import { UpdateCountryDto } from './dto/update-country.dto';
// import { Country } from './entities/country.entity';
import { Model } from 'mongoose';
import { CrudService } from 'src/tools/services/crud.service';
import { WhereDto } from 'src/tools/dto/where.dto';
import { IResponseDto } from 'src/tools/dto/response.dto';
import { Country } from './country.interface';

@Injectable()
export class CountryService {
  // constructor(@InjectModel(Country.name) private readonly countryModel: Model<Country>) {}

  constructor(
    @Inject('COUNTRY_MODEL')
    private countryModel: Model<Country>,
  ) {}

  private readonly crudService = new CrudService<Country>(this.countryModel);

  async create(data: Partial<Country>): Promise<Country> {
    return this.crudService.create(data);
  }

  async findOne(id: string): Promise<IResponseDto<Country>> {
    return this.crudService.findOne(id);
  }

  async update(id: string, data: Partial<Country>): Promise<Country | null> {
    return this.crudService.update(id, data);
  }

  async remove(id: string): Promise<Country | null> {
    return this.crudService.remove(id);
  }

  async findAll(where: WhereDto): Promise<IResponseDto<Country>> {
    return this.crudService.findAll(where);
  }
}

To make the CRUD service works perfectly and give a consistent results i add those interfaces

export interface IResponseDto<T> {
  readonly msg?: String;
  readonly data?: Array<T> | T;
  readonly meta?: IMeta;
}

export interface IMeta {
  pagination?: IPaginationResponse;
}

export interface IPaginationResponse {
  page?: number;
  pageSize?: number;
  pageCount?: number;
  total?: number;
}

An easy comparison between Arduino, STM32, Raspberry PI

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Mon, 19 Jun 2023 22:35:42 +0000

Arduino

Purpose: Arduino boards are primarily used for simple and standalone projects, especially in the field of electronics and physical computing.
Microcontroller: Arduino boards are based on microcontrollers, typically from the Atmel AVR family. These microcontrollers have lower processing power and limited capabilities compared to full-fledged microprocessors.
Programming Language: Arduino boards are programmed using the Arduino IDE, which is based on the C/C++ programming language. It provides a simplified and beginner-friendly programming environment.
I/O Pins: Arduino boards have a limited number of digital and analog input/output pins (e.g., Arduino Uno has 14 digital pins and 6 analog pins) for connecting sensors, actuators, and other external devices.
Real-time Capabilities: Arduino boards have real-time capabilities and can be used for tasks that require precise timing or control, such as robotics or automation.
Power Consumption: Arduino boards are designed to be power-efficient, making them suitable for low-power and battery-powered applications.

Feature	Arduino Uno	Arduino Nano	Arduino Mega	Arduino Due
Microcontroller	ATmega328P	ATmega328P	ATmega2560	AT91SAM3X8E
Operating Voltage	5V	5V	5V	3.3V
Digital I/O Pins	14	14	54	54
Analog Input Pins	6	8	16	12
Flash Memory	32KB	32KB	256KB	512KB
SRAM	2KB	2KB	8KB	96KB
Clock Speed	16MHz	16MHz	16MHz	84MHz
USB Interface	Yes (Type-B)	Yes (Mini USB)	Yes (Type-B)	Native USB
Size	Standard	Compact	Large	Large
Price	Affordable	Budget-friendly	Higher-end	Mid-range

STM32

Purpose: STM32 microcontrollers are commonly used in professional embedded systems and applications that require more processing power and advanced features.
Microcontroller: STM32 microcontrollers are based on the ARM Cortex-M family of microprocessors, offering higher performance and more advanced features compared to Arduino boards.
Programming Language: STM32 microcontrollers can be programmed using various development environments, including the STM32CubeIDE, Keil MDK, and PlatformIO. They support programming languages like C, C++, and assembly.
I/O Pins: STM32 microcontrollers offer a wide range of digital and analog input/output pins, providing more flexibility for connecting external devices and sensors.
Real-time Capabilities: STM32 microcontrollers often have built-in real-time operating systems (RTOS) support and advanced peripherals, making them suitable for real-time applications.
Power Consumption: Power consumption varies depending on the specific STM32 microcontroller, but they generally offer power-saving modes and features for efficient operation.

Feature	STM32F103C8T6	STM32F407VGT6	STM32F429ZIT6	STM32F030F4P6	STM32F767ZIT6
Microcontroller	ARM Cortex-M3	ARM Cortex-M4	ARM Cortex-M4	ARM Cortex-M0	ARM Cortex-M7
Operating Voltage	3.3V	3.3V	3.3V	3.3V	3.3V
Flash Memory	64KB	512KB	2MB	16KB	2MB
SRAM	20KB	192KB	256KB	4KB	512KB
Clock Speed	72MHz	168MHz	180MHz	48MHz	216MHz
Digital I/O Pins	37	82	168	16	144
Analog Input Pins	10	16	24	7	24
USB Interface	No	Yes (Full-Speed)	Yes (High-Speed)	Yes (Full-Speed)	Yes (High-Speed)
Size	Small	Medium	Medium/Large	Small	Large
Price	Affordable	Mid-range	Higher-end	Affordable	Higher-end

Raspberry

Purpose: Raspberry Pi is a single-board computer designed for a wide range of applications, including desktop computing, IoT projects, media centers, and more.
Processor: Raspberry Pi boards are powered by ARM-based processors, offering higher processing power and capabilities compared to microcontrollers.
Operating System: Raspberry Pi boards run various operating systems, including Linux-based distributions like Raspbian (now called Raspberry Pi OS) and Ubuntu, as well as other specialized operating systems.
Programming Languages: Raspberry Pi supports a wide range of programming languages, including Python, C/C++, Java, and more. It provides a full-fledged computing environment.
I/O Pins: Raspberry Pi boards have general-purpose input/output (GPIO) pins, allowing you to interface with external devices and sensors. The number of GPIO pins varies depending on the specific Raspberry Pi model.
Connectivity: Raspberry Pi boards offer built-in Ethernet, USB ports, Wi-Fi, Bluetooth, and HDMI output, enabling easy connectivity with peripherals and other devices.
Power Consumption: Raspberry Pi boards require a stable power supply, and the power consumption varies depending on the specific model and the peripherals connected.

Model	Raspberry Pi Zero W	Raspberry Pi 3 Model B+	Raspberry Pi 4 Model B
Processor	ARM11	Cortex-A53	Cortex-A72
CPU Speed	1 GHz	1.4 GHz	1.5 GHz
RAM	512MB	1GB	2GB, 4GB, 8GB
Wireless	Wi-Fi, Bluetooth	Wi-Fi, Bluetooth	Wi-Fi, Bluetooth
Ethernet	No	Yes	Yes
USB Ports	1	4	2
Video Output	Mini HDMI	HDMI	2x Micro HDMI
GPIO Pins	40	40	40
Storage	microSD	microSD	microSD
Power Supply	Micro USB	Micro USB	USB-C
Dimensions	65mm x 30mm	85mm x 56mm x 17mm	88mm x 58mm x 19.5mm
Price	Affordable	Mid-range	Mid-range/Higher-end

Plotting a circle in python with angles.

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Tue, 16 Aug 2022 15:49:32 +0000

I have got some hard time dealing with angles in space, and because i skipped all of my geometry class i had no idea how to imagine angles in a circle so i decided to find a way to plot them using python

First lets Import Modules



import matplotlib.pyplot as pl
from numpy import sin, cos, pi, linspacet

Adding a center point



plt.plot(0,0, color = 'red', marker = 'o')

Adding a circle



r = 1.5
angles = linspace(0 * pi, 2 * pi, 100) 
print(angles)
xs = cos(angles)
ys = sin(angles)


plt.plot(xs, ys, color = 'green')
plt.xlim(-r, r)
plt.ylim(-r, r)
plt.gca().set_aspect('equal')

Drawing diameter



plt.plot(r-0.5, 0, marker = 'P', color = 'blue')
plt.plot(-r+0.5, 0, marker = 'o', color = 'red')
plt.plot([r, -r], [0, 0], color = 'red')

A function to convert from Degree to Radian



def deg2rad(deg):
    return deg * pi / 180

Now lets draw two lines at 90° and 45°



plt.plot([0, r * cos(deg2rad(90))], [0, r * sin( deg2rad(90))], color = "red")
plt.plot([0, r * cos(deg2rad(45))], [0, r * sin( deg2rad(45))], color = "black")

Show the final result



plt.savefig('angles.png')

Hope that article would save some time.

How to make two Arduinos communicate over serial.

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Mon, 04 Apr 2022 13:04:08 +0000

As we all know, an Arduino can't handle too many sensors and calculate all of them without freaking out, so sometimes we need to out source a sensor to other Arduino and let it calculate a value and send it to us in the master.

Wiring

RX ===> TX
TX ===> RX
GND ===> GND

I needed to send data to the other Arduino, and make it calculate it and send it over to me in the master.

Master code

char number  = ' ';
String message = "";
bool send_data = true;
void setup()
{
  Serial.begin(9600);

}

void loop()
{

  while(send_data){

  Serial.println("Little bord Hi!! ");

   readData();
  delay(2000);
  if(message != ""){
      if(message == "2222"){
      send_data = false;

      Serial.println("Message received");
      Serial.println("******************");
      Serial.println(message);
      Serial.println("******************");
      }
  }
      message = "";

  }


}

void readData(){
  while(Serial.available()){

   if(Serial.available())
   {
      char number = Serial.read();
      message += number ;
   }
  }
}

Slave code

char number  = ' ';
String message = "";
bool is_not_sent = true; 
void setup() 
{
  pinMode(LED_BUILTIN, OUTPUT);
   Serial.begin(9600);
   Serial.println("START");
}


void loop()
{


 readData();
  delay(2000);
 if(is_not_sent)
  {
    if(message != ""){
      message = "Big bro said : " + message;
      // Serial.println(message);
      digitalWrite(LED_BUILTIN, HIGH); 
      delay(500);
      Serial.print(2222);
      delay(500);

      // Todo check wach correct data
      is_not_sent = false;
      message = "";
  }
  }
}



void readData(){
  while(Serial.available()){

   if(Serial.available())
   {
      char number = Serial.read();
      message += number ;
   }
  }
}

Global scope in Laravel, the easy way.

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Wed, 30 Mar 2022 20:18:28 +0000

Ever found your self repeating a query for a specific role, as an example.
Lets put a scenario where we actually need a global scope, we have an orders table, there is free orders and payed orders;

Clients can see only their orders.
Commercials can see orders of their clients.
Shipping and back-office can see all the orders.

First thing we create a scope lets call it App\Scopes\OrderScope.php

<?php

namespace App\Scopes;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;
use Auth;

class ComplaintScope implements Scope
{
    /**
     * Apply the scope to a given Eloquent query builder.
     * @param  \Illuminate\Database\Eloquent\Builder  $builder
     * @param  \Illuminate\Database\Eloquent\Model  $model
     * @return void
     */
    public function apply(Builder $builder, Model $model)
    {
        // builder is the query 
        if (Auth::user()->isClient()) {
            $builder->where('user_id', Auth::id());
        } elseif (Auth::user()->isCommercial()) {
            $builder->whereHas('user', function (Builder $query) {
                $query->where('commercial_id', Auth::user()->id);
            });
        }
    }
}

Then we use it in our model like that.

use App\Scopes\ComplaintScope;

//add that function to the model
    protected static function booted()
    {
        static::addGlobalScope(new ComplaintScope);
    }

I made a pretty logger for flutter

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Sat, 20 Nov 2021 01:15:20 +0000

A flutter package that developers have pretty logs instead just printing everything like a newbie.

Features

Makes it easy to log to console without using print in a colorful way, with multiple colors, and it works only in debug mode, makeing it perfect for pros.

Getting started

Installing

Add the following to your pubspec.yaml file:

dependencies:
  pretty_logger: any

Import the package.

import 'package:pretty_logger/pretty_PLog.dart';

Usage


void main() {
  PLog.info('Hello buddy');
  PLog.success('Welcome');
  PLog.warning('I am a bad man. Be careful');
  PLog.error('Ops. We ran into some trouble');

  PLog.black('black');
  PLog.red('red');
  PLog.white('white');
  PLog.cyan('cyan');
  PLog.green('green');
  PLog.yellow('yellow');

  runApp(const MyApp());
}

Pretty Logger on pub.dev

Pretty Logger on github

CRAO a CLI for creating react apps offline.

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Thu, 07 May 2020 13:13:20 +0000

We can make it offline

We all know the struggle, every time we need to create a new react app wi must start by typing this command

npm create-react-app my-app

Then the skeleton of our app get created automatically with no build configuration, the problem here is there is a lot of NPM packages to download.
If you are like me living in a country with a very slow network, the process of creating new react app can take a while.
On the other hand if you are using a metered connection this is also can be a bad thing.

As we all know, necessity is the mother of invention.
So i made this tool that could help a lot of react developers to create apps offline and very fast you can find it here in NPM or in GitHub

installation

The installation process is as easy as drinking water.

npm install -g create-react-app-offline

Now we don't need internet, lets create our first app.

crao -n <app-name>

for example :

crao -n my-app

It will create a directory called my-app inside the current folder.
Inside that directory, it will generate the initial project structure and install the transitive dependencies:

my-app
├── README.md
├── node_modules
├── package.json
├── .gitignore
├── public
│   ├── favicon.ico
│   ├── index.html
│   └── manifest.json
└── src
    ├── App.css
    ├── App.js
    ├── App.test.js
    ├── index.css
    ├── index.js
    ├── logo.svg
    └── serviceWorker.js
    └── setupTests.js

Let's help each other

You can visit the repo on github or follow me on twitter, and lets work together on making more open source projects.

Telegram bot made easy, a covid-19 statistics bot.

𝙹𝚒𝚋𝚛āʾī𝚕 ⚡ — Tue, 05 May 2020 21:33:38 +0000

Hello there, i've been struggling for days to make a telegram bot, and after i learn all the basics i've found that it was so easy to do, you can try it here @ElBaronBot .
So let's start making our bot.

Getting the API key from bot father

We start by communicating with bot father via this url @BotFather.
Send it /start
Then we send the new bot command /newbot
The bot father asks us for a name for our bot, that name should end with bot, and i'll name mine Elbaronbot, and send it to it.
Last step the @BotFather give us our Access token to control the bot.

Learning how to send and receive messages.

After getting the API key Lets start doing our favorite thing, which is coding.

Open CMD and type : npm init then give your project a name and a discripting.

Now les install the node telegram bot api via this command :

npm i node-telegram-bot-api

Create a new file lets call it index.js and add this line of code to the header for calling this telegram api library

var TelegramBot = require('node-telegram-bot-api');

Then lets make a connection to telegram, polling: true means that our script will keep fetching the telegram conversations for updates.

// Connecting to telegram
telegram = new TelegramBot("1*******:**************************************", {
    polling: true
});

Now lt's listen to new messages :

// Triggers when new message arrive
telegram.on("text", (message) => {
// Sending message to user.
telegram.sendMessage(message.chat.id, "Hi " + message.chat.first_name + " Its working");
}

Making the bot.

Now since we know how to receive and send messages lets make a covid-19 Bot that help us find covid statistica for every country around the world,

I want to trigger this action only when a user start the message with /covid then a country, like this /covid morocco or /covid usa then so some thing with the country name.

Let's make a function that get a country and scrap for data then send a message to the user.

function GetRes(country, telegram, chat_id) {
    let url = "https://api.coronastatistics.live/countries/" + country;
    let settings = {
        method: "Get"
    };
    fetch(url, settings).then(
        res => res.json()
    ).then((json) => {
        resStr = '
        \n Ressaults for : ' + json.country + '
        \n Total cases : ' + json.cases + '
        \n Total active : ' + json.active + '
        \n Total recovered : ' + json.recovered + '
        \n Total deaths : ' + json.deaths + '
        \n Today cases : ' + json.todayCases + '
        \n Today Deaths : ' + json.todayDeaths + '
        ';
            if (typeof json.country !== 'undefined' && json.country) {
                telegram.sendMessage(chat_id,resStr);
            } else {
                telegram.sendMessage(chat_id,"no such country...");
            }
        });
}

Now let's call the function when someone send us a message starting with /covid

var TelegramBot = require('node-telegram-bot-api');
// Connecting to telegram
telegram = new TelegramBot("1*******:**************************************", {
    polling: true
});
// Triggers when new message arrive
telegram.on("text", (message) => {
// Check if the message start with /covid
    if (message.text.toLowerCase().indexOf("/covid") === 0) {
        // remouve that /covid to get only the country 
        country = message.text.replace("/covid ", "");
        //give it to the function so it take care of the rest
        GetRes(country, telegram, message.chat.id);
    }
}

Conclusions

So this is was a basic telegram bot hope you like it you can try it here @ElBaronBot, leave me your messages, and you can follow me on twitter here 𝙹𝚒𝚋𝚛āʾī𝚕 ⚡