vanilla-jet 1.0.0

package/framework/response.js

@@ -0,0 +1,102 @@
+/**
+	Version 3.5
+	Created by: nalancer08 <https://github.com/nalancer08>
+**/
+
+const nunjucks = require('nunjucks');
+var _ = require('underscore');
+
+function Response(res) {
+
+	this.res = null;
+	this.body = '';
+	this.status = 200;
+	this.headers = [];
+	this.autoRespond = true;
+	// Call initialization callback
+	this.init(res);
+}
+
+Response.prototype.init = function(res) {
+
+	var obj = this;
+	obj.res = res;
+}
+
+Response.prototype.setBody = function(body) {
+
+	var obj = this;
+	obj.body = body;
+}
+
+Response.prototype.setStatus = function(status) {
+
+	var obj = this;
+	obj.status = status;
+}
+
+Response.prototype.setHeader = function(name, value) {
+
+	var obj = this;
+	obj.headers.push({
+		name: name,
+		value: value
+	});
+}
+
+Response.prototype.getBody = function() {
+
+	var obj = this;
+	return obj.body;
+}
+
+Response.prototype.getStatus = function() {
+
+	var obj = this;
+	return obj.status;
+}
+
+Response.prototype.getHeader = function(name) {
+
+	var obj = this,
+		ret = null;
+	ret = _.find(obj.headers, function(header) {
+		return header.name == name;
+	});
+	return ret;
+}
+
+Response.prototype.respond = function() {
+
+	var obj = this;
+	this.setHeader('Access-Control-Allow-Origin', '*');
+
+	_.each(obj.headers, function(header) {
+		obj.res.setHeader(header.name, header.value);
+	});
+	obj.res.writeHead(obj.status);
+	obj.res.end(obj.body);
+}
+
+Response.prototype.error404 = function() {
+
+	var obj = this;
+	obj.res.writeHead(404, {"Content-Type": "text/plain"});
+    obj.res.write("404 Not Found\n");
+    obj.res.end();
+}
+
+Response.prototype.render = function(template) {
+
+	var obj = this,
+		path = require("path"),
+		fs = require("fs"),
+		template = 'pages/' + template;
+
+	const filename = path.join(process.cwd(), 'public/' + template);
+	const fileStream = fs.createReadStream(filename);
+	obj.res.writeHead(200, { 'Content-Type': 'text/html' });
+	fileStream.pipe(obj.res);
+}
+
+module.exports = Response;

package/framework/router.js

@@ -0,0 +1,235 @@
+/**
+	Version 3.5
+	Created by: nalancer08 <https://github.com/nalancer08>
+**/
+
+var Request  = require('./request.js');
+var Response = require('./response.js');
+var _ = require('underscore');
+
+function Router(server) {
+
+	this.routes = {
+		'*': [],
+		'get': [],
+		'post': []
+	};
+	this.defaultRoute = '';
+	this.server = server;
+}
+
+Router.prototype.routeToRegExp = function(route) {
+
+	var optionalParam = /\((.*?)\)/g,
+		namedParam    = /(\(\?)?:\w+/g,
+		splatParam    = /\*\w+/g,
+		escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+	// Convert route to regular expression, this was taken from Backbone's router
+	route = route.replace(escapeRegExp, '\\$&')
+		.replace(optionalParam, '(?:$1)?')
+		.replace(namedParam, function(match, optional) {
+			return optional ? match : '([^/?]+)';
+		})
+		.replace(splatParam, '([^?]*?)');
+	return new RegExp(`^${route}(?:\\?([\\s\\S]*))?$`);
+};
+
+Router.prototype.addRoute = function(method, route, handler, insert) {
+
+	var obj = this,
+		insert = insert || false,
+		method = method.toLowerCase(),
+		prev = (obj.server.options.base_url && obj.server.options.base_url != '' && obj.server.options.base_url != '/') ? obj.server.options.base_url : '',
+		instance = {
+			regexp: obj.routeToRegExp(prev + route),
+			handler: handler
+		};
+	// Add the route, may be at the beginning or at the end
+	if (insert) { // Adding the route at the beginning of the route's array
+		obj.routes[method].unshift(instance);
+	} else { // Adding the route at the end of the route's array
+		obj.routes[method].push(instance);
+	}
+};
+
+Router.prototype.removeRoute = function(method, route) {};
+
+Router.prototype.onRequest = function(req, res) {
+
+	var obj = this;
+	var isMatch = false;
+	var zlib = require('zlib');
+	var response = new Response(res);
+	var request = new Request(req, {
+			onDataReceived: function() {
+
+				//console.log(request.path);
+				if (request.path == obj.server.options.base_url) {
+					request.path = obj.server.options.base_url + obj.defaultRoute;
+				}
+
+				// Try with the routes for the current method (get or post)
+				_.each(obj.routes[request.type], function(route) {
+					if ( request.path.match(route.regexp) ) {
+
+						var parts = route.handler.split('.'),
+							clazz = parts[0],
+							method = parts[1],
+							callback = obj.validateCallback(clazz, method);
+
+						if (callback && callback != undefined && callback != '') {
+
+							isMatch = true;
+							handled = callback(request, response, obj.server);
+							return;
+						}
+					}
+				});
+
+				// If not handled yet, try with the wildcard ones
+				if (!handled) {
+					_.each(obj.routes['*'], function(route) {
+
+						if ( request.path.match(route.regexp) ) {
+
+							var parts = route.handler.split('.'),
+								clazz = parts[0],
+								method = parts[1],
+								callback = obj.validateCallback(clazz, method);
+
+							if (callback && callback != undefined && callback != '') {
+
+								isMatch = true;
+								handled = callback(request, response, obj.server);
+								return;
+							}
+						}
+					});
+				}
+
+				// No route catched, maybe it's a static content
+				// or not handled? Well, at this point we call 404
+				if (handled == false && isMatch == false ) {
+
+					var path = require('path'),
+						ext = path.extname(req.url).replace('.', ''),
+						extHandled = false,
+						extHeader = {};
+					var mimes = {
+
+						'png' : 'image/png',
+						'webp': 'image/webp',
+						'jpg' : 'image/jpg',
+						'css' : 'text/css',
+						'gz'  : 'application/x-gzip',
+						'gif' : 'image/gif',
+						'js'  : 'text/javascript',
+						'svg' : 'image/svg+xml',
+						'ttf' : 'application/x-font-ttf',
+						'otf' : 'application/x-font-opentype',
+						'pdf' : 'application/pdf',
+						'json' : 'application/json'
+					};
+
+					var compressionMimes = {
+						'css' : 'text/css',
+						'js'  : 'text/javascript',
+						'gz'  : 'application/x-gzip'
+					};
+
+					if (mimes[ext] != undefined && mimes[ext] != 'undefined') {
+
+						extHandled = true;
+						extHeader = {'Content-Type': mimes[ext]};
+					}
+
+					if (extHandled) {
+
+						var fs = require('fs'),
+							rep = __dirname.replace('core/framework', ''),
+							route = request.path.replace(obj.server.options.base_url, ''),
+							filename = path.join(rep, route),
+							filePrivate = obj.isProtectedFile(route);
+
+						fs.exists(filename, function(exists) {
+
+							if (exists && !filePrivate) {
+								
+								var acceptEncoding = (req.headers['accept-encoding'] != undefined) ? req.headers['accept-encoding'] : '';
+								var fileStream = fs.createReadStream(filename);
+								if (acceptEncoding.match(/\bgzip\b/) && compressionMimes[ext] != undefined) {
+									extHeader['Content-Encoding'] = 'gzip';
+			       					res.writeHead(200, extHeader);
+			       					fileStream.pipe(zlib.createGzip()).pipe(res);
+								} else {
+									res.writeHead(200, extHeader);
+									fileStream.pipe(res);
+								}
+								return;
+
+							} else {
+
+								// Return 404
+								obj.onNotFound(response);
+							}
+						});
+					}
+				}
+			}
+		}),
+		handled = false;
+	isMatch = false;
+};
+
+Router.prototype.isProtectedFile = function(route) {
+
+	let protectedDirs = ['framework', 'external', 'node_mudules'];
+	var routeParts = route.split('/');
+	if (routeParts[1] != undefined && routeParts.length > 2) {
+		return protectedDirs.includes(routeParts[1]);
+	}
+	return true;
+};
+
+Router.prototype.validateExtension = function(route) {};
+
+Router.prototype.validateCallback = function(clazz, method) {
+
+	var obj = this,
+		endpoints = obj.server.functions.endpoints;
+
+	if (endpoints[clazz] != undefined) {
+
+		clazz = endpoints[clazz];
+
+		if (typeof clazz[method] === 'function') {
+			return clazz[method];
+		}
+	}
+	return '';
+};
+/**
+* This method allows to set the default route for the api
+* @param route: String name for the route
+**/
+Router.prototype.setDefaultRoute = function(route) {
+
+	var obj = this;
+	obj.defaultRoute = route;
+};
+
+Router.prototype.getDefaultRoute = function() {
+
+	var obj = this,
+		prev = (obj.server.options.base_url && obj.server.options.base_url != '' && obj.server.options.base_url != '/') ? obj.server.options.base_url : '';
+
+	return (prev + obj.defaultRoute);
+};
+
+Router.prototype.onNotFound = function(response) {
+
+	response.setStatus(404);
+	response.respond();
+};
+
+module.exports = Router;

package/framework/server.js

@@ -0,0 +1,116 @@
+/**
+	Version 3.5
+	Created by: nalancer08 <https://github.com/nalancer08>
+**/
+
+const _ = require('underscore');
+const http = require('http');
+const http2 = require('http2');
+const url = require('url') ;
+const fs = require('fs');
+const nunjucks = require('nunjucks');
+const path = require('path');
+
+var Router = require('./router.js');
+var Dipper = require('./dipper.js');
+var Functions = require('../external/functions.js');
+
+function Server(options) {
+
+	this.httpx = null;
+	this.verbose = true;
+	this.router = null;
+	this.functions = null;
+	this.dipper = null;
+	this.init(options);
+}
+
+Server.prototype.init = function(options) {
+
+	var obj = this,
+		settings = options.settings,
+		opts = settings[options.profile] || {},
+		shared = settings['shared'] || {},
+		security = settings['security'] || {};
+
+	_.defaults(opts, {
+		base_url: '',
+		site_url: '',
+		wsServer: false,
+		onNotFound: obj.onNotFound
+	});
+	obj.options = opts;
+
+	_.defaults(security, {
+		pass_salt: '1234567890',
+		token_salt: '0987654321',
+		version: '1.0'
+	});
+	obj.security = security;
+
+	// Render
+	global.render = nunjucks.configure(path.join(process.cwd(), 'assets'), {
+		autoescape: false,
+		throwOnUndefined: true,
+		noCache: true,
+	});
+	global.dipper = new Dipper(opts, shared);
+
+	// Cheking for http or https
+	if (/^((http):\/\/)/.test(obj.options.site_url) || /^((localhost))/.test(obj.options.site_url)) {
+
+		obj.httpx = http.createServer((req, res) => {
+			//console.log(req.url);
+			obj.router.onRequest.call(obj.router, req, res);
+		});
+
+	} else if (/^((https):\/\/)/.test(obj.options.site_url)) {
+
+		certs = {
+			key: fs.readFileSync(obj.security.key, 'utf8'),
+			cert: fs.readFileSync(obj.security.cert, 'utf8'),
+			allowHTTP1: true
+		};
+		obj.httpx = http2.createSecureServer(certs, (req, res) => {
+			obj.router.onRequest.call(obj.router, req, res);
+		});
+	}
+
+	obj.onNotFound = opts.onNotFound;
+
+	// Initialize router
+	obj.router = new Router(obj);
+
+	// Setting endpoints
+	obj.functions = new Functions(obj);
+};
+
+Server.prototype.start = function() {
+
+	var obj = this;
+	var port = (obj.options.port && obj.options.port != '') ? obj.options.port : 8080;
+
+	// Listen on the specified port
+	obj.httpx.listen(port);
+
+	// Logging
+	obj.log('__________________  Dragonfly server started  ___________________');
+	obj.log(` >           Listening on ${obj.options.site_url}:${obj.options.port}${obj.options.base_url}         < `);
+	obj.log('-----------------------------------------------------------------');
+};
+
+Server.prototype.log = function(value) {
+
+	var obj = this;
+	if (obj.verbose) {
+		console.log(value);
+	}
+};
+
+Server.prototype.onNotFound = function(request, response) {
+
+	response.setStatus(404);
+	response.respond();
+};
+
+module.exports = Server;

package/index.js

@@ -0,0 +1,5 @@
+function helloNpm() {
+    return "hello NPM"
+}
+  
+module.exports = helloNpm

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "vanilla-jet",
+  "version": "1.0.0",
+  "description": "VannilaJet framework",
+  "main": "index.js",
+  "scripts": {
+    "dev": "grunt --env=development & nodemon index.js --ignore '**/public/**'",
+    "build:qa": "grunt build --env=qa",
+    "build:prod": "grunt build --env=production",
+    "start": "pm2 start index.js -- --p production",
+    "test": "npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nalancer08/VanillaJet.git"
+  },
+  "keywords": [
+    "webapp",
+    "spa"
+  ],
+  "author": "Erick Sanchez",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/nalancer08/VanillaJet/issues"
+  },
+  "homepage": "https://github.com/nalancer08/VanillaJet#readme",
+  "dependencies": {
+    "blueimp-md5": "2.8.0",
+    "html-minifier-terser": "7.2.0",
+    "js-beautify": "1.14.8",
+    "jsrsasign": "11.0.0",
+    "jwt-simple": "0.5.3",
+    "minimist": "1.2.6",
+    "nunjucks": "3.2.4",
+    "underscore": ">= 1.12.x",
+    "zlib": "1.0.5"
+  },
+  "devDependencies": {
+    "grunt": "1.6.1",
+    "grunt-cli": "1.4.3",
+    "grunt-contrib-clean": "2.0.1",
+    "grunt-contrib-compress": "2.0.0",
+    "grunt-contrib-concat": "2.1.0",
+    "grunt-contrib-cssmin": "5.0.0",
+    "grunt-contrib-less": "3.0.0",
+    "grunt-contrib-uglify": "5.0.1",
+    "grunt-contrib-watch": "1.1.0",
+    "grunt-run": "0.8.1",
+    "grunt-shell": "4.0.0",
+    "jit-grunt": "0.10.0",
+    "nodemon": "3.0.1"
+  }
+}