Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/bigabdoul/fasthttp
An alternative, light-weight express-like library based on Node's http module.
https://github.com/bigabdoul/fasthttp
Last synced: 5 days ago
JSON representation
An alternative, light-weight express-like library based on Node's http module.
- Host: GitHub
- URL: https://github.com/bigabdoul/fasthttp
- Owner: bigabdoul
- Created: 2020-01-24T22:59:29.000Z (almost 5 years ago)
- Default Branch: master
- Last Pushed: 2023-01-06T15:01:14.000Z (about 2 years ago)
- Last Synced: 2023-03-10T18:52:54.436Z (almost 2 years ago)
- Language: JavaScript
- Size: 902 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 12
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Djoola Fast HTTP
`djoola-fasthttp` is an alternative, light-weight express-like library based on Node's http module. This is an early attempt towards building a fast, reliable, simple yet powerful HTTP library.
```JavaScript
const fasthttp = require("djoola-fasthttp");
const app = fasthttp();
app.get("/", (req, res) => {
const time = new Date().toLocaleTimeString();
res.send(`Welcome on Fast Http Server v0.1!\nLocal time: ${time}`);
});
const port = process.env.PORT || 3000;
app.server.listen(port);
console.log(`Listening on http://localhost:${port}...`);
```
## Installation
This is a Node.js module available through the npm registry.
Before installing, download and install Node.js. It was built with Node.js v12.14.1 but earlier versions might be able to run it.
Installation is done using the npm install command:
```
$ npm install djoola-fasthttp
```
## Features
- Robust routing using path-to-regexp.
- Focus on high performance
- HTTP helpers (redirection, caching, etc)
- Many more to come
## Quick Start
Create the project folder structure:
```
$ mkdir myapp && cd myapp
$ mkdir src && cd src
```
Install dependencies:
```
$ npm init --yes
$ npm install djoola-fasthttp
```
Under the `src` folder, create a file named `main.js` and paste the following into it:
```JavaScript
const fasthttp = require("djoola-fasthttp");
const app = fasthttp();
app.get("/", (req, res) => {
const time = new Date().toLocaleTimeString();
res.send(`Welcome on Fast Http Server v0.1!\nLocal time: ${time}`);
});
app.get("/api/courses/:id?", (req, res) => {
if (req.params.id === undefined) {
res.write("
Available courses
");
for (let i = 0; i < 4; i++) {
res.write(`}
res.send(``);
} else {
res.json(req.parsed);
}
});
app.notFound((req, res) => {
res.json({
error: {
code: 404,
message: "This is an API server. Learn your routes, mate!"
},
request: req.parsed
});
});
const port = process.env.PORT || 3000;
app.server.listen(port);
console.log(`Server listening on http://localhost:${port}...`);
```
From the current _src_ folder, run:
```
$ node main.js
```
Navigate to `http://localhost:3000/` or `http://locahost:3000/api/courses`. You might have to change _3000_ to whatever port number the server is listening on.
## Using middlewares
```JavaScript
const fasthttp = require("djoola-fasthttp");
const app = fasthttp();
const firstMiddle = (req, res, next) => {
console.log("First middleware invoked.");
req.locals.data = 'Data from middleware #1';
next(); // call next() to invoke the next middleware
};
app.use(firstMiddle);
// second inline middleware
app.use((req, res, next) => {
console.log("Second middleware invoked.");
console.log('data from previous middleware:', req.locals.data);
next();
});
app.get("/", (req, res) => {
const time = new Date().toLocaleTimeString();
res.send(`Welcome on Fast Http Server v0.1!\nLocal time: ${time}`);
});
const port = process.env.PORT || 3000;
app.server.listen(port);
console.log(`Server listening on http://localhost:${port}...`);
```
Unlike other middleware handlers, `djoola-fasthttp`'s middleware handler makes sure there are no hanging requests. For instance, in the second middleware above, if you forget to call `next()` and also happen to forget to respond to the client, `djoola-fasthttp`'s middleware handler takes care of ending the response process.