5htp-core 0.2.4 → 0.2.5-2

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

@@ -1,8 +1,8 @@
 /*----------------------------------
 - DEPENDANCES
 ----------------------------------*/
-
 // Npm
+import { v4 as uuid } from 'uuid';
 import { Logger, ILogObject } from "tslog";
 import { format as formatSql } from 'sql-formatter';
 import highlight from 'cli-highlight';
@@ -11,10 +11,10 @@ import highlight from 'cli-highlight';
 import Application, { Service, TPriority } from '@server/app';
 import context from '@server/context';
 import type ServerRequest from '@server/services/router/request';
+import { SqlError } from '@server/services/database/debug';
 
 // Specific
 import logToHTML from './html';
-import BugReporter from "./bugReporter";
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -23,6 +23,8 @@ import BugReporter from "./bugReporter";
 type TLogProfile = 'silly' | 'info' | 'warn' | 'error'
 
 export type Config = {
+    debug?: boolean,
+    bufferLimit: number,
     dev: {
         level: TLogProfile,
     },
@@ -77,14 +79,35 @@ export type TQueryLogs = ChannelInfos & {
     time: number,
 }
 
-export type TLog = ChannelInfos & {
+export type TLog = ILogObject &  ChannelInfos
+
+/*----------------------------------
+- TYPES: BUG REPORT
+----------------------------------*/
+export type ServerBug = {
+    // Context
+    hash: string,
+    date: Date, // Timestamp
+    channelType?: string, 
+    channelId?: string,
 
+    user: string | null | undefined,
+    ip: string | null | undefined,
+    
+    // Error
+    error: Error,
+    stacktrace: string,
+    logs: string,
 }
 
 /*----------------------------------
 - CONST
 ----------------------------------*/
 
+const LogPrefix = '[console]'
+
+const errorMailInterval = (1 * 60 * 60 * 1000); // 1 hour
+
 const logFields = [
     'date',
     'logLevelId',
@@ -99,7 +122,7 @@ const logFields = [
     'lineNumber',
     'argumentsArray',
     'stack',
-]
+] as const
 
 /*----------------------------------
 - LOGGER
@@ -111,13 +134,14 @@ export default class Console extends Service<Config, Hooks, Application> {
 
     // Services
     public logger!: Logger;
-    public bugReport = new BugReporter(this);
 
     // Buffers
     public logs: TLog[] = [];
     public clients: TGuestLogs[] = [];
     public requests: TRequestLogs[] = [];
     public sqlQueries: TQueryLogs[] = [];
+    // Bug ID => Timestamp latest send
+    private sentBugs: {[bugId: string]: number} = {};
 
     // Adapters
     public log = console.log;
@@ -159,20 +183,75 @@ export default class Console extends Service<Config, Hooks, Application> {
             fatal: this.logEntry.bind(this),
         }, envConfig.level);
 
-        setInterval(() => this.clean(), 60000);
+        setInterval(() => this.clean(), 10000);
 
         // Send email report
-        this.app.on('error', (error: Error, request?: ServerRequest) => this.bugReport.server(error, request));
+        this.app.on('error', this.createBugReport.bind(this));
     }
 
     private clean() {
-        // Clean memory from old logs
+        this.config.debug && console.log(LogPrefix, `Clean logs buffer. Current size:`, this.logs.length, '/', this.config.bufferLimit);
+        const bufferOverflow = this.logs.length - this.config.bufferLimit;
+        if (bufferOverflow > 0)
+            this.logs = this.logs.slice(bufferOverflow);
     }
 
     /*----------------------------------
     - LOGGING
     ----------------------------------*/
 
+    public async createBugReport( error: Error, request?: ServerRequest ) {
+
+        // Print the error so it's accessible via logs
+        if (error instanceof SqlError)  {
+            let printedQuery: string;
+            try {
+                printedQuery = this.printSql( error.query );
+            } catch (error) {
+                printedQuery = 'Failed to print query:' + (error || 'unknown error');
+            }
+            console.error(`Error caused by this query:`, printedQuery);
+        }
+        console.error(LogPrefix, `Sending bug report for the following error:`, error);
+
+        // Prevent spamming the mailbox if infinite loop 
+        const bugId = ['server', request?.user?.name, undefined, error.message].filter(e => !!e).join('::');
+        const lastSending = this.sentBugs[bugId];
+        this.sentBugs[bugId] = Date.now();
+        const shouldSendReport = lastSending === undefined || lastSending < Date.now() - errorMailInterval;
+        if (!shouldSendReport)
+            return;
+
+        // Get context
+        const now = new Date();
+        const hash = uuid();
+        const { channelType, channelId } = this.getChannel();
+
+        // On envoi l'email avant l'insertion dans bla bdd
+        // Car cette denrière a plus de chances de provoquer une erreur
+        const logsHtml = this.printHtml(
+            this.logs.filter(e => e.channelId === channelId), 
+            true
+        );
+
+        const bugReport: ServerBug = {
+            // Context
+            hash: hash,
+            date: now,
+            channelType, 
+            channelId,
+            // User
+            user: request?.user?.email,
+            ip: request?.ip,
+            // Error
+            error,
+            stacktrace: error.stack || error.message,
+            logs: logsHtml
+        }
+
+        await this.runHook('bugReport', bugReport);
+    }
+
     public getChannel() {
         return context.getStore() || {
             channelType: 'master',
@@ -182,6 +261,7 @@ export default class Console extends Service<Config, Hooks, Application> {
 
     private logEntry(entry: ILogObject) {
 
+        // Don't keep logs from the admin sashboard
         const [channelType, channelId] = entry.requestId?.split(':') || ['master'];
         if (entry.requestId === 'admin')
             return;
@@ -192,22 +272,6 @@ export default class Console extends Service<Config, Hooks, Application> {
         for (const k of logFields)
             miniLog[k] = entry[k];
 
-        // remove webpack path
-        if (miniLog.filePath !== undefined) {
-
-            const appPrefix = '/webpack:/' + this.app.pkg.name + '/src/';
-            const appPrefixIndex = miniLog.filePath.indexOf(appPrefix);
-
-            const corePrefix = '/webpack:/' + this.app.pkg.name + '/node_modules/5htp-core/src/';
-            const corePrefixIndex = miniLog.filePath.indexOf(corePrefix);
-
-            if (appPrefixIndex !== -1)
-                miniLog.filePath = '@/' + miniLog.filePath.substring(appPrefixIndex + appPrefix.length);
-            else if (corePrefixIndex !== -1)
-                miniLog.filePath = '@' + miniLog.filePath.substring(corePrefixIndex + corePrefix.length);
-
-        }
-
         this.logs.push(miniLog as TLog);
     }
 
@@ -285,11 +349,30 @@ export default class Console extends Service<Config, Hooks, Application> {
         if (channelId !== undefined)
             filters.channelId = channelId;
 
-        const fromBuffer = this.logs.filter(
-            e => e.channelId === channelId && e.channelType === channelType
-        ).reverse();
+        const entries: TLog[] = []
+        for (const log of this.logs) {
+
+            // Filters
+            if (!(log.channelId === channelId && log.channelType === channelType))
+                continue;
+
+            // Remove path prefixs
+            if (log.filePath !== undefined) {
+
+                const appPrefix = '/webpack:/' + this.app.pkg.name + '/src/';
+                const appPrefixIndex = log.filePath.indexOf(appPrefix);
+    
+                const corePrefix = '/webpack:/' + this.app.pkg.name + '/node_modules/5htp-core/src/';
+                const corePrefixIndex = log.filePath.indexOf(corePrefix);
+    
+                if (appPrefixIndex !== -1)
+                    log.filePath = '@/' + log.filePath.substring(appPrefixIndex + appPrefix.length);
+                else if (corePrefixIndex !== -1)
+                    log.filePath = '@' + log.filePath.substring(corePrefixIndex + corePrefix.length);
+            }
+        }
         
-        return this.printHtml(fromBuffer);
+        return this.printHtml( entries.reverse() );
     }
  
     public printHtml(logs: TLog[], full: boolean = false): string {

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

@@ -8,6 +8,7 @@ import mysql from 'mysql2/promise';
 // Core: general
 import Application from '@server/app';
 import Service from '@server/app/service';
+import { Anomaly } from '@common/errors';
 
 // Core: specific
 import { SqlError } from './debug';
@@ -26,20 +27,17 @@ const LogPrefix = '[database][connection]';
 - SERVICE CONFIG
 ----------------------------------*/
 
+type ConnectionConfig = {
+    name: string,
+    databases: string[],
+    host: string,
+    port: number,
+    login: string,
+    password: string,
+}
+
 export type DatabaseServiceConfig = {
-    list: string[],
-    dev: {
-        host: string,
-        port: number,
-        login: string,
-        password: string,
-    },
-    prod: {
-        host: string,
-        port: number,
-        login: string,
-        password: string,
-    }
+    connections: ConnectionConfig[]
 }
 
 export type THooks = {
@@ -71,10 +69,11 @@ type TSelectQueryResult = any;
 /*----------------------------------
 - SERVICES
 ----------------------------------*/
-export default class DatabaseConnection extends Service<DatabaseServiceConfig, THooks, Application> {
+export default class DatabaseManager extends Service<DatabaseServiceConfig, THooks, Application> {
 
     private initialized = false;
     public connection!: mysql.Pool;
+    public connectionConfig?: ConnectionConfig;
 
     public tables: TDatabasesList = {};
     public metas = new MetadataParser(this);
@@ -92,37 +91,47 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
 
         this.initialized = false;
 
-        this.app.on('cleanup', () => this.cleanup());
+        // Try to connect to one of the databases
+        const connectionErrors: string[] = []
+        for (const connectionConfig of this.config.connections){
+            try {
+                await this.connect(connectionConfig)
+                break;
+            } catch (error) {
+                console.warn(LogPrefix, `Failed to connect to ${connectionConfig.name}: ` + error);
+                connectionErrors.push(connectionConfig.name + ': ' + error);
+            }
+        }
 
-        this.connection = await this.connect();
+        // Coudnt connect to any database
+        if (this.connectionConfig === undefined)
+            throw new Anomaly(`Couldnt connect to any database.`, { connectionErrors });
 
-        this.tables = await this.metas.load( this.config.list );
+        // Disconnect from the database when the app is terminated
+        this.app.on('cleanup', () => this.disconnect());
 
+        // Ready to make queries
         this.initialized = true;
-
     }
 
-    public async cleanup() {
+    public async disconnect() {
         return this.connection.end();
     }
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
-    public async connect() {
+    public async connect(config: ConnectionConfig) {
 
-        console.info(LogPrefix, `Connecting to databases ...`);
-
-        const creds = this.config[ this.app.env.profile ];
-
-        return await mysql.createPool({
+        console.info(LogPrefix, `Trying to connect to ${config.name} ...`);
+        this.connection = mysql.createPool({
 
             // Identification
-            host: creds.host,
-            port: creds.port,
-            user: creds.login,
-            password: creds.password,
-            database: this.config.list[0],
+            host: config.host,
+            port: config.port,
+            user: config.login,
+            password: config.password,
+            database: config.databases[0],
 
             // Pool
             waitForConnections: true,
@@ -147,7 +156,12 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
                 //console.info(LogPrefix, 'queryFormat', query);
                 return query;
             }
-        });
+        })
+
+        this.connectionConfig = config;
+
+        this.tables = await this.metas.load( config.databases );
+        console.info(LogPrefix, `Successfully connected to ${config.name}.`);
     }
 
     private typeCast( field: mysql.Field, next: Function ) {
@@ -226,13 +240,16 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
 
     public getTable( path: string ): TMetasTable {
 
+        if (this.connectionConfig === undefined)
+            throw new Error(`No connection has been initialised.`);
+
         // 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];
+            db = this.connectionConfig.databases[0];
             table = path;
         }
             

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

@@ -27,7 +27,7 @@ import BaseRouter, {
     TRouteOptions, defaultOptions
 } from '@common/router';
 import { buildRegex, getRegisterPageArgs } from '@common/router/register';
-import { layoutsList } from '@common/router/layouts';
+import { layoutsList, getLayout } from '@common/router/layouts';
 import { TFetcherList, TFetcher } from '@common/router/request/api';
 import type { TFrontRenderer } from '@common/router/response/page';
 import type { TSsrUnresolvedRoute, TRegisterPageArgs } from '@client/services/router';
@@ -147,7 +147,6 @@ export default class ServerRouter<
         // Since route registering requires all services to be ready,
         // We load routes only when all services are ready
         this.app.on('ready', async () => {
-
             // Use require to avoid circular references
             this.registerRoutes([
                 ...require("metas:@/server/routes/**/*.ts"),
@@ -228,9 +227,13 @@ export default class ServerRouter<
         options: TRoute["options"],
         renderer: TFrontRenderer<{}, { message: string }>
     ) {
+
+        // Automatic layout form the nearest _layout folder
+        const layout = getLayout('Error ' + code, options);
+
         this.errors[code] = {
             code,
-            controller: (context: TRouterContext<this>) => new Page(null, renderer, context),
+            controller: (context: TRouterContext<this>) => new Page(null, renderer, context, layout),
             options
         };
     }
@@ -503,7 +506,7 @@ declare type Routes = {
                 return response;
         }
 
-        throw new NotFound(`The requested endpoint was not found.`);
+        throw new NotFound();
     }
 
     private async resolveApiBatch( fetchers: TFetcherList, request: ServerRequest<this> ) {
@@ -542,9 +545,14 @@ declare type Routes = {
         // Rapport / debug
         if (code === 500) {
 
+            // Report error
             await this.app.runHook('error', e, request);
 
-            // Pour déboguer les erreurs HTTP
+            // Don't exose technical errors to users
+            if (this.app.env.profile === 'prod')
+                e.message = "We encountered an internal error, and our team has just been notified. Sorry for the inconvenience.";
+
+        // Pour déboguer les erreurs HTTP
         } else if (this.app.env.profile === "dev")
             console.warn(e);
 

package/src/client/pages/_layout/base.less

@@ -1,13 +0,0 @@
-#page {
-    transition: opacity 5s cubic-bezier(0,.3,0,.99);
-    animation: showMain 1s ease-out;
-    @keyframes showMain { 
-        0% {    opacity: 0.3; }
-        100% {   opacity: 1; }
-    }
-
-    body.loading & {
-        cursor: wait;
-        opacity: 0.1;
-    }
-}

package/src/client/pages/_layout/landing/index.less

@@ -1,5 +0,0 @@
-body {
-
-    
-
-}

package/src/client/pages/_layout/landing/index.tsx

@@ -1,55 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import React from 'react';
-
-// Core
-
-// Core components
-import Button, { Props as ButtonProps } from '@client/components/button';
-import useHeader from '@client/pages/useHeader';
-
-/*----------------------------------
-- CONTROLEUR
-----------------------------------*/
-import './index.less';
-export default ({ headline, subtitle, cta, preview }: {
-    
-    headline: string,
-    subtitle: string,
-    cta: ButtonProps,
-    preview: [string, string]
-
-}) => {
-
-    useHeader({
-        title: headline,
-        subtitle: subtitle,
-    });
-
-    /*----------------------------------
-    - RENDER
-    ----------------------------------*/
-    return (
-        <div id="landing">
-
-            <header>
-                <div class="text card">
-                    <h1>{headline}</h1>
-                    <p>
-                        {subtitle}
-                    </p>
-                    <Button type="guide" {...cta} />
-                </div>
-
-                <figure>        
-                    <img class="image" src={preview[0]} />
-                    <legend>{preview[1]}</legend>
-                </figure>
-            </header>
-            
-        </div>
-    )
-}