Forem: Kater Akeren

Getting started with NestJs

Kater Akeren — Sat, 18 Feb 2023 01:45:56 +0000

NestJS is a powerful and feature-rich framework for building web applications and APIs using TypeScript. It is built on top of the popular Express.js framework and is heavily influenced by Angular, making it a great choice for developers who are already familiar with Angular.

Before getting started with NestJS, it's important to have a basic understanding of TypeScript, Node.js, and Express.js. Once you have that, you can start building your first NestJS application.

Installing NestJS: You can install NestJS by running the following command in your terminal:

npm install -g @nestjs/cli

Creating a new project: Once you have the NestJS CLI installed, you can create a new project by running the following command:

nest new project-name

Setting up the project structure: NestJS uses a modular structure, which makes it easy to organize and maintain your code. The main components of a NestJS project include controllers, services, and modules.
Creating a controller: Controllers handle incoming requests and send responses. In NestJS, controllers are decorated with the @Controller() decorator. To create a controller, you can use the following command:

nest generate controller name-of-controller

Creating a service: Services handle the business logic of your application. They are responsible for performing tasks such as data validation, database operations, and API calls. To create a service, you can use the following command:

nest generate service name-of-service

Creating a module: Modules are used to group related controllers and services together. To create a module, you can use the following command:

nest generate module name-of-module

Starting the server: Once you have set up your project structure, you can start the server by running the following command:

nest start

Testing your application: NestJS provides a powerful testing framework that makes it easy to test your controllers, services, and other components. You can use the following command to run your tests:

nest test

In conclusion, NestJS is a powerful and feature-rich framework for building web applications and APIs using TypeScript. With its modular structure, it makes it easy to organize and maintain your code. And with its built-in support for testing, it makes it easy to ensure your code is working as expected.

A step-by-step guide to installing Node.js on Ubuntu

Kater Akeren — Tue, 29 Dec 2020 01:48:00 +0000

Introduction

JavaScript server side programming is supported by Node.js. It's constructed using the JavaScript V8 engine from Google Chrome. It enables programmers to make swift, greatly scalable, and data-intensive applications.

The installation of nodejs on Ubuntu 20.04 and later is demonstrated in this guide. To install particular versions of the nodejs, we will install it using the apt PPA software repository.

Using apt and the NodeSource PPA to install node.js

A personal package archive (PPA), which is actively handled and maintained by NodeSource, can be used to upgrade or install a new type of nodejs version. Nodejs versions are accessible in a wider variety on the PPA than in the official Ubuntu repositories. There are nodejs versions 12, 13, 14, 15, 16, and 18 available. Take a look at the NodeSource documentation for more information.

Installing the PPA will let you to access and use its packages, so let's do that first. Use curl to get the installation script for your choice version from your home directory, being sure to replace 16.x with your chosen version string. Any software should be installed in LTS versions.

$ cd ~
$ curl -sL https://deb.nodesource.com/setup_16.x -o nodesource_setup.sh

The PPA will be added to your configuration and local package cache after you take the aforementioned action. You'll now have the freedom to install the nodejs package because it will be updated automatically:

$ sudo apt install nodejs

Run node with the -v version flag to ensure that nodejs is properly installed:

$ node -v

Output

v16.16.0

Npm does not need to be installed individually because it is included in the NodeSource nodejs package together with the node binary.

With apt and the NodeSource PPA, you have successfully installed nodejs and npm.

HTTP Response Status Codes

Kater Akeren — Sat, 03 Oct 2020 13:01:00 +0000

Overview

Without a library that provides you with all the HTTP status codes in a single box, creating APIs has never been simple. Because of this, I developed an appealing, adaptable, and abstracted package that includes all HTTP API status response codes that are listed in Request for Comments (RFC).

Usage


const express = require('express');
const { Response } = require('http-status-codez');
const User = require('./models/user');

const app = express();

app.get('/api/v1/users', catchAsync(async (req, res, next) => {
  const users = await User.find();

  res.status(Response.HTTP_OK).json({
    status: 'success',
    results: users.length,
    data: {
      users,
    },
  });

}));

app.get('/api/v1/users/:id', catchAsync(async (req, res, next) => {
  const user = await User.findById(req.params.id);

  if (!user) {
    return next(
      new AppError('User not found with that ID', Response.HTTP_NOT_FOUND);
    );
  }

  res.status(Response.HTTP_OK).json({
    status: 'success',
    data: {
      user,
    },
  });

Implementation Description

Code	Instance Properties	Phrase
100	HTTP_CONTINUE	Continue
101	HTTP_SWITCHING_PROTOCOLS	Switching Protocols
102	HTTP_PROCESSING	Processing
103	HTTP_EARLY_HINTS	Early Hints
200	HTTP_OK	OK
201	HTTP_CREATED	Created
202	HTTP_ACCEPTED	Accepted
203	HTTP_NON_AUTHORITATIVE_INFORMATION	Non Authoritative Information
204	HTTP_NO_CONTENT	No Content
205	HTTP_RESET_CONTENT	Reset Content
206	HTTP_PARTIAL_CONTENT	Partial Content
207	HTTP_MULTI_STATUS	Multi-Status
208	HTTP_ALREADY_REPORTED	Already Reported
226	HTTP_IM_USED	IM Used
300	HTTP_MULTIPLE_CHOICES	Multiple Choices
301	HTTP_MOVED_PERMANENTLY	Moved Permanently
302	HTTP_FOUND	Found
303	HTTP_SEE_OTHER	See Other
304	HTTP_NOT_MODIFIED	Not Modified
305	HTTP_USE_PROXY	Use Proxy
306	HTTP_RESERVED	Reserved
307	HTTP_TEMPORARY_REDIRECT	Temporary Redirect
308	HTTP_PERMANENTLY_REDIRECT	Permanent Redirect
400	HTTP_BAD_REQUEST	Bad Request
401	HTTP_UNAUTHORIZED	Unauthorized
402	HTTP_PAYMENT_REQUIRED	Payment Required
403	HTTP_FORBIDDEN	Forbidden
404	HTTP_NOT_FOUND	Not Found
405	HTTP_METHOD_NOT_ALLOWED	Method Not Allowed
406	HTTP_NOT_ACCEPTABLE	Not Acceptable
407	HTTP_PROXY_AUTHENTICATION_REQUIRED	Proxy Authentication Required
408	HTTP_REQUEST_TIMEOUT	Request Timeout
409	HTTP_CONFLICT	Conflict
410	HTTP_GONE	Gone
411	HTTP_LENGTH_REQUIRE	Length Required
412	HTTP_PRECONDITION_FAILED	Precondition Failed
413	HTTP_REQUEST_ENTITY_TOO_LARGE	Request Entity Too Large
414	HTTP_REQUEST_URI_TOO_LONG	Request-URI Too Long
415	HTTP_UNSUPPORTED_MEDIA_TYPE	Unsupported Media Type
416	HTTP_REQUESTED_RANGE_NOT_SATISFIABLE	Requested Range Not Satisfiable
417	HTTP_EXPECTATION_FAILED	Expectation Failed
418	HTTP_I_AM_A_TEAPOT	I'm a teapot
419	HTTP_INSUFFICIENT_SPACE_ON_RESOURCE	Insufficient Space on Resource
420	HTTP_METHOD_FAILURE	Method Failure
421	HTTP_MISDIRECTED_REQUEST	Misdirected Request
422	HTTP_UNPROCESSABLE_ENTITY	Unprocessable Entity
423	HTTP_LOCKED	Locked
424	HTTP_FAILED_DEPENDENCY	Failed Dependency
425	HTTP_TOO_EARLY	Too Early
426	HTTP_UPGRADE_REQUIRED	Upgrade Required
428	HTTP_PRECONDITION_REQUIRED	Precondition Required
429	HTTP_TOO_MANY_REQUESTS	Too Many Requests
431	HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE	Request Header Fields Too Large
451	HTTP_UNAVAILABLE_FOR_LEGAL_REASONS	Unavailable For Legal Reasons
500	HTTP_INTERNAL_SERVER_ERROR	Internal Server Error
501	HTTP_NOT_IMPLEMENTED	Not Implemented
502	HTTP_BAD_GATEWAY	Bad Gateway
503	HTTP_SERVICE_UNAVAILABLE	Service Unavailable
504	HTTP_GATEWAY_TIMEOUT	Gateway Timeout
505	HTTP_VERSION_NOT_SUPPORTED	HTTP Version Not Supported
506	HTTP_VARIANT_ALSO_NEGOTIATES_EXPERIMENTAL	Variant Also Negotiates
507	HTTP_INSUFFICIENT_STORAGE	Insufficient Storage
508	HTTP_LOOP_DETECTED	Loop Detecte
5010	HTTP_NOT_EXTENDED	Not Extended
511	HTTP_NETWORK_AUTHENTICATION_REQUIRED	Network Authentication Required

What you need to know about Node.js

Kater Akeren — Tue, 25 Aug 2020 14:12:00 +0000

What is Node.js?

Node.JS is a concept for executing JavaScript on the server.
Ryan Dahl, the original creator of Node.js, who has recently released another ground-breaking technology called Deno.
Node.js is a cross-platform, open-source JavaScript run-time that is based on the V8 JavaScript engine found in Google Chrome.
A non-blocking, single-threaded, event-driven I/O model
NPM packages are used in the development of Node.js.
It has shown to be the greatest tool for creating data-intensive, quickly scalable, and network applications.

The underlying architecture of Node.js

Node.js's foundational components include JavaScript, V8, libuv, C++, and JavaScript. As Node developers, the five characteristics provide a greater degree of abstraction that greatly facilitates our work.

V8 Engine
- Without it, Node.js would not have been able to understand the JavaScript programs we create.
- It is in charge of converting Node.js code into machine code that the computer can comprehend and properly execute.
Libuv
- Asynchronous I/O (Input/Output) is a key focus of this open-source software.-
- Node.js has access to operating systems, file systems, networking, and other systems thanks to this layer.
- It implements the two Node.js functionalities that are most crucial:
- Event Loop: this is in charge of carrying out basic operations like Callbacks, Network IO, and others.
- Thread Pool: In charge of heavier tasks like file access, compression, and other things.
The V8 and Libuv are both built in C++, and the V8 also includes some JavaScript code in its library. In other words, JavaScript and C++ were used to create the language node.js

Apply Node.js to:

Streaming of data
API with database integration (preferably NoSQL Databases)
A real-time chat program
Server-side web applications
Hardware programming

Avoid using Node.js for:

Programs that use a lot of server-side processing (High CPU Intensive usage)

Install Node.js now.

Go to Node.JS
Pick the version that is compatible with your OS. Because they are stable, LTS (Long Term Support) versions are strongly suggested.
Download and set it up.
Keep in mind to read and follow each stage's appropriate instruction.

Checking to see whether Node.js is installed properly

Open a terminal window or CLI (Command Line Interface) and enter the following command:

    node -v or node --version

love and best wishes ❤️...

A complete guide to writing React Applications: A Step-by-step tutorial guide

Kater Akeren — Fri, 24 Jul 2020 03:54:00 +0000

Introduction

A simple open-source JavaScript package called React is used to create interactive user interfaces. This fantastic effort can serve as an ideal foundation for the creation of single-page or mobile applications. It is kept up-to-date by Facebook Inc., a network of independent developers, and businesses around the world. This post will teach you how to write pure React code and then show you how to use one of its beautiful tools, Parcel❤️

Layers of React Abstraction (Libraries)

When creating a reactively based application, React primarily offers us two layers of abstraction.

The first layer is an interface that makes React available to us and demonstrates how to use it efficiently. All methods used come from this library, with the exception of one: rendering oneself to the DOM.
The second library is the rendering layer, which uses the React DOM extensively to render content to the browser.

The two aforementioned libraries form the foundation for creating a React-based application, while there are many additional React libraries as well, such as A-Frame React, React Native, React 360, React Blessed, and others.

Let's set up a workspace

Firstly, create your project 📂 directory. Mine is going to be called todo-app 📁 since we're going to be building a task manager app. Create an index.html 📄 and put it into a src/ 📁 directory inside of the created project folder (todo-app 📂). Open the working directory with any text editor.

Let's write Pure React

Let’s write pure React. No Webpack or parcel, JSX, and Babel; just some cool JavaScript on the page with its two layers of abstracted libraries. Open the index.html 📄 and put:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Todo App</title>
</head>
<body>
    <div id="root-container">Hello, React!</div>
    <!-- Load React. -->
    <!-- Note: when deploying, replace "development.js" with "production.min.js". -->
    <script src="https://unpkg.com/react@16/umd/react.development.js" crossorigin></script>
    <script src="https://unpkg.com/react-dom@16/umd/react-dom.development.js" crossorigin></script>

    <!-- Our pure React goes below -->
    <script >

    </script>
</body>
</html>

Let's create a component

Now, in the last script tag let's create a component called, App. React is all about creating components, and then taking those components and making more components out of those components created.

const getElement = (name) => {
    return document.querySelector(name);
}
const App  = () => {
    return React.createElement(
        'div',
        {},
        React.createElement('h1', {}, 'Todo App')
    );
}
ReactDOM.render(React.createElement(App), getElement('#root-container'));

The first thing we do is to create a reusable function to get elements from the DOM; it will help us extensively throughout our development process.
Secondly, we create our own component, App
There are two types of components, function components, and class components. The component we'd create is a functional component.
A function component must at all-time return a markup (which is what React.createElement generates)
React.createElement creates one instance of some components. If you pass it a string, it will create a DOM tag with that as the string. We used div and h1, those tags are output to the DOM
The second empty object (you can put null too) is attributes we're passing to the tag or component. Whatever we put in this will be output to the element (like id or style.)
ReactDOM.render is what takes our rendered App component and puts in the DOM (in our case we're putting it in the root-container element)

Let's separate the script out of the index.html 📄

Let's separate the script tag on the DOM to its own script file. We will do that by making a new file in your src/ 📂 directory called App.js and cut and paste your code into it. In addition, we will modify the code by creating another component called User. Remember to point the path of App.js in the index.html file.

const getElement = (name) => {
  return document.querySelector(name);
};

const User = () => {
  return React.createElement("div", {}, [
    React.createElement("h2", {}, "Kater"),
    React.createElement("h3", {}, "kater@dev.com"),
    React.createElement("h4", {}, "user")
  ]);
};

const App = () => {
  return React.createElement(
    "div",
    {},
    React.createElement("h1", {}, "Todo App - Users"),
    React.createElement(User),
    React.createElement(User)
  );
};

ReactDOM.render(React.createElement(App), getElement("#root-container"));

To make an element have multiple children, just pass it an array of elements.
We created a second new component, the User component. This component represents a user. When you have distinct ideas represented as markup, that's a good idea to separate it into a component as we did above.
Since we have a new User component, we can use it multiple times! We just use multiple calls to React.createElement in the App component.
Okay so we can have multiple users but it's not a useful component yet since not all users have the username, email, and role. Let's make the component more meaningful.

const getElement = (name) => {
  return document.querySelector(name);
};

const User = (props) => {
  return React.createElement("div", {}, [
    React.createElement("h2", {}, props.username),
    React.createElement("h3", {}, props.name),
    React.createElement("h4", {}, props.email),
    React.createElement("h5", {}, props.role)
  ]);
};

const App = () => {
  return React.createElement(
    "div",
    {},
    React.createElement("h1", {}, "Todo App - Users"),
    React.createElement(User, {
      username: "kater",
      name: "Kater Akeren",
      email: "kater@dev.to",
      role: "Software Engineer"
    }),
    React.createElement(User, {
      username: "fabs",
      name: "Fabian Aondo",
      email: "fabian@valuebeam.com",
      role: "CTO"
    }),
    React.createElement(User, {
      username: "juliet-faith",
      name: "Juliet-Faith Idoko",
      email: "juliet-faith@lunetsoft.com",
      role: "UI Designer"
    })
  );
};

ReactDOM.render(React.createElement(App), getElement("#root-container"));

We have a more reusable and flexible component that accepts props from its parent. Props are variables that a parent (App) passes to its children (the instances of User.) Now each user can be different! Now that is far more useful than it was since each instance of the User component can represent not just Kater, but any User. This is the most profound power of React! We can make multiple, reusable components. We can then use these components to build larger components, which in turn make up yet-larger components. This is how React apps are made profoundly.
We can destruct the props and make it look:

const getElement = (name) => {
  return document.querySelector(name);
};

const User = ({ username, name, email, role }) => {
  return React.createElement("div", {}, [
    React.createElement("h2", {}, username),
    React.createElement("h3", {}, name),
    React.createElement("h4", {}, email),
    React.createElement("h5", {}, role)
  ]);
};

const App = () => {
  return React.createElement(
    "div",
    {},
    React.createElement("h1", {}, "Todo App - Users"),
    React.createElement(User, {
      username: "kater",
      name: "Kater Akeren",
      email: "kater@dev.to",
      role: "Software Engineer"
    }),
    React.createElement(User, {
      username: "fabs",
      name: "Fabian Aondo",
      email: "fabian@valuebeam.com",
      role: "CTO"
    }),
    React.createElement(User, {
      username: "juliet-faith",
      name: "Juliet-Faith Idoko",
      email: "juliet-faith@lunetsoft.com",
      role: "UI Designer"
    })
  );
};

ReactDOM.render(React.createElement(App), getElement("#root-container"));

Parcel

The parcel is a modern web application bundler, differentiated by its developer experience. It offers blazing-fast performance utilizing multicore processing and requires zero configuration. Already our React app has two components in one file: App and User. It'd be better if these were in separate files so it'd be easier to keep track of what was where. This is where Parcel can help us profoundly. We will install parcel as a dev-dependence, but it can be installed globally. if you want to check it up: 👉 Getting started with Parcel.

First, let's initialize the npm registry package.json file by simply typing the command below in the root terminal of your working directory; for it to keep track of the npm packages we will be installing.
install parcel:
Now inside of our package.json we will configure parcel below in the script section:

"scripts" {
  "dev": "parcel src/index.html"
}

Start the parcel server:

React and ReactDOM dependencies

Lastly, before we do a complete refactoring; let's fix the React and ReactDOM dependencies. Right now these are coming from unpkg.com. Unpkg isn't meant to serve production traffic. We install both libraries from the npm registry. Remove completely the Unpkg libraries from the index.html

Complete Refactoring

import to the top of App.js the two installed libraries and the User component

import React from "react";
import {render} from "react-dom";
import { User } from "./User";

const getElement = (name) => {
  return document.querySelector(name);
};

const App = () => {
  return React.createElement(
    "div",
    {},
    React.createElement("h1", {}, "Todo App - Users"),
    React.createElement(User, {
      username: "kater",
      name: "Kater Akeren",
      email: "kater@dev.to",
      role: "Software Engineer"
    }),
    React.createElement(User, {
      username: "fabs",
      name: "Fabian Aondo",
      email: "fabian@valuebeam.com",
      role: "CTO"
    }),
    React.createElement(User, {
      username: "juliet-faith",
      name: "Juliet-Faith Idoko",
      email: "juliet-faith@lunetsoft.com",
      role: "UI Designer"
    })
  );
};

render(React.createElement(App), getElement("#root-container"));

Create a new file called User.js cut the User component in the App.js and past it to the newly created User.js:

import React from "react";
export const User = ({ username, name, email, role }) => {
  return React.createElement("div", {}, [
    React.createElement("h2", {}, username),
    React.createElement("h3", {}, name),
    React.createElement("h4", {}, email),
    React.createElement("h5", {}, role)
  ]);
};

Conclusion

I thank you for traveling with me up to this point in my journey, we have successfully learnt and unearthed React technology's fundamentals, starting from an abstract perspective and ended with its sleek, lightning-quick speed employing multicore processing, and needs no configuration. Regards and ❤️

References

Data sanitization against NoSQL query injection in MongoDB and Node.js application

Kater Akeren — Wed, 22 Jul 2020 00:02:00 +0000

Introduction

Any software application that accepts user input data has a cancer at its core called injection attacks. As a result of inadequate input sanitation of data before sending it to the database, this risky vulnerability appears in a range of different applications. The NoSQL paradigm is not an exception. The consequent effect of such an act permits or makes room for a variety of databases to be subject to injection attacks, the most hazardous type of software fault.

Any developer must safeguard against injection attacks in order to stop hostile actors from accessing and changing sensitive data, such as passwords, usernames, email addresses, authentication tokens, and other data.

What is a NoSQL database?

Literature claims that the term NoSQL, which stands for "Not Only SQL," was first used in 1998. NoSQL is a cutting-edge database design that supports a wide range of data formats and offers excellent backend support for big data applications.

According to Dr. Patrick Obilikwu in his lecture note on Database Management Systems II, NoSQL databases are characterized by horizontal scalability, schema-free data models, simple cloud deployment, and are built on the scale-out architecture and fault tolerance. The emergence and subsequent exponential expansion of big data applications is the driving force behind a wide range of paradigms, not just the SQL paradigm.

NoSQL databases are highly appropriate for:

Big Data capability
Fast performance
Easy replication
High scalability
High availability

NoSQL injection

Since NoSQL databases like MongoDB still run queries based on user input data, they are still susceptible to injection attacks if the input data is not properly sanitized. The syntax is the primary distinction between SQL and NoSQL injection attacks.

Let's pretend that a NoSQL query injection will let us to enter into the application with a given password even though we don't know the user's username. Since the request content is encoded as JSON, we will enter the simulated injection query as our username rather than supplying a valid username. -

{
  "username": {"$gt":""},
  "password": "$#@Call4Code"
}

The aforementioned code snippet illustrated how NoSQL injection queries can be used to attack an application built with MongoDB as the database backend support and Node.JS. You'll be surprised to learn that the code above will work because the query is always evaluating to true.

Protecting against the NoSQL injection

Using the npm package named express-mongo-sanitize we can easily defend ourselves against this harmful attack. It significantly aids in mitigating and preventing this harmful malicious attack on our database.

Installation

npm install express-mongo-sanitize

Usage

const express = require('express');
const mongoSanitize = require('express-mongo-sanitize');

const app = express();

/*
** IMPORT ROUTES
*/
const userRouter = require('./api/routes/userRoutes');
const postRouter = require('./api/routes/postRoutes');

/*
** GLOBAL MIDDLEWARES
*/
app.use(express.json());
// Data sanitization against NoSQL query injection
app.use(mongoSanitize()); 

/*
** ROUTES
*/
app.use('/api/v1/users', userRouter);
app.use('/api/v1/posts', postRouter);

/*
** HANDLING UNHANDLED ROUTES
*/
app.all('*', (req, res, next) => {
    next(new AppError(`Can't find ${req.originalUrl} on this Server!`, 404));
});

/*
** GLOBAL ERROR
*/
app.use(globalErrorHandler);

module.exports = app;

When we look at the request body, request parameters, and request query strings to remove the dollar ($) signs and dots (.) accordingly before performing the queries, the mongoSanitize function, which we have called, produces a middleware function that we can utilize to avoid the attack.

Task-Manager RESTFul API: Demystifying Abstract concepts in Node.js and MongoDB

Kater Akeren — Tue, 21 Apr 2020 03:39:17 +0000

What is Node.JS?

Node.JS is a JavaScript runtime built on Chrome's V8 JavaScript engine. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient to build fast, adaptive, and network applications.

What is an API?

Application Programming Interface is a piece of software that can be used by another piece of software, in order to allow applications to talk to each other with a set of defined rules.
REST decides how the API looks like. It stands for “Representational State Transfer”

Program Overview

It is a task manager application built using NODE JS and MongoDB. It follows a RESTFul API design architecture. The app sends an email notification upon registration and deactivation of the user's account. It's richly built with a simple scientific technique and best practices in the world of API design.

Features

Sending Emails
Authentication and Security
Sorting, Pagination, and Filtering
Avatar upload

Hosted Domain Link

Task Manager API

Postman Collection Link

Task Manager API Shared Postman documentation

Github Repository

Task Manager API

Building an Asynchronous Weather Application with the core of Node.JS

Kater Akeren — Sun, 22 Mar 2020 16:08:12 +0000

What is Node.JS?

Node.JS is a JavaScript runtime built on Chrome's V8 JavaScript engine. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient to build fast, adaptive, and network applications.

Asynchronous

It is a simple workable technique to perform long network requests without blocking the main thread. This makes use of callbacks, promises, and async/await to achieve asynchronously.

Overview

The program consists of only two functions (forecast and geocode) in the utils directory and an entry point to the application called app.js. The user is required to provide a location name that is converted behind the scene to coordinates pairs (Longitude and Latitude) that are then passed to the forecast function to display the current location weather with a report briefly.

Features

Forcast using the Darksky API
Geocoding using the Mapbox API
Inputs from Command Line Interface (CLI)

Github Repository

Weather App

Result Screenshot

Validation Error Message

Code snippets

Critical Examination of filter() Array Method in JavaScript

Kater Akeren — Mon, 13 Jan 2020 00:14:41 +0000

filter() calls a provided callback function once for each element in an array and constructs a new array of all the values for which callback returns a value that coerces to true. In other words filter() creates a new array under a given condition from an existing array.

The Syntax

Example using an array of integers

Filtering an Array of Objects

The very common use case of filter() is with an array of objects through their properties

Forem: Kater Akeren

Getting started with NestJs

A step-by-step guide to installing Node.js on Ubuntu

Introduction

Using apt and the NodeSource PPA to install node.js

HTTP Response Status Codes

Overview

Usage

Implementation Description

Links

What you need to know about Node.js

What is Node.js?

The underlying architecture of Node.js

Apply Node.js to:

Avoid using Node.js for:

Install Node.js now.

Checking to see whether Node.js is installed properly

A complete guide to writing React Applications: A Step-by-step tutorial guide

Introduction

Layers of React Abstraction (Libraries)

Let's set up a workspace

Let's write Pure React

Let's create a component

Let's separate the script out of the index.html 📄

Parcel

React and ReactDOM dependencies

Complete Refactoring

Conclusion

References

Data sanitization against NoSQL query injection in MongoDB and Node.js application

Introduction

What is a NoSQL database?

NoSQL injection

Protecting against the NoSQL injection

Installation

Usage

Task-Manager RESTFul API: Demystifying Abstract concepts in Node.js and MongoDB

What is Node.JS?

What is an API?

Program Overview

Features

Hosted Domain Link

Postman Collection Link

Github Repository

Further Reading

Building an Asynchronous Weather Application with the core of Node.JS

What is Node.JS?

Asynchronous

Overview

Features

Github Repository

Result Screenshot

Validation Error Message

Code snippets

Critical Examination of filter() Array Method in JavaScript

The Syntax

Example using an array of integers

Filtering an Array of Objects