hotstaq 0.5.3

package/src/schemas/HotDBInflux.ts

@@ -0,0 +1,211 @@
+import { InfluxDB, ClientOptions, WriteApi, QueryApi, FluxTableMetaData, flux, Point } from "@influxdata/influxdb-client";
+
+import { ConnectionStatus, HotDB } from "../HotDB";
+import { HotDBConnectionInterface } from "../HotDBConnectionInterface";
+import { InfluxSchema } from "./influx/InfluxSchema";
+
+/**
+ * The Influx database connection.
+ */
+export class HotDBInflux extends HotDB<InfluxDB, void, InfluxSchema>
+{
+	/**
+	 * The Influx write api.
+	 */
+	writeApi: WriteApi;
+	/**
+	 * The Influx query api.
+	 */
+	queryApi: QueryApi;
+
+	constructor (db: InfluxDB = null, type: string = "influx", schema: InfluxSchema = null)
+	{
+		super (db, type, schema);
+	}
+
+	/**
+	 * Connect to the database.
+	 */
+	async connect (connectionInfo: HotDBConnectionInterface): Promise<any[]>
+	{
+		return (new Promise<any[]> ((resolve, reject) =>
+			{
+				let influxConnection: ClientOptions = {
+						"url": connectionInfo.server
+					};
+
+				if (connectionInfo.org == null)
+					throw new Error (`An org must be specified when connecting to Influx.`);
+
+				if (connectionInfo.database == null)
+					throw new Error (`A database (aka bucket) must be specified when connecting to Influx.`);
+
+				if (connectionInfo.token != null)
+					influxConnection.token = connectionInfo.token;
+				else
+				{
+					// This is mostly for Influx 1.8
+					influxConnection.token = `${connectionInfo.username}:${connectionInfo.password}`;
+				}
+
+				try
+				{
+					this.connectionStatus = ConnectionStatus.Connecting;
+					this.db = new InfluxDB (influxConnection);
+
+					this.writeApi = this.db.getWriteApi (connectionInfo.org, connectionInfo.database);
+					this.queryApi = this.db.getQueryApi (connectionInfo.org);
+
+					this.connectionStatus = ConnectionStatus.Connected;
+					resolve ([true]);
+				}
+				catch (ex)
+				{
+					throw new Error (ex.message);
+				}
+			}));
+	}
+
+	multiQuery: undefined;
+	queryOne: undefined;
+	//syncAllTables: undefined;
+	syncTable: undefined;
+	tableCheck: undefined;
+
+	/**
+	 * Checks to see if this has a database connection.
+	 */
+	protected dbCheck (): void
+	{
+		if (this.db == null)
+			throw new Error ("Not connected to a database!");
+	}
+
+	/**
+	 * Write to the database. This will only store the point. It will not send to the database 
+	 * unless sendPoints is called.
+	 */
+	addPoint (point: Point): void
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		this.writeApi.writePoint (point);
+	}
+
+	/**
+	 * Write to the database. This will only store the points. It will not send to the database 
+	 * unless sendPoints is called.
+	 */
+	addPoints (points: Point[]): void
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		this.writeApi.writePoints (points);
+	}
+
+	/**
+	 * Writes all stored points to the database.
+	 */
+	async sendPoints (): Promise<void>
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		return (new Promise<void> ((resolve, reject) =>
+			{
+				this.writeApi.close ().then (() =>
+					{
+						resolve ();
+					})
+					.catch ((ex) =>
+					{
+						throw new Error (ex.message);
+					});
+			}));
+	}
+
+	/**
+	 * Write to the database. This will call close and send the point immediately to the database.
+	 * Do not use this to send lots of data. If you're sending batches of data, be sure to use 
+	 * writePoints.
+	 */
+	async write (point: Point): Promise<void>
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		this.addPoint (point);
+
+		return (this.sendPoints ());
+	}
+
+	/**
+	 * Write points to the database. This will call close and send the point immediately to the database.
+	 */
+	async writePoints (points: Point[]): Promise<void>
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		this.addPoints (points);
+
+		return (this.sendPoints ());
+	}
+
+	/**
+	 * The query to make.
+	 */
+	async query (queryString: string, values: any[] = [], 
+		nextFunc: (row: string[], tableMeta: FluxTableMetaData) => void = null, 
+		errorFunc: (error: Error) => void = null): Promise<void>
+	{
+		if (this.queryApi == null)
+			throw new Error ("The Influx query API is not instantiated! Is Influx connected?");
+
+		return (new Promise<void> (async (resolve, reject) =>
+			{
+				let ary = [{ raw: [queryString] }];
+
+				for (let iIdx = 0; iIdx < values.length; iIdx++)
+				{
+					let value: any = values[iIdx];
+
+					ary.push (value);
+				}
+
+				/// @fixme Is this correct? wtf? Hardly any documentation on TemplateStringsArray or flux usage.
+				let inputQuery: TemplateStringsArray = String.raw.apply (String, ary);
+
+				this.queryApi.queryRows (inputQuery, {
+						"next": (row: string[], tableMeta: FluxTableMetaData) => 
+						{
+							if (nextFunc != null)
+								nextFunc (row, tableMeta);
+						},
+						"error": (errorObj: Error) => 
+						{
+							if (errorFunc != null)
+								errorFunc (errorObj);
+						},
+						"complete": () => 
+						{
+							resolve ();
+						}
+					});
+			}));
+	}
+
+	/**
+	 * Disconnect from the server.
+	 */
+	async disconnect (): Promise<void>
+	{
+		this.dbCheck ();
+
+		this.queryApi = null;
+		await this.writeApi.close ();
+		this.db = null;
+	}
+}

package/src/schemas/HotDBMigration.ts

@@ -0,0 +1,24 @@
+/**
+ * Migration data related to table changes.
+ */
+export abstract class HotDBMigration
+{
+    /**
+     * The version of this migration. **NOTE USE WHOLE INTEGERS ONLY**
+     */
+    version: number;
+
+    constructor (version: number = 1)
+    {
+        this.version = version;
+    }
+
+    /**
+     * Executes when migrating the table upwards.
+     */
+    abstract up (): Promise<void>;
+    /**
+     * Executes when migrating the table downwards, or undoing actions.
+     */
+    abstract down (): Promise<void>;
+}

package/src/schemas/HotDBMySQL.ts

@@ -0,0 +1,312 @@
+import * as mysql from "mysql";
+
+import * as ppath from "path";
+import * as vm from "vm";
+
+import { ConnectionStatus, HotDB } from "../HotDB";
+import { HotDBConnectionInterface } from "../HotDBConnectionInterface";
+import { HotIO } from "../HotIO";
+import { HotDBMigration } from "./HotDBMigration";
+import { MySQLSchema } from "./mysql/MySQLSchema";
+
+/**
+ * The database results.
+ */
+export interface MySQLResults
+{
+	error: any;
+	results: any;
+	fields: mysql.FieldInfo[];
+}
+
+/**
+ * The MySQL database connection.
+ */
+export class HotDBMySQL extends HotDB<mysql.Connection, MySQLResults, MySQLSchema>
+{
+	constructor (db: mysql.Connection = null, type: string = "mysql", schema: MySQLSchema = null)
+	{
+		super (db, type, schema);
+	}
+
+	/**
+	 * Connect to the database.
+	 */
+	async connect (connectionInfo: HotDBConnectionInterface): Promise<any[]>
+	{
+		return (new Promise<any[]> ((resolve, reject) =>
+			{
+				this.connectionStatus = ConnectionStatus.Connecting;
+				this.db = mysql.createConnection ({
+						host: connectionInfo.server,
+						user: connectionInfo.username,
+						password: connectionInfo.password,
+						port: connectionInfo.port,
+						database: connectionInfo.database
+					});
+				this.db.connect ((err: mysql.MysqlError, ...args: any[]): void =>
+					{
+						if (err != null)
+						{
+							this.connectionStatus = ConnectionStatus.Disconnected;
+
+							throw err;
+						}
+
+						this.connectionStatus = ConnectionStatus.Connected;
+						resolve (args[0]);
+					});
+			}));
+	}
+
+	/**
+	 * Checks to see if this has a database connection.
+	 */
+	protected dbCheck (): void
+	{
+		if (this.db == null)
+			throw new Error ("Not connected to a database!");
+	}
+
+	/**
+     * Synchronize all tables.
+     */
+	/*async syncAllTables (migrationsDirectory: string, throwErrors: boolean = true): Promise<boolean>
+	{
+		this.dbCheck ();
+
+		const migrationsPath: string = ppath.normalize (migrationsDirectory);
+
+		if (await HotIO.exists (migrationsPath) === false)
+			throw new Error (`Migrations directory ${migrationsDirectory} does not exist.`);
+
+		let files: string[] = await HotIO.listFiles (migrationsPath);
+		let versions: {
+				version: number;
+				fileContent: string;
+			}[] = [];
+
+		for (let iIdx = 0; iIdx < files.length; iIdx++)
+		{
+			let file: string = ppath.normalize (files[iIdx]);
+			let fileContent: string = await HotIO.readTextFile (file);
+
+			let context = { HotDBMigration: HotDBMigration, db: this, migrationPath: file };
+			vm.createContext (context);
+			let migrationVersion: any = vm.runInContext (
+`${fileContent}
+let migration = new Migration ();
+return (migration.version);
+`, context);
+
+			versions.push ({ version: migrationVersion, fileContent: fileContent });
+		}
+
+		versions.sort ();
+
+		await this.syncMigrationsTableTracker ();
+
+		let madeModifications: boolean = false;
+
+		for (let tableName in this.schema.tables)
+		{
+			let tempResult: boolean = await this.syncTable (tableName, throwErrors);
+
+			if (tempResult === true)
+				madeModifications = true;
+		}
+
+		return (madeModifications);
+	}*/
+
+    /**
+     * Synchronize a table. This will create/modify the table based on whether it 
+	 * exists, and if there's been any changes to any fields.
+     */
+	/*async syncTable (tableName: string, throwErrors: boolean = true): Promise<boolean>
+	{
+		this.dbCheck ();
+
+		let tableExists: boolean =  await this.tableCheck (tableName);
+		let madeModifications: boolean = false;
+
+		if (tableExists === false)
+		{
+			let structure: string[] = await this.schema.generateTableStructure (tableName);
+			// This should always be structure[0]. There should only be 1 string to process 
+			// for a newly created table.
+			let tempResults = await this.query (structure[0], []);
+
+			if (tempResults.error == null)
+				madeModifications = true;
+			else
+			{
+				if (throwErrors === true)
+					throw new Error (`Error while creating table ${tableName}: ${tempResults.error.message}`);
+			}
+		}
+		else
+		{*/
+			/*let structure: string[] = await this.schema.generateTableStructure (
+										tableName, HotDBGenerationType.Modify, this);
+			let tempResults = await this.multiQuery (structure);
+
+			for (let iIdx = 0; iIdx < tempResults.length; iIdx++)
+			{
+				let results = tempResults[iIdx];
+
+				if (results.error != null)
+				{
+					madeModifications = false;
+
+					if (throwErrors === true)
+						throw new Error (`Error while creating table ${tableName}: ${results.error.message}`);
+				}
+				else
+					madeModifications = true;
+			}*/
+		/*}
+
+		return (madeModifications);
+	}*/
+
+	/**
+	 * Sync the migrations table tracker. This keeps track of all database table migrations. 
+	 * If the "migrations" table is missing, it will be created.
+	 */
+	async syncMigrationsTableTracker (): Promise<void>
+	{
+		if (await this.tableCheck ("migrations") === false)
+		{
+			/// @todo Verify that this actually created.
+			await this.db.query (`create table if not exists migrations (
+					version datetime not null
+				);`);
+		}
+	}
+
+	/**
+	 * Checks if the table exists.
+	 */
+	async tableCheck (tableName: string): Promise<boolean>
+	{
+		this.dbCheck ();
+
+		let tableExists: boolean = await new Promise<boolean> ((resolve, reject) =>
+			{
+				this.db.query ("SELECT table_name FROM information_schema.tables where table_name = ?;", [tableName], 
+					(err: mysql.MysqlError, results: any, fields: mysql.FieldInfo[]) =>
+					{
+						let result: boolean = false;
+
+						if (results != null)
+						{
+							if (results.length > 0)
+								result = true;
+						}
+
+						resolve (result);
+					});
+			});
+
+		return (tableExists);
+	}
+
+	/**
+	 * The query to make.
+	 */
+	async query (queryString: string, values: any[] = []): Promise<MySQLResults>
+	{
+		this.dbCheck ();
+
+		let dbresults: MySQLResults = await new Promise<MySQLResults> ((resolve, reject) =>
+			{
+				this.db.query (queryString, values, 
+					(err: mysql.MysqlError, results: any, fields: mysql.FieldInfo[]) =>
+					{
+						resolve ({ error: err, results: results, fields: fields });
+					});
+			});
+
+		return (dbresults);
+	}
+
+	/**
+	 * Make a single query. If there are no results, null will be in MySQLResults.results
+	 */
+	async queryOne (queryString: string, values: any[] = []): Promise<MySQLResults>
+	{
+		this.dbCheck ();
+
+		let dbresults: MySQLResults = await new Promise<MySQLResults> ((resolve, reject) =>
+			{
+				this.db.query (queryString, values, 
+					(err: mysql.MysqlError, results: any, fields: mysql.FieldInfo[]) =>
+					{
+						let tempResults = null;
+
+						if (results != null)
+						{
+							if (results.length > 0)
+								tempResults = results[0];
+						}
+
+						resolve ({ error: err, results: tempResults, fields: fields });
+					});
+			});
+
+		return (dbresults);
+	}
+
+	/**
+	 * Make multiple queries. **Warning! This can be a security vulnerability 
+	 * if misused! Ideally this should only be used when making changes to tables!
+	 * Additionally, this could overwhelm the server and each command sent is not 
+	 * guaranteed to be done in order.**
+	 */
+	async multiQuery (queryStrings: string[] | { query: string; values: any[]; }[]): Promise<MySQLResults[]>
+	{
+		this.dbCheck ();
+
+		let alldbresults: MySQLResults[] = [];
+		let promises = [];
+
+		for (let iIdx = 0; iIdx < queryStrings.length; iIdx++)
+		{
+			/// @fixme This could overwhelm the server, and each query most likely will 
+			/// not be done in a deterministic order. Consider adding a 5-10ms delay between
+			/// each query.
+			promises.push (new Promise<MySQLResults> ((resolve, reject) =>
+				{
+					let queryString: string | { query: string; values: any[]; } = queryStrings[iIdx];
+					let queryValues: any[] = [];
+
+					if (typeof (queryString) !== "string")
+					{
+						queryValues = queryString.values;
+						queryString = queryString.query;
+					}
+
+					this.db.query (queryString, queryValues, 
+						(err: mysql.MysqlError, results: any, fields: mysql.FieldInfo[]) =>
+						{
+							resolve ({ error: err, results: results, fields: fields });
+						});
+				}));
+		}
+
+		alldbresults = await Promise.all (promises);
+
+		return (alldbresults);
+	}
+
+	/**
+	 * Disconnect from the server.
+	 */
+	async disconnect (): Promise<void>
+	{
+		this.dbCheck ();
+
+		this.db.destroy ();
+	}
+}

package/src/schemas/HotDBSchema.ts

@@ -0,0 +1,21 @@
+export enum HotDBGenerationType
+{
+	Create,
+	Modify
+}
+
+/**
+ * The parent database schema.
+ */
+export class HotDBSchema
+{
+	/**
+	 * The name of this schema.
+	 */
+	name: string;
+
+	constructor (name: string)
+	{
+		this.name = name;
+	}
+}

package/src/schemas/influx/InfluxSchema.ts

@@ -0,0 +1,19 @@
+import { HotDBSchema } from "../HotDBSchema";
+
+/**
+ * The Influx schema.
+ */
+export class InfluxSchema extends HotDBSchema
+{
+	/**
+	 * The buckets in this schema.
+	 */
+	buckets: { [name: string]: any };
+
+	constructor (name: string)
+	{
+		super (name);
+
+		this.buckets = {};
+	}
+}

package/src/schemas/mysql/MySQLSchema.ts

@@ -0,0 +1,90 @@
+import { MySQLSchemaTable } from "./MySQLSchemaTable";
+import { MySQLSchemaField } from "./MySQLSchemaField";
+import { HotDBSchema, HotDBGenerationType } from "../HotDBSchema";
+import { HotDBMySQL } from "../HotDBMySQL";
+
+/**
+ * The MySQL schema.
+ */
+export class MySQLSchema extends HotDBSchema
+{
+	/**
+	 * The tables in this schema.
+	 */
+	tables: { [name: string]: MySQLSchemaTable };
+
+	constructor (name: string)
+	{
+		super (name);
+
+		this.tables = {};
+	}
+
+	/**
+	 * Add a table to this schema.
+	 */
+	addTable (table: MySQLSchemaTable): void
+	{
+		this.tables[table.name] = table;
+	}
+
+	/**
+	 * Add a field to a table.
+	 */
+	addFieldToTable (tableName: string, field: MySQLSchemaField)
+	{
+		if (this.tables[tableName] == null)
+			throw new Error (`Table ${tableName} does not exist!`);
+
+		this.tables[tableName].fields.push (field);
+	}
+
+	/**
+	 * Add a field to a table.
+	 */
+	addFieldsToTable (tableName: string, fields: MySQLSchemaField[])
+	{
+		if (this.tables[tableName] == null)
+			throw new Error (`Table ${tableName} does not exist!`);
+
+		for (let iIdx = 0; iIdx < fields.length; iIdx++)
+		{
+			let field: MySQLSchemaField = fields[iIdx];
+			this.tables[tableName].fields.push (field);
+		}
+	}
+
+	/**
+	 * Generate a table's structure. If type is set to modify, you must pass a db with an 
+	 * active connection.
+	 */
+	async generateTableStructure (tableName: string, 
+		type: HotDBGenerationType = HotDBGenerationType.Create, db: HotDBMySQL = null): Promise<string[]>
+	{
+		if (this.tables[tableName] == null)
+			throw new Error (`Unable to generate table structure for ${tableName}. Table doesn't exist.`);
+
+		let table: MySQLSchemaTable = this.tables[tableName];
+		let generatedStructure: string[] = await table.generate (type, db);
+
+		return (generatedStructure);
+	}
+
+	/**
+	 * Generate the entire db structure. If type is set to modify, you must pass a db with an 
+	 * active connection.
+	 */
+	async generateStructure (type: HotDBGenerationType = HotDBGenerationType.Create, db: HotDBMySQL = null): Promise<string[][]>
+	{
+		let result: string[][] = [];
+
+		for (let key in this.tables)
+		{
+			let generatedStructure: string[] = await this.generateTableStructure (key, type, db);
+
+			result.push (generatedStructure);
+		}
+
+		return (result);
+	}
+}