implemented db init/create

Author: gambitier

Projects/BooksLibrary/.env.sample

@@ -1,4 +1,9 @@
 BASE_URL=http://localhost:7272/api/v1
 PORT=7272
 NODE_ENV=development
-API_VERSION=0.0.1
+API_VERSION=0.0.1
+
+DB_USER_NAME = someusername
+DB_USER_PASSWORD = somepass
+DB_NAME = somename
+DB_HOST = host

Projects/BooksLibrary/package-lock.json

@@ -30,7 +30,10 @@
         "express": "^4.17.3",
         "express-fileupload": "^1.3.1",
         "jsonwebtoken": "^8.5.1",
+        "pg": "^8.7.3",
         "reflect-metadata": "^0.1.13",
+        "sequelize": "^6.17.0",
+        "sequelize-typescript": "^2.1.3",
         "tsyringe": "^4.6.0"
     }
 }

Projects/BooksLibrary/package.json

@@ -7,7 +7,7 @@
     "Database": {
         "Type": "SQL",
         "ORM": "Sequelize",
-        "Flavour": "MySQL"
+        "Flavour": "PostGreSQL"
     },
     "FileStorage": {
         "Provider": "AWS-S3"

Projects/BooksLibrary/src/app.config.json

@@ -1,17 +1,33 @@
-import { AuthenticationType, AuthorizationType, Configurations } from './configuration.types';
-import * as AppConfig from '../app.config.json';
+import {
+    AuthenticationType,
+    AuthorizationType,
+    Configurations,
+    DatabaseFlavour,
+    DatabaseORM,
+    DatabaseType,
+} from './configuration.types';
+import * as configuration from '../app.config.json';
 
 export class ConfigurationManager {
     static _config: Configurations = null;
 
+    public static DatabaseFlavour = (): DatabaseFlavour => {
+        return ConfigurationManager._config.Database.Flavour;
+    };
+
     public static loadConfigurations = (): void => {
         ConfigurationManager._config = {
             BaseUrl: process.env.BASE_URL,
             SystemIdentifier: '',
             MaxUploadFileSize: 0,
             Auth: {
-                Authentication: AppConfig.Auth.Authentication as AuthenticationType,
-                Authorization: AppConfig.Auth.Authorization as AuthorizationType,
+                Authentication: configuration.Auth.Authentication as AuthenticationType,
+                Authorization: configuration.Auth.Authorization as AuthorizationType,
+            },
+            Database: {
+                Type: configuration.Database.Type as DatabaseType,
+                ORM: configuration.Database.ORM as DatabaseORM,
+                Flavour: configuration.Database.Flavour as DatabaseFlavour,
             },
         };
     };

Projects/BooksLibrary/src/config/configuration.manager.ts

@@ -1,10 +1,22 @@
 export type AuthorizationType = 'Custom'; //TBD: Other options need to be supported
 export type AuthenticationType = 'Custom'; //TBD: Other options need to be supported
+
+export type DatabaseFlavour = 'MySQL' | 'PostGreSQL' | 'MongoDB';
+export type DatabaseType = 'SQL' | 'NoSQL';
+export type DatabaseORM = 'Sequelize' | 'Knex' | 'Mongoose';
+
+export interface DatabaseConfig {
+    Type: DatabaseType;
+    ORM: DatabaseORM;
+    Flavour: DatabaseFlavour;
+}
+
 export interface Configurations {
     SystemIdentifier: string;
     BaseUrl: string;
     MaxUploadFileSize: number;
     Auth: AuthConfig;
+    Database: DatabaseConfig;
 }
 export interface AuthConfig {
     Authentication: AuthenticationType;

Projects/BooksLibrary/src/config/configuration.types.ts

@@ -0,0 +1,28 @@
+import { Logger } from 'common/logger';
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+if (process.env.NODE_ENV === 'test') {
+    Logger.instance().log('================================================');
+    Logger.instance().log('Environment   : ' + process.env.NODE_ENV);
+    Logger.instance().log('Database name : ' + process.env.DB_NAME);
+    Logger.instance().log('Database user : ' + process.env.DB_USER_NAME);
+    Logger.instance().log('Database host : ' + process.env.DB_HOST);
+    Logger.instance().log('================================================');
+}
+
+export class DbConfig {
+    public static config = {
+        username: process.env.DB_USER_NAME,
+        password: process.env.DB_USER_PASSWORD,
+        database: process.env.DB_NAME,
+        host: process.env.DB_HOST,
+        dialect: 'mysql',
+        pool: {
+            max: 20,
+            min: 0,
+            acquire: 30000,
+            idle: 10000,
+        },
+    };
+}

Projects/BooksLibrary/src/database/sql/sequelize/database.config.ts

@@ -0,0 +1,99 @@
+import { Logger } from 'common/logger';
+import { IDatabaseConnector } from 'database/database.connector.interface';
+import { DbConfig } from './database.config';
+import { Dialect } from 'sequelize';
+import { Sequelize } from 'sequelize-typescript';
+import { ConfigurationManager } from 'config/configuration.manager';
+import { PostgresqlClient } from './dilect.clients/postgresql.client';
+
+export class DatabaseConnector_Sequelize implements IDatabaseConnector {
+    private _sequelize: Sequelize = null;
+
+    private getDialect = (): Dialect => {
+        let dialect: Dialect = 'postgres';
+        const flavour = ConfigurationManager.DatabaseFlavour();
+
+        if (flavour === 'MySQL') {
+            dialect = 'mysql';
+        }
+        if (flavour === 'PostGreSQL') {
+            dialect = 'postgres';
+        }
+
+        return dialect;
+    };
+
+    connect = async (): Promise<boolean> => {
+        try {
+            const config = DbConfig.config;
+            const dialect: Dialect = this.getDialect();
+            const modelsPath = [__dirname + '/models'];
+            const options = {
+                host: config.host,
+                dialect: dialect,
+                models: modelsPath,
+                pool: {
+                    max: config.pool.max,
+                    min: config.pool.min,
+                    acquire: config.pool.acquire,
+                    idle: config.pool.idle,
+                },
+                logging: false, //TODO: Please provide a function here to handle logging...
+            };
+
+            this._sequelize = new Sequelize(config.database, config.username, config.password, options);
+
+            Logger.instance().log(`Connecting to database '${config.database}' ...`);
+            Logger.instance().log(`Database flavour: ${config.dialect}`);
+            Logger.instance().log(`Database host: ${config.host}`);
+
+            await this.createDatabase();
+            // test the connection by trying to authenticate to database server
+            // with the config that we have defined above
+            await this._sequelize.authenticate();
+            // alter: true is not adviced to be used on prod env
+            await this._sequelize.sync({ alter: true });
+
+            return true;
+        } catch (err) {
+            Logger.instance().log(err.message);
+            return false;
+        }
+    };
+
+    sync(): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+
+    private getClient = () => {
+        const flavour = ConfigurationManager.DatabaseFlavour();
+
+        if (flavour === 'PostGreSQL') {
+            return PostgresqlClient;
+        }
+
+        throw new Error('Only PostGreSQL is supported for now!');
+    };
+
+    createDatabase = async (): Promise<boolean> => {
+        try {
+            const client = this.getClient();
+            await client.createDb();
+            return true;
+        } catch (err) {
+            Logger.instance().log(err.message);
+        }
+    };
+
+    dropDatabase(): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+
+    executeQuery(query: string): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+
+    migrate(): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+}

Projects/BooksLibrary/src/database/sql/sequelize/database.connector.sequelize.ts

@@ -0,0 +1,33 @@
+import { Logger } from 'common/logger';
+import { DbConfig } from '../database.config';
+import { Client } from 'pg';
+
+export class PostgresqlClient {
+    static async executeQuery(query: string) {
+        try {
+            const config = DbConfig.config;
+            const client = new Client({
+                user: config.username,
+                host: config.host,
+                password: config.password,
+                port: 5432,
+            });
+
+            await client.connect();
+            await client.query(query);
+            await client.end();
+        } catch (err) {
+            Logger.instance().log(err.message);
+        }
+    }
+
+    public static createDb = async () => {
+        try {
+            const config = DbConfig.config;
+            const query = `CREATE DATABASE ${config.database}`;
+            await PostgresqlClient.executeQuery(query);
+        } catch (error) {
+            Logger.instance().log(error.message);
+        }
+    };
+}