model-redis 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 William Mantly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# Model Redis
+
+Simple ORM model for redis in NodsJS. The only external dependence is `redis`.
+This provides a simple ORM interface, with schema, for redis. This is not meant 
+for large data sets and is geared more for small, internal infrastructure based
+projects that do not require complex data model.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "model-redis",
+  "version": "0.1.0",
+  "description": "Simple ORM model for redis in NodsJS",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wmantly/model-redis.git"
+  },
+  "keywords": [
+    "nodeJS",
+    "redis",
+    "orm"
+  ],
+  "author": "William Mantly",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wmantly/model-redis/issues"
+  },
+  "homepage": "https://github.com/wmantly/model-redis#readme"
+}

package/src/object_validate.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const process_type = {
+	number: function(key, value){
+		if(key.min && value < key.min) return `is to small, min ${key.min}.`
+		if(key.max && value > key.max) return `is to large, max ${key.max}.`
+	},
+	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){
+	return typeof(value) === 'function' ? value() : value;
+} 
+
+function processKeys(map, data, partial){
+	let errors = [];
+	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)){
+			errors.push({key, message:`${key} is required.`});
+			continue;
+		} 
+
+		if(data.hasOwnProperty(key) && map[key].type && typeof(data[key]) !== map[key].type){
+			errors.push({key, message:`${key} is not ${map[key].type} type.`});
+			continue;
+		}
+
+		out[key] = data.hasOwnProperty(key) && data[key] !== undefined ? data[key] : returnOrCall(map[key].default);
+
+		if(data.hasOwnProperty(key) && process_type[map[key].type]){
+			let typeError = process_type[map[key].type](map[key], data[key]);
+			if(typeError){
+				errors.push({key, message:`${key} ${typeError}`});
+				
+				continue;
+			}
+		}
+	}
+
+	if(errors.length !== 0){
+		throw new ObjectValidateError(errors);
+		return {__errors__: errors};
+	}
+
+	return out;
+}
+
+function parseFromString(map, data){
+	let types = {
+		boolean: function(value){ return value === 'false' ? false : true },
+		number: Number,
+		string: String,
+		object: JSON.parse
+	};
+
+	for(let key of Object.keys(data)){
+		if(map[key] && map[key].type){
+			data[key] = types[map[key].type](data[key]);
+		}
+	}
+
+	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 || {});
+	this.status = 422;
+}
+
+ObjectValidateError.prototype = Error.prototype;
+
+
+module.exports = {processKeys, parseFromString, ObjectValidateError, parseToString};

package/src/redis_model.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const objValidate = require('./object_validate');
+
+
+function setUpTable(client){
+
+	class Table{
+		static _indexed = [];
+
+		constructor(data){
+			for(let key in data){
+				this[key] = data[key];
+			}
+		}
+
+		static async get(index){
+			try{
+
+				if(typeof index === 'object'){
+					index = index[this._key]
+				}
+
+				let result = await client.HGETALL(`${this.prototype.constructor.name}_${index}`);
+
+				if(Object.keys(result).length === 0){
+					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.
+				result = objValidate.parseFromString(this._keyMap, result);
+
+				return new this.prototype.constructor(result)
+
+			}catch(error){
+				throw error;
+			}
+
+		}
+
+		static async exists(data){
+			try{
+				await this.get(data);
+
+				return true
+			}catch(error){
+				return false;
+			}
+		}
+
+		static async list(index_key, value){
+			// return a list of all the index keys for this table.
+			try{
+
+				if(index_key && !this._indexed.includes(index_key)) return [];
+
+				if(index_key && this._indexed.includes(index_key)){
+					return await client.SMEMBERS(`${this.prototype.constructor.name}_${index_key}_${value}`);
+				}
+
+				return await client.SMEMBERS(this.prototype.constructor.name);
+
+			}catch(error){
+				throw error;
+			}
+		}
+
+		static async listDetail(index_key, value){
+			// Return a list of the entries as instances.
+			let out = [];
+
+			for(let entry of await this.list(index_key, value)){
+				out.push(await this.get(entry));
+			}
+
+			return out;
+		}
+
+		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);
+
+				// Do not allow the caller to overwrite an existing index key,
+				if(data[this._key] && await this.exists(data)){
+					let error = new Error('EntryNameUsed');
+					error.name = 'EntryNameUsed';
+					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
+				await client.SADD(this.prototype.constructor.name, String(data[this._key]));
+
+				// Create index keys lists
+				for(let index of this._indexed){
+					if(data[index]) await client.SADD(
+						`${this.prototype.constructor.name}_${index}_${data[index]}`,
+						String(data[this._key]
+					));
+				}
+
+				// Add the values for this entry.
+				for(let key of Object.keys(data)){
+					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){
+				throw error;
+			}
+		}
+
+		async update(data, key){
+			// Update an existing entry.
+			try{
+				// Check to see if entry name changed.
+				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);
+
+					// Remove the updated failed so it doesnt keep it
+					delete newData.updated;
+
+					// Create a new record for the updated entry. If that succeeds,
+					// delete the old recored
+					if(await this.add(newData)) await this.remove();
+
+				}else{
+					// Update what ever fields that where passed.
+
+					// Validate the passed data, ignoring required fields.
+					data = objValidate.processKeys(this.constructor._keyMap, data, true);
+					
+					// Update the index keys
+					for(let index of this.constructor._indexed){
+						if(data[index]){
+							await client.SREM(
+								`${this.constructor.name}_${index}_${this[index]}`,
+								String(this[this.constructor._key])
+							);
+
+							await client.SADD(
+								`${this.constructor.name}_${index}_${data[index]}`,
+								String(data[this.constructor._key] || this[this.constructor._key])
+							);
+						}
+
+					}
+					// 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.constructor.name}_${this[this.constructor._key]}`, key, data[key]);
+					}
+				}
+
+				return this;
+			
+			} catch(error){
+				// Pass any error to the calling function
+				throw error;
+			}
+		}
+
+		async remove(data){
+			// Remove an entry from this table.
+
+			try{
+				// Remove the index key from the tables members list.
+
+				await client.SREM(this.constructor.name, this[this.constructor._key]);
+
+				for(let index of this.constructor._indexed){
+					await client.SREM(`${this.constructor.name}_${index}_${data[value]}`, data[this.constructor._key]);
+				}
+
+				// Remove the entries hash values.
+				let count = await client.DEL(`${this.constructor.name}_${this[this.constructor._key]}`);
+
+				// Return the number of removed values to the caller.
+				return count;
+
+			} catch(error) {
+				throw error;
+			}
+		};
+
+	}
+}
+
+module.exports = setUpTable;