5htp-core 0.3.7 → 0.3.9

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

@@ -58,7 +58,7 @@ export default abstract class Service<
     TConfig extends TServiceConfig, 
     THooks extends THooksList,
     TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex
+    TServicesIndex extends StartedServicesIndex = {}
 > {
 
     public started?: Promise<void>;
@@ -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/app.tsconfig.json

@@ -5,7 +5,7 @@
         "baseUrl": "..",
         "paths": {
 
-            "@/server/models": ["./server/.generated/models.d.ts"],
+            "@/server/models": ["./server/.generated/models.ts"],
 
             "@client/*": ["../node_modules/5htp-core/src/client/*"],
             "@common/*": ["../node_modules/5htp-core/src/common/*"],

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/connection.ts

@@ -188,7 +188,9 @@ export default class DatabaseManager {
 
             const table = db[field.table];
             if (table === undefined) {
-                console.error("Field infos:", field);
+                // We don't throw error, sinc eit can be a virtual table
+                //console.error("Field infos:", field);
+                return next();
                 throw new Error(`Table metadatas for ${field.db}.${field.table} were not loaded.`);
             }
 

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;
 
             }
@@ -375,7 +385,7 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
 
         // Build query
         return this.database.query(`
-            UPDATE ${tableName} SET ${egalitesData} WHERE ${egalitesWhere};
+            UPDATE \`${tableName}\` SET ${egalitesData} WHERE ${egalitesWhere};
         `, opts);
 
     }
@@ -396,23 +406,37 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
     - OPERATIONS: INSERT
     ----------------------------------*/
 
-    public tryInsert = (table: string, data: TObjetDonnees) =>
+    public tryInsert = <TData extends TObjetDonnees>(table: string, data: TData | TData[]) =>
         this.insert(table, data, { try: true });
 
+    public async insert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData, 
+        opts?: TInsertQueryOptions<TData>
+    ): Promise<TData>;
+
+    public async insert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData[], 
+        opts?: TInsertQueryOptions<TData[]>
+    ): Promise<TData>;
+
     public async insert<TData extends TObjetDonnees>(
         path: string, 
         data: TData | TData[], 
         opts: TInsertQueryOptions<TData> = {}
-    ): Promise<OkPacket> {
+    ): Promise<TData | TData[]> {
 
         const table = this.database.getTable(path);
 
         // Normalize data
-        if (!Array.isArray(data))
+        let returnSingleResult = false;
+        if (!Array.isArray(data)) {
             data = [data];
-        else if (data.length === 0) {
+            returnSingleResult = true;
+        } else if (data.length === 0) {
             console.warn(LogPrefix, `Insert nothing in ${path}. Cancelled.`);
-            return emptyOkPacket;
+            return [];
         }
 
         // Upsert
@@ -439,28 +463,14 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
                 okPacket.warningCount += queryResult.warningCount;
             }
 
-            return okPacket;
-
         } else {
             const query = this.buildInsertStatement(table, data, opts) + upsertStatement;
 
             const queryResult = await this.database.query<mysql.OkPacket>(query + ';', opts);
 
-            return {
-                constructor: {
-                    name: 'OkPacket'
-                },
-                fieldCount: queryResult.fieldCount,
-                affectedRows: queryResult.affectedRows,
-                changedRows: queryResult.changedRows,
-                insertId: queryResult.insertId,
-                serverStatus: queryResult.serverStatus,
-                warningCount: queryResult.warningCount,
-                message: queryResult.message,
-                procotol41: queryResult.procotol41,
-            };
         }
-        // OLD: return [data, queryResult?.insertId, queryResult];
+        
+        return returnSingleResult ? data[0] : data;
     }
 
     private buildInsertStatement<TData extends TObjetDonnees>(

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

@@ -0,0 +1,28 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+import type Application from "@server/app";
+
+import type SQL from "@server/services/database";
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class Model<TData extends {}> {
+
+    public abstract tableName: string;
+
+    public constructor( app: Application & { SQL: SQL }, private SQL = app.SQL) {
+
+    }
+
+    public async create( data: TData | TData[] ): Promise< TData | TData[] > {
+        return await this.SQL.insert( this.tableName, data );
+    }
+
+}

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/router/index.ts

@@ -598,7 +598,10 @@ declare type Routes = {
             console.warn(e);
 
         if (request.accepts("html"))
-            await response.runController(route, { message: e.message });
+            await response.runController(route, { 
+                message: e.message,
+                type: e.constructor.name
+            });
         else if (request.accepts("json"))
             await response.json(e.message);
         else

package/src/server/services/schema/request.ts

@@ -47,17 +47,10 @@ export default class RequestValidator extends ServerSchemaValidator implements R
         const schema = fields instanceof Schema ? fields : new Schema(fields);
 
         // Les InputError seront propagées vers le middleware dédié à la gestion des erreurs
-        const { values } = schema.validate(
-            this.request.data, 
-            this.request.data, 
-            {}, 
-            {
-                debug: this.config.debug,
-                throwError: true,
-                validateDeps: false
-            },
-            []
-        );
+        const values = schema.validate( this.request.data, {
+            debug: this.config.debug,
+            validateDeps: false
+        }, []);
 
         return values;
     }

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": []
-}