5htp-core 0.3.7 → 0.3.8

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.3.7",
+	"version": "0.3.8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -80,7 +80,9 @@
 		"validator": "^13.7.0",
 		"ws": "^8.2.2",
 		"yaml": "^1.10.2",
-		"yargs-parser": "^21.1.1"
+		"yargs-parser": "^21.1.1",
+		"youch": "^3.3.3",
+		"youch-terminal": "^2.2.3"
 	},
 	"devDependencies": {
 		"@types/cookie": "^0.4.1",

package/src/common/router/index.ts

@@ -15,7 +15,7 @@ import type {
     TRouteHttpMethod 
 } from '@server/services/router';
 
-import type { TUserRole } from '@server/services/users';
+import type { TUserRole } from '@server/services/auth';
 
 import type { TAppArrowFunction } from '@common/app';
 

package/src/common/validation/validators.ts

@@ -145,10 +145,9 @@ export default class SchemaValidators {
     /*----------------------------------
     - CHAINES
     ----------------------------------*/
-    public string = ({ min, max, include, ...opts }: TValidator<string> & { 
+    public string = ({ min, max, ...opts }: TValidator<string> & { 
         min?: number, 
-        max?: number,
-        include?: string
+        max?: number 
     } = {}) => new Validator<string>('string', (val, input, output, corriger?: boolean) => {
 
         // Check type

package/src/server/{services → app/container}/console/index.ts

@@ -5,6 +5,8 @@
 // Node
 import { serialize } from 'v8';
 import { formatWithOptions } from 'util';
+import Youch from 'youch';
+import forTerminal from 'youch-terminal';
 
 // Npm
 import { v4 as uuid } from 'uuid';
@@ -13,8 +15,7 @@ import { format as formatSql } from 'sql-formatter';
 import highlight from 'cli-highlight';
 
 // Core libs
-import type { Application } from '@server/app';
-import Service from '@server/app/service';
+import type ApplicationContainer from '..';
 import context from '@server/context';
 import type { ServerBug } from '@common/errors';
 import type ServerRequest from '@server/services/router/request';
@@ -117,7 +118,7 @@ const logLevels = {
 /*----------------------------------
 - LOGGER
 ----------------------------------*/
-export default class Console extends Service<Config, Hooks, Application, Services> {
+export default class Console {
 
     // Services
     public logger!: Logger<ILogObj>;
@@ -134,17 +135,27 @@ export default class Console extends Service<Config, Hooks, Application, Service
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
+    /*
+        WARN: This service should depend on the less services as possible, and be usable ASAP.
+            So bug reports can be sent at any state of the app, includoing thre most early
+    */
+    public constructor( 
+        private container: typeof ApplicationContainer, 
+        private config: Config,
+    ) {
 
-    protected async start() {
+        console.log("Setting up Console shell module.");
 
         const origLog = console.log
 
-        const envConfig = this.config[ this.app.env.profile === 'prod' ? 'prod' : 'dev' ];
+        const Env = container.Environment;
+
+        const envConfig = this.config[ Env.profile === 'prod' ? 'prod' : 'dev' ];
         const minLogLevel = logLevels[ envConfig.level ];
 
         this.logger = new Logger({
             // Use to improve performance in production
-            hideLogPositionForProduction: this.app.env.profile === 'prod',
+            hideLogPositionForProduction: Env.profile === 'prod',
             type: 'pretty',
             prettyInspectOptions: {
                 depth: 2
@@ -201,13 +212,10 @@ export default class Console extends Service<Config, Hooks, Application, Service
         setInterval(() => this.clean(), 10000);
     }
 
-    public async ready() {
-
-    }
-
-    public async shutdown() {
-
-    }
+    // Avoid to use lifecycle functions
+    protected async start() {}
+    public async ready() {}
+    public async shutdown() {}
 
     /*----------------------------------
     - LOGS FORMATTING
@@ -218,7 +226,7 @@ export default class Console extends Service<Config, Hooks, Application, Service
         if (filepath === undefined)
             return undefined;
 
-        const projectRoot = this.app.container.path.root;
+        const projectRoot = this.container.path.root;
         if (filepath.startsWith( projectRoot ))
             filepath = filepath.substring( projectRoot.length )
 
@@ -257,6 +265,34 @@ export default class Console extends Service<Config, Hooks, Application, Service
 
     public async createBugReport( error: Error, request?: ServerRequest ) {
 
+        // Print error
+        this.logger.error(LogPrefix, `Sending bug report for the following error:`, error);
+        /*const youchRes = new Youch(error, {});
+        const jsonResponse = await youchRes.toJSON()
+        console.log( forTerminal(jsonResponse, {
+            // Defaults to false
+            displayShortPath: false,
+
+            // Defaults to single whitspace
+            prefix: ' ',
+
+            // Defaults to false
+            hideErrorTitle: false,
+
+            // Defaults to false
+            hideMessage: false,
+
+            // Defaults to false
+            displayMainFrameOnly: false,
+
+            // Defaults to 3
+            framesMaxLimit: 3,
+        }) );*/
+
+        const application = this.container.application;
+        if (application === undefined) 
+            return console.error(LogPrefix, "Can't send bug report because the application is not instanciated");
+
         // Print the error so it's accessible via logs
         if (error instanceof SqlError)  {
             let printedQuery: string;
@@ -267,7 +303,7 @@ export default class Console extends Service<Config, Hooks, Application, Service
             }
             console.error(`Error caused by this query:`, printedQuery);
         }
-        console.error(LogPrefix, `Sending bug report for the following error:`, error);
+
         if (error.dataForDebugging !== undefined)
             console.error(LogPrefix, `More data about the error:`, error.dataForDebugging);
 
@@ -306,7 +342,7 @@ export default class Console extends Service<Config, Hooks, Application, Service
             logs: logsHtml
         }
 
-        await this.app.reportBug( bugReport );
+        await application.reportBug( bugReport );
     }
 
     public getChannel() {

package/src/server/app/container/index.ts

@@ -8,9 +8,11 @@ import './patch';
 import path from 'path';
 
 // Core
+import type Application from '..';
 import type { StartedServicesIndex } from '../service';
 import Services, { ServicesContainer } from '../service/container';
 import ConfigParser, { TEnvConfig } from './config';
+import Console from './console';
 
 /*----------------------------------
 - CLASS
@@ -26,6 +28,9 @@ export class ApplicationContainer<
     public Services = Services as ServicesContainer<TServicesIndex>;
     public Environment: TEnvConfig;
     public Identity: Config.Identity;
+    public Console: Console;
+
+    public application?: Application;
 
     public constructor() {
 
@@ -33,6 +38,16 @@ export class ApplicationContainer<
         const configParser = new ConfigParser( this.path.root );
         this.Environment = configParser.env();
         this.Identity = configParser.identity();
+        this.Console = new Console(this, {
+            debug: false,
+            bufferLimit: 10000,
+            dev: {
+                level: 'log'
+            },
+            prod: {
+                level: 'log'
+            }
+        });
     }
 
     // Context
@@ -51,6 +66,45 @@ export class ApplicationContainer<
         },
     }
 
+    public start( ApplicationClass: typeof Application ) {
+
+        // Instanciate Application
+        try {
+            this.application = new ApplicationClass;
+        } catch (error) {
+            this.handleBug(error, "Failed to instanciate the Application Class");
+            process.exit(1);
+        }
+
+        // Start application
+        try {
+            this.application.start();
+        } catch (error) {
+            this.handleBug(error, "Failed to start the Application");
+            process.exit(1);
+        }
+    }
+
+    public async handleBug( rejection: Error, message: string ) {
+        if (this.Console) {
+            try {
+
+                this.Console.createBugReport(rejection);
+
+            } catch (consoleError) {
+                console.error(
+                    message, rejection, 
+                    "Failed to transmiss the previous error to console:", consoleError
+                );
+                process.exit(1);
+            }
+        } else {
+            console.error(message, rejection);
+            process.exit(1);
+        }
+    }
+
+
     /*----------------------------------
     - HMR
     - TODO: move in dev server

package/src/server/app/index.ts

@@ -11,7 +11,7 @@ import ServicesContainer, {
     TRegisteredService, 
     TServiceMetas 
 } from './service/container';
-import type { ServerBug } from '../services/console';
+import type { ServerBug } from './container/console';
 
 // Built-in
 import type { default as Router, Request as ServerRequest } from '@server/services/router';
@@ -82,9 +82,6 @@ export class Application<
     public debug: boolean = false;
     public launched: boolean = false;
 
-    // Mandatory services
-    public Console = this.use('Core/Console');
-
     /*----------------------------------
     - INIT
     ----------------------------------*/
@@ -96,16 +93,20 @@ export class Application<
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
         super(self, {}, {}, self);
-
-        // We can't pass this in super so we assign here
-        this.parent = this;
-        this.app = this;
-
-        // Gestion crash
+        
+        // Handle unhandled crash
+        this.on('error', e => this.container.handleBug(e, "An error occured in the application"));
+        
         process.on('unhandledRejection', (error: any, promise: any) => {
+            console.log("unhandledRejection");
             // We don't log the error here because it's the role of the app to decidehiw to log errors
             this.runHook('error', error);
         });
+
+        // We can't pass this in super so we assign here
+        this.parent = this;
+        this.app = this;
+        
     }
 
     /*----------------------------------
@@ -122,16 +123,12 @@ export class Application<
     - LAUNCH
     ----------------------------------*/
     
-    protected async start() {
+    public async start() {
 
         console.log("Build date", BUILD_DATE);
         console.log("Core version", CORE_VERSION);
-        console.log(`5HTP Core`, process.env.npm_package_version);
         const startTime = Date.now();
 
-        // Handle errors & crashs
-        this.on('error', e => this.Console.createBugReport(e))
-
         console.info(`[boot] Start services`);
         await this.startServices();
         this.debug && console.info(`[boot] Services are ready`);
@@ -147,13 +144,6 @@ export class Application<
     public async ready() {
 
 
-    }
-
-    // Default error handler
-    public async reportBug( bug: ServerBug ) {
-
-        console.error( bug.error );
-
     }
 
     public async shutdown() {
@@ -208,6 +198,16 @@ export class Application<
                 unused.join(', '));
     }
 
+    /*----------------------------------
+    - ERROR HANDLING
+    ----------------------------------*/
+    // Default error handler
+    public async reportBug( bug: ServerBug ) {
+
+        console.error( bug.error );
+
+    }
+
 }
 
 export default Application

package/src/server/app/service/index.ts

@@ -144,6 +144,7 @@ export default abstract class Service<
     // this.use immediatly instanciate the subservice for few reasons:
     // - The subservice instance can be accesses from another service in the constructor, no matter the order of loading of the services
     // - Consistency: the subserviuce proprties shouldn't be assogned to two different values according depending on the app lifecycle
+    // Don't throw errors here since process.on('unhandledRejection') has not been configurated at this step (constructor ran after properties initialization)
     public use<
         TInstalledServices extends this["app"]["servicesContainer"]["allServices"],
         TServiceId extends keyof TInstalledServices,
@@ -172,8 +173,9 @@ export default abstract class Service<
         if (registered === undefined) { 
             if (serviceUseOptions.optional)
                 return undefined;
-            else
+            else {
                 throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
+            }
         }
 
         // Bind subservices
@@ -193,20 +195,43 @@ export default abstract class Service<
 
         // Instanciate
         console.log(`[app] Load service`, registered.metas.id);
-        const ServiceClass = registered.metas.class().default;
+        let ServiceClass;
+        try {
+            ServiceClass = registered.metas.class().default;
+        } catch (error) {
+            console.error("Failed to load the class of the", registered.metas.id, "service:", error);
+            throw error;
+        }
 
         // Create class instance
-        const service = new ServiceClass(
-            this, 
-            registered.config, 
-            registered.subServices, 
-            this.app || this
-        )
-        const serviceInstance = service.getServiceInstance();
+        this.config.debug && console.log(`[app] Instanciate service`, registered.metas.id);
+        let service;
+        try {
+            service = new ServiceClass(
+                this, 
+                registered.config, 
+                registered.subServices, 
+                this.app || this
+            )
+        } catch (error) {
+            console.error("Failed to instanciate class of the", registered.metas.id, "service");
+            throw error;
+        }
+
+        // Hande custom instance getter (ex: SQL callable class)
+        this.config.debug && console.log(`[app] Get service instance for`, registered.metas.id);
+        let serviceInstance;
+        try {
+            serviceInstance = service.getServiceInstance();
+        } catch (error) {
+            console.error("Failed to get service instance for the ", registered.metas.id, "service");
+            throw error;
+        }
 
         // Bind his own metas
         service.metas = registered.metas;
         ServicesContainer.allServices[ registered.metas.id ] = serviceInstance;
+        this.config.debug && console.log(`[app] Service`, registered.metas.id, 'Loaded');
 
         return serviceInstance;
     }
@@ -250,7 +275,7 @@ export default abstract class Service<
             await service.started.catch(e => {
                 console.error("Catched error while starting service " + serviceScope, e);
                 if (this.app.env.profile === 'prod')
-                    process.exit();
+                    process.exit(1);
                 else
                     throw e;
             })

package/src/server/context.ts

@@ -1,4 +1,4 @@
 import { AsyncLocalStorage } from 'async_hooks';
-import type { ChannelInfos } from '@server/services/console';
+import type { ChannelInfos } from '@server/app/container/console';
 
 export default new AsyncLocalStorage<ChannelInfos>();

package/src/server/index.ts

@@ -1,12 +1,4 @@
-// Load Application container
-import './app/container';
-
-// Load services setup
+import AppContainer from './app/container';
 import '@/server/config/*.ts';
-
-// Load Application
 import Application from '@/server';
-const application = new Application;
-
-// Start application
-application.start();
+AppContainer.start( Application );

package/src/server/services/{users → auth}/index.ts

@@ -65,7 +65,7 @@ export type TServices = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default abstract class UsersManagementService<
+export default abstract class AuthService<
     TUser extends {},
     TApplication extends Application,
     TJwtSession extends {} = {},

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

@@ -233,9 +233,19 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
                 // SQL query
                 } else if (typeof value === 'function' && value.string !== undefined)
                     value = ' ' + value.string;
-                else
-                    value = ' ' + mysql.escape(value);
+                // Escape value
+                else {
 
+                    const lastKeyword = stringBefore.trim().split(' ').pop();
+
+                    // Escape table name
+                    if (lastKeyword === 'FROM')
+                        value = '`' + value + '`';
+                    else
+                        value = mysql.escape(value);
+
+                    value = ' ' + value;
+                }
                 stringBefore += value;
 
             }

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

@@ -83,7 +83,6 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
         if (this.services.disks)
             this.disk = this.services.disks.get( this.config.disk );
         
-        
     }
 
     public async ready() {
@@ -116,8 +115,10 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
     ) {
 
         // Parse url if router service is provided
-        if (this.services.router !== undefined)
-            url = this.services.router.url(url);
+        if (this.services.router === undefined)
+            throw new Error(`Please bind the Router service to the Fetch service in order to contact APIs.`);
+
+        url = this.services.router.url(url);
 
         // Send request
         const res = await got(url, {

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

@@ -14,7 +14,7 @@ import Service, { AnyService, TRegisteredService } from '@server/app/service';
 import SocketScope, { WebSocket } from './scope';
 import type Router from '@server/services/router';
 export type { WebSocket, default as SocketScope } from './scope';
-import type UsersManagementService from '../users';
+import type UsersManagementService from '../auth';
 
 /*----------------------------------
 - TYPES

package/src/server/services/console/service.json

@@ -1,6 +0,0 @@
-{
-    "id": "Core/Console",
-    "name": "Console",
-    "parent": "app",
-    "dependences": []
-}