redid database structures and now running SQLite and Seqelize

src/app.js

@@ -1,15 +1,25 @@
 import {Logger} from './models/logger';
 import {Config} from './config/config'
-import {DbTools} from './models/database/tools';
+import {Database} from './models/database/database';
 import {Server} from './server';
 import {Router} from './controllers/routes/router';
 
 init();
 async function init() {
+    Logger.SetLevel(Logger.VERBOSE_LOGS);
+    
     await Config.load();
-    await DbTools.connect();
-    await DbTools.testConnection();
+    await Database.init();
+    await Database.testConnection();
     await Server.start();
     await Router.initEndpoints();
+
 }
+
+// Logger.database('Database Log');
+// Logger.debug('Debug mode enabled');
+// Logger.info('Informatic log');
+// Logger.warn('Warning');
+// Logger.error('An error has occured');
+// Logger.panic('A fatal error has occured, exiting');
  

src/controllers/routes/router.js

@@ -9,12 +9,13 @@ let app;
 export class Router {
     static async initEndpoints() {
         Logger.info('Setting up API HTTP endpoints');
-        
+
         app = Server.App;
+
         app.get('/', [MiddleWare.analytics, Router.frontPage]);
         
-        app.get('/user/:id', (req, res) => [MiddleWare.analytics]);
-        app.delete('/user/:id', (req, res) => {});
+        app.get('/user/:id', [MiddleWare.analytics]);
+        app.delete('/user/:id', [MiddleWare.analytics]);
         app.post('/user', [MiddleWare.analytics, Controllers.UserController.newUser]);
         
         app.use([MiddleWare.analytics, StatusCodes.pageNotFound]);

src/controllers/user.js

@@ -4,6 +4,11 @@ import {ControllerHandler} from './controllerHandler';
 export class UserController extends ControllerHandler {
     static newUser(req, res, next) {
         Logger.info('NEW USER');
+
+        let username = req.body.username || null;
+        let email = req.body.email || null;
+        let password = req.body.password || null;
+
         next();
     }
 }

src/models/database/baseDatabase.js

@@ -0,0 +1,75 @@
+import Sequelize from 'sequelize';
+
+import {Logger} from '../logger';
+import {Config} from '../../config/config';
+
+let connection;
+
+let user;
+let auth;
+let session;
+
+export class BaseDatabase {
+    static get Connection() {return connection}
+
+    static async init() {
+        Logger.info('Connecting to SQLite Database');
+
+        connection = new Sequelize('database', 'user', 'password', {
+            host: 'localhost',
+            dialect: 'sqlite',
+            logging: Logger.database,
+            operatorsAliases: false,
+            storage: 'src/models/database/sqlite/database.sqlite',
+        });
+
+        user = connection.define('user', {
+            id: {
+                type: Sequelize.BIGINT,
+                primaryKey: true,
+                unique: true
+            },
+            username: Sequelize.TEXT,
+            password: Sequelize.TEXT,
+            email: Sequelize.TEXT,
+            ip: Sequelize.TEXT,
+            lastupdated: Sequelize.TEXT,
+            verified: Sequelize.BOOLEAN,
+            authcode: Sequelize.STRING,
+            timeauthed: Sequelize.TEXT
+        });
+        
+        auth = connection.define('auth', {
+            id: {
+                type: Sequelize.BIGINT,
+                primaryKey: true,
+                unique: true
+            },
+            selector: Sequelize.TEXT,
+            validator: Sequelize.TEXT,
+            uid: Sequelize.BIGINT,
+            expires: Sequelize.TEXT
+        });
+
+        session = connection.define('session', {
+            sessionid: {
+                type: Sequelize.BIGINT,
+                primaryKey: true,
+                unique: true
+            },
+            sessiondata: Sequelize.TEXT,
+            timecreated: Sequelize.TEXT,
+            timeupdated: Sequelize.TEXT
+        });
+        try {
+            await connection.sync();
+        } catch (e) {
+            Logger.panic('Failed to connect to SQLite Database, error:', e)
+        }
+        Logger.info('Connected to SQLite Database');
+    }
+
+    static async testConnection() {
+
+    }
+}

src/models/database/database.js

@@ -1,41 +1,29 @@
-import mysql from 'mysql';
+import Sequelize from 'sequelize';
 
+import {BaseDatabase} from './baseDatabase';
 import {Logger} from '../logger';
-import {Config} from '../../config/config';
 
-let connection;
+export class Database extends BaseDatabase {
+    static async exec(query) {
+        let connection = BaseDatabase.Connection;
+        let res;
 
-export class Database {
-    static get Connection() {return connection}
-
-    static async connect() {
-        Logger.info('Connecting to mySQL database');
         let promise = new Promise((resolve, reject) => {
-            connection = mysql.createConnection(Config.Database);
-
-            connection.connect((err) => {
-                if (err) {
-                    Logger.panic('Failed to connect to the database as user ' + Config.Database.user);
-                    reject();
-                }
-                Logger.info('Connected to mySQL as id ' + connection.threadId);
-                resolve();
-            });
+            connection
+                .query(query)
+                .then(result => {
+                    res = result[0][0].result;
+                    resolve();
+                })
+                .catch(err => {
+                    Logger.error('An error occured while querying a database: ' + err);
+                    reject()
+                });
         });
-        await promise;
-    }
 
-    static async testConnection() {
-        let promise = new Promise((resolve, reject) => {
-            connection.query('SELECT 1 + 1 AS solution', async function (err, results, fields) {
-                if (err) {
-                    Logger.panic('Failed to query the database');
-                    reject();
-                }
-                Logger.info('Database connection tested and secure');
-                resolve();
-            });
-        });
         await promise;
+        return res;
     }
 }
+
+Database.users = require('./users').UserTools;

src/models/database/tools.js

@@ -1,152 +0,0 @@
-import {Database} from './database';
-import {Logger} from '../logger';
-
-export class DbTools extends Database {
-    static async getRow(table, id) {
-        let connection = Database.Connection;
-        let res;
-        
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`SELECT * FROM \`${table}\` WHERE \`${table}\`.\`id\` = '${id}';`, async(err, results, fields) => {
-                if (err) {
-                    Logger.warn(`Error querying ${table} with ${id}`);
-                    return -1;
-                    reject();
-                }
-                res = results;
-                resolve();
-            });
-        });
-        await promise;
-        if (res[0]) {
-            return res[0];
-        } else {
-            return -1;
-        }
-    }
-    
-    static async getID(table, column, term) {
-        let connection = Database.Connection;
-        let res;
-        
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`SELECT \`id\` FROM \`${table}\` WHERE \`${table}\`.\`${column}\` = '${term}';`, async(err, results, fields) => {
-                if (err) {
-                    Logger.warn(`Error querying ${table}'s ${column} with ${term}`);
-                    return -1;
-                    reject();
-                }
-                res = results;
-                resolve();
-            });
-        });
-        await promise;
-    
-        let id = 0;
-        if (res[0]) {
-            id = res[0].id;
-        } else {
-            id = 0;
-        }
-        return id;
-    }
-    
-    static async createUser(id, username, password, email, phone, ip, token, lastupdated, admin, authcode) {
-        let connection = Database.Connection;
-    
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`INSERT INTO \`Users\` (\`id\`, \`username\`, \`password\`, \`email\`, \`phone\`, \`ip\`, \`token\`, \`lastupdated\`, \`verified\`, \`authcode\`, \`timeauthed\`,\`admin\`) VALUES ('${id}', '${username}', '${password}', '${email}', '${phone}', '${ip}', '${token}', '${lastupdated}', '0', '${authcode}', 'UNAUTHORISED', '${admin}');` , async(err, results, fields) => {
-                if (err) {
-                    Logger.warn(`Error inserting user ${username}`);
-                    return -1;
-                    reject();
-                }
-                resolve();
-            });
-        });
-        await promise;
-    }
-    
-    static async deleteUser(id) {
-        let connection = Database.Connection;
-    
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`DELETE FROM \`Users\` WHERE \`id\` = '${id}'`, async(err, results, fields) => {
-                if(err) {
-                    Logger.warn(`Error deleting User at ID ${id}`);
-                    return -1;
-                    reject();
-                }
-                resolve();
-            });
-        });
-        await promise;
-        return 1;
-    }
-    
-    static async updateUserIP(id, ip) {
-        let connection = Database.Connection;
-    
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`UPDATE \`Users\` SET \`ip\` = '${ip}' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
-                if(err) {
-                    Logger.warn(`Error updating User ip at ID ${id}`);
-                    return -1;
-                    reject();
-                }
-                resolve();
-            });
-        });
-        await promise;
-        return 1;
-    }
-    
-    static async authUser(id, timeauthed) {
-        let connection = Database.Connection;
-    
-        let promise = new Promise((resolve, reject) => {
-            connection.query(`UPDATE \`Users\` SET \`verified\` = '1' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
-                if(err) {
-                    Logger.warn(`Error authorizing User at ID ${id}`);
-                    return -1;
-                    reject();
-                }
-                resolve();
-            });
-        });
-        await promise;
-    
-        let promise1 = new Promise((resolve, reject) => {
-            connection.query(`UPDATE \`Users\` SET \`timeauthed\` = '${timeauthed}' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
-                if(err) {
-                    Logger.warn(`Error authorizing User at ID ${id}`);
-                    return -1;
-                    reject();
-                }
-                resolve();
-            });
-        });
-        await promise1;
-    
-        return 1;
-    }
-    
-    static async exec(cmd) {
-        let connection = Database.Connection;
-        let res;
-    
-        let promise = new Promise((resolve, reject) => {
-            connection.query(cmd, async(err, results, fields) => {
-                if (err) {
-                    Logger.warn(`Error executing ${cmd} on the database`);
-                    return -1;
-                    reject();
-                }
-                res = results;
-                resolve();
-            })
-        });
-        await promise;
-        return res;
-    }
-}

src/models/database/users.js

@@ -0,0 +1,11 @@
+import Sequelize from 'sequelize';
+
+import {BaseDatabase} from './baseDatabase';
+import {Logger} from '../logger';
+import {Config} from '../../config/config';
+
+export class UserTools extends BaseDatabase {
+    static async testing() {
+        Logger.debug('Hello, world!');
+    }
+}

src/models/logger.js

@@ -1,29 +1,51 @@
 const colours = require('colors/safe');
 
+let LogLevel = 1;
 export class Logger {
+    static SetLevel(level) {
+        LogLevel = level;
+    }
+
+    static get VERBOSE_LOGS() {return 0;}
+    static get DEBUG_LOGS() {return 1;}
+    static get INFO_LOGS() {return 2;}
+    static get WARN_LOGS() {return 3;}
+
+    static database(message) {
+        if (LogLevel > 0) return; 
+        let d = new Date();
+        console.log('[' + d.toLocaleString() + '] [' 
+            + colours.magenta('SQLITE') + '] ' + message);
+    }
+
+    static debug(message) {
+        if (LogLevel > 1) return; 
+        let d = new Date();
+        console.log('[' + d.toLocaleString() + '] [' 
+            + colours.cyan('DEBUG') + '] ' + message);
+    }
+
     static info(message) {
-        if (!message) throw 'No message defined';
+        if (LogLevel > 2) return; 
         let d = new Date();
         console.log('[' + d.toLocaleString() + '] [' 
             + colours.green('INFO') + '] ' + message);
     }
 
     static warn(message) {
-        if (!message) throw 'No message defined';
+        if (LogLevel > 3) return; 
         let d = new Date();
         console.log('[' + d.toLocaleString() + '] [' 
             + colours.yellow('WARN') + '] ' + message);
     }
 
     static error(message) {
-        if (!message) throw 'No message defined';
         let d = new Date();
         console.log('[' + d.toLocaleString() + '] [' 
             + colours.red('ERROR') + '] ' + message);
     }
 
     static panic(message) {
-        if (!message) throw 'No message defined';
         let d = new Date();
         console.log('[' + d.toLocaleString() + '] [' 
             + colours.red('PANIC') + '] ' + message);