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.
you can find the full documentation for Grandjs ecosystem here
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
//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
Grandjs now supports the following
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!
open the command prompt and navigate to the project folder and just say
npm install grandjs --save
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();
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")
})
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
Grandjs allows you to set cors configuration on multiple level of routes as the following:
// 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
},
})
// 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
};
}
}
// 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
}
}
}
}
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
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
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 objectres is the response object to send response or set headersnext is a function to call to continue to the next middleware or to start executing the routersNote
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.
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
// 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 |
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")
})
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
}
}
}
}
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
}
}
}
}
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: "/"
});
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
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
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");
}
}
}
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"
},
});
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");
}
});
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 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 |
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);
}
});
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 |
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' }
*/
}
});
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
}
}
}
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
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 functionThis 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 functionthis 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 functionthis function is like the native api of node.js, it allows you to send strings to the client
res.end("hello world");
res.sendFile functionres.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 functionthis 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: "test@gmail.com", id: 1});
res.redirect functionThis 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 functionthis 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: "test@gmail.com", id: 1});
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
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!");
}
}
}
}
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
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 functionthis 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 functionThis function checks if the string is emain or not
this function takes two parameters
| parameter | type | description |
|---|---|---|
| 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("test@gmail.com", (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 functionThis 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 functionThis 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 functionThis 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
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
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");
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");
This Module is deprecated, you can use Express session and Cookie-parser instead!
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());
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 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");
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
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
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
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
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
┬
├ 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();
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>
)
}
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, {});
This project is licensed under the MIT License - see the LICENSE.md file for details
FAQs
A backend framework for solid web apps based on node.js
The npm package grandjs receives a total of 19 weekly downloads. As such, grandjs popularity was classified as not popular.
We found that grandjs demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
Socket researchers have discovered malicious npm packages targeting crypto developers, stealing credentials and wallet data using spyware delivered through typosquats of popular cryptographic libraries.
Security News
Socket's package search now displays weekly downloads for npm packages, helping developers quickly assess popularity and make more informed decisions.
Security News
A Stanford study reveals 9.5% of engineers contribute almost nothing, costing tech $90B annually, with remote work fueling the rise of "ghost engineers."