5htp-core 0.1.2 → 0.2.1

package/src/server/services/cron/index.ts

@@ -3,8 +3,8 @@
 ----------------------------------*/
 
 // Core
+import Application, { Service } from '@server/app';
 import { NotFound } from '@common/errors';
-import app from '@server/app';
 import context from '@server/context';
 
 /*----------------------------------
@@ -19,25 +19,19 @@ export { default as CronTask } from './CronTask';
 - SERVICE CONFIG
 ----------------------------------*/
 
-export type CronServiceConfig = {
+export type Config = {
    
 }
 
-declare global {
-    namespace Core {
-        namespace Config {
-            interface Services {
-                cron: CronServiceConfig
-            }
-        }
-    }
+export type Hooks = {
+
 }
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 
-export class CronManager {
+export default class CronManager extends Service<Config, Hooks, Application> {
 
     public static taches: { [nom: string]: CronTask } = {}
     public static timer: NodeJS.Timeout;
@@ -45,11 +39,15 @@ export class CronManager {
     /*----------------------------------
     - HOOKS
     ----------------------------------*/
-    public constructor() {
-        app.on('cleanup', () => this.cleanup());
+
+    public async register() {
+
     }
 
-    public async load() {
+    public async start() {
+        
+        this.app.on('cleanup', () => this.cleanup());
+
         clearInterval(CronManager.timer);
         CronManager.timer = setInterval(() => {
 
@@ -116,16 +114,4 @@ export class CronManager {
             throw new Error(`L'instance de la tâche cron ${name} n'a pas été trouvée`);
         return cron;
     }
-}
-
-/*----------------------------------
-- REGISTER SERVICE
-----------------------------------*/
-app.register('cron', CronManager);
-declare global {
-    namespace Core {
-        interface Services {
-            cron: CronManager;
-        }
-    }
 }

package/src/server/services/database/bucket.ts

@@ -0,0 +1,40 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import { TQueryOptions } from './connection';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+const LogPrefix = '[database][bucket]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class Queriesbucket {
+
+    public queries: Set<string>;
+
+    public constructor( 
+        private queryOptions: TQueryOptions<'bucket'> = {},
+        queriesList: string[] = [],  
+    ) {
+        this.queries = new Set<string>(queriesList);
+    }
+
+    public add( query: string ) {
+        this.queries.add(query);
+        return this;
+    }
+
+    public delete( query: string ) {
+        this.queries.delete(query);
+    }
+
+    public run() {
+        this.queryOptions.log && console.log(LogPrefix, `Run queries bucket`, ...this.queries);
+    }
+}

package/src/server/services/database/connection.ts

@@ -6,46 +6,97 @@
 import mysql from 'mysql2/promise';
 
 // Core: general
-import app from '@server/app';
-import loadMetadata, { TDatabasesList } from './metas';
-import { seconds } from '@common/utils';
+import Application from '@server/app';
+import Service from '@server/app/service';
+
+// Core: specific
+import { SqlError } from './debug';
+import type Console from '../console';
+import MetadataParser, { TDatabasesList, TMetasTable, TColumnTypes, TMetasColonne } from './metas';
+import { TMySQLTypeName, mysqlToJs, js as jsTypes } from './datatypes';
+import Bucket from './bucket';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[database][connection]';
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+export type DatabaseServiceConfig = {
+    list: string[],
+    dev: {
+        host: string,
+        port: number,
+        login: string,
+        password: string,
+    },
+    prod: {
+        host: string,
+        port: number,
+        login: string,
+        password: string,
+    }
+}
+
+export type THooks = {
+
+}
 
 /*----------------------------------
-- DEFINITIONS TYPESSQL
+- TYPES
 ----------------------------------*/
 
+type TBasicQueryOptions = {
+    bucket?: Bucket,
+    simulate?: boolean,
+    log?: boolean,
+    returnQuery?: boolean,
+}
+
+export type TQueryOptions<TOmitValues extends keyof TBasicQueryOptions = never, TRequireValues extends keyof TBasicQueryOptions = never> = (
+    Omit<TBasicQueryOptions, TOmitValues> 
+    & 
+    Required<Pick<TBasicQueryOptions, TRequireValues>>
+)
+
+export type TQueryResult = TSelectQueryResult;
+
+// TODO: specifiy return type of every mysql query type
+type TSelectQueryResult = any;
 
 /*----------------------------------
 - SERVICES
 ----------------------------------*/
-export default class FastDatabase {
+export default class DatabaseConnection extends Service<DatabaseServiceConfig, THooks, Application> {
 
     private initialized = false;
     public connection!: mysql.Pool;
-    public tables: TDatabasesList = {};
 
-    public config = app.config.database;
+    public tables: TDatabasesList = {};
+    public metas = new MetadataParser(this);
 
     /*----------------------------------
     - HOOKS
     ----------------------------------*/
-    public constructor() {
 
-        app.on('cleanup', () => this.cleanup());
+    public async register() {
 
     }
-
+    
     public loading: Promise<void> | undefined = undefined;
-    public async load() {
-
-        // Wait for database service to be ready
-        //await seconds(5);
+    public async start() {
 
         this.initialized = false;
 
+        this.app.on('cleanup', () => this.cleanup());
+
         this.connection = await this.connect();
 
-        this.tables = await loadMetadata( app.config.database.list, this.connection);
+        this.tables = await this.metas.load( this.config.list );
 
         this.initialized = true;
 
@@ -60,9 +111,9 @@ export default class FastDatabase {
     ----------------------------------*/
     public async connect() {
 
-        console.info(`Connecting to databases ...`);
+        console.info(LogPrefix, `Connecting to databases ...`);
 
-        const creds = this.config[ app.env.profile ];
+        const creds = this.config[ this.app.env.profile ];
 
         return await mysql.createPool({
 
@@ -93,102 +144,184 @@ export default class FastDatabase {
             multipleStatements: true,
 
             queryFormat: function (query, values) {
-                //console.info('queryFormat', query);
+                //console.info(LogPrefix, 'queryFormat', query);
                 return query;
             }
         });
     }
 
-    private typeCast(field, next) {
+    private typeCast( field: mysql.Field, next: Function ) {
 
-        // Metadata must be loaded
+        // Wait for the connection to be initialized
         if (!this.initialized)
             return next();
 
-        let type = field.type;
-        if (field.db) {
-
-            // TODO: A revoir, car les infos passées peuvent être des alias
+        // Normal column
+        let databaseColumn: TMetasColonne | undefined;
+        if (field.db && field.table && field.name) {
 
             const db = this.tables[ field.db ];
             if (db === undefined) {
-                return next();
                 console.error("Field infos:", field);
                 throw new Error(`Database metadatas for ${field.db} were not loaded.`);
             }
 
             const table = db[field.table];
             if (table === undefined) {
-                return next();
                 console.error("Field infos:", field);
                 throw new Error(`Table metadatas for ${field.db}.${field.table} were not loaded.`);
             }
 
-            const column = table.colonnes[field.name];
-            if (column === undefined) {
-                return next();
-                console.error("Field infos:", field);
-                throw new Error(`Column metadatas for ${field.db}.${field.table}.${field.name} were not loaded.`);
+            databaseColumn = table.colonnes[field.name];
+        }
+
+
+        let type: TColumnTypes;
+        if (databaseColumn !== undefined) {
+
+            type = databaseColumn.type;
+
+        // If the column name has not been found in the concerned table, 
+        //  We assume it's a computed column
+        } else {
+
+            const mysqlType = {
+                name: field.type as TMySQLTypeName,
+                params: []
             }
 
-            type = column.type;
+            let jsTypeName = mysqlToJs[ mysqlType.name ];
+            if (jsTypeName === undefined) {
+                console.warn(`The mySQL data type « ${mysqlType.name} » has not been associated with a JS equivalent in mysqlToJs. Using any instead.`);
+                jsTypeName = mysqlToJs['UNKNOWN'];
+            }
 
-        } 
+            type = {
+                sql: mysqlType,
+                js: {
+                    name: jsTypeName,
+                    params: []
+                }
+            }
+        }
 
-        const val = field.string();
+        // Retrieve value
+        let val = field.string();
         if (val === null)   
             return undefined;
 
-        // https://www.w3schools.com/sql/sql_datatypes.asp  
-        switch (type) {
-
-            case 'SET':
-                return val.split(',');
-
-            case 'DECIMAL':
-            case 'FLOAT':
-            case 'NEWDECIMAL':
-            case 'DOUBLE':
-                return parseFloat(val);
-                
-            case 'INT':
-            case 'LONG':
-            case 'LONGLONG':
-            case 'TINYINT':
-            case 'SMALLINT':
-            case 'MEDIUMINT':
-                return parseInt(val);
-
-            case 'DATE':
-            case 'DATETIME':
-                return new Date(val);
-
-            case 'VARCHAR':
-            case 'CHAR':
-            case 'VAR_STRING':
-            case 'LONGTEXT':
-            case 'TEXT':
-            case 'ENUM':
-                return val;
-
-            case 'JSON':
-                return JSON.parse(val);
-            
+        // Cast value
+        const jsTypeParser = jsTypes[ type.js.name ];
+        const castedVal = jsTypeParser.parse(val);
+        //console.log(LogPrefix, `type cast`, val, `(${type.sql.name}) =>`, castedVal, `(${type.js.name})`);
+        
+        return castedVal;
+    }
+
+    /*----------------------------------
+    - METADATA
+    ----------------------------------*/
+
+    public getTable( path: string ): TMetasTable {
+
+        // Parse path
+        let db: string, table: string;
+        if (path.includes('.'))
+            ([db, table] = path.split('.'));
+        else {
+            // Only the table = use the main database (first of the list in the config)
+            db = this.config.list[0];
+            table = path;
         }
+            
+        // Retrieve table info
+        if (this.tables[db] === undefined)
+            throw new Error(`Database "${db}" not loaded. Did you add it in the database config ?`);
+        if (this.tables[db][table] === undefined)
+            throw new Error(`Table "${db}.${table}" not loaded.`);
+
+        return this.tables[db][table];
 
-        console.warn("/!\\ UNHANDLED TYPE " + type + " for field " + field.name);
-        return val;
     }
-}
 
-/*----------------------------------
-- REGISTER SERVICE
-----------------------------------*/
-app.register('database', FastDatabase);
-declare global {
-    namespace Core {
-        interface Services {
-            database: FastDatabase;
+    /*----------------------------------
+    - QUERY
+    ----------------------------------*/
+    public bucket(
+        queryOptions: TQueryOptions<'bucket'> = {},
+        queriesList: string[] = [], 
+    ) {
+        return new Bucket(queryOptions, queriesList);
+    }
+
+    public async query<TResult extends TQueryResult>(
+        query: string,
+        opts: TQueryOptions<'bucket', 'bucket'>
+    ): Promise<Bucket>;
+
+    public async query<TResult extends TQueryResult>(
+        query: string,
+        opts: TQueryOptions<'returnQuery', 'returnQuery'>
+    ): Promise<string>;
+
+    public async query<TResult extends TQueryResult>(
+        query: string,
+        opts: TQueryOptions<'simulate', 'simulate'>
+    ): Promise<void>;
+
+    public async query<TResult extends TQueryResult>(
+        query: string,
+        opts?: TQueryOptions
+    ): Promise<TResult>;
+
+    public async query<TResult extends TQueryResult>(
+        query: string,
+        opts: TQueryOptions = {}
+    ): Promise<TResult | Bucket | string | void> {
+
+        if (opts.bucket) 
+            return opts.bucket.add(query);
+
+        if (opts.returnQuery === true)
+            return query;
+
+        if (opts.log === true)
+            console.log(`[database][query]`, query);
+
+        if (opts.simulate === true)
+            return;
+
+        try {
+
+            const startTime = Date.now();
+
+            // Lancement de la requête
+            const [rows, fields] = await this.connection.query(query);
+
+            if (opts.log !== false)
+                this.log(query, startTime);
+
+            return rows as unknown as TResult;
+            
+        } catch (error) {
+
+            throw new SqlError(error, query);
         }
     }
+
+    private log( query: string, startTime: number ) {
+
+        const console = this.app.use<Console>('console');
+        if (!console) return;
+
+        const { channelType, channelId } = console.getChannel();
+        if (channelId !== 'admin')
+            console.sqlQueries.push({
+                channelType,
+                channelId,
+                date: new Date(),
+                query: query.trim(),
+                time: Date.now() - startTime,
+            });
+    }
 }

package/src/server/services/database/datatypes.ts

@@ -1,74 +1,97 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+import type { TMetasColonne } from './metas';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
 type JsType = {
     parse: (value: string) => any,
-    typescript: string
+    print: (col: TMetasColonne) => string
 }
 
-const js: {
-    [type: string]: JsType
-} = {
+export type TJsTypeName = keyof typeof js;
+export type TMySQLTypeName = keyof typeof mysqlToJs;
+
+/*----------------------------------
+- LISTS
+----------------------------------*/
+export const js = {
     array: {
         parse: (val: string) => val.split(','),
-        typescript: 'string[]'
+        print: (col) => (col.type.sql.params.length 
+            ? '(' + col.type.sql.params.map( param => "'" + param + "'").join(' | ') + ')'
+            : 'string'
+        ) + '[]'
+    },
+    enum: {
+        parse: (val: string) => val,
+        print: (col) => col.type.sql.params.map( param => "'" + param + "'").join(' | ')
     },
     float: {
         parse: (val: string) => parseFloat(val),
-        typescript: 'number'
+        print: (col) => 'number'
     },
     int: {
         parse: (val: string) => parseFloat(val),
-        typescript: 'number'
+        print: (col) => 'number'
     },
     date: {
         parse: (val: string) => new Date(val),
-        typescript: 'Date'
+        print: (col) => 'Date'
     },
     string: {
         parse: (val: string) => val,
-        typescript: 'string'
+        print: (col) => 'string'
     },
     object: {
         parse: (val: string) => JSON.parse(val),
-        typescript: 'object'
+        print: (col) => 'object'
     },
     
     // When we were not able to find an equivalent
     unknown: {
         parse: (val: any) => val,
-        typescript: 'any'
+        print: (col) => 'any'
     },
-}
-
-export const mysqlToJs: {
-    [type: string]: JsType
-} = {
-
-    'SET': js.array,
+} as const
 
-    'DECIMAL': js.float,
-    'FLOAT': js.float,
-    'NEWDECIMAL': js.float,
-    'DOUBLE': js.float,
+// https://www.w3schools.com/sql/sql_datatypes.asp  
+export const mysqlToJs = {
+    // Float
+    'DECIMAL': 'float',
+    'FLOAT': 'float',
+    'NEWDECIMAL': 'float',
+    'DOUBLE': 'float',
+    'POINT': 'float',
         
-    'INT': js.int,
-    'BIGINT': js.int,
-    'LONG': js.int,
-    'LONGLONG': js.int,
-    'TINYINT': js.int,
-    'SMALLINT': js.int,
-    'MEDIUMINT': js.int,
+    // Integres
+    'INT': 'int',
+    'BIGINT': 'int',
+    'LONG': 'int',
+    'LONGLONG': 'int',
+    'TINYINT': 'int',
+    'SMALLINT': 'int',
+    'MEDIUMINT': 'int',
 
-    'DATE': js.date,
-    'DATETIME': js.date,
+    // Dates
+    'DATE': 'date',
+    'DATETIME': 'date',
 
-    'VARCHAR': js.string,
-    'CHAR': js.string,
-    'VAR_STRING': js.string,
-    'LONGTEXT': js.string,
-    'TEXT': js.string,
-    'ENUM': js.string,
+    // Strings
+    'VARCHAR': 'string',
+    'CHAR': 'string',
+    'VAR_STRING': 'string',
+    'LONGTEXT': 'string',
+    'TEXT': 'string',
+    'ENUM': 'enum',
 
-    'JSON': js.object,
+    // Objects
+    'SET': 'array',
+    'JSON': 'object',
 
     // When we were not able to find an equivalent
-    'UNKNOWN': js.unknown,
-}
+    'UNKNOWN': 'unknown',
+} as const

package/src/server/services/database/debug.ts

@@ -0,0 +1,20 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export class SqlError extends Error {
+
+    public constructor( 
+        public original: Error, 
+        public query: string 
+    ) {
+        super(original.message);
+
+        this.name = original.name;
+        this.message = original.message;
+        this.stack = original.stack;
+    }
+}