Forem: Jemarie Baldespiñosa

Mastering Custom Middlewares in Express.js: Enhancing Your Node.js Apps

Jemarie Baldespiñosa — Sat, 30 Sep 2023 02:44:03 +0000

Custom middlewares in Express.js allow you to add your own logic and functionality to the request-response cycle of your application. These middlewares are functions that can be executed before or after route handlers, and they can perform tasks such as authentication, authorization, logging, data validation, and more. Here's how to create and use custom middlewares in Express.js:

Creating a Custom Middleware:

To create a custom middleware, define a function that takes three arguments: req (the request object), res (the response object), and next (a function to call the next middleware in the chain). The next function is crucial because it allows the middleware to pass control to the next middleware or route handler in the chain.

Here's an example of a simple custom middleware that logs the current timestamp for every incoming request:

   function logTimestamp(req, res, next) {
     console.log(`Request received at ${new Date()}`);
     next(); // Call the next middleware or route handler
   }

Using the Custom Middleware:

To use the custom middleware, simply pass it as a function to app.use() or specify it for a specific route using app.use() or app.METHOD(). Here's how you can use the logTimestamp middleware:

   const express = require('express');
   const app = express();

   // Use the custom middleware for all routes
   app.use(logTimestamp);

   // Define your route handlers
   app.get('/', (req, res) => {
     res.send('Home Page');
   });

   app.listen(3000, () => {
     console.log('Server is running on port 3000');
   });

In this example, the logTimestamp middleware is used for all routes. It logs the timestamp before passing control to the route handler.

Order of Middleware Matters:

The order in which you use middlewares is important. Middlewares are executed in the order they are defined. Be mindful of the order to ensure that the middleware functions are called in the desired sequence.

Conditionally Using Middleware:

You can also conditionally use middleware based on specific routes or conditions. For example, you might want to apply authentication middleware only to certain routes. Use app.use() or app.METHOD() as needed to apply middleware selectively.

Custom middlewares in Express.js provide a flexible way to add functionality and logic to your application at various stages of the request-response cycle. You can create as many custom middlewares as needed to suit the requirements of your application.

*TRUE LEARNERS WOUDN'T QUIT *

"Embrace the journey of learning. Every step forward is a step toward greatness."
"Learning is the key that unlocks the doors to a world of possibilities."
"Challenge yourself to learn something new every day, and watch your potential unfold."
"In the world of knowledge, there are no shortcuts. Every lesson learned is a stepping stone to success."
"Don't be afraid to stumble. Every mistake is a lesson, and every lesson makes you stronger."
"Education is your passport to a brighter future. Invest in yourself and watch your dreams take flight."
"Learning is not a destination; it's a lifelong journey. Keep moving forward."
"The pursuit of knowledge is a noble endeavor. Let curiosity be your guide."
"Believe in your ability to learn, grow, and achieve. The sky is not the limit; it's just the beginning."
"Education is the foundation upon which you can build anything. Start today and build your dreams."

-Jemarie Baldespiñosa

Middleware: The Hidden Hero of Web Development

Jemarie Baldespiñosa — Thu, 28 Sep 2023 05:08:31 +0000

INTRODUCTION:
Middleware in web development refers to a set of functions or processes that are executed between receiving an HTTP request and sending an HTTP response in a web application. Middlewares act as intermediaries that can perform various tasks such as request processing, authentication, authorization, logging, error handling, and more. They are an integral part of many web frameworks and are used to enhance the functionality and security of web applications.

Here is an introduction to middlewares in web development:

Request-Response Flow:
- In a typical web application, a client (such as a web browser) sends an HTTP request to a server. The server processes the request and sends back an HTTP response. This flow involves multiple steps, and middlewares are executed at various stages of this process.
Middleware Chain:
- Middlewares are organized in a chain, where each middleware function in the chain has access to the request and response objects and can perform its specific task. The order in which middlewares are executed matters, as they can modify the request or response data.
Common Uses of Middlewares:
- Logging: Middleware can log incoming requests, including details like the request method, URL, headers, and timestamps. This is valuable for debugging and monitoring.

Authentication: Middleware can check whether a user is authenticated before allowing access to protected routes. It can validate user credentials, tokens, or session data.
Authorization: Middleware can verify whether the authenticated user has the necessary permissions to access certain resources or perform specific actions.
Validation: Middleware can validate incoming data, such as form submissions or API payloads, to ensure it meets certain criteria or constraints.
Error Handling: Middleware can catch and handle errors that occur during request processing. It can send appropriate error responses to the client.
CORS (Cross-Origin Resource Sharing): Middleware can handle CORS headers to control which domains are allowed to access resources on the server.
Compression: Middleware can compress response data to reduce bandwidth usage and improve page load times.
Session Management: Middleware can manage user sessions, maintaining user-specific data between requests.

Express.js and Middleware:
- In Node.js, the Express.js web framework is a popular choice for building web applications. Express makes extensive use of middlewares. You can use built-in middlewares or create custom ones to add functionality to your Express application.

For example, you can use the express.json() middleware to parse incoming JSON data, or you can use the express.static() middleware to serve static files like CSS, JavaScript, and images.

Custom Middlewares:
- Developers often create custom middlewares tailored to the specific needs of their applications. Custom middlewares can perform tasks such as data validation, authentication checks, or custom logging.
Middleware Execution Order:
- The order in which middlewares are added to the middleware chain matters. Middlewares are executed in the order they are defined. This can affect the behavior of your application, so it's important to carefully consider the order.

In summary, middlewares play a crucial role in web development by enabling developers to add functionality and logic to the request-response cycle of web applications. They provide a way to modularize and enhance the behavior of web servers, making it easier to implement features like authentication, authorization, and error handling while keeping the codebase clean and maintainable.__

"Why did the developer start using middlewares? Because they realized that even in the 'middle' of challenges, they could 'ware' their coding skills and conquer anything!" 😄🚀
-Jemarie B.

HTTP Request

Jemarie Baldespiñosa — Tue, 26 Sep 2023 05:44:30 +0000

An HTTP request is a message sent from a client (typically a web browser) to a web server, requesting a specific action to be performed or a resource to be retrieved. HTTP (Hypertext Transfer Protocol) is the foundation of data communication on the World Wide Web, and it defines a set of rules for how requests and responses should be formatted and handled.

HTTP requests consist of several key components:

HTTP Method (Verb): The method indicates the type of request being made and what action should be taken by the server. Common HTTP methods include:
- GET: Retrieve data from the server.
- POST: Send data to the server to create a new resource.
- PUT: Update an existing resource on the server.
- DELETE: Remove a resource from the server.
- And others like PATCH, HEAD, OPTIONS, etc.
Request URL (Uniform Resource Locator): The URL specifies the address of the resource the client wants to interact with. It includes the protocol (e.g., http:// or https://), domain name (e.g., example.com), path (e.g., /products/123), and optional query parameters (e.g., ?search=query).
HTTP Headers: Headers provide additional information about the request or the client making the request. Common headers include User-Agent (information about the client), Accept (the types of responses the client can handle), and Authorization (authentication credentials).
Request Body (Optional): For some HTTP methods like POST and PUT, a request may include a body containing data or content that the server should process or store. The format of the request body depends on the content type specified in the Content-Type header.

Here's an example of a simple HTTP request using the GET method:

GET /products/123 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8
Accept-Language: en-US,en;q=0.9

In this example, the client is requesting the resource located at /products/123 on the example.com server using the GET method. The request includes headers describing the client and the types of responses it can handle.

The server processes the request, performs the requested action (e.g., retrieving product details), and sends an HTTP response back to the client with the requested data or indicating the result of the action.

LET'S DIVE DEEPER

HTTP (Hypertext Transfer Protocol) requests are a fundamental part of web communication, and they come in various forms and are used for various purposes. Let's dive deeper into some essential concepts and components of HTTP requests:

HTTP Methods (HTTP Verbs):

GET: Used to request data from a specified resource. For example, when you open a web page in your browser, it sends a GET request to the server to retrieve the page's content.
POST: Used to send data to the server for processing. Commonly used when submitting forms or sending data to create a new resource on the server, like submitting a login form.
PUT: Used to update a resource or create it if it doesn't exist. It typically sends data to update an existing resource at the specified URL.
DELETE: Used to request the removal of a resource at the specified URL.
PATCH: Used to partially update a resource. It sends data to modify only specific parts of a resource, leaving the rest unchanged.
HEAD: Similar to GET, but it only requests the headers of the response, not the actual data. This is often used to check if a resource has changed since the last request.
OPTIONS: Used to retrieve information about the communication options available for a resource. It's commonly used to check which HTTP methods are allowed for a resource.

Request Headers:

HTTP request headers provide additional information about the request, such as:

User-Agent: Identifies the client making the request (e.g., the web browser or HTTP client).
Accept: Specifies the types of responses the client can handle (e.g., JSON, HTML).
Authorization: Provides authentication credentials if required.
Content-Type: Indicates the media type of the request body when sending data (e.g., application/json, text/html).

Request URL and Path:

The URL (Uniform Resource Locator) specifies the complete address of the resource being requested.
The path part of the URL indicates the location of the resource on the server. For example, in https://example.com/products/123, /products/123 is the path.

Request Body:

For HTTP methods like POST, PUT, and PATCH, a request can include a body that contains data to be processed by the server. The format and content of the body depend on the request's Content-Type header.

Query Parameters:

Query parameters can be included in the URL to provide additional information to the server. They are typically used for filtering, sorting, or customizing the response. For example, in https://example.com/search?q=keyword&page=1, q and page are query parameters.

Cookies and Sessions:

HTTP requests can include cookies, which are small pieces of data stored on the client's side and sent with each request. Cookies are often used for session management and tracking user interactions.

Status Codes and Responses:

After processing an HTTP request, the server sends an HTTP response back to the client. The response includes a status code (e.g., 200 OK, 404 Not Found) that indicates the result of the request.

HTTP requests and responses are essential for client-server communication on the web, enabling the retrieval of web pages, API interactions, and much more. Understanding these components is crucial for web developers working with web applications and services.

Binary Newbie Coder's Dreams

Jemarie Baldespiñosa — Wed, 20 Sep 2023 09:04:12 +0000

THIS SONG WILL CELEBRATE THE WORLD OF CODING, THE PASSION OF CODERS AND THE JOURNEY OF TURNING INDEAS INTO SOFTWARE:)

(Verse 1)
In the world of code, we craft our dreams,
Lines of logic, like flowing streams.
From "Hello, World!" to the grandest scheme,
We're the architects of the digital scene.
(Chorus)
We're coding through the night and day,
Debugging errors that come our way.
In binary and bytes, we find our play,
In this coder's world, we're here to stay.
(Verse 2)
Syntax errors, they test our might,
But we're not giving up without a fight.
With every bug, we gain insight,
Coding's a journey, not just a flight.
(Chorus)
We're coding through the night and day,
Debugging errors that come our way.
In binary and bytes, we find our play,
In this coder's world, we're here to stay.
(Bridge)
From Python's grace to JavaScript's
thrill, We bend the languages to our will.
We're the creators, with skills to fill,
The digital canvas, with code we instill.
(Chorus)
We're coding through the night and day,
Debugging errors that come our way.
In binary and bytes, we find our play,
In this coder's world, we're here to stay.
(Outro)
So here's to the coders, the ones who dare,
To transform ideas into software.
In the realm of code, we're a special pair,
Building the future, with lines that care.

--------------------------------------------...
Thank you so much, I hope you enjoy it!
ORIGINAL LYRICS||ORIGINAL LYRICS
-Jemarie Baldespiñosa

"Step-by-Step Guide to Building an Express server in Node.js"

Jemarie Baldespiñosa — Wed, 20 Sep 2023 07:59:20 +0000

Creating your first Node.js + Express server is a great project to start with! Here's a step-by-step guide to help you get started:

Step 1: Set Up Your Development Environment
Before you begin, make sure you have Node.js and npm (Node Package Manager) installed on your computer. You can download and install them from the official Node.js website: https://nodejs.org/

Step 2: Create a Project Directory
Create a new directory for your project. You can do this using your computer's file explorer or by running the following command in your terminal:

mkdir my-express-server
cd my-express-server

Step 3: Initialize a Node.js Project
Inside your project directory, initialize a new Node.js project by running:

npm init -y

This will create a package.json file that will store information about your project.

Step 4: Install Express
Now, let's install Express as a dependency for your project. In your terminal, run:

npm install express --save

Step 5: Create Your Server File
Create a JavaScript file for your Express server. You can name it server.js or something similar. In this file, you'll write the code for your server.

Step 6: Write Your Express Server Code
Here's a basic example of an Express server in server.js:

const express = require('express');
const app = express();
const port = 3000;

// Define a route
app.get('/', (req, res) => {
  res.send('Hello, Express World!');
});

// Start the server
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

This code creates an Express server that listens on port 3000 and responds with "Hello, Express World!" when you access the root URL.

Step 7: Start Your Express Server
In your terminal, navigate to your project directory and run your server:

node server.js

You should see the message "Server is running on http://localhost:3000" in your terminal.

Step 8: Test Your Server
Open a web browser or use a tool like Postman to visit http://localhost:3000 in your browser. You should see the "Hello, Express World!" message.
-------------------------------------------------...
Congratulations! You've created your first Node.js + Express server. From here, you can continue to build and expand your server by adding more routes, middleware, and functionality to suit your project's needs.

STARTING YOUR JOURNEY: NODE.JS AND EXPRESS SERVERE CREATION -Jemarie Baldespiñosa