Jai Server: Ultra-Fast

Fast, Powerfull, Robust web framework for creating API in Node.js

About

Jai Server is an ultra-high-performance, easy-to-use web framework for Node.js, engineered for building lightning-fast and highly scalable web applications and APIs.

With its innovative lightweight architecture and powerful features, Jai Server dramatically outperforms popular frameworks like Express.js while maintaining simplicity, flexibility, and developer-friendly ergonomics.

🚀 Quick Start

npm install jai-server

const JaiServer = require('jai-server');

const app = JaiServer();

app.get('/', (req, res) => {
  res.send('Hello, Jai Server!');
});

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

🌟 Features

✅ Ready to use: Minimal setup required for rapid development #easy-setup
🔄 RESTful API support: Create robust APIs with ease #rest-api
⚙️ Flexible configuration: Easily adapt to your project needs #customizable
📁 Static file serving: Effortlessly serve static content #static-files
🛣️ Advanced routing: Powerful and intuitive routing system #routing
🔀 Middleware support: Fine-grained control over request/response flow #middleware
🌐 Comprehensive HTTP method support: GET, POST, PUT, PATCH, OPTIONS, HEAD, DELETE #http-methods
🔒 Built-in security features: Enhance your application's security out of the box #security
🚀 Exceptional performance: Blazing fast, outperforming other popular frameworks #high-performance
⚡ Low overhead: Minimal impact on system resources for efficient scaling #efficient
🔧 HTTP/2 support: Leverage modern web technologies for improved speed #http2
🔌 Extensible plugin ecosystem: Extend functionality with a growing library of plugins #extensible

📊 Performance Benchmark

Jai Server significantly outperforms Express.js in rigorous benchmark tests:

Jai Server Performance

┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐
│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev   │ Max   │
├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤
│ Latency │ 14 ms │ 16 ms │ 34 ms │ 35 ms │ 20.68 ms │ 7.48 ms │ 54 ms │
└─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘
┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg      │ Stdev  │ Min     │
├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤
│ Req/Sec   │ 46,367  │ 46,367  │ 46,847  │ 48,191  │ 47,126.4 │ 675.32 │ 46,361  │
├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤
│ Bytes/Sec │ 9.18 MB │ 9.18 MB │ 9.27 MB │ 9.54 MB │ 9.33 MB  │ 134 kB │ 9.18 MB │
└───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘

237k requests in 5.03s, 46.7 MB read

Express.js Performance

┌─────────┬───────┬───────┬────────┬────────┬──────────┬──────────┬────────┐
│ Stat    │ 2.5%  │ 50%   │ 97.5%  │ 99%    │ Avg      │ Stdev    │ Max    │
├─────────┼───────┼───────┼────────┼────────┼──────────┼──────────┼────────┤
│ Latency │ 68 ms │ 71 ms │ 116 ms │ 126 ms │ 74.66 ms │ 11.31 ms │ 154 ms │
└─────────┴───────┴───────┴────────┴────────┴──────────┴──────────┴────────┘
┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬──────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg      │ Stdev    │ Min     │
├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤
│ Req/Sec   │ 10,775  │ 10,775  │ 13,855  │ 13,991  │ 13,221.6 │ 1,231.34 │ 10,773  │
├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤
│ Bytes/Sec │ 2.65 MB │ 2.65 MB │ 3.41 MB │ 3.44 MB │ 3.25 MB  │ 303 kB   │ 2.65 MB │
└───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴──────────┴─────────┘

67k requests in 5.02s, 16.3 MB read

Key Performance Insights

3x Faster: Jai Server handles an impressive ~40,304 req/sec compared to Express.js's ~13,221 req/sec
67% Lower Latency: 24.32ms average for Jai Server vs 74.66ms for Express.js
2.6x Higher Throughput: 8.5 MB/sec for Jai Server vs 3.25 MB/sec for Express.js
Consistent Performance: Jai Server shows remarkably low standard deviation in requests per second, indicating stable and reliable performance under high load
Efficient Resource Utilization: Jai Server processes 3 times more requests while maintaining lower and more consistent latency

Jai Server delivers exceptional, consistent, and scalable performance, making it the ideal choice for high-load applications, microservices, real-time systems, and performance-critical projects. #performance-comparison #high-throughput #low-latency

📥 Installation

Get started with Jai Server in your project:

npm install jai-server

🎯 Usage Examples

Basic Server

const JaiServer = require('jai-server');

const app = JaiServer();

app.get('/', (req, res) => {
  res.send('Welcome to Jai Server!');
});

app.listen({ port: 3000 }, () => {
  console.log('Server running on http://localhost:3000');
});

Serve Static Files

const JaiServer = require('jai-server');

const app = JaiServer({
  static: {
    dir: `${__dirname}/public`,
    basePath: '/static',
  },
});

app.listen({ port: 3000 }, () => {
  console.log('Static files served at http://localhost:3000/static');
});

HTTPS and HTTP/2 Support

const fs = require('fs');
const JaiServer = require('jai-server');

const app = JaiServer({
  http2: true,
  allowHTTP1: true,
  https: {
    key: fs.readFileSync('path/to/key.pem'),
    cert: fs.readFileSync('path/to/cert.pem'),
  },
});

app.get('/', (req, res) => {
  res.send('Secure Jai Server!');
});

app.listen({ port: 443 }, () => {
  console.log('Secure server running on https://localhost');
});

RESTful API with Route Parameters

const JaiServer = require('jai-server');

const app = JaiServer();

app.get('/users/:id', (req, res) => {
  res.json({ userId: req.params.id, message: 'User details' });
});

app.listen({ port: 3000 });

Using Middleware and Routers

const JaiServer = require('jai-server');

const app = JaiServer();
const router = JaiServer.Router();

// Middleware
app.use((req, res, next) => {
  console.log(`Request received at ${new Date()}`);
  next();
});

// Router
router.get('/hello', (req, res) => {
  res.send('Hello from the router!');
});

app.use('/api', router);

app.listen({ port: 3000 });

Built-in Response Methods

res.send(data)

Sends a response in HTML, text, or any other format. Automatically sets the appropriate Content-Type header.

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

res.json(data)

Sends a JSON response with Content-Type: application/json.

app.get('/user', (req, res) => {
  res.json({ id: 1, name: 'John Doe' });
});

res.redirect(link, [statusCode])

Redirects the client to the given URL. The default status code is 302.

app.get('/old-route', (req, res) => {
  res.redirect('/new-route');
});

res.status(statusCode)

Sets the HTTP status code for the response. Chainable with other response methods.

app.get('/error', (req, res) => {
  res.status(404).send('Page Not Found');
});

res.header(key, value)

Sets custom headers for the response.

app.get('/custom-header', (req, res) => {
  res.header('X-Custom-Header', 'MyValue').send('Header set!');
});

res.sendFile(filePath, [options], [callback])

Serves a file to the client. Options can include root directory, cache settings, etc.

app.get('/download', (req, res) => {
  res.sendFile('path/to/file.txt',{
    fallthrough:false // Optional: default false
  },(err)=>{ // Optional Call Back/Next

  });
});

Middleware and Routers

Jai Server supports middleware and routers for more complex applications:

const JaiServer = require('jai-server');
const app = JaiServer();
const router = JaiServer.Router();

// Middleware
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

// Router
router.get('/hello', (req, res) => {
  res.send('Hello from the router!');
});

app.use('/api', router);

app.listen({ port: 3000 });

📘 API Reference

JaiServer(options)

Creates a new Jai Server instance.

Options

Option	Type	Description	Default
`host`	`string`	Host name	`'localhost'`
`port`	`number`	Port number	`3000`
`static`	`object`	Static file serving options (jai-static)	`null`
`https`	`object`	HTTPS options	`null`
`http2`	`boolean`	Enable HTTP/2	`false`
`allowHTTP1`	`boolean`	Allow HTTP/1 on HTTP/2 server	`true`
`allowHTTP1`	`boolean`	Allow HTTP/1 on HTTP/2 server	`true`
`timeout`	`number`	Timeout req after ms, default 60000(1min)	`60000`

app.METHOD(path, handler)

Routes an HTTP request, where METHOD is the HTTP method in lowercase.

app.get('/path', (req, res) => { /* ... */ });
app.post('/path', (req, res) => { /* ... */ });
// Other HTTP methods: put, patch, delete, options, head

app.use([path,] function [, function...])

Mounts middleware function(s) at the specified path.

app.listen(options[, callback])

Starts the server.

🚀 Advanced Features

Middleware Chaining: Create complex request processing pipelines
Custom Error Handling: Implement application-specific error management
Request Body Parsing: Built-in support for JSON and URL-encoded bodies
Modular Routing: Organize routes using the Router class
WebSocket Support: Real-time, bidirectional communication
Database Integration: Easy connection with popular databases
Authentication Middleware: Secure your routes and APIs
Rate Limiting: Protect your server from abuse
CORS Support: Configure Cross-Origin Resource Sharing
Compression: Optimize response size for faster transmission

📄 License

Jai Server is open-source software licensed under the MIT license.

Author

Harpal Singh: @hsk11 . Website: Jaijs.org.

Built with ❤️ by Harpal Singh

#jai-server #node-js-framework #web-development #backend #api-development #performance-optimization #microservices #realtime-applications #node-js #web-framework #high-performance #rest-api #http2 #express-alternative #api #web-api #restapi #http-server #nodejs-api Enhanced Response Methods #jaijs

jai-server