hotstaq 0.5.3

package/src/HotIO.ts

@@ -0,0 +1,160 @@
+import * as fs from "fs";
+import * as fse from "fs-extra";
+
+const util = require ("util");
+const asyncExec = util.promisify (require ("child_process").exec);
+
+/**
+ * Handles IO for the server.
+ */
+export class HotIO
+{
+	/**
+	 * Read a text file.
+	 */
+	static async readTextFile (path: string): Promise<string>
+	{
+		return (await new Promise (
+			(resolve: any, reject: any): void =>
+			{
+				fs.readFile (path, (err: NodeJS.ErrnoException, data: Buffer): void =>
+					{
+						if (err != null)
+							throw err;
+
+						let content: string = data.toString ();
+
+						resolve (content);
+					});
+			}));
+	}
+
+	/**
+	 * Write to a text file.
+	 */
+	static async writeTextFile (path: string, content: string): Promise<string>
+	{
+		return (await new Promise (
+			(resolve: any, reject: any): void =>
+			{
+				fs.writeFile (path, content, (err: NodeJS.ErrnoException): void =>
+					{
+						if (err != null)
+							throw err;
+
+						resolve ();
+					});
+			}));
+	}
+
+	/**
+	 * Make a directory.
+	 */
+	static async mkdir (path: string): Promise<void>
+	{
+		return (await new Promise (
+			(resolve: any, reject: any): void =>
+			{
+				fs.mkdir (path, { recursive: true }, 
+					(err: NodeJS.ErrnoException, path: string) => 
+					{
+						if (err != null)
+							throw err;
+
+						resolve ();
+					});
+			}));
+	}
+
+	/**
+	 * Delete a file.
+	 */
+	static async rm (path: string): Promise<void>
+	{
+		return (await new Promise (
+			(resolve: any, reject: any): void =>
+			{
+				fs.rm (path, 
+					(err: NodeJS.ErrnoException) => 
+					{
+						if (err != null)
+							throw err;
+
+						resolve ();
+					});
+			}));
+	}
+
+	/**
+	 * Copy files to a location.
+	 */
+	static async copyFiles (src: string, dest: string): Promise<void>
+	{
+		return (fse.copy (src, dest));
+    }
+
+	/**
+	 * Copy a file to a location.
+	 */
+	static async copyFile (src: string, dest: string, flags?: number): Promise<void>
+	{
+		return (fse.copyFile (src, dest, flags));
+    }
+
+	/**
+	 * Move a file to a location.
+	 */
+	static async moveFile (src: string, dest: string, options: fse.MoveOptions = { overwrite: false }): Promise<void>
+	{
+		return (fse.move (src, dest, options));
+    }
+
+	/**
+	 * Checks if a file is at a location.
+	 */
+	static async exists (path: string): Promise<boolean>
+	{
+		return (new Promise<boolean> ((resolve, reject) =>
+			{
+				fs.stat (path, (err: NodeJS.ErrnoException, stats: fs.Stats) =>
+					{
+						if (err != null)
+						{
+							if (err.code === "ENOENT")
+								resolve (false);
+							else
+								throw err;
+						}
+
+						resolve (true);
+					});
+			}));
+    }
+
+	/**
+	 * List files at a location.
+	 */
+	static async listFiles (path: string): Promise<string[]>
+	{
+		return (new Promise<string[]> ((resolve, reject) =>
+			{
+				fs.readdir (path, (err: NodeJS.ErrnoException, files: string[]) =>
+					{
+						if (err != null)
+							throw err;
+
+						resolve (files);
+					});
+			}));
+    }
+
+	/**
+	 * Execute a command.
+	 */
+	static async exec (cmd: string): Promise<string>
+	{
+		let output = await asyncExec (cmd);
+
+		return (output.stdout);
+	}
+}

package/src/HotLog.ts

@@ -0,0 +1,158 @@
+/**
+ * The logging level.
+ */
+export enum HotLogLevel
+{
+	/**
+	 * Prints only info messages.
+	 */
+	Info,
+	/**
+	 * Prints only warning messages.
+	 */
+	Warning,
+	/**
+	 * Prints only error messages.
+	 */
+	Error,
+	/**
+	 * Prints all messages.
+	 */
+	Verbose,
+	/**
+	 * Prints all messages, except verbose.
+	 */
+	All,
+	/**
+	 * Doesn't print any message.
+	 */
+	None
+}
+
+/**
+ * The logger.
+ */
+export class HotLog
+{
+	/**
+	 * The logging level.
+	 */
+	logLevel: HotLogLevel;
+
+	constructor (logLevel: HotLogLevel = HotLogLevel.All)
+	{
+		this.logLevel = logLevel;
+	}
+
+	/**
+	 * Log a message.
+	 */
+	log (level: HotLogLevel, message: string)
+	{
+		if (this.logLevel === HotLogLevel.Verbose)
+		{
+			if (level === HotLogLevel.Error)
+				this.error (message);
+
+			if (level === HotLogLevel.Warning)
+				this.warning (message);
+
+			if ((level === HotLogLevel.Info) || 
+				(level === HotLogLevel.Verbose))
+			{
+				this.info (message);
+			}
+		}
+
+		if (this.logLevel === HotLogLevel.All)
+		{
+			if (level === HotLogLevel.Error)
+				this.error (message);
+
+			if (level === HotLogLevel.Warning)
+				this.warning (message);
+
+			if (level === HotLogLevel.Info)
+				this.info (message);
+		}
+
+		if (this.logLevel === HotLogLevel.Error)
+		{
+			if (level === HotLogLevel.Error)
+				this.error (message);
+		}
+
+		if (this.logLevel === HotLogLevel.Warning)
+		{
+			if (level === HotLogLevel.Warning)
+				this.warning (message);
+		}
+
+		if (this.logLevel === HotLogLevel.Info)
+		{
+			if (level === HotLogLevel.Info)
+				this.info (message);
+		}
+	}
+
+	/**
+	 * Log a verbose message.
+	 */
+	verbose (message: string)
+	{
+		if (this.logLevel === HotLogLevel.Verbose)
+			console.info (message);
+	}
+
+	/**
+	 * Log a message.
+	 */
+	info (message: string)
+	{
+		if ((this.logLevel === HotLogLevel.All) || 
+			(this.logLevel === HotLogLevel.Verbose) || 
+			(this.logLevel === HotLogLevel.Info))
+		{
+			console.info (message);
+		}
+	}
+
+	/**
+	 * Log a warning.
+	 */
+	warning (message: string)
+	{
+		if ((this.logLevel === HotLogLevel.All) || 
+			(this.logLevel === HotLogLevel.Verbose) || 
+			(this.logLevel === HotLogLevel.Warning))
+		{
+			console.warn (message);
+		}
+	}
+
+	/**
+	 * Log an error message.
+	 */
+	error (message: string | Error)
+	{
+		if ((this.logLevel === HotLogLevel.All) || 
+			(this.logLevel === HotLogLevel.Verbose) || 
+			(this.logLevel === HotLogLevel.Error))
+		{
+			let msg: string = "";
+
+			if (typeof (message) === "string")
+				msg = message;
+			else
+			{
+				if (message.message != null)
+					msg = message.message;
+
+				if (message.stack != null)
+					msg = message.stack;
+			}
+
+			console.error (msg);
+		}
+	}
+}

package/src/HotPage.ts

@@ -0,0 +1,206 @@
+import { Hot } from "./Hot";
+import { HotFile } from "./HotFile";
+import { HotStaq } from "./HotStaq";
+import { HotAPI } from "./HotAPI";
+import { HotTestElement } from "./HotTestElement";
+import { HotTestMap, HotTestPath } from "./HotTestMap";
+
+/**
+ * A page to preprocess.
+ */
+export interface IHotPage
+{
+	/**
+	 * The processor to use.
+	 */
+	processor: HotStaq;
+	/**
+	 * The name of the page.
+	 */
+	name?: string;
+	/**
+	 * The route used to get to this page.
+	 */
+	route?: string;
+	/**
+	 * The name of the page. File ordering matters here.
+	 * Every file is processed incrementally.
+	 */
+	files?: HotFile[];
+	/**
+	 * The associated tester name.
+	 */
+	testerName?: string;
+	/**
+	 * The associated tester map.
+	 */
+	testerMap?: string;
+	/**
+	 * The elements to test on this page.
+	 */
+	testElements?: { [name: string]: HotTestElement; };
+	/**
+	 * The test paths to test on this page.
+	 */
+	testPaths?: { [name: string]: HotTestPath; };
+}
+
+/**
+ * A page to preprocess.
+ */
+export class HotPage implements IHotPage
+{
+	/**
+	 * The processor to use.
+	 */
+	processor: HotStaq;
+	/**
+	 * The name of the page.
+	 */
+	name: string;
+	/**
+	 * The route used to get to this page.
+	 */
+	route: string;
+	/**
+	 * The name of the page. File ordering matters here.
+	 * Every file is processed incrementally.
+	 */
+	files: HotFile[];
+	/**
+	 * The associated tester name.
+	 */
+	testerName: string;
+	/**
+	 * The associated tester map.
+	 */
+	testerMap: string;
+	/**
+	 * The elements to test on this page.
+	 */
+	testElements: { [name: string]: HotTestElement; };
+	/**
+	 * The test paths to test on this page.
+	 */
+	testPaths: { [name: string]: HotTestPath; };
+
+	constructor (copy: IHotPage | HotStaq)
+	{
+		if (copy instanceof HotStaq)
+		{
+			this.processor = copy;
+			this.name = "";
+			this.testerName = "";
+			this.testerMap = "";
+			this.route = "";
+			this.files = [];
+			this.testElements = {};
+			this.testPaths = {};
+		}
+		else
+		{
+			this.processor = copy.processor;
+			this.name = copy.name || "";
+			this.testerName = copy.testerName || "";
+			this.testerMap = copy.testerMap || "";
+			this.route = copy.route || "";
+			this.files = copy.files || [];
+			this.testElements = copy.testElements || {};
+			this.testPaths = copy.testPaths || {};
+		}
+	}
+
+	/**
+	 * Add a file to process. It's recommend to load the file prior to 
+	 * adding it to a page if it's about to be used.
+	 */
+	async addFile (file: HotFile): Promise<void>
+	{
+		file.page = this;
+
+		this.files.push (file);
+	}
+
+	/**
+	 * Get the API associated with this page.
+	 */
+	getAPI (): HotAPI
+	{
+		return (this.processor.api);
+	}
+
+	/**
+	 * Get the tester API associated with this page.
+	 */
+	getTesterAPI (): HotAPI
+	{
+		return (this.processor.testerAPI);
+	}
+
+	/**
+	 * Add all files in the page. Could decrease page loading performance.
+	 * It's recommend to load the file prior to adding it to a page.
+	 */
+	async load (file: HotFile): Promise<void>
+	{
+		for (let iIdx = 0; iIdx < this.files.length; iIdx++)
+		{
+			let file: HotFile = this.files[iIdx];
+
+			await file.load ();
+		}
+	}
+
+	/**
+	 * Process a page and get the result.
+	 */
+	async process (args: any = null): Promise<string>
+	{
+		let output: string = "";
+
+		for (let iIdx = 0; iIdx < this.files.length; iIdx++)
+		{
+			let file: HotFile = this.files[iIdx];
+
+			Hot.Output = "";
+			file.page = this;
+
+			output += await file.process (args);
+		}
+
+		return (output);
+	}
+
+	/**
+	 * Add a test element.
+	 */
+	addTestElement (elm: HotTestElement): void
+	{
+		if (this.testElements[elm.name] != null)
+			throw new Error (`Test element ${elm.name} already exists!`);
+
+		this.testElements[elm.name] = elm;
+	}
+
+	/**
+	 * Get a test element.
+	 */
+	getTestElement (name: string): HotTestElement
+	{
+		if (this.testElements[name] == null)
+			throw new Error (`Test element ${name} doest not exist!`);
+
+		return (this.testElements[name]);
+	}
+
+	/**
+	 * Create a test path.
+	 */
+	createTestPath (pathName: string, driverFunc: HotTestPath): void
+	{
+		if (this.testPaths[pathName] != null)
+			throw new Error (`Test path ${pathName} already exists!`);
+
+		this.testPaths[pathName] = driverFunc;
+	}
+}

package/src/HotRoute.ts

@@ -0,0 +1,137 @@
+import { HotServer } from "./HotServer";
+import { HotRouteMethod, HTTPMethod, ServerExecutionFunction, TestCaseFunction, TestCaseObject } from "./HotRouteMethod";
+import { HotClient } from "./HotClient";
+import { HotLog } from "./HotLog";
+
+/**
+ * The route to use.
+ */
+export class HotRoute
+{
+	/**
+	 * The server that maintains the connections.
+	 */
+	connection: HotServer | HotClient;
+	/**
+	 * The associated logger.
+	 */
+	logger: HotLog;
+	/**
+	 * The route.
+	 */
+	route: string;
+	/**
+	 * The version.
+	 */
+	version: string;
+	/**
+	 * The prefix to add to the beginning of each route method.
+	 */
+	prefix: string;
+	/**
+	 * The authorization credentials to be used by the client 
+	 * when connecting to the server.
+	 */
+	authCredentials: any;
+	/**
+	 * The calls that can be made.
+	 */
+	methods: HotRouteMethod[];
+	/**
+	 * The errors and their JSON that can be thrown. Can be:
+	 * * not_authorized
+	 */
+	errors: { [error: string]: any };
+
+	constructor (connection: HotServer | HotClient, route: string, methods: HotRouteMethod[] = [])
+	{
+		this.connection = connection;
+		this.logger = null;
+
+		if (this.connection != null)
+		{
+			if (this.connection.processor != null)
+				this.logger = this.connection.processor.logger;
+		}
+
+		this.route = route;
+		this.version = "v1";
+		this.prefix = "";
+		this.authCredentials = null;
+		this.methods = methods;
+		this.errors = {
+				"not_authorized": HotRoute.createError ("Not authorized.")
+			};
+	}
+
+	/**
+	 * Create an error JSON object.
+	 */
+	static createError (message: string): any
+	{
+		return ({ error: message });
+	}
+
+	/**
+	 * Add an API method to this route.
+	 * 
+	 * @param method The name of the method to add. If a HotRouteMethod is supplied, the 
+	 * rest of the arguments supplied will be ignored.
+	 */
+	addMethod (
+		method: HotRouteMethod | string,
+		executeFunction: ServerExecutionFunction = null,
+		type: HTTPMethod = HTTPMethod.POST,
+		testCases: (string | TestCaseFunction)[] | TestCaseFunction[] | TestCaseObject[] = null
+		): void
+	{
+		if (typeof (method) === "string")
+			method = new HotRouteMethod (this, method, executeFunction, type, null, null, null, testCases);
+
+		this.methods.push (method);
+	}
+
+	/**
+	 * Get a method by it's name.
+	 */
+	getMethod (name: string): HotRouteMethod
+	{
+		let foundMethod: HotRouteMethod = null;
+
+		for (let iIdx = 0; iIdx < this.methods.length; iIdx++)
+		{
+			let method: HotRouteMethod = this.methods[iIdx];
+
+			if (method.name === name)
+			{
+				foundMethod = method;
+
+				break;
+			}
+		}
+
+		return (foundMethod);
+	}
+
+	/**
+	 * Executes before all routes have been registered.
+	 */
+	onPreRegister: () => Promise<void> = null;
+	/**
+	 * Executes when first registering this route with Express. If 
+	 * this returns false, the route will not be registered.
+	 */
+	onRegister: () => Promise<boolean> = null;
+	/**
+	 * Executes after all routes have been registered.
+	 */
+	onPostRegister: () => Promise<void> = null;
+
+	/**
+	 * Executes when authorizing a called method.
+	 * The value returned from here will be passed to onExecute in the 
+	 * called HotRouteMethod. Undefined returning from here will mean 
+	 * the authorization failed.
+	 */
+	onAuthorizeUser: (req: any, res: any) => Promise<any> = null;
+}