Grandjs

A backend framework for solid web apps based on node.js

You want to build a solid web application but you don't want to use express and a lot of packages you need to build a basic website, Grandjs is one framework includes all main functionalities you need to build amazing, solid and secured web application without need for a ton of packages and libraries.

• Grandjs is built for solid and extended web apps

Documentation

you can find the full documentation for Grandjs ecosystem here

Prerequisites

1- you need to install node.js on your system 2- init a new project using npm, so then we will be able to install this framework

Features

• fewer packages and more productivity
• Framework includes the most needed functionalities to build a perfect web app
• depends on Handlebars template Engine which is friendly with many developers
• solid routing system built on Javascript object-oriented programming and you can extend it as you need
• controlled handling for every error page in your app
• Grandjs is built for solid and extended web apps
• Built in template engine using jsx
• Extendable Routing System
• Accepts Express Packages such as (body-parser, cookie-parser, morgan, cors)
• built in cors Handler Built in request body parser Usable for Typescript Apps

//require HTTP module
const http = require("http");
//require Grandjs framework
const Grandjs = require("grandjs");

// set the configuration of the framework
Grandjs.setConfig({
    //define the port
    port: process.env.PORT || 3000,
    // http is optional you can specify http or https, if you don't specify Grandjs automatically require HTTP module
    http: http,
    // if you specified https so you should ssl files in this object
    httpsMode: {
        key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
        cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
    }
    // define the static files container folder
    staticFolder: {
        // set the path of the folder of assets
        path: path.join(process.cwd(), "/public"),
        // set the global url that will be consumed by http request
        url: "/public"
    },
        //set the encryption key, Grandjs uses encription key to cypher info
    ENCRYPTION_KEY: "ncryptiontestforencryptionproces",
    // use native request body parser or not
    nativeParser: true || false,

    //set error page for global error pages
    errorPage(req, res) {
        res.end("error page");
    }
});

// init Grandjs
Grandjs.initServer();

content

• Installing
• Getting Started
  • Server configuration
  • Server Static
  • Cors -Accessing Grandjs Server
  • Grandjs MiddleWares
  • Router
    • extend Router class
    • Router Static
    • define get routers
    • define post routers
    • Access on request and response objects
    • Request object
      • Request params
      • Handle post request
      • Request Uploaded Files
    • Response object
      • res.render function
      • res.write function
      • res.end function
      • res.sendFile function
      • res.json function
      • res.redirect function
    • middleWares
    • Use Router class inside another router class
    • TypeScript Decorators
  • Validation
    • validation.strip_html_tags function
    • validation.checkEmail function
    • validation.notEmpty function
    • validation.checkContainsNumber function
    • validation.checkIsNumber function
  • cryption
    • encrypt
    • decrypt
  • session
  • Auth module
  • Flash Messages
  • Add MimeTypees
  • Grandjs File Upload
  • Socket Io Support
• Built With
• Contributing
• Versioning
• Authors
• License
• Acknowledgments
• JSX

Whats New ?

Grandjs now supports the following

• JSX Syntax for rendering dynamic content instead of using template engins
• many of express packages are now compatible with Grandjs such as cookie-parser, session, flash, morgan, express-fileupload, body-parser
• Typescript support!, Grandjs has major updates one of these updates is rebuilding the package again using typescript and changing the architecture of the project

Please don't Forget to support us by rating the project!, Also you can contribute us

Objectives

We aim to make grandjs the successor of express js with new vision, architecture, and modern javascript features like Router inheritance to build extendable, scalable web applications without repeating your self!

Installing

open the command prompt and navigate to the project folder and just say

npm install grandjs --save

Getting Started

Server configuration

to start with Grandjs just install it and call it in your file as the following Javascript

//require Grandjs framework in javascript
const {Server, Router, Request, Response} = require("grandjs");

Typescript

import {Server, Router, Request, Response} from "grandjs"

if you want to require HTTP or HTTPS module to pass it to Grand js you can, in all cases, Grandjs behind the seen requires HTTP module as a default.

Now you need to call setConfig function to set some configuration for the project

Grandjs.setConfig({});

this function takes one parameter as an object

Example on all configuration

//javascript
const {Server, Router} = require("grandjs");

//typescript
import {Server, Router} from "grandjs";

// define Grandjs configuration
Server.setConfig({
    //define the port
    port: process.env.PORT || 3000,
    // http is optional you can specify http or https, if you don't specify Grandjs automatically require HTTP module
    http: http,
    // if you specified https so you should ssl files in this object
    httpsMode: {
        key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
        cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
    },
    // define the static files container folder
    staticFolder: {
        // set the path of the folder of assets
        path: path.join(process.cwd(), "/public"),
        // set the global url that will be consumed by http request
        url: "/public"
    },
    //set the encryption key, Grandjs uses encription key to cypher info
    ENCRYPTION_KEY: "ncryptiontestforencryptionproces",
    // use native request body parser or not
    nativeParser: true || false,

    //set error page for global error pages
    errorPage(req, res) {
        res.end("error page");
    },
    // configure cors
    cors : {
        origin: '*',
        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
        preflightContinue: false,
        optionsSuccessStatus: 204
    }
})

until now Grandjs doesn't work so you need to call "init function" to initialize the server

Server.initServer();

Server Static

Grandjs Exposes a function that allows you to specify static and assets directories easily with one function!

This function is called Server.static, this function takes one parameter as an object with the following properties

property	type	required	description
url	string	true	the exposed url that will be resolved when it requested
path	string	true	the internal path that will be resolved to read the files from it
middlewares	Array	true	A set of middlewares that you can apply before reading the files or resolve the directory

Example

class MainRouter extends Router{}
const mainRouter = new MainRouter({base: "/"});

mainRouter.static({
    url: "/assets",
    path: path.join(process.cwd(), "/my-internal-assets")
})

Cors

Grandjs uses Cors Module which is used in express, you can use the default settings of it as you use in expressjs

Grandjs installs cors and set default configuration automatically, however you can set your own configurations

Cors Configuration

Grandjs allows you to set cors configuration on multiple level of routes as the following:

• cors setting over all app routes Example

// javascript
const {Server} = require("grandjs");
// typescript

import {Server} from "grandjs";

Server.setConfig({
    cors : {
        origin: '*',
        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
        preflightContinue: false,
        optionsSuccessStatus: 204
    },

})

• cors setting over specific Router "group of routes" Example

// javascript
const {Server, Router} = require("grandjs");
// typescript

import {Server, Router} from "grandjs";
class HomeRouter extends Router{
    constructor(options) {
        super(options);
        this.cors = {
            origin: '*',
            methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
            preflightContinue: false,
            optionsSuccessStatus: 204
        };
    }
}

• cors setting over specific route Example

// javascript
const {Server, Router} = require("grandjs");
// typescript

import {Server, Router} from "grandjs";
class HomeRouter extends Router{
    constructor(options) {
        super(options);
        this.getRouters = [this.homePage()];
    }
    homePage() {
        return {
            cors: {
                origin: '*',
                methods: 'GET,',
                preflightContinue: false,
                optionsSuccessStatus: 204
        }   ,
            //define the url of router
            url: "/",
            // define the method of the router
            method: "GET",
            handler: () => {
                // handle the request and do the functionalities
            }
        }
    }
}

Accessing Grandjs Server

After initializing grandjs, maybe you want to use the created server or access on it's properties so you can access on grandjs node server via this property from grandjs

// javascript
const {Server} = require("grandjs");
// typescript

import {Server} from "grandjs";


Server.Server
// -> http Server

Grandjs MiddleWares

as every nodejs developer used to add middleware to the express app to be executed before the routes, grandjs does also something similar

In grandjs you have three types of middlewares

• global middleare over app
• global middleware over single router class (group of routes)
• private middleware over single route

we will explain the last two types of middlewares in the Router section, but here we will talk about global middlewares over app.

Global middlewares over app are middlewares you want to run before executing any router in the app, this type of middlewares often is used for injecting dependencies in the app or make global settings for the whole app.

to set global middleware you can use Server.use function as the following:

// javascript
const {Server} = require("grandjs");
// typescript

import {Server} from "grandjs";
Server.setConfig({});

// add global middleware here
Server.use();
Server.initServer();

Server.use function takes one argument which should be a function, this function has regular three arguments as the following:

Server.use((req, res, next) => {
    // continue
    return next();
});

• req is the incoming request object
• res is the response object to send response or set headers
• next is a function to call to continue to the next middleware or to start executing the routers

Note

Grandjs takes the function which passed in use function and pushes it to an array of middlewares which will be executed later when a route hs requested, so these middlewares will be executed by their arrange inside the array. To continue to the next global middleware or to start executing the matched router class you have to call next function, without it the routes will not be executed.

Router

• Grandjs Routing system is built upon object-oriented programming, so Router is a class inside Grandjs you extend it and add routes to it as you wanna

to work with router class you need to extend it or instatiate it directly and every class implies a group of routes have a specific base url

extend Router class

// javascript
const {Server, Router} = require("grandjs");
// typescript

import {Server, Router} from "grandjs";
class HomeRouter extends Router{
    constructor(options) {
        super(options);
    }
}

As any extended class, you should call the super inside the constructor and pass the options parameter

parameter	type
options	Object

Now after defining the class, you should define the get routers which related to this class Router class has a property called "getRouters" this is an array and you push inside it the routers you add within the class with the GET method

Example

class HomeRouter extends Router{
    constructor(options) {
        super(options);
        this.getRouters = []
    }
}

you can add routers which related to this class as methods inside the class and every method you use it as a router it should return an object has the following properties

Property	type	description
URL	string (required)	the URL of the router
method	string (required)	HTTP method get / post / patch / put / delete
handler	function (required)	the function you want to run when the request URL matches the router url
middleWares	array (optional)	if you want to run a function or more to check about something before running the final handler of the router

Router Static

Grandjs Exposes a function that allows you to specify static and assets directories easily with one function!

This function is called Router.static, this function takes one parameter as an object with the following properties

property	type	required	description
url	string	true	the exposed url that will be resolved when it requested
path	string	true	the internal path that will be resolved to read the files from it
middlewares	Array	false	A set of middlewares that you can apply before reading the files or resolve the directory

Example

class MainRouter extends Router{}
const mainRouter = new MainRouter({base: "/"});

mainRouter.static({
    url: "/assets",
    path: path.join(process.cwd(), "/my-internal-assets")
})

Define get routers

Example

// javascript
const {Server} = require("grandjs");
// typescript

import {Server} from "grandjs";
class HomeRouter extends Router{
    constructor(options) {
        super(options);

        //push the homePage method route into getRouters array
        this.getRouters.push(this.homePage());
    }
    homePage() {
        return {
            //define the url of router
            url: "/",
            // define the method of the router
            method: "GET",
            handler: (req, res) => {
                // handle the request and do the functionalities
            }
        }
    }
}

Define post routers

Example

class HomeRouter extends Grandjs.Router{
    constructor(options) {
        super(options);

        //push the homePage method route into getRouters array
        this.postRouters.push(this.homePagePost());
    }
    homePagePost() {
        return {
            //define the url of router
            url: "/",
            // define the method of the router
            method: "POST",
            handler: (req, res) => {
                // handle the request and do the functionalities
            }
        }
    }
}

instantiate router class

Example

// javascript
const {Server, Router} = require("grandjs");
// typescript

import {Server, Router} from "grandjs";
class HomeRouter extends Router{
    constructor(options) {
        super(options);

        //push the homePage method route into getRouters array
        this.getRouters = [this.homePage()];
    }
    homePage() {
        return {
            //define the url of router
            url: "/",
            // define the method of the router
            method: "GET",
            handler: () => {
                // handle the request and do the functionalities
            }
        }
    }
}
// instantiate the class
const homeRoters = new HomeRouter({base: "/"});

when you instantiate the class you should define the options parameter as an object includes two properties

property	type	descriptions
base	string (required)	implies the base URL you want to add routers to it. so if you defined it as "/admin" all routers inside this class would be added to /admin
staticFolder	object(optional)	the name of the folder you want to serve assets and static files from it. The default value of it is the global staticFolder that you specified in setConfig function
staticFolder.path	string(optional)	the path to read files from
staticFolder.url	string	the url that will resolve the static and assets content

Example

const homeRoters = new HomeRouter({
    base: "/"
});

Note

you can also specify the basename of the router class inside the class constructor as the following:

class HomeRouters extends Router{
    constructor() {
        this.base = "/admin"
    }
}

if you follow this pattern so you don't need to add base property when you instantiate the class because the base will be passed before

Build Router

after instantiating the router, to make it works you need to call build method to start building and constructing the router

const homeRoters = new HomeRouter({
    base: "/"
});
// this builds the router to be ready for runtime execution
homeRouters.build();

Note

Building routers should be before Server.initServer method

Access on request and response objects

to handle the routers and check requests and responses you need to access them, so these objects are accessible using different ways

1- req & res objects are properties inside the class

Example

class HomeRouter extends Router{
    constructor(options) {
        super(options);

        //push the homePage method route into getRouters array
        this.getRouters = [this.homePage()];
    }
    homePage() {
        return {
            //define the url of router
            url: "/",
            // define the method of the router
            method: "GET",
            handler: () => {
                // handle the request and do the functionalities
                //request object: this.req
                // response object: this.res
                //console the request object headers
                console.log(this.req.headers);
                this.res.end("hello home page");
            }
        }
    }
}

2- request & response are accessable as parameters inside handler function

Example

homePage() {
    return {
        url: "/",
        method: "get",
        handler: (req, res) => {
            console.log(req.headers);
            res.end("hello home page");
        }
    }
}

Specify a separated folder for static files for this group of routes

const homeRoters = new HomeRouter({
    base: "/",
    //specify the container folder fo static file for all routes inside this class
    // front path
    staticFolder: {
        path: path.join(process.cwd(), "/assets"),
        url: "/assets"
    },
});

Router add route

This function enables you to add routers to the class from outside it

homeRoters.addRoute(obj);

this function takes one (required) parameter as an object has the following properties

Property	type	description
URL	string (required)	the URL of the router
method	string (required)	HTTP method get / post / patch / put / delete
handler	function (required)	the function you want to run when the request URL matches the router url
middleWares	array (optional)	if you want to run a function or more to check about something before running the final handler of the router

Example

// javascript
const {Server, Router} = require("grandjs");
// typescript

import {Server, Router} from "grandjs";
const adminRoute = new Router({
    baes: "/admin"
})
// add main route to admin base
adminRoute.addRoute({
    url: "/",
    method: "get",
    handler: (req, res) => {
        res.end("hello admin");
    }
});
// add profile page route to admin base
homePage.addRoute({
    url: "/profile",
    method: "get",
    handler: (req, res) => {
        res.end("hello profile");
    }
});

Router class errorPage

you can specify a custom error page for every class you instantiate it to control on error links in a group of routes to do that you need to define "errorPage" method to the class

1- define it inside the class

Example

class HomeRouter extends Grandjs.Router{
    constructor(options) {
        super(options);
    }
    homePage() {
        return {
            url: "/",
            method: "get",
            handler: () => {
                this.res.end("hello home page");
            }
        }
    }
    aboutPage() {
        return {
            url: "/about",
            method: "get",
            handler: () => {
                this.res.end("hello about page");
            }
        }
    }
    // customize error page
    errorPage() {
        this.res.end("error page")
    }
}

2-Define error page from outside the class

Example

const homeRouter = new Router({
    baes: "/"
})
// add main route to admin base
homeRouter.addRoute({
    url: "/",
    method: "get",
    handler: (req, res) => {
        res.end("hello homepage");
    }
});
// add profile page route to admin base
homeRouter.addRoute({
    url: "/about",
    method: "get",
    handler: (req, res) => {
        res.end("hello aboutpage");
    }
});
homeRouter.errorPage = (req, res) => {
    res.end("error page");
}

not that if you didn't define error page for the router class it automatically call error page which you specified in setConfig function

Global middleWares

Global middleware is a way to apply middlewares on a class which includes a group of routers

globalMiddleWares is an array inside the class you can define it inside the constructor and put inside it functions that you want to run when the client requests the base name of that class

Example

class HomeRouter extends Router{
    constructor(options) {
        super(options);
        // you can add one middleWare or more and it would be applied according to the arrangment
        this.globalMiddleWares = [this.sendMessage]
    }
    sendMessage(req, res, next) {
        res.write("message from middleWare");
        // continue to the next hanlders
        next();
    }
    homePage() {
        return {
            url: "/",
            method: "get",
            handler: () => {
                this.res.end("hello home page");
            }
        }
    }
    aboutPage() {
        return {
            url: "/about",
            method: "get",
            handler: () => {
                this.res.end("hello about page");
            }
        }
    }
    // customize error page
    errorPage() {
        this.res.end("error page")
    }
}

not that the middlWares array can include many middleWare functions and the middleWares are applied according to the indexing inside the array

Every middleWare has three parameters

parameter	type	description
req	object	implies the coming request object contains all information about the request
res	object	represents the response object
next	function	is a function you can execute it to continue to the next middleware or to the final handler of the router

Router URL define params

you can add params to the URL of the router to make dynamic routes like the following:

url: "/posts/:postId"

to access the parameters inside the URL using request.params property

Example

const homePage = new Router({
    baes: "/"
})
home.addRoute({
    url: "/posts/:postId",
    method: "get",
    handler: (req, res) => {
        console.log(req.params);
    }
});

Request Object

this is an object you can access on it inside the handler of the route and the object contains all information about the request which is coming

Property	type	description
req.method	string	returns the method of the current request
req.pathname	string	returns the requested URL without query string
req.path	string	returns the requested URL with query string
req.href	string	returns the requested URL with query string
req.url	object	returns object contains the parsed URL
req.query	object	contains the query & search in the URL(it parsed as key and value)
req.params	object	returns the query parameters if it exists as key and value
req.validation	object	returns an object contains some helper functions to validate the email and string
req.data	object	returns an object contains the posted data if the method is "post"
req.body	object	returns an object contains the posted data if the method is "post"
req.headers	object	returns the headers of the coming request
req.flash	object	this object enables you to set messages to send it to handlebars to show to the user

Request params

returns an object contains the parameters of the router URL and it's value if it exists if there are no params so it returns an empty object

Example

const homePage = new Router({
    baes: "/"
})
home.addRoute({
    url: "/posts/:category",
    method: "get",
    handler: (req, res) => {
        // user requested http://localhost:300/posts/tech?postId=2
        console.log(req.params); //output {category:"tech"};
        console.log(req.query) //output {postId: 2}
        console.log(req.pathname) //output /posts/tech
        console.log(req.path) //output /posts/tech?postId=2
        console.log(req.href) //output /posts/tech?postId=2
        console.log(req.method) //output "get"
        console.log(req.url)
        console.log(req.body);
        console.log(req.data);
        /* output
        Url {
        protocol: null,
        slashes: null,
        auth: null,
        host: null,
        port: null,
        hostname: null,
        hash: null,
        search: '?postId=2',
        query: 'postId=2',
        pathname: '/posts/tech',
        path: '/posts/tech?postId=2',
        href: '/posts/tech?postId=2' }
        */
    }
});

Handle post request

Grandjs handles all types of post requests and submitted data and returns them as an object called req.data and another property req.body this object contains all the submitted data and you can access on it inside the handler function if the method of the router is post

Example

postAdminPage() {
    return {
        method: "post",
        url: "/admin/addinfo",
        handler: (req, res) => {
            console.log(req.data || req.data) //output {} contains all submitted info
        }
    }
}

Request Uploaded Files

In Grandjs You can upload files easily without any extra settings, all you should do is specifying Request header as multipart/form-data

Grandjs Uses multiparty package for file uploading

You can access on the uploaded files via files property in the request object as the following:

postAdminPage() {
    return {
        method: "post",
        url: "/admin/uploadInfo",
        handler: (req, res) => {
            console.log(req.files) //output {} contains all uploaded files
        }
    }
}

req.files property is an object which includes the uploaded files as properties, each property incarnates the uploaded file as an object, but if there are multiple files uploaded with the same filed name so they will be grouped together inside the property name as an array of objects

each object has the following properties:

{
      name: 'images' // the name of the filed,
      filename: 'download (1).jpeg' // original file name,
      data: <Buffer> // the file content as buffer,
      size: 14473 // size of file,
      extension: '.jpg' // the extension type of file,
      mimetype: 'image/jpeg' // mime type of file,
      stream: [Duplex] // ability to use this file to stream it,
       headers: [Object] // the sent headers with this file,
      byteOffset: 147,
      byteCount: 27975 // bytes count

Note

For Request Body parsing you have two options

1- use native Grandjs request parser which will also parse request with formdata

2- use body-parser package for parsing json requests and use express-fileupload for parsing multipart/form-data request body

Response Object

this is an object you can access on it inside the handler of the route This object contains all methods that you need to send a response or content to the coming request

res.render function

This function you use it to render HTML content using JSX Stateless Components

res.render()

takes one parameter as an object, this object should contain the following properties

property	type	description
Component	Function	A functional Component written in JSX Syntax to be rendered as an HTML
data	object (optional)	object contains the data you want to render inside the rendered component

Example

Create App.jsx File

// import View here (mandatory)
// javascript
const {View} = require("grandjs");

// typescript
import {View} from "grandjs";
const App = (props) => {
    return (
        <div>
            Hello world
            <h2>{props.message}</h2>
        </div>
    )
}
// use native exporting method either for typescript or javascript
module.exports = App

// javascript
const {Server, Router, View} = require("grandjs");

// typescript
import {Server, Router, View} from "grandjs";

// load jsx file
const App = View.importJsx("./App.jsx");
    homePageRouter() {
        return {
            url: "/",
            method: "get",
            handler: () => {
                // render jsx component
                this.res.render(App, {message: "Hello Grandjs"})
            }
        }
    }

res.write function

this function is like the native api of node.js, it allows you to send strings to the client

res.write("hello world");
//end the response
res.end("");

res.end function

this function is like the native api of node.js, it allows you to send strings to the client

res.end("hello world");

res.sendFile function

res.sendFile(path);

this function takes on parameter

parameter	type	description
path	String (required)	this parameter should specify the path of the file which you want to send

this function uses promise to return a catch function if the file isn't exist

Example

res.sendFile("/views/pages/home.html").catch((err) => {
    console.log(err) //output no such file
})

res.json function

this function sends json data, it accepts one parameter this parameter should be an object and Grandjs stringify this object automatically

res.json({user: "tarek", email: "[e-mail]", id: 1});

res.redirect function

This function is used to make redirect to another link It accepts one parameter

parameter	type	description
url	String (required)	this parameter should specify url that you want to redirect to

res.redirect("/anotherurl");

res.status function

this function sets the status of the response with http status code, it accepts one parameter which is the status code of the response

res.status(200).json({user: "tarek", email: "[e-mail]", id: 1});

MiddleWares

middleWares is a group of functions used to run something before executing the final handler

the middWares property should be an array includes the functions

Every middleware should have three parameters

parameter	type	description
req	object	implies the coming request object contains all information about the request
res	object	represents the response object
next	function	is a function you can execute it to continue to the next middleWare or to the final handler of the router

Example

//middle ware
function writeWithMiddleware(req, res, next) {
    // has three parameters
    /*
    1- req: the request object
    2- res: the response object
    3- next: a function you execute it to continue to the handler
    */
   res.write("from middleware");
   next();
}
homePage() {
    return {
        url: "/home",
        middleWares: [],
        method: "get",
        handler: (req, res) => {
            res.end("hello home page");

            // final output on the browser:
            //from middleware
            //hello home page
        }
    }
}

note that the middlWares array can include many middleWare functions and the middleWares are applied according to the indexing inside the array

Use Router class inside another router class

you can build a router class and append another router class to its parent, This is designed for special use case as the following: suggest you have parent router class has basename /admin and you want to group some of routes to manage products for example so the default way you can create another class with basename /admin/products so we came up with the solution to use router classes inside another routing classes which give you the flexibility to use child routes inside parent route as the following:

// admin product routes
class ProductRoutes extends Router{
    constructor(options) {
        super(options);
        // add post routers to the array
        this.postRouters = [this.addProduct()]
    }
    addProduct() {
        return {
            url: "/product",
            method: "POST",
            handler: (req, res) => {
                console.log(req.data);
            }
        }
    }
}

// admin router
class AdminRoutes extends Router{
    constructor(options) {
        super(options)
        this.getRouters = [this.homePage()];
        // use child router class
        this.useRouter(ProductRoutes)
    }
    homePaage() {
        return {
            url: "/",
            method: "GET",
            handler: (req, res) => {
                res.end("home page!");
            }
        }
    }
}

TypeScript Decorators

If you are using typescript wit Grandjs, you can use decorators to decorate your route methods! Currently grandjs supports the following decorators

• GET (for get methods)
• POST (for post methods)
• PATCH (for patch methods)
• PUT (for put methods)
• DELETE (for delete methods)
• MiddleWare (for methods that act as middleWares)

Example

import {Router, Request, Response} from "grandjs"
import {GET, POST, PATCH, PUT, DELETE, MiddleWare} from "grandjs";

class UserRouter extends Router{
  // get user page
  @GET({url: "/user"})
  getUserPage(req: Request, res: Response) {
    return res.status(200).json({status: 200, message: "hello world"});
  }
  // middleware
  @MiddleWare
  userMiddleWare(req: Request, res: Response, next: Function) {
    // check the user
    if(req.user) {
      // continue
      return next();
    } else {
      return res.status(401).json({status: 401, message: "user is not authorized"});
    }
  }
}

Note the decorator function injects the method into the proper array of methods, so if you use @GET decorator it will be injected in getRouters array, the same thing for other routes, if you use @MiddleWare decorator, it will inject the method in globalMiddleWares array

Validation

Grandjs includes awesome validation system to validate inputs and remove strip tags and check the correct email you can access on validation using on of two ways 1- importing the module

Example

//javascript
const {validation} = require("grandjs");

// typescript
import {validation} from "grandjs";

2- as a property inside the request object

const handler = (req, res) => {
    console.log(req.validation);
}

validation.striphtmltags function

this function removes weird characters from the string to insure that there is no harmful characters inside the string

let str = "h1hello worldh1"
Grandjs.helpers.validation.strip_html_tags(str) // output hello world

validation.checkEmail function

This function checks if the string is emain or not

this function takes two parameters

parameter	type	description
email	string (required)	this parameter is required and it should be a string that you want to test it as email or not
cb	function (optional)	this is a callback function you can call it and includes one parameter either be true or false

This function you can call it async with a callback function or sync without callback

1- with callback function

Grandjs.helpers.validation.checkEmail("[e-mail]", (email) => {
    if(email) {
        console.log(email) //output true if it email
    } else {
        console.log(email) // output false if itsn't email
    }
});

2- without callback

let email = Grandjs.helpers.validation.checkEmail("test@gmail");
console.log(email) // returns true if it email, if not,  returns false

validation.notEmpty function

This function checks if the given string is empty or not

it accepts two parameters

parameter	type	description
string	string (required)	to test it is empty or not
cb	function (optional)	this is a callback function you can call it and includes one parameter either be true or false

This function you can call it async with a callback function or sync without callback

1- with callback function

Grandjs.helpers.validation.notEmpty("", (notEmpty) => {
    if(notEmpty) {
        console.log(notEmpty) //output true if it is not empty
    } else {
        console.log(notEmpty) // output false if it is empty
    }
});

2- without callback

let notEmpty = Grandjs.helpers.validation.notEmpty("");
console.log(email) // returns true if it isn't empty, if it is empty,  returns false

validation.checkContainsNumber function

This function checks if the given string contains numbers or not

it accepts three parameters

parameter	type	description
string	string (required)	to test it contains numbers or not
count	Number (required)	refers to the count of the number you want to test the string contains. if you specify it for example 5 so the function checks if the given string contains five numbers
cb	function (optional)	this is a callback function you can call it and includes one parameter either be true or false

This function you can call it async with a callback function or sync without callback

1- with callback function

Grandjs.helpers.validation.checkContainsNumber("Grandjs32test1", 3, (containsNumbers) => {
    if(containsNumbers) {
        console.log(containsNumbers) //output true if it contains number
    } else {
        console.log(containsNumbers) // output false if it doesn't contain three numbers
    }
});

2- without callback

let containsNumbers =
Grandjs.helpers.validation.checkContainsNumber("Grandjs32test1", 3);
console.log(containsNumbers) // returns true if it contains 3 numbers, returns false if not

validation.checkIsNumber function

This function checks if the given parameter is a number or not you can use this function to authenticate phone number and stuff like that

it accepts two parameters

parameter	type	description
value	any (required)	to test it is number or not
cb	function (optional)	this is a callback function you can call it and includes one parameter either be true or false

This function you can call it async with a callback function or sync without callback

1- with callback function

let test = 1222;
Grandjs.helpers.validation.checkIsNumber(test, (number) => {
    if(number) {
        console.log(number) //output true if it is number
    } else {
        console.log(number) // output false if it isn't number
    }
});

2- without callback

let test = 1222;
let number = Grandjs.helpers.validation.checkIsNumber(test);
console.log(number) // returns true if it is number, returns false if not

Cryption

Grandjs gives you functionalities to crypt important info and cipher them and decrypt them encryption functions are inside helpers inside grandjs library This helper uses the ENCRYPTION_KEY that you specify in setConfig function.

not that the length of ENCRYPTION_KEY should be 32 character

enCrypt

Grandjs.helpers.enCrypt(text);

This function takes one parameter which refers to the string you wanna encrypt or cipher it

parameter	type	description
text	string (required)	implies the text that you wanna cipher it

This function rreturns the string after cipher it

const {Cipher} = require("grandjs");
// encrypt password
let encryptedPassword = Cipher.enCrypt("passowrd");

deCrypt

const {Cipher} = require("grandjs");
Cipher.deCrypt(text);

This function takes one parameter which refers to the string you wanna decrypt or decipher it

parameter	type	description
text	string (required)	implies the text that you wanna decipher it

This function rreturns the string after decipher it

// encrypt password
let decryptedPassword = Grandjs.helpers.deCrypt("passowrd");

Session

This Module is deprecated, you can use Express session and Cookie-parser instead!

Flash Messages

This Module is deprecated, you can use express flash messages instead!

Example

// javascript
const {Server} = require("grandjs");
// typescript
import {Server} = from "grandjs";

const flash = require('express-flash'),
const session = require('express-session')
const cookieParser = require("cookie-parser");
Server.use(cookieParser('keyboard cat'));
Server.use(session({ cookie: { maxAge: 60000 }}));
Server.use(flash());

Add MimeTypes

if you want to serve more static files with another mimetype not exist in our built in mimetypes, so you can use the following function

Server.addMimeTypes(extention, mimeType);

This function takes two parameters

Parameter	type	description
extention	string (required)	represents the extention of the file that you want to check
mimeType	string (required)	The mime type that you want to set in the response header for the specific file

Exmple

Server.addMimeTypes(".pdf", "application/pdf");

Grandjs File Upload

Grandjs includes a small helpers for working with files and images specifically, you can use it via calling it from grandjs:

// javascript
const {FileUpload} = require("grandjs");
// typescript
import {FileUpload} from "grandjs"

file upload has property called uploadPath which is the destination to save files in, you can change it anytime by calling setUploadPath method as the following:

FileUpload.setUploadPath("./uploads");

FileUpload has implementation to make a directory in a specific destination

Example

FileUpload.makeDirectory("./uploads/images");

Save Base64 as image

you can save base 64 file as image using this function:

FileUpload.saveImageBase64(data, uploadPath)
/*
uploadPth: // default is uploadPath of the class
*/

this function returns promise

Socket Io Support

Grandjs is extendable to use with socket io for realtime applications, here is an example on using grandjs with socket io

const {Server} = require("grandjs");
const socketIo = require("socket.io");
Server.setConfig({
    //define the port
    port: process.env.PORT || 3000,
    // http is optional you can specify http or https, if you don't specify Grandjs automatically require HTTP module
    http: http,
    // if you specified https so you should ssl files in this object
    httpsMode: {
        key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
        cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
    }
    //set the encryption key, Grandjs uses encription key to cypher info
    ENCRYPTION_KEY: "ncryptiontestforencryptionproces",

    //set error page for global error pages
    errorPage(req, res) {
        res.end("error page");
    }
});

// init Grandjs
Server.initServer();


const io = socketIo(Server.Server);
io.on("connect", () => {
    console.log("connected successfully")
})

now once you run the application you can connect on socket via port 3000

JSX

Writing JSX in Grandjs

About

Grandjs Depends on JSX for rendering dynamic/static HTML markups, it converts the jsx syntax to html string by native parser, also the rendered JSX markup is a stateless

Grandjs loads JSX components and files on runtime fastly without a need to bable or any transpilers, Grandjs uses import-jsx package for requiring jsx files

Why ?

Actually there is many different template engines can be used, all these template engines are efficient and good to work with, but you will learn a new syntax of each template engine, also you will suffer from the hassle of searching helpers for this template engine to add new features like conditions, mathematical operations inside the html markup, however we have JSX! Most of developers now know JSX and know how can they render it, "thanks React!", so We see using JSX is good, efficient and fast in rendering and Friendly syntax that allow you to write the whole Application in just javascript, with getting the benefits if Javascript methods, helpers, functions inside the HTML markup

How ?

Grandjs exports an object called View, this object includes some builtin methods and configuration for parsing, and caching jsx syntax and converting it to html strings and then send this HTML markup to the browser

Note JSX syntax shouldn't be written in the entry point file, you should create a folder called views for example and put all JSX code there by dividing into functional components and requiring the component you wherever you want Example

Project Structure

Directory Structure

 ┬  
 ├ views
    ┬
    ├ App.jsx
    ├ Home.jsx
 ├ index.js

in App.jsx

// jsx
// importing {View} is mandatory
const {View} = require("grandjs");
// typescript
import {View} from "grandjs";
const App = (props) => {
    return (
        <div>
            <h1>hello App Component</h1>
        </div>
    )
}
module.exports = App;

in Home.jsx file

const {View} = require("grandjs");
// typescript
import {View} from "grandjs";
const App = View.importJsx("./App.jsx");
const Home = (props) => {
    return (
        <div>
            <h1>This is home page</h1>
            <App/>
        </div>
    )
}
module.exports = Home;

Note

1- Any Component you write you have to import {View} inside the file that you write the component in, to make grandjs recognize and compile that file

2- The component should be a functional Component as the following:

const App = (props) => {
    return (
        <div>
            <h1>hello App Component</h1>
        </div>
    )
}

3- You have to export the component as a nodejs module in commonjs syntax like the following:

module.exports = App;

4- Importing JSX Component Should be using View.importJsx function which will recognize that this file is jsx syntax

const Home = View.importJsx("./views/Home.jsx");

// importing {View} is mandatory
const {Server, View, Router} = require("grandjs");
// typescript
import {Server, View, Router} from "grandjs";
// import Home Page
const Home = View.importJsx("./views/Home.jsx");
const router = new Router({base: "/"})

router.addRoute({
    url: "/",
    method: "GET",
    handler: (req, res) => {
        return res.status(200).render(Home, {})
    }
})
router.build();
Server.setConfig({port: 3000});
Server.initServer();

View Define Styles

Grandjs exposes to you a method called View.createStyle which is a method in View class that you can use to create a style as an object and use this style with defined classes inside your component as you can do in react

Example

const {View} = require("grandjs")

const Styles = View.createStyle({
    title: {
        backgroundColor: "red"
    }
    title2: {
        color: "green"
    }
})

const App = () => {
    const classes = Styles();
    return (
        <h1 className={classes.title}></h1>
    )
}

View Render Component To HTML

Also View class exposes to you a method called renderToHtml which is can be used to render the component into raw html string, this can be useful if you want to send your components as mail templates!

const {View} = require("grandjs");
const Home = View.importJsx("./views/Home.jsx");

const template = View.renderToHtml(Home, {});

Built With

• Tarek Salem

Authors

• Tarek Salem - Initial work - github

License

This project is licensed under the MIT License - see the LICENSE.md file for details

Acknowledgments

• url-pattern
• Handlebars template engine
• Hat tip to anyone whose code was used
• Inspiration