@63klabs/cache-data 1.2.2

package/src/lib/tools/ResponseDataModel.class.js

@@ -0,0 +1,183 @@
+
+/* ****************************************************************************
+ * Response Data Model
+ * ----------------------------------------------------------------------------
+ * 
+ * Provides a class that can be used to store and complie data to send back
+ * as a response.
+ * 
+ *************************************************************************** */
+
+/**
+ * A response object that can be used to collect data to be sent back as a response.
+ * A structured skeleton may be created during construction to create an order of
+ * presenting various keys. As the program executes, additional data may be added.
+ * Other response objects may be added with keys to fill out the object. If there are
+ * key collisions then new items matching that key are added as an element in an array.
+ * 
+ * Extends ResponseDataModel, can be used to extend as an interface.
+ * 
+ * @example
+ * let obj = new Response(); // you can pass a skeleton that you will add to, or the full object to the constructor
+ * obj.addItem(newItem); // where newItem is another response object or regular structured object which will be added as a node
+ * obj.addItemByKey(newItem2,"employees");// where newItem2 is another response object or regular structured object which will be added as a node. Note that you can override a label by passing a new one. For example pluralizing a label
+ * obj.removeEmpty(); // optional, it will remove empty keys
+ * 	response = {
+ * 		statusCode: 200,
+ * 		body: dataResponse.toString(),
+ * 		headers: {'content-type': 'application/json'}
+ * 	};
+ *
+ */
+class ResponseDataModel {
+
+	_responseData = null;
+	_label = "";
+
+	/**
+	 * Used for collecting parts of a response. A data skeleton may be passed in as an object.
+	 * 
+	 * @param {*} data Can be a skeleton with various fields set to {}, [], "", null or defaults.
+	 * @param {*} label 
+	 */
+	constructor(data = null, label = "") {
+		if (data !== null) {
+			this._responseData = data;
+		}
+
+		if (label !== "") {
+			this._label = label;
+		}
+	};
+	
+	/**
+	 * Get the label that will be used when this object is added to another 
+	 * ResponseDataModel or returned as a response
+	 * @returns {string} a label to use as a key for the object
+	 */
+	getLabel() {
+		return this._label;
+	};
+
+	/**
+	 * Get the data object
+	 * @returns {*} A copy of the data object
+	 */
+	getResponseData() {
+		return JSON.parse(JSON.stringify(this._responseData));
+	};
+
+	/**
+	 * Add an item as part of an array.
+	 * If the responseObject is null, it will be transformed into an array and the item will be added at index 0
+	 * If the responseObject is an array, the item will be added as the next index
+	 * If the responseObject is an object, the item will be added as an array element under the label (or 'items' if label is "")
+	 * @param {ResponseDataModel|*} item 
+	 */
+	addItem(item) {
+
+		let data = null;
+		let label = "";
+
+		if ( item instanceof ResponseDataModel ) {
+			data = item.getResponseData();
+			label = item.getLabel(); // see if there is an override key/label
+		} else {
+			data = item;
+		}
+
+		if ( label === "" ) {
+			if ( this._responseData === null ) {
+				this._responseData = [];
+			}
+
+			if ( Array.isArray(this._responseData)) {
+				this._responseData.push(data);
+			} else if ( this._responseData instanceof Object ) {
+				if ( !("items" in this._responseData) || this._responseData.items === null) {
+					this._responseData.items = [];
+				}
+				this._responseData.items.push(data);
+			}
+		} else {
+			if ( this._responseData === null ) {
+				this._responseData = {};
+			}
+
+			if ( !(label in this._responseData) || this._responseData[label] === null) {
+				this._responseData[label] = [];
+			}
+
+			this._responseData[label].push(data);
+		}
+		
+	};
+	
+	/**
+	 * Add an item by key
+	 * @param {ResponseDataModel|*} item 
+	 * @param {string} key 
+	 */
+	addItemByKey(item, key = "") {
+
+		if ( this._responseData === null ) {
+			this._responseData = {};
+		}
+
+		let data = null;
+		let label = "";
+
+		if ( item instanceof ResponseDataModel ) {
+			data = item.getResponseData();
+			label = (key !== "" ? key : item.getLabel() ); // see if there is an override key/label
+		} else {
+			data = item;
+			label = key;
+		}
+
+		// check if the key exists, if it does (and it is not an "empty" placeholder) then we will add this item to an array
+		if ( label in this._responseData 
+			&& this._responseData[label] !== null // any placeholder
+			&& this._responseData[label] !== "" // string placeholder
+			&& this._responseData[label] != 0 // number placeholder
+			&& !( this._responseData[label] instanceof Object && Object.keys(this._responseData[label]).length === 0 && Object.getPrototypeOf(this._responseData[label]) === Object.prototype ) // object placeholder
+			) {
+			// if it is not yet an array, convert to array and move existing data to index 0
+			if ( !Array.isArray(this._responseData[label]) ) {
+				let temp = JSON.parse(JSON.stringify(this._responseData[label])); // no pointers, create copy
+				this._responseData[label] = []; // reassign to array
+				this._responseData[label].push(temp); // move original element to array
+			}
+			this._responseData[label].push(data); // push the new data onto array
+		} else {
+			this._responseData[label] = data; // replace
+		}
+		
+	};
+	
+	/**
+	 * 
+	 * @returns {*} The data object. If there is a label then it is returned as a key value pair where the label is the key
+	 */
+	toObject() {
+		let obj = {};
+		if (this._label === "") {
+			obj = this.getResponseData();
+		} else {
+			let key = this._label;
+			obj[key] = this.getResponseData();
+		}
+		return obj;
+	};
+
+	/**
+	 * 
+	 * @returns {string} A stringified JSON object (using .toObject() ) for use as a response
+	 */
+	toString() {
+		return JSON.stringify(this.toObject());
+	};
+
+};
+
+module.exports = ResponseDataModel;

package/src/lib/tools/Timer.class.js

@@ -0,0 +1,189 @@
+/* */
+const DebugAndLog = require("./DebugAndLog.class");
+
+class Timer {
+	constructor(name, start = false) {
+		this.name = name;
+		this.startTime = -1;
+		this.stopTime = -1;
+		this.latestMessage = "";
+		
+		if (start) {
+			this.start();
+		} else {
+			this.updateMessage("Timer '"+this.name+"' created at  "+this.now());
+		}
+	};
+
+	async updateMessage(message) {
+		this.latestMessage = message;
+		DebugAndLog.diag(this.latestMessage);
+	};
+
+	/**
+	 * Start the timer
+	 */
+	async start() {
+		if ( this.startTime === -1 ) {
+			this.startTime = this.now();
+			this.updateMessage("Timer '"+this.name+"' started at "+this.startTime);
+		}
+	};
+
+	/**
+	 * Stop the timer
+	 * 
+	 * @returns {number} The time elapsed in milliseconds
+	 */
+	stop() {
+		if ( this.stopTime === -1 ) {
+			this.stopTime = this.now();
+			this.updateMessage("Timer '"+this.name+"' stopped at "+this.stopTime+". Time elapsed: "+this.elapsed()+" ms");
+		}
+		return this.elapsed();
+	};
+
+	/**
+	 * The amount of time elapsed between the start and stop of the timer.
+	 * If the timer is still running it will be the amount of time between
+	 * start and now(). If the timer is stopped it will be the amount of
+	 * time between the start and stop.
+	 * 
+	 * @returns {number}
+	 */
+	elapsed() {
+		return ((this.isRunning()) ? this.now() : this.stopTime ) - this.startTime;
+	};
+
+	/**
+	 * The amount of time elapsed between the start of the timer and now()
+	 * Even if the timer is stopped, it will use now() and this value will
+	 * continue to increase during execution.
+	 * 
+	 * Use elapsed() to get the amount of time between start and stop.
+	 * 
+	 * @returns {number}
+	 */
+	elapsedSinceStart() {
+		return (this.now() - this.startTime);
+	};
+
+	/**
+	 * The amount of time elapsed since the timer was stopped and will increase
+	 * during execution. If the timer has not been stopped, it will 
+	 * return -1 (negative one)
+	 * 
+	 * @returns {number}
+	 */
+	elapsedSinceStop() {
+		return (this.isRunning() ? -1 : this.now() - this.stopTime);
+	};
+
+	/**
+	 * The time now. Same as Date.now()
+	 * 
+	 * @returns {number}
+	 */
+	now() {
+		return Date.now();
+	};
+
+	/**
+	 * Was the timer started
+	 * @returns {boolean}
+	 */
+	wasStarted() {
+		return (this.startTime > 0);
+	};
+
+	/**
+	 * 
+	 * @returns {boolean} Returns true if timer has not yet been started
+	 */
+	notStarted() {
+		return !(this.wasStarted());
+	};
+
+	/**
+	 * 
+	 * @returns {boolean} True if the timer is currently running. False if not running
+	 */
+	isRunning() {
+		return (this.wasStarted() && this.stopTime < 0);
+	};
+
+	/**
+	 * 
+	 * @returns {boolean} True if the timer was stopped. False if not stopped
+	 */
+	wasStopped() {
+		return (this.wasStarted() && this.stopTime > 0);
+	};
+
+	/**
+	 * 
+	 * @returns {string} Text string denoting stating. 'NOT_STARTED', 'IS_RUNNING', 'IS_STOPPED'
+	 */
+	status() {
+		var s = "NOT_STARTED";
+		if ( this.wasStarted() ) {
+			s = (this.isRunning() ? "IS_RUNNING" : "IS_STOPPED");
+		}
+		return s;
+	};
+
+	/**
+	 * Messages are internal updates about the status
+	 * @returns {string} The latest message from the timer
+	 */
+	message() {
+		return (this.latestMessage);
+	};
+
+	/**
+	 * For debugging and testing, an object of the timer may be generated
+	 * to see the current values of each timer function.
+	 * 
+	 * @param {boolean} sendToLog Should the timer details object be sent to the console log
+	 * @returns { 
+	 *   {
+	 * 		name: string,
+	 * 		status: string,
+	 * 		started: boolean,
+	 * 		running: boolean,
+	 * 		stopped: boolean,
+	 * 		start: number,
+	 * 		stop: number,
+	 * 		elapsed: number,
+	 * 		now: number,
+	 * 		elapsedSinceStart: number,
+	 * 		elapsedSinceStop: number,
+	 * 		latestMessage: string
+	 *   }
+	 * } An object describing the state of the timer
+	 */
+	details(sendToLog = false) {
+		var details = {
+			name: this.name,
+			status: this.status(),
+			started: this.wasStarted(),
+			running: this.isRunning(),
+			stopped: this.wasStopped(),
+			start: this.startTime,
+			stop: this.stopTime,
+			elapsed: this.elapsed(),
+			now: this.now(),
+			elapsedSinceStart: this.elapsedSinceStart(),
+			elapsedSinceStop: this.elapsedSinceStop(),
+			latestMessage: this.message()
+		};
+
+		if (sendToLog) {
+			DebugAndLog.debug("Timer '"+this.name+"' details",details);
+		}
+
+		return details;
+	};
+};
+
+module.exports = Timer; 

package/src/lib/tools/generic.response.html.js

@@ -0,0 +1,88 @@
+contentType = "text/html; charset=utf-8";
+
+headers = {
+	"Content-Type": contentType
+};
+
+html = (title, body) => {
+	return `<html><head><title>${title}</title></head><body>${body}</body></html>`;
+}
+
+response200 = {
+	statusCode: 200,
+	headers: headers,
+	body: html("200 OK", "<p>Success</p>")
+};
+
+response400 = {
+	statusCode: 400,
+	headers: headers,
+	body: html("400 Bad Request", "<p>Bad Request</p>")
+};
+
+response401 = {
+	statusCode: 401,
+	headers: headers,
+	body: html("401 Unauthorized", "<p>Unauthorized</p>")
+};
+
+response403 = {
+	statusCode: 403,
+	headers: headers,
+	body: html("403 Forbidden", "<p>Forbidden</p>")
+};
+
+response404 = {
+	statusCode: 404,
+	headers: headers,
+	body: html("404 Not Found", "<p>Not Found</p>")
+};
+
+response405 = {
+	statusCode: 405,
+	headers: headers,
+	body: html("405 Method Not Allowed", "<p>Method Not Allowed</p>")
+};
+
+response500 = {
+	statusCode: 500,
+	headers: headers,
+	body: html("500 Error", "<p>Internal Server Error</p>")
+};
+
+/**
+ * 
+ * @param {number|string} statusCode 
+ * @returns {{statusCode: number, headers: object, body: Array|Object|string}}
+ */
+response = function (statusCode) {
+	// convert to int
+	statusCode = parseInt(statusCode, 10);
+
+	switch (statusCode) {
+		case 200:
+			return this.response200;
+		case 400:
+			return this.response400;
+		case 401:
+			return this.response401;
+		case 403:
+			return this.response403;
+		case 404:
+			return this.response404;
+		case 500:
+			return this.response500;
+		default:
+			return this.response500;
+	}
+};
+
+module.exports = {
+	contentType,
+	headers,
+	html,
+	response200,
+	response404,
+	response500,
+	response
+}

package/src/lib/tools/generic.response.json.js

@@ -0,0 +1,102 @@
+contentType = "application/json"
+
+headers = {
+	"Content-Type": contentType
+};
+
+json = function (data = null) {
+	return data ? data : {};
+};
+
+response200 = {
+	statusCode: 200,
+	headers: headers,
+	body: {
+		message: "Success"
+	}
+};
+
+response400 = {
+	statusCode: 400,
+	headers: headers,
+	body: {
+		message: "Bad Request"
+	}
+};
+
+response401 = {
+	statusCode: 401,
+	headers: headers,
+	body: {
+		message: "Unauthorized"
+	}
+};
+
+response403 = {
+	statusCode: 403,
+	headers: headers,
+	body: {
+		message: "Forbidden"
+	}
+};
+
+response404 = {
+	statusCode: 404,
+	headers: headers,
+	body: {
+		message: "Not Found"
+	}
+};
+
+response405 = {
+	statusCode: 405,
+	headers: headers,
+	body: {
+		message: "Method Not Allowed"
+	}
+};
+
+response500 = {
+	statusCode: 500,
+	headers: headers,
+	body: {
+		message: "Internal Server Error"
+	}
+};
+
+/**
+ * 
+ * @param {number|string} statusCode 
+ * @returns {{statusCode: number, headers: object, body: Array|Object|string}}
+ */
+response = function (statusCode) {
+	// convert to int
+	statusCode = parseInt(statusCode, 10);
+
+	switch (statusCode) {
+		case 200:
+			return this.response200;
+		case 400:
+			return this.response400;
+		case 401:
+			return this.response401;
+		case 403:
+			return this.response403;
+		case 404:
+			return this.response404;
+		case 500:
+			return this.response500;
+		default:
+			return this.response500;
+	}
+};
+
+module.exports = {
+	contentType,
+	headers,
+	json,
+	response200,
+	response404,
+	response500,
+	response
+}

package/src/lib/tools/generic.response.rss.js

@@ -0,0 +1,88 @@
+contentType = "application/rss+xml";
+
+headers = {
+	"Content-Type": contentType
+};
+
+rss = (body) => {
+	return `<?xml version="1.0" encoding="UTF-8" ?><rss version="2.0">${body}</rss>`;
+}
+
+response200 = {
+	statusCode: 200,
+	headers: headers,
+	body: rss("<hello>Success</hello>")
+};
+
+response400 = {
+	statusCode: 400,
+	headers: headers,
+	body: rss("<error>Bad Request</error>")
+};
+
+response401 = {
+	statusCode: 401,
+	headers: headers,
+	body: rss("<error>Unauthorized</error>")
+};
+
+response403 = {
+	statusCode: 403,
+	headers: headers,
+	body: rss("<error>Forbidden</error>")
+};
+
+response404 = {
+	statusCode: 404,
+	headers: headers,
+	body: rss("<error>Not Found</error>")
+};
+
+response405 = {
+	statusCode: 405,
+	headers: headers,
+	body: rss("<error>Method Not Allowed</error>")
+};
+
+response500 = {
+	statusCode: 500,
+	headers: headers,
+	body: rss("<error>Internal Server Error</error>")
+};
+
+/**
+ * 
+ * @param {number|string} statusCode 
+ * @returns {{statusCode: number, headers: object, body: Array|Object|string}}
+ */
+response = function (statusCode) {
+	// convert to int
+	statusCode = parseInt(statusCode, 10);
+
+	switch (statusCode) {
+		case 200:
+			return this.response200;
+		case 400:
+			return this.response400;
+		case 401:
+			return this.response401;
+		case 403:
+			return this.response403;
+		case 404:
+			return this.response404;
+		case 500:
+			return this.response500;
+		default:
+			return this.response500;
+	}
+};
+
+module.exports = {
+	contentType,
+	headers,
+	rss,
+	response200,
+	response404,
+	response500,
+	response
+}