theta42/deployments
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

testing

Browse Source
This commit is contained in:
William Mantly
2021-01-25 23:42:47 -05:00
parent 10d10079aa
commit e585683664
22 changed files with 3116 additions and 1268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
nodejs/utils/object_validate.js
View File

@ -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};

19
nodejs/utils/redis.js
View File

@ -4,7 +4,7 @@ const {createClient} = require('redis');
const {promisify} = require('util');
const config = {
prefix: 'sso_'
prefix: 'deploy_'
}
function client() {
@ -13,6 +13,9 @@ function client() {
const _client = client();
const SCAN = promisify(_client.SCAN).bind(_client);
module.exports = {
client: client,
HGET: promisify(_client.HGET).bind(_client),
@ -24,4 +27,18 @@ module.exports = {
HGETALL: promisify(_client.HGETALL).bind(_client),
SMEMBERS: promisify(_client.SMEMBERS).bind(_client),
RENAME: promisify(_client.RENAME).bind(_client),
HSCAN: promisify(_client.HSCAN).bind(_client),
SCAN: async function(match){
let coursor = 0;
let results = [];
do{
let res = await SCAN(coursor, 'MATCH', config.prefix+match);
coursor = Number(res[0]);
results.push(...res[1].map(e => e.replace(config.prefix, '')))
} while(coursor);
return results
}
};

273
nodejs/utils/redis_model.js
View File

@ -4,187 +4,158 @@ const client = require('../utils/redis');
const objValidate = require('../utils/object_validate');
let table = {};
table.get = async function(data){
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;
class Table{
constructor(data){
for(let key in data){
this[key] = data[key];
}
}
// Get all the hash keys for the passed index key.
let res = await client.HGETALL(`${this._name}_${data[this._key]}`);
static async get(index){
try{
// If the redis query resolved to something, prepare the data.
if(res){
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.
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
}
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){
// Return true or false if the requested entry exists ignoring error's.
try{
await this.get(data);
return true
}catch(error){
return false;
}
};
table.list = async function(){
// return a list of all the index keys for this table.
try{
return await client.SMEMBERS(this._name);
}catch(error){
throw error;
}
};
table.listDetail = async function(){
// Return a list of the entries as instances.
let out = [];
for(let entry of await this.list()){
out.push(await this.get(entry));
}
return out
};
table.add = async function(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._name}:${data[this._key]} already exists`;
error.status = 409;
return new this.prototype.constructor(result)
}catch(error){
throw error;
}
// Add the key to the members for this redis table
await client.SADD(this._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, data[key]);
static async exists(index){
try{
await this.get(data);
return true
}catch(error){
return false;
}
}
static async list(){
// return a list of all the index keys for this table.
try{
return await client.SMEMBERS(this.prototype.constructor.name);
}catch(error){
throw error;
}
}
static async listDetail(){
// Return a list of the entries as instances.
let out = [];
for(let entry of await this.list()){
out.push(await this.get(entry));
}
// return the created redis entry as entry instance.
return await this.get(data[this._key]);
} catch(error){
throw error;
return out
}
};
table.update = async function(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);
static async add(data){
// Add a entry to this redis table.
try{
// Validate the passed data by the keyMap schema.
// Check to see if entry name changed.
if(data[this._key] && data[this._key] !== this[this._key]){
data = objValidate.processKeys(this._keyMap, data);
// Merge the current data into with the updated data
let newData = Object.assign({}, this, 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;
// 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._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]);
throw error;
}
// Add the key to the members for this redis table
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.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;
}
return this;
} catch(error){
// Pass any error to the calling function
throw error;
}
};
table.remove = async function(data){
// Remove an entry from this table.
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]){
data = data || this;
try{
// Remove the index key from the tables members list.
await client.SREM(this._name, data[this._key]);
// Merge the current data into with the updated data
let newData = Object.assign({}, this, data);
// Remove the entries hash values.
let count = await client.DEL(`${this._name}_${data[this._key]}`);
// Remove the updated failed so it doesnt keep it
delete newData.updated;
// Return the number of removed values to the caller.
return count;
// Create a new record for the updated entry. If that succeeds,
// delete the old recored
if(await this.add(newData)) await this.remove();
} catch(error) {
throw error;
}else{
// Update what ever fields that where passed.
// Validate the passed data, ignoring required fields.
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.constructor.name}_${this[this.constructor._key]}`, key, data[key]);
}
}
return this;
} catch(error){
// Pass any error to the calling function
throw error;
}
}
};
function Table(data){
// Create a table instance.
let instance = Object.create(data);
Object.assign(instance, table);
async remove(data){
// Remove an entry from this table.
// Return the table instance to the caller.
return Object.create(instance);
try{
// Remove the index key from the tables members list.
await client.SREM(this.constructor.name, this[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 = Table;