About majidai

majidai is a configuration centralized nodejs web framework. It works on native node environment without installing other third party libraries.

It is released under MIT liscense.

Installation

                        
npm install majidai
                        

create server.js with the following content and run "node server.js" from the same directory.

                            
const majidai = require("majidai");
const server = new majidai();
server.start();
                            

Open the browser and access to http://locahost. You will see following page.

※ By default, majidai listens at 80 port which can be changed by passing http.port parameter.

const config = {
    http: {
        port: 8000
    }
};
const server = new majidai(config);

OR

const server = new majidai({http: {port: 8000}});

Logging

majidai emits 2 types of events which can be used for logging purpose.

1. stdout: it contains client information(access time,ip,http method) in json object format
2. stderr: it contains error message

                            
const server = new majidai();

server.on('stdout', function (data) {
    console.log(data);
    // {time: '', ip: '', hostName: '', userAgent: '', referrer: '', url: '', method: ''}

    // write to file if needed
});

server.on('stderr', function (data) {
    console.error(data);
    // error content (string)

    // write to file if needed
});

server.start();
                            

Structure

This is the general style for writing code using majidai.

server.METHOD(PATH, CALLBACK)

"METHOD" denotes following 3 methods for creating a route.

1. get : only listens for http GET method
2. post: only listens for http POST method
3. listen: listens for multiple http methods

"PATH" denotes a path to listen. For eg, "/", "/top",etc

                                
server.get('/order/{item}/{quantity}', (request, response) => {
    // when  a request is http://〇〇/order/orange/20

    // get item name
    var itemName = request.mj.getParams("item");
    console.log(itemName);
    // oranage

    // get item quantity
    var itemQuantity  = request.mj.getParams("quantiry");
    console.log(itemQuantity);
    // 20


    // OR
    // get all data
    var getData = request.mj.getParams();
    console.log(getData);
    // { item: 'orange', quantity: '20' }

    // get value for item
    var itemName_ = getData.item;
    console.log(itemName_);
    // oranage

    // get value for quantity
    var itemQuantity_ = getData.quantity;
    console.log(itemQuantity_);
    // 20

    return "something";
});
                                
                            

"CALLBACK" is a function which receives request<http.IncomingMessage> and response<http.ServerResponse> object as argument. Return statement from CALLBACK will be the response.

    
function CALLBACK(request, response){
    // do something

    return "response";
}
    

get

                            
const server = new majidai();

server.get('/top', (request, response) => {
    // do something
    // code for GET request at http://〇〇/top

    return "something";
});

server.start();
                            

post

                            
const server = new majidai();

server.post('/login', (request, response) => {
    // do something
    // code for POST request at http://〇〇/login

    return "something";
});

server.start();
                            

listen

                            
const server = new majidai();

server.listen({ method: ["GET", "POST"], path: "/profile" }, (request, response) => {
    // do something
    // code for both GET request & POST request at http://〇〇/profile

    return "something";
});

server.start();
                            

getParams

If no parameter is passed, it will return all the GET data in JSON format.

const server = new majidai();

server.get("/home", (request,response) => {
    // get the value of price when request is http://〇〇/home?price=230)
    var price = request.mj.getParams("price");
    console.log(price);
    // 230
    
    // OR
    // get all data
    var getData = request.mj.getParams();
    console.log(getData);
    // { price: '230' }
    
    // get value for price
    var price_ = getData.price;
    console.log(price);
    // 230


    return "something";
});

server.start();

it works on all types of routing including parameterized routing.

server.post("/home/{user}", (request,response) => {  
    // when POST request is received at http://〇〇/home/dakc?page=profile   

    // get all data for GET parameter
    var getData = request.mj.getParams();
    console.log(getData);
    // { page: 'profile', user: 'dakc' }

    return "something";
});    

postParams

This method will return the data sent as POST parameter. Data sent through x-www-form-urlencoded, application/json will be returned as json object.

If no argument is passed, it will return all the data in JSON format.

const server = new majidai();

server.post("/home", (request,response) => {  
    // lets get the value of price (eg, <input name="price" value="2000">)
    var price = request.mj.postParams("price");

    // get all data send by POST method
    var postData = request.mj.postParams();
    // get value for id
    var idSent = postData.id;

    // do something

    return "something";
});

server.start();

※ multipart/form-data is not supported by default, but we can use other libraries.

text

const server = new majidai();

server.get("/", (request, response) => {
    return response.mj.text("Hello!");
});

server.start();

const server = new majidai();

server.get("/", (request, response) => {
    return "Hello!";
});

server.start();

json

const server = new majidai();

server.get("/", (request, response) => {
    return response.mj.json({id: 1, name: 'majidai'});
});

server.start();

const server = new majidai();

server.get("/", (request, response) => {
    return {id: 1, name: 'majidai'};
});

server.start();

static

const server = new majidai();

server.get("/", (request, response) => {
    return response.mj.static("/somewhere/static/home.html");
});

server.start();

Beside this, refer to serving static for files at specific folder.

redirect

const server = new majidai();

server.get("/", (request, response) => {
    // redirect to somewhere 
    return response.mj.redirect("/somewhere");
});

server.start();

error

const server = new majidai();

server.get("/", (request, response) => {
    // return internal server error
    return response.mj.error(500);
});

server.start();

Serve Static

By default, static serving function is set to off. By setting the "documentRoot" of "http" property to a existing directory, majidai will serve all the static files below that path.

const config = {
    directoryIndex: "index.html",   // default page to display when directory is accessed
    directoryTraversal: true,       // it will list all the files if no directoryIndex was found (Default: false)
    http: {
        documentRoot: '/var/www/html' // files below this directory will be accessible through web
    }
};
const server = new majidai(config);
server.start();

Put index.html with javascript files and css files on documentRoot directory and access to http://localhost. You will be able to see the contents of index.html.

Customize Error Page

We can customize error page by calling "customizeErrorPage" method.

const server = new majidai();    

server.get("/", (request, response) => {
    // return internal server error
    return response.mj.error(500, "contact to server admin");
});

server.start();

// customize error page
server.customizeErrorPage(function(errContent) {
    // format to html
    let htmlContent = `
        <html>
        <head>
        <title>custom error</title>
        </head>
        <body>
        <h1><span style='color:#ff0000'>Woops!</span> Something Went Wrong</h1>
        <p>${errContent}</p>
        </body>
        </html>
    `;
    
    // must return a object with "contentType" and "content"
    return {
        contentType: "text/html",
        content: htmlContent
    };
});

        

setMimeType

If mimetype is not supported by default, We can Set the mimetype for file extension by using "setMimeType" method.

const server = new majidai();

server.setMimeType(".gif", "image/gif");

server.get("/", (request, response) => {
    // show gif image on browser
    return response.mj.static("/somewhere/something.gif");
});

server.start();

        

configuration

majidia is a configuration centralized framework. We can create a config based on environment.

Below is the default configuration. We can change the content and create different types of configuration files as per our need.
For eg,

1. config.dev.js
2. config.prod.js

module.exports = {
    // ===========================================
    // common configuration
    contentType: "text/plain",
    charset: "utf-8",
    maxBodySize: 100 * 1024, // byte
    directoryIndex: "index.html",
    directoryTraversal: false,
    allowedMethod: ["GET", "POST", "HEAD", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"],
    responseHeader: {
        "x-frame-options": "SAMEORIGIN",
        "x-xss-protection": "0",
        "server": "majidai/2.1",
        "Access-Control-Allow-Origin": "*",
        "Accept": "*/*",
    },
    
    // ===========================================
    // http configuration
    http: {
        port: 80,
        host: "0.0.0.0",
        documentRoot: "",
        listen: true,
    },

    // ===========================================
    // https configuration
    https: {
        port: 443,
        host: "0.0.0.0",
        documentRoot: "",
        listen: false,
        http2: false,
        pfx: "",
        passphrase: "",
    },
};

        

Create https server

By default, "listen" property for https is set to "false". By changing it to "true" and passing the ssl certificate in "PKCS#12" format, we can easily create https server.
Also http2 protocol is set to off by default. We can activate it by just passing http2 attribute set to true.

        
const majidai = require("majidai");

var config = {
    https: {
        listen: true,
        documentRoot: "public",
        pfx: "ssl/certificate.pfx",
        passphrase: "p@ssword",
        http2:true
    }
};

let server = new majidai(config);

server.on('stdout', data => console.log(data));
server.on('stderr', data => console.error(data));

server.start();
        
        

sample

// import majidai 
const majidai = require("majidai");

// import configuration for dev environment
const config = require("config.dev.js"):

// create majidai server instance
const server = new majidai(config):

// show the client information on console
server.on("stdout", data => console.log(data));

// on error show on console
server.on("stderr", data => console.error(data));

// create routing that listens for GET & POST
server.listen({methods: ["GET", "POST"], path: "/order/{item}/{quantity}"}, req => {
    // get all GET data
    var getData = req.mj.getParams();

    // get all POST data
    var postData = req.mj.postParams();

    // return all data as application/json
    return {
        get: getData,
        post: postData
    }
});

// start server
server.start();

docker

docker run -it --rm -p 80:80 dakc/majidai npx /data/server.js