updated files to ES6

Vagrantfile

@@ -132,8 +132,8 @@ Vagrant.configure("2") do |config|
   end
 
   config.vm.provision "shell", inline: <<~SHELL
-    cp -a /etc/openresty/. /vagrant/openresty
+    # cp -a /etc/openresty/. /vagrant/openresty
-    rm -rf /etc/openresty
+    # rm -rf /etc/openresty
-    ln -s /vagrant/openresty /etc/openresty
+    # ln -s /vagrant/openresty /etc/openresty
   SHELL
 end

nodejs/models/auth.js

@@ -5,8 +5,8 @@ Auth = {}
 Auth.errors = {}
 
 Auth.errors.login = function(){
-	let error = new Error('PamLoginFailed');
+	let error = new Error('LoginFailed');
-	error.name = 'PamLoginFailed';
+	error.name = 'LoginFailed';
 	error.message = `Invalid Credentials, login failed.`;
 	error.status = 401;
 
@@ -20,7 +20,7 @@ Auth.login = async function(data){
 
 		return {user, token}
 	}catch(error){
-		throw error;
+		throw this.errors.login();
 	}
 };
 

nodejs/models/token.js

@@ -1,39 +1,52 @@
 'use strict';
 
-const redis_model = require('../utils/redis_model')
+const Table = require('../utils/redis_model');
 const UUID = function b(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,b)};
 
 
-const Token = function(data){
+class Token extends Table{
-	return redis_model({
+	static _key = 'token';
-		_name: `token_${data.name}`,
+	static _keyMap = {
-		_key: 'token',
-		_keyMap: Object.assign({}, {
 		'created_by': {isRequired: true, type: 'string', min: 3, max: 500},
 		'created_on': {default: function(){return (new Date).getTime()}},
 		'updated_on': {default: function(){return (new Date).getTime()}, always: true},
 		'token': {default: UUID, type: 'string', min: 36, max: 36},
 		'is_valid': {default: true, type: 'boolean'}
-		}, data.keyMap || {})
+	}
-	});
-};
 
-Token.check = async function(data){
+	constructor(...args){
+		super(...args);
+	}
+
+	async check(){
 		try{
 			return this.is_valid;
 		}catch(error){
 			return false
 		}
 	}
-
-var InviteToken = Object.create(Token({
-	name: 'invite',
-	keyMap:{
-		claimed_by: {default:"__NONE__", isRequired: false, type: 'string',}
 }
-}));
 
-InviteToken.consume = async function(data){
+class AuthToken extends Token{
+	constructor(...args){
+		super(...args);
+	}
+
+	static async add(data){
+		data.created_by = data.username;
+		return super.add(data)
+
+	}
+
+}
+
+class InviteToken extends Token{
+	static _keyMap = {
+		...super._keyMap,
+		claimed_by: {default:"__NONE__", isRequired: false, type: 'string',},
+	}
+
+	async consume(data){
 		try{
 			if(this.is_valid){
 				data['is_valid'] = false;
@@ -47,14 +60,6 @@ InviteToken.consume = async function(data){
 			throw error;
 		}
 	}
+}
 
-var AuthToken = Object.create(Token({
+module.exports = {Token, InviteToken, AuthToken};
-	name: 'auth',
-}));
-
-AuthToken.add = async function(data){
-	data.created_by = data.username;
-	return AuthToken.__proto__.add(data);
-};
-
-module.exports = {Token, InviteToken, AuthToken}

nodejs/models/user_redis.js

@@ -1,14 +1,13 @@
 'use strict';
 
-const objValidate = require('../utils/object_validate');
+const Table = require('../utils/redis_model');
 const {Token, InviteToken} = require('./token');
 const bcrypt = require('bcrypt');
 const saltRounds = 10;
 
-const User = require('../utils/redis_model')({
+class User extends Table{
-	_name: 'user',
+	static _key = 'username';
-	_key: 'username',
+	static _keyMap = {
-	_keyMap: {
 		'created_by': {isRequired: true, type: 'string', min: 3, max: 500},
 		'created_on': {default: function(){return (new Date).getTime()}},
 		'updated_by': {default:"__NONE__", isRequired: false, type: 'string',},
@@ -17,27 +16,23 @@ const User = require('../utils/redis_model')({
 		'password': {isRequired: true, type: 'string', min: 3, max: 500},
 		'backing': {default:"redis", isRequired: false, type: 'string',},
 	}
-});
 
-User.backing = "redis";
+	static backing = 'redis'
 
-
+	static async add(data) {
-User.add = async function(data) {
 		try{
 			data['password'] = await bcrypt.hash(data['password'], saltRounds);
 			data['backing'] = data['backing'] || 'redis';
 
 
-		console.log('set password', data)
+		return await super.add(data)
-
-		return this.__proto__.add(data);
 
 		}catch(error){
 			throw error;
 		}
-};
+	}
 
-User.addByInvite = async function(data){
+	static async addByInvite(data){
 		try{
 			let token = await InviteToken.get(data.token);
 
@@ -62,17 +57,17 @@ User.addByInvite = async function(data){
 
 	};
 
-User.setPassword = async function(data){
+	async setPassword(data){
 		try{
 			data['password'] = await bcrypt.hash(data['password'], saltRounds);
 
-		return this.__proto__.update(data);
+			return this.update(data);
 		}catch(error){
 			throw error;
 		}
-};
+	}
 
-User.invite = async function(){
+	async invite(){
 		try{
 			let token = await InviteToken.add({created_by: this.username});
 			
@@ -81,12 +76,12 @@ User.invite = async function(){
 		}catch(error){
 			throw error;
 		}
-};
+	}
 
-User.login = async function(data){
+	static async login(data){
 		try{
-		let user = await User.get(data);
 
+			let user = await User.get(data);
 			let auth = await bcrypt.compare(data.password, user.password);
 
 			if(auth){
@@ -102,6 +97,10 @@ User.login = async function(data){
 		}
 	};
 
+
+}
+
+module.exports = {User};
 module.exports = {User};
 
 

nodejs/routes/host.js

@@ -4,10 +4,12 @@ const router = require('express').Router();
 const {Host} = require('../models/host');
 
 
+const Model = Host;
+
 router.get('/', async function(req, res, next){
 	try{
 		return res.json({
-			hosts:  await Host[req.query.detail ? "listDetail" : "list"]()
+			hosts:  await Model[req.query.detail ? "listDetail" : "list"]()
 		});
 	}catch(error){
 		return next(error);
@@ -17,36 +19,36 @@ router.get('/', async function(req, res, next){
 router.post('/', async function(req, res, next){
 	try{
 		req.body.created_by = req.user.username;
-		await Host.add(req.body);
+		let item = await Model.add(req.body);
 
 		return res.json({
-			message: `Host "${req.body.host}" added.`
+			message: `"${item[Model._key]}" added.`
 		});
 	} catch (error){
 		return next(error);
 	}
 });
 
-router.get('/:host(*)', async function(req, res, next){
+router.get('/:item(*)', async function(req, res, next){
 	try{
 
 		return res.json({
-			host: req.params.host,
+			item: req.params.item,
-			results: await Host.get({host: req.params.host})
+			results: await Model.get(req.params.item)
 		});
 	}catch(error){
 		return next(error);
 	}
 });
 
-router.put('/:host(*)', async function(req, res, next){
+router.put('/:item(*)', async function(req, res, next){
 	try{
 		req.body.updated_by = req.user.username;
-		let host = await Host.get(req.params.host);
+		let item = await Model.get(req.params.item);
-		await host.update.call(host, req.body);
+		await item.update(req.body);
 
 		return res.json({
-			message: `Host "${req.params.host}" updated.`
+			message: `"${req.params.item}" updated.`
 		});
 
 	}catch(error){
@@ -55,13 +57,13 @@ router.put('/:host(*)', async function(req, res, next){
 	}
 });
 
-router.delete('/:host(*)', async function(req, res, next){
+router.delete('/:item(*)', async function(req, res, next){
 	try{
-		let host = await Host.get(req.params);
+		let item = await Model.get(req.params.item);
-		let count = await host.remove.call(host, host);
+		let count = await item.remove();
 
 		return res.json({
-			message: `Host ${req.params.host} deleted`,
+			message: `${req.params.item} deleted`,
 		});
 
 	}catch(error){
@@ -69,11 +71,11 @@ router.delete('/:host(*)', async function(req, res, next){
 	}
 });
 
-router.get('/lookup/:host(*)', async function(req, res, next){
+router.get('/lookup/:item(*)', async function(req, res, next){
 	try{
 		return res.json({
-			string: req.params.host,
+			string: req.params.item,
-			results: await Host.lookUp(req.params.host),
+			results: await Model.lookUp(req.params.item),
 		});
 
 	}catch(error){

nodejs/utils/object_validate.js

@@ -8,7 +8,7 @@ const process_type = {
 	string: function(key, value){
 		if(key.min && value.length < key.min) return `is too short, min ${key.min}.`
 		if(key.max && value.length > key.max) return `is too short, max ${key.max}.`
-	}
+	},
 }
 
 function returnOrCall(value){
@@ -20,6 +20,7 @@ function processKeys(map, data, partial){
 	let out = {};
 
 	for(let key of Object.keys(map)){
+
 		if(!map[key].always && partial && !data.hasOwnProperty(key)) continue;
 
 		if(!partial && map[key].isRequired && !data.hasOwnProperty(key)){
@@ -57,6 +58,7 @@ function parseFromString(map, data){
 		boolean: function(value){ return value === 'false' ? false : true },
 		number: Number,
 		string: String,
+		object: JSON.parse
 	};
 
 	for(let key of Object.keys(data)){
@@ -68,6 +70,14 @@ function parseFromString(map, data){
 	return data;
 }
 
+function parseToString(data){
+	let types = {
+		object: JSON.stringify
+	}
+
+	return (types[typeof(data)] || String)(data);
+}
+
 function ObjectValidateError(message) {
 	this.name = 'ObjectValidateError';
 	this.message = (message || {});
@@ -77,4 +87,4 @@ function ObjectValidateError(message) {
 ObjectValidateError.prototype = Error.prototype;
 
 
-module.exports = {processKeys, parseFromString, ObjectValidateError};
+module.exports = {processKeys, parseFromString, ObjectValidateError, parseToString};

nodejs/utils/redis_model.js

@@ -1,60 +1,46 @@
 'use strict';
 
-const {createClient} = require('redis');
+const client = require('../utils/redis');
 const objValidate = require('../utils/object_validate');
 
-var client = createClient({});
-client.connect()
 
-
+class Table{
-let table = {};
+	constructor(data){
-
+		for(let key in data){
-table.get = async function(data){
+			this[key] = data[key];
-	try{
+		}
-		// if the data argument was passed as the index key value, make a data
-		// object and add the index key to it.
-		if(typeof data !== 'object'){
-			let key = data;
-			data = {};
-			data[this._key] = key;
 	}
 
-		// Get all the hash keys for the passed index key.
+	static async get(index){
-		let res = await client.HGETALL(`${this._name}_${data[this._key]}`);
+		try{
 
-		// If the redis query resolved to something, prepare the data.
+			if(typeof index === 'object'){
-		if(Object.keys(res).length){
+				index = index[this._key]
+			}
+
+			let result = await client.HGETALL(`${this.prototype.constructor.name}_${index}`);
+
+			if(!result){
+				let error = new Error('EntryNotFound');
+				error.name = 'EntryNotFound';
+				error.message = `${this.prototype.constructor.name}:${index} does not exists`;
+				error.status = 404;
+				throw error;
+			}
 
 			// Redis always returns strings, use the keyMap schema to turn them
 			// back to native values.
-			res = objValidate.parseFromString(this._keyMap, res);
+			result = objValidate.parseFromString(this._keyMap, result);
 
-			// Make sure the index key in in the returned object.
+			return new this.prototype.constructor(result)
-			res[this._key] = data[this._key];
-
-			// Create a instance for this redis entry.
-			var entry = Object.create(this);
-
-			// Insert the redis response into the instance.
-			Object.assign(entry, res);
-
-			// Return the instance to the caller.
-			return entry;
-		}
 
 		}catch(error){
-		throw error
+			throw error;
 		}
 
-	let error = new Error('EntryNotFound');
+	}
-	error.name = 'EntryNotFound';
-	error.message = `${this._name}:${data[this._key]} does not exists`;
-	error.status = 404;
-	throw error;
-};
 
-table.exists = async function(data){
+	static async exists(index){
-	// Return true or false if the requested entry exists ignoring error's.
 		try{
 			await this.get(data);
 
@@ -62,20 +48,19 @@ table.exists = async function(data){
 		}catch(error){
 			return false;
 		}
-};
+	}
 
-table.list = async function(){
+	static async list(){
 		// return a list of all the index keys for this table.
 		try{
-
+			return await client.SMEMBERS(this.prototype.constructor.name);
-		return await client.SMEMBERS(this._name);
 
 		}catch(error){
 			throw error;
 		}
-};
+	}
 
-table.listDetail = async function(){
+	static async listDetail(){
 		// Return a list of the entries as instances.
 		let out = [];
 
@@ -84,12 +69,11 @@ table.listDetail = async function(){
 		}
 
 		return out
-};
+	}
 
-table.add = async function(data, noMemberAdd){
+	static async add(data){
 		// Add a entry to this redis table.
 		try{
-
 			// Validate the passed data by the keyMap schema.
 
 			data = objValidate.processKeys(this._keyMap, data);
@@ -98,38 +82,32 @@ table.add = async function(data, noMemberAdd){
 			if(data[this._key] && await this.exists(data)){
 				let error = new Error('EntryNameUsed');
 				error.name = 'EntryNameUsed';
-			error.message = `${this._name}:${data[this._key]} already exists`;
+				error.message = `${this.prototype.constructor.name}:${data[this._key]} already exists`;
 				error.status = 409;
 
 				throw error;
 			}
 
 			// Add the key to the members for this redis table
-		if(!noMemberAdd) await client.SADD(this._name, data[this._key]);
+			await client.SADD(this.prototype.constructor.name, data[this._key]);
 
 			// Add the values for this entry.
 			for(let key of Object.keys(data)){
-			await client.hSet(`${this._name}_${data[this._key]}`, key, String(data[key]));
+				await client.HSET(`${this.prototype.constructor.name}_${data[this._key]}`, key, objValidate.parseToString(data[key]));
 			}
 
 			// return the created redis entry as entry instance.
 			return await this.get(data[this._key]);
 		} catch(error){
-		console.error('redis model | table.add:', error)
 			throw error;
 		}
-};
+	}
 
-table.update = async function(data, key){
+	async update(data, key){
 		// Update an existing entry.
 		try{
-		// If an index key is passed, we assume is passed, assume we are not
-		// part of an entry instance. Make one and recall this from from a entry
-		// instance,
-		if(key) return await (await this.get(key)).update(data);
-
 			// Check to see if entry name changed.
-		if(data[this._key] && data[this._key] !== this[this._key]){
+			if(data[this.constructor._key] && data[this.constructor._key] !== this[this.constructor._key]){
 
 				// Merge the current data into with the updated data 
 				let newData = Object.assign({}, this, data);
@@ -145,12 +123,12 @@ table.update = async function(data, key){
 				// Update what ever fields that where passed.
 
 				// Validate the passed data, ignoring required fields.
-			data = objValidate.processKeys(this._keyMap, data, true);
+				data = objValidate.processKeys(this.constructor._keyMap, data, true);
 				
 				// Loop over the data fields and apply them to redis
 				for(let key of Object.keys(data)){
 					this[key] = data[key];
-				await client.HSET(`${this._name}_${this[this._key]}`, key, data[key]);
+					await client.HSET(`${this.constructor.name}_${this[this.constructor._key]}`, key, data[key]);
 				}
 			}
 
@@ -160,18 +138,18 @@ table.update = async function(data, key){
 			// Pass any error to the calling function
 			throw error;
 		}
-};
+	}
 
-table.remove = async function(data){
+	async remove(data){
 		// Remove an entry from this table.
 
-	data = data || this;
 		try{
 			// Remove the index key from the tables members list.
-		await client.SREM(this._name, data[this._key]);
+
+			await client.SREM(this.constructor.name, this[this.constructor._key]);
 
 			// Remove the entries hash values.
-		let count = await client.DEL(`${this._name}_${data[this._key]}`);
+			let count = await client.DEL(`${this.constructor.name}_${this[this.constructor._key]}`);
 
 			// Return the number of removed values to the caller.
 			return count;
@@ -181,14 +159,7 @@ table.remove = async function(data){
 		}
 	};
 
-function Table(data){
+}
-	// Create a table instance.
-	let instance = Object.create(data);
-	Object.assign(instance, table);
 
-	// Return the table instance to the caller.
-	return Object.create(instance);
-
-};
 
 module.exports = Table;