Jai Server: Ultra-Fast, Secure Node.js Web Framework

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

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 │ 16 ms │ 18 ms │ 38 ms │ 38 ms │ 24.32 ms │ 8.57 ms │ 54 ms │
└─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘
┌───────────┬─────────┬─────────┬────────┬─────────┬────────┬────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%    │ 97.5%   │ Avg    │ Stdev  │ Min     │
├───────────┼─────────┼─────────┼────────┼─────────┼────────┼────────┼─────────┤
│ Req/Sec   │ 39,519  │ 39,519  │ 40,287 │ 40,959  │ 40,304 │ 483.62 │ 39,497  │
├───────────┼─────────┼─────────┼────────┼─────────┼────────┼────────┼─────────┤
│ Bytes/Sec │ 8.34 MB │ 8.34 MB │ 8.5 MB │ 8.64 MB │ 8.5 MB │ 103 kB │ 8.33 MB │
└───────────┴─────────┴─────────┴────────┴─────────┴────────┴────────┴─────────┘

203k requests in 5.02s, 42.5 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

📚 Table of Contents

• Installation
• Usage Examples
• API Reference
• Advanced Features
• Contributing
• License

📥 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

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.

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