general,web,db - rewrite db module, add async handling

app.js

@@ -8,17 +8,15 @@
 // GDS: Global Data System
 global['gds'] = {
 	debug: (process.env.NODE_ENV === 'debug') ? true : false,
-	db: null,
 	cache: {},
 	cfg: require(__dirname+'/bin/config')
 };
-global['modules'] = {};
 global['__dirname'] = __dirname;
 
 /**
  * load modules
  */
-let load = (name) => {
+let load = global['requireModule'] = (name) => {
 	return require(__dirname+'/bin/'+name+'/module');
 };
 
@@ -33,16 +31,9 @@ env_vars.forEach((el) => {
 });
 if(env_missing) process.exit();
 
-global['modules'].events = load('events'); // event handler
+load('events'); // event handler
 
-global['modules'].logs = load('logs'); // log handler
+global['logs'] = load('logs'); // log handler
-global['logs'] = global['modules'].logs; // alias
 
-global['modules'].database = load('database'); // database service
+let web = load('web'); // web server
-global['modules'].web = load('web'); // web server
+web.start(); // start web server
-global['modules'].auth = load('auth'); // authentication handler
-
-global['logs'] = global['modules'].logs; // alias
-
-// start web server
-global['modules'].web.start();

bin/database/module.js

@@ -13,28 +13,40 @@ var sanitize = require('mongo-sanitize');
 var crypto = require('crypto');
 var methods = {};
 
-// connect
+var log = require(global['__dirname']+'/bin/logs/module');
-mongoose.connect(global['gds'].cfg.mongoose.uri, {
+var cfg = require(global['__dirname']+'/bin/config');
-	useNewUrlParser: true
-});
-mongoose.set('useFindAndModify', false);
-
-global['gds'].db = mongoose.connection;
 
+var db;
 var mdls = require('./models.js');
-var models = mdls(global['gds'].db);
+var models;
 
-(async function() {
-	global['gds'].db = await global['gds'].db.useDb(global['gds'].cfg.mongoose.db);
 
-	models = mdls(global['gds'].db);
+/**
-})();
+ * connects to db
+ * @author Ruben Meyer
+ * @async
+ */
+methods.connect = async () => {
+	if(typeof db !== "undefined") return;
+
+	// connect
+	mongoose.connect(cfg.mongoose.uri, {
+		useNewUrlParser: true,
+		useUnifiedTopology: true,
+		useFindAndModify: false
+	});
+
+
+	db = mongoose.connection;
+	db = await db.useDb(cfg.mongoose.db);
+	models = mdls(db);
 
 	// connection error handling
-global['gds'].db.on('error', (data) => {
+	db.on('error', (data) => {
-	global['modules'].logs.error('MongoDB connection error:\n', data);
+		log.error('MongoDB connection error:\n', data);
 		process.exit(); // exit on connection error
 	});
+}
 
 //  //    //  //////// ////////  ///////
 //  //    //  //       //        //    //
@@ -48,18 +60,18 @@ global['gds'].db.on('error', (data) => {
 /**
  * Adds User to Database
  * @author Ruben Meyer
+ * @async
  * @param {String} nick nickname
  * @param {String} email email
  * @param {String} passhash hashed password
  * @param {Number} group Group id (normally 0 -> user)
- *	@param {Function} callback Callback function (error, reply)
+ * @return {Array} async (reply, err)
  */
-methods.addUser = (nick, email, passhash, group, callback) => {
+methods.addUser = async (nick, email, passhash, group) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof nick !== 'string') return {err: new TypeError('nick is not a string::database.addUser('+nick+','+email+','+passhash+','+group+')', module.filename)};
-	if(typeof nick !== 'string') return callback(new TypeError('nick is not a string::database.addUser('+nick+','+email+','+passhash+','+group+',callback)', module.filename));
+	if(typeof email !== 'string') return {err: new TypeError('email is not a string::database.addUser('+nick+','+email+','+passhash+','+group+')', module.filename)};
-	if(typeof email !== 'string') return callback(new TypeError('email is not a string::database.addUser('+nick+','+email+','+passhash+','+group+',callback)', module.filename));
+	if(typeof passhash !== 'string') return {err: new TypeError('passhash is not a string::database.addUser('+nick+','+email+','+passhash+','+group+')', module.filename)};
-	if(typeof passhash !== 'string') return callback(new TypeError('passhash is not a string::database.addUser('+nick+','+email+','+passhash+','+group+',callback)', module.filename));
+	if(isNaN(group)) return {err: new TypeError('group is not a number::database.addUser('+nick+','+email+','+passhash+','+group+')', module.filename)};
-	if(isNaN(group)) return callback(new TypeError('group is not a number::database.addUser('+nick+','+email+','+passhash+','+group+',callback)', module.filename));
 
 	let userModel = models.user;
 
@@ -69,70 +81,70 @@ methods.addUser = (nick, email, passhash, group, callback) => {
 	user.passhash = sanitize(passhash);
 	user.group = sanitize(group);
 
-	user.save((err) => {
+	try {
-		if(!err) callback(null, 1);
+		reply = await user.save();
-		else callback(err);
+		return {reply: 1};
-	});
+	} catch(err) {
+		return {err: err};
+	}
 };
 
 
 /**
- * Deletes User from Database
+ * deletes user identified by haystack from database
  * @author Ruben Meyer
- * @TODO
+ * @async
+ * @TODO add functionality
  * @param {String} haystack email or nick
- * @param {Function} callback Callback function (error, reply)
+ * @return {Array} async(reply, err)
  */
-methods.delUser = (haystack, callback) => {
+methods.delUser = async (haystack) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof haystack !== 'string') return {err: new TypeError('haystack is not a string::database.delUser('+haystack+')', module.filename)};
-	if(typeof haystack !== 'string') return callback(new TypeError('haystack is not a string::database.delUser('+haystack+',callback)', module.filename));
 
 	let userModel = models.user;
 
 	// sanitize input
 	haystack = sanitize(haystack);
 
-	userModel.findOneAndDelete().or([{nickname: haystack}, {email: haystack}])
+	try {
-	.then((rep) => {
+		reply = await userModel.findOneAndDelete().or([{nickname: haystack}, {email: haystack}]).exec();
-		// TODO delete user
+		log.debug('deleted user: '+haystack);
-		global['logs'].debug('deleted user: '+haystack);
+		return {reply: 1};
-		callback(null, 1);
+	} catch(err) {
-	}).catch((err) => {
+		return {err: err};
-		callback(err);
+	}
-	});
 };
 
 
 /**
  * get all users
  * @author Ruben Meyer
- * @param {Function} callback Callback function (reply -> Array users)
+ * @async
+ * @return {Array} async(reply, err)
  */
-methods.getUsers = (callback) => {
+methods.getUsers = async () => {
-	if(typeof callback !== 'function') callback = function() {};
-
 	let userModel = models.user;
 
-	userModel.find({})
+	try {
-	.then((users) => {
+		users = await userModel.find({}).exec();
 		if(users.length > 0)
-			return callback(null, users);
+			return {reply: users};
 		else
-			return callback(null, false);
+			return {reply: false};
-	}).catch((err) => {
+	} catch(err) {
-		return callback(err);
+		return {err: err};
-	});
+	}
 };
 
 /**
- * query users by email, nickname or rememberme token
+ * query users by UUID, email, nickname or rememberme token
  * @author Ruben Meyer
+ * @async
  * @param {String|String[]} haystack email or nick
- * @param {Function} callback Callback function (reply -> Array users)
+ * @return async(reply, err)
  */
-methods.getUser = (haystack, callback) => {
+methods.getUser = async (haystack) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof haystack !== 'string' && typeof haystack !== 'object') return {err: new TypeError('email or nickname is not a string|object::database.getUser('+haystack+')', module.filename)};
-	if(typeof haystack !== 'string' && typeof haystack !== 'object') return callback(new TypeError('email or nickname is not a string|object::database.getUser('+haystack+',callback)', module.filename));
 
 	let userModel = models.user;
 
@@ -154,35 +166,39 @@ methods.getUser = (haystack, callback) => {
 		}
 	}
 
-	userModel.find().or(or)
+	try {
-	.then((users) => {
+		users = await userModel.find().or(or).exec();
+
 		if(users.length > 0)
-			return callback(null, users);
+			return {reply: users};
 		else
-			return callback(null, false);
+			return {reply: false};
-	}).catch((err) => {
+	} catch(err) {
-		return callback(err);
+		return {err: err};
-	});
+	}
 };
 
 
 /**
  * updates obj keys in user entry
  * @author Ruben Meyer
+ * @async
  * @param {Number} id User ID
  * @param {Object} obj data
- * @param {Function} callback Callback function
+ * @return {Array} async(reply, err)
  */
-methods.updateUser = (id, obj, callback) => {
+methods.updateUser = async (id, obj) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof id !== 'string') return {err: new TypeError('id is not a string::database.updateUser('+id+','+JSON.stringify(obj)+')', module.filename)};
-	if(typeof id !== 'string') return callback(new TypeError('id is not a string::database.updateUser('+id+','+JSON.stringify(obj)+',callback)', module.filename));
+	if(typeof obj !== 'object') return {err: new TypeError('obj is not an object::database.updateUser('+id+','+JSON.stringify(obj)+')', module.filename)};
-	if(typeof obj !== 'object') return callback(new TypeError('obj is not an object::database.updateUser('+id+','+JSON.stringify(obj)+',callback)', module.filename));
 
 	let userModel = models.user;
-	userModel.findByIdAndUpdate(id, obj, (err, data) => {
+
-		if(err) callback(err);
+	try {
-		else callback(null, data);
+		data = await userModel.findByIdAndUpdate(id, obj).exec();
-	});
+		return {data: data};
+	} catch(err) {
+		return {err: err};
+	}
 
 };
 
@@ -190,43 +206,49 @@ methods.updateUser = (id, obj, callback) => {
 /**
  * updates data based on login
  * @author Ruben Meyer
+ * @async
  * @TODO UPDATE METHOD; PROBABLY OUTDATED
  * @param {Number} id User ID
  * @param {Object} data data JSON -> remember
- * @param {Function} callback Callback function (date => 'Login Date', token => 'RememberMe Cookie Token')
+ * @return {Array} async({date => 'Login Date', token => 'RememberMe Cookie Token'}, err)
  */
-methods.addActivity = (id, data, callback) => {
+methods.addActivity = async (id, data) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof id !== 'string') return {err: new TypeError('id is not a string::database.updateNewAction('+id+','+JSON.stringify(options)+')', module.filename)};
-	if(typeof id !== 'string') return callback(new TypeError('id is not a string::database.updateNewAction('+id+','+JSON.stringify(options)+',callback)', module.filename));
+	if(typeof options !== 'object' && options !== null) return {err: new TypeError('obj is not an object::database.updateUserProfile('+id+','+JSON.stringify(obj)+')', module.filename)};
-	if(typeof options !== 'object' && options !== null) return callback(new TypeError('obj is not an object::database.updateUserProfile('+id+','+JSON.stringify(obj)+',callback)', module.filename));
 
 	let date = new Date().toISOString();
 	let timestamp = new Date(date).getTime();
 
-	functions.updateUserProfile(id, {
+	try {
+		reply = await methods.updateUser(id, {
 			last_action: date
-	}, (err, rep) => {
+		});
-		if(err) return callback(err);
+
 		if(options.rememberme && options.new_token !== false) {
 			var token = ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, (c) => (c ^ crypto.randomBytes(new Uint8Array(1).length)[0] & 15 >> c / 4).toString(16));
-
 			var Remember =  models.remember;
-			Remember.findOneAndUpdate({userId: id}, {token: token, timestamp: Date.now()}, {upsert: true}, (err1, data) => {
+
-				if(err1) callback(err1);
+			try {
-				return callback(null, {
+				data = await Remember.findOneAndUpdate({userId: id}, {token: token, timestamp: Date.now()}, {upsert: true}).exec();
+				return {reply: {
 					date: date,
 					timestamp: timestamp,
 					token: token
-				});
+				}};
-			});
+			}
+			catch(err) {
+				return {err: err};
+			}
 		} else {
-			callback(null, {
+			return {reply: {
 				date: date,
 				timestamp: timestamp,
 				token: options.old_token
-			});
+			}};
+		}
+	} catch(err) {
+		return {err: err};
 	}
-	});
 };
 
 
@@ -241,27 +263,28 @@ methods.addActivity = (id, data, callback) => {
 /**
  * get Applications
  * @author Ruben Meyer
- * @param {Function} callback Callback function (err, apps)
+ * @async
+ * @return {Array} async(apps, err)
  */
-methods.getApps = (callback) => {
+methods.getApps = async () => {
-	if(typeof callback !== 'function') callback = function() {};
 	var Application = models.application;
-
+	try {
-	Application.find({}, (err, apps) => {
+		apps = await Application.find({}).exec();
-		if(err) callback(err);
+		return {reply: apps};
-		else callback(null, apps);
+	} catch(err) {
-	});
+		return {err: err};
+	}
 };
 
 /**
  * return auth obj
  * @author Ruben Meyer
+ * @async
  * @param {Object} obj data obj (aId, uId)
- * @param {Function} callback Callback function (err, obj) obj -> (aId, uId, token)
+ * @return {Array} async({timestamp, token}, err)
  */
-methods.setAuthCode = (obj, callback) => {
+methods.setAuthCode = async (obj) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof obj !== 'object') return {err: new TypeError('obj is not an object::database.setAuthCode('+JSON.stringify(obj)+')', module.filename)};
-	if(typeof obj !== 'object') return callback(new TypeError('obj is not an object::database.setAuthCode('+JSON.stringify(obj)+',callback)', module.filename));
 
 
 	var AuthCode = models.authCode;
@@ -275,74 +298,80 @@ methods.setAuthCode = (obj, callback) => {
 		timestamp: Date.now()
 	};
 
-	AuthCode.findOneAndUpdate(query, change, {upsert: true}, (err1, data) => {
+	try {
-		if(err1) callback(err1);
+		data = await AuthCode.findOneAndUpdate(query, change, {upsert: true}).exec();
-		return callback(null, {
+		return {reply: {
 			timestamp: change.timestamp,
 			token: change.token
-		});
+		}};
-	});
+	} catch(err) {
+		return {err: err};
+	}
 };
 
 /**
  * return auth obj
  * @author Ruben Meyer
+ * @async
  * @param {Object} obj data obj (aId, aSecret, uId, token)
- * @param {Function} callback Callback function (err, bool)
+ * @return {Array} async(bool, err)
  */
-methods.getAuth = (obj, callback) => {
+methods.getAuth = async (obj) => {
-	if(typeof callback !== 'function') callback = function() {};
+	if(typeof obj !== 'object') return {err: new TypeError('obj is not an object::database.getAuthCode('+JSON.stringify(obj)+')', module.filename)};
-	if(typeof obj !== 'object') return callback(new TypeError('obj is not an object::database.getAuthCode('+JSON.stringify(obj)+',callback)', module.filename));
 
 	var AuthCode = models.authCode;
-	AuthCode.findOne({
+
+	try {
+		data = await AuthCode.findOne({
 			$and: [
 				{applicationId: mongoose.Types.ObjectId(obj.aId)},
 				{userId: mongoose.Types.ObjectId(obj.uId)},
 				{token: obj.token}
 			]
-	}, (err, data) => {
+		}).exec();
-		if(err) callback(err);
+
-		else {
 		if(typeof data === "object") {
-				if(data === null || data === []) return callback(null, false);
+			if(data === null || data === []) return {reply: false};
 			var Application = models.application;
 
-				Application.findOne({
+			try {
+				data1 = await Application.findOne({
 					$and: [
 						{_id: mongoose.Types.ObjectId(obj.aId)},
 						{secret: obj.aSecret}
 					]
-				}, (err1, data1) => {
+				}).exec();
-					if(err1) callback(err1);
+
-					else {
 				if(obj.token == data.token
 				&& obj.aId == String(data.applicationId)
 				&& obj.uId == String(data.userId)
 				&& obj.aSecret == data1.secret) {
-							callback(null, true);
+					return {reply: true};
-							//functions.setAuthCode({
+					//methods.setAuthCode({
 					//	aId: obj.aId,
 					//	uId: obj.uId
-							//}, () => {});
+					//});
 				}
-						else callback(null, false);
+				else return{reply: false};
+			} catch(err) {
+				return {err: err};
 			}
-				});
+		} else return {reply: false};
-			} else callback(null, false);
+	} catch(err) {
+		return {err: err};
 	}
-	});
 
 };
 
 /**
  * return if app is permitted to do access call
  * @author Ruben Meyer
+ * @async
  * @param {Object} obj data obj (aId, redirectUrl)
- * @param {Function} callback Callback function (err, bool)
+ * @return {Array} async(bool, err)
  */
-methods.verifyAppCall = (obj, callback) => {
+methods.verifyAppCall = async (obj) => {
-
+	return {};
 };
 
 //  ////////  ////////  ////////  ////////  ////////
@@ -354,17 +383,20 @@ methods.verifyAppCall = (obj, callback) => {
 ////////////////////////////////////////////////////////
 
 /**
- * callback with user count
+ * returns user count
  * @author Ruben Meyer
- * @param {Function} callback Callback function (reply -> int)
+ * @async
+ * @return {Array} async(int, err)
  */
-methods.userCount = (callback) => {
+methods.userCount = async () => {
-	if(typeof callback !== 'function') callback = function() {};
-
 	let userModel = models.user;
-	userModel.countDocuments({}, (err, count) => {
+
-		callback((err) ? err : count);
+	try {
-	});
+		count = await userModel.countDocuments({}).exec();
+		return {reply: count};
+	} catch(err) {
+		return {err: err};
+	}
 };
 
 

bin/web/module.js

@@ -7,6 +7,8 @@
 // init
 var methods = {};
 
+var cfg = require(global['__dirname']+'/bin/config');
+
 /**
  * start web server
  * @author Ruben Meyer
@@ -33,7 +35,7 @@ methods.start = () => {
 	// Access Control Headers
 	app.use( (req, res, next) => {
 		res.set({
-			'X-Powered-By': global['gds'].cfg.web.poweredBy
+			'X-Powered-By': cfg.web.poweredBy
 		});
 		res.header("Access-Control-Allow-Origin", "*");
 		res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
@@ -50,6 +52,7 @@ methods.start = () => {
 		// path already cached; not exist
 		if(global['gds'].cache.web[joined_path] == false) {
 			res.status(404).end();
+			global['logs'].info("[web] (404) path not found: "+joined_path);
 		// path already cached; exist
 		} else if(global['gds'].cache.web[joined_path] == true){
 			let contentType = mime.contentType(path.extname(joined_path));
@@ -66,6 +69,7 @@ methods.start = () => {
 					fs.createReadStream(joined_path).pipe(res);
 				} else {
 					res.status(404).end();
+					global['logs'].info("[web] (404) path not found: "+joined_path);
 				}
 			});
 		}
@@ -76,7 +80,7 @@ methods.start = () => {
 	app.use(bp.urlencoded({
 		extended: true
 	}));
-	app.use(cp(global['gds'].cfg.web.cookieKey));
+	app.use(cp(cfg.web.cookieKey));
 
 	// Pretty print
 	if(app.get('env') === 'debug')
@@ -84,7 +88,7 @@ methods.start = () => {
 
 	// Sessions
 	session_options = {
-		secret: global['gds'].cfg.web.sessionKey,
+		secret: cfg.web.sessionKey,
 		resave: false,
 		saveUninitialized: false, cookie: {}};
 	if(app.get('env') === 'production') {
@@ -93,13 +97,19 @@ methods.start = () => {
 	app.use(session_handler(session_options));
 
 	// web routes
-	app.use('/', require(global['__dirname']+'/bin/web/routes/static'));
+	(async function() {
-	app.use('/api', require(global['__dirname']+'/bin/web/routes/api'));
+		let mRoutes = require(global['__dirname']+'/bin/web/routes/static');
+		let mainRoutes = await mRoutes.getRoutes();
+		app.use('/', mainRoutes);
+		let rAPI = require(global['__dirname']+'/bin/web/routes/api');
+		let restAPI = await rAPI.getRoutes();
+		app.use('/api', restAPI);
 
 		// start server
-	app.listen(global['gds'].cfg.web.port, () => {
+		app.listen(cfg.web.port, () => {
-		global['modules'].logs.log("Server is listening on port: "+global['gds'].cfg.web.port);
+			global['logs'].log("Server is listening on port: "+cfg.web.port);
 		});
+	})();
 };
 
 module.exports = methods;

bin/web/routes/api.js

@@ -6,6 +6,12 @@
 
 var express = require('express');
 var route = express.Router();
+asyncer = require('express-async-handler');
+
+getRoutes = async () => {
+	let db = global['requireModule']('database');
+	await db.connect();
+
 
 	/**
 	 * register a user; currently not implemented
@@ -29,7 +35,7 @@ route.post('/register', (req, res) => {
 	 * @POST ['email', 'password']
 	 * @TODO add new activity 'action.user.login'
 	 */
-route.post('/login', (req, res) => {
+	route.post('/login', asyncer(async (req, res) => {
 		// if user is logged in (existing session); FAIL
 		if(req.session.user) {
 			return res.type('json').end(JSON.stringify({
@@ -52,11 +58,12 @@ route.post('/login', (req, res) => {
 		let pass = req.body.password;
 
 		// database query: get user by email
-	global['modules'].database.getUser(email, (err, rep) => {
+		user = await db.getUser(email);
+
 		// if database error
-		if(err) {
+		if(user.err) {
 			// log error while debugging
-			global['logs'].debug(err);
+			global['logs'].debug(user.err);
 
 			// login failed because of database error
 			return res.type('json').status(500).end(JSON.stringify({
@@ -69,7 +76,7 @@ route.post('/login', (req, res) => {
 		}
 
 		// no reply (user does not exist) or password is wrong
-		if(!rep || rep === null || rep.length == 0 || rep.length > 1 || !global['modules'].auth.validateHash(rep[0].passhash, pass)) {
+		if(!user.reply || user.reply === null || user.reply.length == 0 || user.reply.length > 1 || !global['requireModule']('auth').validateHash(user.reply[0].passhash, pass)) {
 			return res.type('json').status(401).end(JSON.stringify({
 				status: 401,
 				message: 'msg.auth.login.failed'
@@ -81,8 +88,8 @@ route.post('/login', (req, res) => {
 
 			// add session data
 			req.session.user = {
-				'id': rep[0]._id,
+				'id': user.reply[0]._id,
-				'group': rep[0].group
+				'group': user.reply[0].group
 			};
 
 			return res.type('json').end(JSON.stringify({
@@ -91,8 +98,8 @@ route.post('/login', (req, res) => {
 				type: 'form' // TODO: types - { form, access_app}
 			}));
 		}
-	});
+
-});
+	}));
 
 	/**
 	 * apps verify token
@@ -135,7 +142,7 @@ route.get('/cancel', (req, res) => {
 	 * @method GET
 	 * @GET ['id']
 	 */
-route.get('/redirect', (req, res) => {
+	route.get('/redirect', asyncer(async (req, res) => {
 		// if user is logged in
 		if(req.session && req.session.user) {
 			// missing query data to retrieve app
@@ -149,13 +156,14 @@ route.get('/redirect', (req, res) => {
 			}
 
 			// set auth code
-		global['modules'].database.setAuthCode({
+			authCode = await db.setAuthCode({
 				aId: req.query.id,
 				uId: req.session.user.id
-		}, (err, rep) => {
+			});
+
 			// database error
-			if(err) {
+			if(authCode.err) {
-				global['logs'].debug(err);
+				global['logs'].debug(authCode[1]);
 				return res.type('json').status(500).end(JSON.stringify({
 					status: 500,
 					message: [
@@ -165,10 +173,10 @@ route.get('/redirect', (req, res) => {
 			}
 			else if(rep) {
 				// retrieve apps
-				global['modules'].database.getApps((err2, rep2) => {
+				apps = await db.getApps();
 				// database error
-					if(err2) {
+				if(apps.reply) {
-						global['logs'].debug(err2);
+					global['logs'].debug(apps.err);
 					return res.type('json').status(500).end(JSON.stringify({
 						status: 500,
 						message: [
@@ -177,14 +185,13 @@ route.get('/redirect', (req, res) => {
 					}));
 				}
 				// for each app
-					rep2.forEach((app) => {
+				apps.reply.forEach((app) => {
 					// if app.id is equal to queried app
 					if(app.id == req.query.id) {
 						// redirect to app
 						return res.redirect(app.access+"?uid="+req.session.user.id+"&token="+rep.token);
 					}
 				});
-				});
 			} else {
 				// database error
 				return res.type('json').status(500).end(JSON.stringify({
@@ -194,7 +201,6 @@ route.get('/redirect', (req, res) => {
 					]
 				}));
 			}
-		});
 		// user isnt logged in
 		} else {
 			return res.type('json').end(JSON.stringify({
@@ -202,7 +208,7 @@ route.get('/redirect', (req, res) => {
 				message: 'msg.auth.login.required'
 			}));
 		}
-});
+	}));
 
 	/**
 	 * logout user
@@ -237,4 +243,9 @@ if(global['gds'].debug) {
 		});
 	}
 
-module.exports = route;
+	return route;
+};
+
+module.exports = {
+	getRoutes: getRoutes
+};

bin/web/routes/static.js

@@ -4,12 +4,16 @@
  * (c) Ruben Meyer <contact@rxbn.de>
  */
 
-var express = require('express');
+express = require('express');
-var route = express.Router();
+route = express.Router();
+asyncer = require('express-async-handler');
 
-var fs = require('fs');
+fs = require('fs');
-var path = require('path');
+path = require('path');
 
+
+
+// reduce IO file checks - save file state in cache
 var fileCheck = (file) => {
 	if(typeof global['gds'].cache.web == 'undefined') global['gds'].cache.web = {};
 	let dir = global['__dirname'] + '/bin/web/views';
@@ -29,28 +33,31 @@ var fileCheck = (file) => {
 	}
 };
 
+let getRoutes = async () => {
+	let db = global['requireModule']('database');
+	await db.connect();
+
 	/**
 	 * main page
 	 * @url /
 	 * @method all
 	 */
-route.all('/', function(req, res, next) {
+	route.all('/', asyncer(async (req, res, next) => {
 		// TODO: show login page or dashboard
 		// res.end('login or dashboard');
-	global['modules'].database.getApps((err, rep) => {
+		apps = await db.getApps();
 		res.render('index', {
 			session: req.session,
-			apps: rep
+			apps: apps.reply
-		});
-	})
 		});
+	}));
 
 	/**
 	 * login page or apprequest page
 	 * @url /
 	 * @method GET
 	 */
-route.get('/authenticate', (req, res) => {
+	route.get('/authenticate', asyncer(async (req, res) => {
 
 		if(req.session) {
 			// if there isnt an apprequest
@@ -59,7 +66,8 @@ route.get('/authenticate', (req, res) => {
 		}
 
 		// query apps
-	global['modules'].database.getApps((err, rep) => {
+		apps = await db.getApps();
+
 		// set appId in appRequest
 		if(req.query.appId) {
 			if(req.query.appId && typeof req.query.appId == "string") {
@@ -77,7 +85,7 @@ route.get('/authenticate', (req, res) => {
 			res.render('request', {
 				session: req.session,
 				appRequest: req.session.appRequest,
-				apps: rep
+				apps: apps.reply
 			});
 		// if user isnt logged in, show login page
 		} else {
@@ -85,7 +93,7 @@ route.get('/authenticate', (req, res) => {
 
 			let view_obj = { session: req.session };
 			if(req.query.appId) {
-				rep.forEach((app) => {
+				apps.reply.forEach((app) => {
 					if(app._id == req.query.appId)
 						view_obj["login_title"] = "Login to use "+app.name+" via authRxbn"; // appRequest app name
 				})
@@ -94,8 +102,7 @@ route.get('/authenticate', (req, res) => {
 
 			res.render('login', view_obj);
 		}
-	});
+	}));
-});
 
 	/**
 	 * all other routes
@@ -124,6 +131,7 @@ route.all('/*', (req, res, next) => {
 					let regex = new RegExp(rule.expression, "g");
 					if(regex.test(req.path)) {
 						if(rule.type == "404") {
+							global['logs'].info("[web] (404) path not found: "+req.path);
 							return res.status(404).render('error/404', {
 								error_code: 404,
 								error_msg: 'msg.request.file.not_found',
@@ -156,6 +164,7 @@ route.all('/*', (req, res, next) => {
 				cfg: global['gds'].cfg
 			});
 		} else {
+			global['logs'].info("[web] (404) path not found: "+req.path);
 			return res.status(404).render('error/404', {
 				error_code: 404,
 				error_msg: 'msg.request.file.not_found',
@@ -168,4 +177,9 @@ route.all('/*', (req, res, next) => {
 		// TODO: show login page or page
 	});
 
-module.exports = route;
+	return route;
+};
+
+module.exports = {
+	getRoutes: getRoutes
+};

package.json

@@ -7,13 +7,12 @@
   "license": "",
   "dependencies": {
     "body-parser": "^1.19.0",
-    "chalk": "^4.1.0",
     "cookie-parser": "^1.4.5",
     "express": "^4.17.1",
+    "express-async-handler": "^1.1.4",
     "express-session": "^1.17.1",
     "mongo-sanitize": "^1.1.0",
     "mongoose": "^5.9.28",
-    "pug": "^3.0.0",
+    "pug": "^3.0.0"
-    "vorpal": "^1.12.0"
   }
 }