5htp-core 0.3.0 → 0.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",
@@ -97,6 +97,6 @@
 		"babel-plugin-glob-import": "^0.0.7"
 	},
 	"peerDependencies": {
-		"5htp": "0.3.0"
+		"5htp": "0.3.1"
 	}
 }

package/src/client/components/Select/index.tsx

@@ -6,11 +6,11 @@
 import React from 'react';
 
 // Core
-import Dropdown, { TDropdownControl, Props as DropdownProps } from '@client/components/dropdown';
+import { Props as DropdownProps } from '@client/components/dropdown';
 import Input from '@client/components/inputv3';
 
 // Specific
-import ChoiceSelector, { 
+import { 
     Props as SelectorProps, 
     Choice,
 } from './ChoiceSelector';
@@ -24,6 +24,8 @@ export type Props = DropdownProps & SelectorProps & {
     errors?: string[],
 }
 
+export type { Choice } from './ChoiceSelector';
+
 const ChoiceElement = ({ choice, currentList, onChange, multiple, includeCurrent }: {
     choice: Choice,
     currentList: Choice[],

package/src/client/services/router/index.tsx

@@ -40,7 +40,7 @@ import * as appRoutes from '@/client/pages/**/*.tsx';
 - CONFIG
 ----------------------------------*/
 
-const debug = true;
+const debug = false;
 const LogPrefix = '[router]'
 
 /*----------------------------------
@@ -61,6 +61,8 @@ export type Response = ClientResponse<ClientRouter> | ServerResponse<ServerRoute
 - TYPES: ROUTES LOADING
 ----------------------------------*/
 
+// WARN: To be updated with the mplemenations list of Router.page
+//      (both server and client side)
 export type TRegisterPageArgs<TProvidedData extends TFetcherList = {}, TRouter extends Router = Router> = ([
     path: string,
     controller: TDataProvider<TProvidedData> | null,
@@ -219,6 +221,25 @@ export default class ClientRouter<
         return currentRoute;
     }
 
+    public page(
+        path: string,
+        controller: TDataProvider<{}> | null,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
+    public page(
+        path: string,
+        options: Partial<TRoute["options"]>,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
+    public page(
+        path: string,
+        options: Partial<TRoute["options"]>,
+        controller: TDataProvider<{}> | null,
+        renderer: TFrontRenderer<{}>
+    ): TRoute;
+
     public page(...args: TRegisterPageArgs): TRoute {
 
         const { path, options, controller, renderer, layout } = getRegisterPageArgs(...args);

package/src/client/services/router/response/index.tsx

@@ -86,7 +86,7 @@ export default class ClientPageResponse<
             route: this.route,
             api: this.request.api,
 
-            ...this.request.router.config.context()
+            ...this.request.router.config.context( this.request.router )
         }
 
         context.context = context;

package/src/common/errors/index.ts

@@ -16,6 +16,26 @@ type TDetailsErreur = {
     urlRequete?: string,
 }
 
+/*----------------------------------
+- 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,
+}
+
 /*----------------------------------
 - ERREURS
 ----------------------------------*/

package/src/common/validation/validators.ts

@@ -10,6 +10,8 @@ import {
     isURL
 } from 'validator';
 
+import normalizeUrl, { Options as NormalizeUrlOptions } from 'normalize-url';
+
 // Core
 import { InputError } from '@common/errors';
 import FileToUpload from '@client/components/inputv3/file/FileToUpload';
@@ -157,16 +159,25 @@ export default class SchemaValidators {
             
         }, opts)
 
-    public url = (opts: TValidator<string> & {} = {}) => 
+    public url = (opts: TValidator<string> & {
+        normalize?: NormalizeUrlOptions
+    } = {}) => 
         new Validator<string>('url', (inputVal, input, output, corriger?) => {
 
             let val = this.string(opts).validate(inputVal, input, output, corriger);
 
+            // Check if URL
             if (!isURL(val, {
                 // https://www.npmjs.com/package/validator
             }))
                 throw new InputError(`Please provide a valid URL.`);
 
+            // Normalize
+            if (opts.normalize !== undefined)
+                val = normalizeUrl(val, opts.normalize);
+
+            console.log("@@@@@@@@@@@@@NORMALISZE URL", opts.normalize, val);
+
             return val;
         }, opts)
 

package/src/server/app/commands.ts

@@ -41,15 +41,35 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class CommandsManager extends Service<Config, Hooks, Application> {
+export default class CommandsManager extends Service<Config, Hooks, Application, Services> {
 
     public priority = 2 as 2;
 
     public commandsIndex: CommandsList = {}
 
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    protected async start() {
+        
+    }
+
+    protected async ready() {
+
+    }
+
+    protected async shutdown() {
+
+    }
+
     /*----------------------------------
     - DEFINITIONS
     ----------------------------------*/

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

@@ -35,6 +35,7 @@ export type TEnvConfig = {
 type AppIdentityConfig = {
 
     name: string,
+    identifier: string,
     description: string,
     author: {
         name: string,

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

@@ -8,19 +8,22 @@ import './patch';
 import path from 'path';
 
 // Core
-import Services from '../service/container';
+import type { StartedServicesIndex } from '../service';
+import Services, { ServicesContainer } from '../service/container';
 import ConfigParser, { TEnvConfig } from './config';
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ApplicationContainer {
+export class ApplicationContainer<
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
-    public Services = Services;
+    public Services = Services as ServicesContainer<TServicesIndex>;
     public Environment: TEnvConfig;
     public Identity: Config.Identity;
 

package/src/server/app/index.ts

@@ -7,6 +7,7 @@ import AppContainer from './container';
 import ApplicationService, { AnyService } from './service';
 import CommandsManager from './commands';
 import ServicesContainer, { TRegisteredService, TServiceMetas } from './service/container';
+import type { ServerBug } from '../services/console';
 
 // Built-in
 import type { default as Router, Request as ServerRequest } from '@server/services/router';
@@ -48,7 +49,7 @@ export const Service = ServicesContainer;
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
-export class Application extends ApplicationService<Config, Hooks, /* TODO: this ? */Application> {
+export class Application extends ApplicationService<Config, Hooks, /* TODO: this ? */Application, {}> {
 
     /*----------------------------------
     - PROPERTIES
@@ -72,8 +73,8 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
     public debug: boolean = false;
     public launched: boolean = false;
 
-    // All service instances by service id
-    public allServices: {[serviceId: string]: AnyService} = {}
+    // Mandatory services
+    public Console = this.use('Core/Console');
 
     /*----------------------------------
     - INIT
@@ -81,10 +82,14 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
 
     public constructor() {
 
+        const self = 'self' as unknown as Application;
+
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
-        super({}, {}, {}, {});
+        super(self, {}, {}, self);
 
+        // We can't pass this in super so we assign here
+        this.parent = this;
         this.app = this;
 
         // Gestion crash
@@ -113,9 +118,9 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
         console.log(`5HTP Core`, process.env.npm_package_version);
 
         // Handle errors & crashs
-        this.on('error', this.error.bind(this))
+        this.on('error', e => this.Console.createBugReport(e))
 
-        this.debug && console.info(`[boot] Start services`);
+        console.info(`[boot] Start services`);
         await this.startServices();
 
         this.debug && console.info(`[boot] App ready`);
@@ -132,8 +137,10 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
     }
 
     // Default error handler
-    public async error( e: Error ) {
-        console.error( e );
+    public async reportBug( bug: ServerBug ) {
+
+        console.error( bug.error );
+
     }
 
     public async shutdown() {
@@ -150,30 +157,38 @@ export class Application extends ApplicationService<Config, Hooks, /* TODO: this
 
             // Don't check services prop as it will trigger an error (it's a proxy)
             // TODO: exclude all properties coming from the Service class itself
-            if (propName === 'services' || typeof this[ propName ] !== 'object')
+            if (propName === 'services' || this[ propName ] === undefined)
                 continue;
 
             // Check if this property is a service registration
-            const registered = this[ propName ] as TRegisteredService;
-            if (registered?.type !== 'service')
+            const service = this[ propName ] as TRegisteredService;
+            const isService = (
+                service instanceof ApplicationService
+                ||
+                (
+                    typeof service === 'function'
+                    &&
+                    service.serviceInstance instanceof ApplicationService
+                )
+            )
+            if (!isService)
                 continue;
 
             // Instanciate the service
-            const service = this.registerService( propName, registered );
-            this[ propName ] = service;
+            this.bindService( propName, service );
 
             // Register commands
             if (service.commands)
                 this.commandsManager.fromList( service.commands );
 
             // Start service
-            await this.startService( service );
+            await this.startService( propName, service );
         }
 
         // Check if any setup service has not been used
         const unused: string[] = []
         for (const serviceNS in ServicesContainer.registered)
-            if (this.allServices[ serviceNS ] === undefined)
+            if (ServicesContainer.allServices[ serviceNS ] === undefined)
                 unused.push(serviceNS);
         
         if (unused.length !== 0)

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

@@ -4,7 +4,7 @@
 
 // Specific
 import type { 
-    AnyService, 
+    AnyService, StartedServicesIndex,
     // Hooks
     THookCallback, THooksIndex 
 } from ".";
@@ -46,13 +46,18 @@ const LogPrefix = '[service]';
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ServicesContainer {
+export class ServicesContainer<
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
 
     public registered: TRegisteredServicesIndex = {}
 
-    public setup( 
-        serviceId: string, 
-        serviceConfig: {} 
+    // All service instances by service id
+    public allServices: {[serviceId: string]: AnyService} = {}
+
+    public setup<TServiceId extends keyof TServicesIndex>( 
+        serviceId: keyof TServicesIndex, 
+        serviceConfig: TServicesIndex[TServiceId]["config"]
     ): TRegisteredService {
 
         // Check if the service is installed & has been indexed
@@ -86,25 +91,6 @@ export class ServicesContainer {
         return service;
     }
 
-    public use( 
-        serviceId: string, 
-        // TODO: Only subservices types supported by the parent service
-        subServices: TRegisteredServicesIndex = {}
-    ): TRegisteredService {
-
-        // Check of the service has been configurated
-        const registered = this.registered[ serviceId ];
-        if (registered === undefined)
-            throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
-
-        // Bind subservices
-        registered.subServices = subServices;
-
-        // Return the service metas
-        // The parent service will take care of instanciating & starting it
-        return registered;
-    }
-
     public callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
         instance: TInstance, 
         funcName: TCallableName
@@ -129,6 +115,9 @@ export class ServicesContainer {
                     ? instance[ method ].bind( instance )
                     : instance[ method ];
 
+        // Allow us to recognize a callable as a service 
+        callable.serviceInstance = instance;
+
         return callable as TInstance[TCallableName] & TInstance;
     }
 }

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

@@ -6,12 +6,13 @@
 import type { Application } from "..";
 import type { Command } from "../commands"; 
 import type { TServiceMetas, TRegisteredServicesIndex, TRegisteredService } from './container';
+import ServicesContainer from './container';
 
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
 
-export type AnyService = Service<{}, {}, Application, TStartedServicesIndex>
+export type AnyService = Service<{}, {}, Application, {}>
 
 type TServiceConfig = {
     debug?: boolean
@@ -52,7 +53,7 @@ export default abstract class Service<
     TConfig extends TServiceConfig, 
     THooks extends THooksList,
     TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+    TServicesIndex extends StartedServicesIndex
 > {
 
     public started?: Promise<void>;
@@ -62,26 +63,34 @@ export default abstract class Service<
     public metas!: TServiceMetas;
     public bindings: string[] = []
 
-    public static createInstance?: (
-        parent: AnyService, 
-        config: TServiceConfig,
-        services: TRegisteredServicesIndex,
-        app: Application
-    ) => Service<TServiceConfig, THooksList, Application, StartedServicesIndex>;
+    public app: TApplication;
 
     public constructor( 
-        public parent: AnyService, 
+        public parent: AnyService | 'self', 
         public config: TConfig,
-        services: TRegisteredServicesIndex,
-        public app: TApplication
+        // Make this argument appear as instanciated sercices index
+        // But actually, Setup.use returns a registered service, not yet launched
+        services: TServicesIndex,
+        app: TApplication | 'self'
     ) {
 
+        if (this.parent === 'self') 
+            this.parent = this;
+
+        this.app = app === 'self'
+            ? this as unknown as TApplication
+            : app
+
         // Instanciate subservices
         for (const localName in services)
-            this.registerService( localName, services[localName] );
+            this.bindService( localName, services[localName] as unknown as TRegisteredService );
         
     }
 
+    public getServiceInstance() {
+        return this;
+    }
+
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -90,7 +99,7 @@ export default abstract class Service<
 
         // Instanciate subservices
         for (const localName in this.services)
-            await this.startService( this.services[localName] );
+            await this.startService( localName, this.services[localName] );
 
         // Start service
         if (this.start)
@@ -112,66 +121,103 @@ export default abstract class Service<
     - SUBSERVICES
     ----------------------------------*/
 
-    public services: TRegisteredServicesIndex = {} as TRegisteredServicesIndex/*new Proxy({}, {
+    public registered: TRegisteredServicesIndex = {} as TRegisteredServicesIndex;
+
+    public services: TServicesIndex = {} as TServicesIndex;
+    
+    /*new Proxy({}, {
         get: (target, prop, recever) => {
             if (!( prop in target )) {
                 
-                throw new Error(`You made reference to the "${prop}" service, but this one hasn't been loaded yet. Loaded services: ` + Object.keys(this.services).join(', '));
+                throw new Error(`You made reference to the "${prop}" service, but this one hasn't been loaded or started yet. 
+                    Registered services: ${Object.keys(this.services).join(', ')} ; 
+                    Loaded services: ${Object.keys(this.services).join(', ')}
+                `);
             }
         }
     }) as TRegisteredServicesIndex*/
 
-    protected registerService( localName: string, registered: TRegisteredService ): AnyService {
+    // 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
+    public use<TServiceId extends keyof TServicesIndex>( 
+        serviceId: TServiceId, 
+        // TODO: Only subservices types supported by the parent service
+        subServices: TServicesIndex[TServiceId]["services"] = {}
+    ) {
 
-        // Service already instabciates on the app scope
-        let service = this.app.allServices[ registered.metas.id ];
+        // Check of the service has been configurated
+        const registered = ServicesContainer.registered[ serviceId ];
+        if (registered === undefined)
+            throw new Error(`Unable to use service "${serviceId}": This one hasn't been setup.`);
 
-        // Service not yet instanciated
-        if (service === undefined) {
+        // Bind subservices
+        registered.subServices = subServices;
 
-            // Instanciate
-            console.log(`[app] Load service`, registered.metas.id);
-            const ServiceClass = registered.metas.class().default;
-            // Create class instance
-            service = ServiceClass.createInstance !== undefined
-                ? ServiceClass.createInstance(this, registered.config, registered.subServices, this.app)
-                : new ServiceClass(this, registered.config, registered.subServices, this.app);
+        // Check if not already instanciated
+        const existing = ServicesContainer.allServices[ serviceId ];
+        if (existing !== undefined) {
+            console.info("Service", serviceId, "already instanciated through another service.");
+            return existing;
+        }
 
-            service.metas = registered.metas;
+        // Instanciate
+        console.log(`[app] Load service`, registered.metas.id);
+        const ServiceClass = registered.metas.class().default;
 
-        } else {
-            console.warn(`[app] Service`, registered.metas.id, 'already instanciated in this app.');
-        }
+        // Create class instance
+        const service = new ServiceClass(this, registered.config, registered.subServices, this.app || this)
+            .getServiceInstance()
 
-        // Bind to app
-        this.services[ localName ] = service;
-        service.bindings.push(this.constructor.name + '.' + localName);
-        this.app.allServices[ registered.metas.id ] = service;
+        // Bind his own metas
+        service.metas = registered.metas;
+        ServicesContainer.allServices[ registered.metas.id ] = service;
 
         return service;
-        
     }
 
-    protected async startService( service: AnyService ) {
+    protected bindService( localName: string, service: AnyService ) {
 
-        // Service already started
-        if (service.started)
-            return;
-
-        // Start servuce & eventually his subservices
-        console.log(`[app] Start service`, service.metas.id);
-        service.status = 'starting';
-        service.started = service.launch();
-        await service.started.catch(e => {
-            console.error("Catched error while starting service " + service.metas.id, e);
-            if (this.app.env.profile === 'prod')
-                process.exit();
-            else
-                throw e;
-        })
+        const serviceScope = this.constructor.name + '.' + localName;
+
+        // Fix the parent service (the app could be provided as parent because the dev called this.use() in the app class definition)
+        service.parent = this;
+
+        // Bind subservice to service
+        //console.log(`Binding service ${serviceScope}`);
+        service.bindings.push(serviceScope);
+
+        // Since now we have the localname, we can bind the service in this.service too
+        this.services[localName] = service;
 
-        console.log(`[app] Service`, service.metas.id, 'started (bound to:', service.bindings.join(', '),')');
-        service.status = 'running';
+        // For serices that have been passed through this.use
+        if ((localName in this) && this[localName] === undefined)
+            this[ localName ] = service;
+        
+    }
+
+    protected async startService( localName: string, service: AnyService ) {
+        // Service already started
+        if (!service.started) {
+
+            const serviceScope = this.constructor.name + '.' + localName;
+
+            // Start servuce & eventually his subservices
+            console.log(`[app] Start service`, serviceScope);
+            service.status = 'starting';
+            service.started = service.launch();
+            await service.started.catch(e => {
+                console.error("Catched error while starting service " + serviceScope, e);
+                if (this.app.env.profile === 'prod')
+                    process.exit();
+                else
+                    throw e;
+            })
+
+            // Bind to app
+            console.log(`[app] Service`, serviceScope, 'started (bound to:', service.bindings.join(', '),')');
+            service.status = 'running';
+        }
     }
 
     /*----------------------------------

package/src/server/app.tsconfig.json

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

package/src/server/index.ts

@@ -5,7 +5,8 @@ import './app/container';
 import '@/server/config/*.ts';
 
 // Load Application
-import application from './app/instance';
+import Application from '@/server';
+const application = new Application;
 
 // Start application
 application.start();

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

@@ -65,10 +65,14 @@ export type Hooks = {
 
 }
 
+export type Services = {
+    disks: DisksManager,
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class Cache extends Service<Config, Hooks, Application> {
+export default class Cache extends Service<Config, Hooks, Application, Services> {
 
     public commands = registerCommands(this);
 
@@ -79,9 +83,7 @@ export default class Cache extends Service<Config, Hooks, Application> {
     public constructor( 
         parent: AnyService, 
         config: Config,
-        services: {
-            disks: TRegisteredService< DisksManager >,
-        },
+        services: Services,
         app: Application, 
     ) {
 

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

@@ -11,6 +11,7 @@ import highlight from 'cli-highlight';
 import type { Application } from '@server/app';
 import Service from '@server/app/service';
 import context from '@server/context';
+import type { ServerBug } from '@common/errors';
 import type ServerRequest from '@server/services/router/request';
 import { SqlError } from '@server/services/database/debug';
 
@@ -38,6 +39,10 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -82,25 +87,6 @@ export type TDbQueryLog = 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
@@ -129,7 +115,7 @@ const logFields = [
 /*----------------------------------
 - LOGGER
 ----------------------------------*/
-export default class Console extends Service<Config, Hooks, Application> {
+export default class Console extends Service<Config, Hooks, Application, Services> {
 
     // Services
     public logger!: Logger;
@@ -184,9 +170,6 @@ export default class Console extends Service<Config, Hooks, Application> {
         }, envConfig.level);*/
 
         setInterval(() => this.clean(), 10000);
-
-        // Send email report
-        this.app.on('error', this.createBugReport.bind(this));
     }
 
     public async ready() {
@@ -259,7 +242,7 @@ export default class Console extends Service<Config, Hooks, Application> {
             logs: logsHtml
         }
 
-        await this.runHook('bugReport', bugReport);
+        await this.app.reportBug( bugReport );
     }
 
     public getChannel() {

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

@@ -28,11 +28,15 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 
-export default class CronManager extends Service<Config, Hooks, Application> {
+export default class CronManager extends Service<Config, Hooks, Application, Services> {
 
     public static taches: { [nom: string]: CronTask } = {}
     public static timer: NodeJS.Timeout;

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

@@ -4,7 +4,7 @@
 
 // Npm
 import mysql from 'mysql2/promise';
-import type { ResultSetHeader } from 'mysql2';
+import type { OkPacket } from 'mysql2';
 import dottie from 'dottie';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
@@ -29,6 +29,10 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - DEFINITIONS TYPES
 ----------------------------------*/
@@ -42,6 +46,7 @@ export type TSelectQueryOptions = TQueryOptions & {
 export type TUpdateQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = TQueryOptions;
 
 export type TInsertQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = TQueryOptions & {
+    bulk?: boolean,
     upsert?: TColsToUpsert<TData>, // When "*", we use table.upsertableColumns
     upsertMode?: 'increment'
     try?: boolean
@@ -66,13 +71,27 @@ type TColsToUpsert<TData extends TObjetDonnees> = (
 
 const LogPrefix = '[database]'
 
+const emptyOkPacket = {
+    constructor: {
+        name: 'OkPacket'
+    },
+    fieldCount: 0,
+    affectedRows: 0,
+    changedRows: 0,
+    insertId: 0,
+    serverStatus: 0,
+    warningCount: 0,
+    message: '',
+    procotol41: true,
+} as OkPacket
+
 /*----------------------------------
 - CORE
 ----------------------------------*/
 
 // TODO: build callable instance sithut instanciating the service
 
-export default class SQL extends Service<Config, Hooks, Application> {
+export default class SQL extends Service<Config, Hooks, Application, Services> {
 
     public database: Database;
 
@@ -88,16 +107,8 @@ export default class SQL extends Service<Config, Hooks, Application> {
         this.database = new Database(this, config);
     }
 
-    public static createInstance(
-        parent: AnyService, 
-        config: Config,
-        services: TRegisteredServicesIndex,
-        app: Application
-    ) {
-        return Services.callableInstance(
-            new SQL(parent, config, services, app),
-            'sql'
-        )
+    public getServiceInstance() {
+        return Services.callableInstance(this, 'sql')
     }
 
     /*----------------------------------
@@ -321,7 +332,7 @@ export default class SQL extends Service<Config, Hooks, Application> {
         data: TData, 
         where?: (keyof TData)[] | TObjetDonnees, 
         opts?: TUpdateQueryOptions<TData>
-    ]): Promise<ResultSetHeader> {
+    ]): Promise<OkPacket> {
 
         let [tableName, data, where, opts] = args;
 
@@ -389,7 +400,7 @@ export default class SQL extends Service<Config, Hooks, Application> {
         path: string, 
         data: TData | TData[], 
         opts: TInsertQueryOptions<TData> = {}
-    ): Promise<ResultSetHeader> {
+    ): Promise<OkPacket> {
 
         const table = this.database.getTable(path);
 
@@ -398,39 +409,54 @@ export default class SQL extends Service<Config, Hooks, Application> {
             data = [data];
         else if (data.length === 0) {
             console.warn(LogPrefix, `Insert nothing in ${path}. Cancelled.`);
-            return {
-                fieldCount: 0,
-                affectedRows: 0,
-                changedRows: 0,
-                insertId: 0,
-                serverStatus: 0,
-                warningStatus: 0,
-                info: undefined
-            };
+            return emptyOkPacket;
         }
 
-        let querySuffix: string = '';
-
         // Upsert
+        let upsertStatement: string = '';
         if (opts.upsert !== undefined)
-            querySuffix += ' ' + this.buildUpsertStatement<TData>(table, opts as With<TInsertQueryOptions<TData>, 'upsert'>);
+            upsertStatement = ' ' + this.buildUpsertStatement<TData>(table, opts as With<TInsertQueryOptions<TData>, 'upsert'>);
         
         // Create basic insert query
-        const query = this.buildInsertStatement(table, data, opts) + querySuffix;
-
-        const queryResult = await this.database.query<mysql.OkPacket>(query + ';', opts);
-
-        return {
-            fieldCount: queryResult.fieldCount,
-            affectedRows: queryResult.affectedRows,
-            changedRows: queryResult.changedRows,
-            insertId: queryResult.insertId,
-            serverStatus: queryResult.serverStatus,
-            warningCount: queryResult.warningCount,
-            message: queryResult.message,
-            procotol41: queryResult.procotol41,
-        };
-        
+        if (opts.bulk === false) {
+
+            const okPacket = { ...emptyOkPacket }
+
+            for (const row of data) {
+
+                const query = this.buildInsertStatement(table, [row], opts) + upsertStatement;
+
+                const queryResult = await this.database.query<mysql.OkPacket>(query + ';', opts)
+
+                okPacket.fieldCount += queryResult.fieldCount;
+                okPacket.affectedRows += queryResult.affectedRows;
+                okPacket.changedRows += queryResult.changedRows;
+                okPacket.insertId = queryResult.insertId;
+                okPacket.serverStatus += queryResult.serverStatus;
+                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];
     }
 

package/src/server/services/disks/driver.ts

@@ -14,6 +14,10 @@ export type THooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - TYPE
 ----------------------------------*/
@@ -52,7 +56,7 @@ export type TReadFileOptions = {
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
     TBucketName = keyof Config["buckets"]
-> extends Service<Config, {}, Application> {
+> extends Service<Config, {}, Application, Services> {
 
     public abstract mount(): Promise<void>;
     

package/src/server/services/disks/drivers/s3/index.ts

@@ -53,7 +53,7 @@ export default class S3Driver<
     public constructor( 
         public parent: AnyService, 
         public config: TConfig,
-        public services: TRegisteredServicesIndex,
+        public services: {},
         public app: Application
     ) {
 

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

@@ -24,25 +24,27 @@ export type Hooks = {
 
 }
 
-type TMountpointList = { [name: string]: Driver }
+export type Services = {
+
+}
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
-    MountpointList extends TMountpointList = {},
+    MountpointList extends Services = {},
     TConfig extends Config = Config,
     TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication> {
+> extends Service<TConfig, Hooks, TApplication, MountpointList> {
 
-    public default: Driver;
+    public default!: Driver;
 
-    public mounted: TMountpointList = this.services;
+    public mounted: MountpointList = this.services;
 
     public constructor( 
         parent: AnyService, 
         config: TConfig,
-        drivers: TRegisteredServicesIndex< Driver >,
+        drivers: MountpointList,
         app: TApplication, 
     ) {
 
@@ -51,6 +53,14 @@ export default class DisksManager<
         if (Object.keys( drivers ).length === 0)
             throw new Error("At least one disk driver should be mounted.");
 
+        console.log('start disks service', Object.keys( drivers ), Object.keys( this.mounted ), Object.keys( this.services ));
+
+        const defaultDisk = drivers[ this.config.default ];
+        if (defaultDisk === undefined)
+            console.log(`Default disk "${this.config.default as string}" not mounted.`);
+
+        this.default = defaultDisk;
+
     }
 
     /*----------------------------------
@@ -58,12 +68,6 @@ export default class DisksManager<
     ----------------------------------*/
 
     public async start() {
-
-        const defaultDisk = this.mounted[ this.config.default ];
-        if (defaultDisk === undefined)
-            console.log(`Default disk "${this.config.default as string}" not mounted.`);
-
-        this.default = defaultDisk;
         
     }
 

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

@@ -41,6 +41,10 @@ export type Hooks = {
 
 }
 
+export type Services = {
+
+}
+
 /*----------------------------------
 - TYPES: EMAILS
 ----------------------------------*/
@@ -105,7 +109,7 @@ type TOptions = {
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default class Email extends Service<Config, Hooks, Application> {
+export default class Email extends Service<Config, Hooks, Application, Services> {
     
     private transporters = this.config.transporters;
 

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

@@ -65,9 +65,6 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
     ) {
 
         super(parent, config, services, app);
-
-        if (this.services.disks)
-            this.disk = this.services.disks.get( config.disk );
         
     }
 
@@ -77,7 +74,8 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
 
     public async start() {
 
-        
+        if (this.services.disks)
+            this.disk = this.services.disks.get( this.config.disk );
         
         
     }
@@ -114,7 +112,7 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
         { width, height, fit, quality }: TImageConfig, 
         saveToBucket: string,
         saveToPath?: string,
-        disk?: FsDriver
+        disk?: string
     ): Promise<Buffer | null> {
 
         // Define target disk

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

@@ -96,7 +96,9 @@ export type Config<
 
 export type Services = {
     disks?: DisksManager
-} & TRegisteredServicesIndex< RouterService<ServerRouter> >
+} & {
+    [routerServiceId: string]: RouterService
+}
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
 type TRouterServicesList = {
@@ -132,7 +134,7 @@ export default class ServerRouter<
     public constructor( 
         parent: AnyService, 
         config: TConfig,
-        services: TRegisteredServicesIndex<RouterService>,
+        services: Services,
         app: TApplication, 
     ) {
 
@@ -156,8 +158,6 @@ export default class ServerRouter<
             if (routerService instanceof RouterService)
                 this.routerServices[ serviceName ] = routerService;
         }
-
-        console.log("this.routerServices", Object.keys( this.routerServices ));
     }
 
     public async ready() {

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

@@ -11,16 +11,22 @@ import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type RequestService from './request/service';
 
+export type Services = {
+    
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default abstract class RouterService<
     TConfig extends {} = {}
-> extends Service<TConfig, {}, Application> {
+> extends Service<TConfig, {}, Application, Services> {
 
     public constructor( 
         // Parent is always a router in RouterService
-        public router: Router, 
+        // Warning: for now, it's possible that router is actually the app
+        //      It's fixed with a not very clean way in Service.bindService
+        router: Router, 
         config: TConfig,
         services: TRegisteredServicesIndex,
         app: Application
@@ -30,6 +36,6 @@ export default abstract class RouterService<
         
     }
 
-    public abstract requestService( request: ServerRequest<TRouter> ): RequestService | null;
+    public abstract requestService( request: ServerRequest<Router> ): RequestService | null;
 
 }

package/src/server/services/security/encrypt/aes/index.ts

@@ -10,11 +10,6 @@ import type { Application } from '@server/app';
 import Service from '@server/app/service';
 import { Forbidden } from '@common/errors';
 
-/*----------------------------------
-- CONFIG
-----------------------------------*/
-
-
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
@@ -33,6 +28,14 @@ export type Hooks = {
 
 }
 
+export type Services = {
+    
+}
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
 type TEncryptOptions = {
     encoding: Encoding
 }
@@ -44,7 +47,7 @@ type TDecryptOptions = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application> {
+export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application, Services> {
 
     /*----------------------------------
     - LIFECYCLE

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

@@ -32,36 +32,39 @@ export type Hooks = {
 
 }
 
+export type Services<TUser extends {}> = {
+    users: UsersManagementService<TUser, Application>,
+    router: Router
+}
+
 /*----------------------------------
 - MANAGER
 ----------------------------------*/
 export default class WebSocketCommander<
     TUser extends {},
-    TConfig extends Config<TUser>= Config<TUser>
-> extends Service<TConfig, Hooks, Application> {
+    TConfig extends Config<TUser>= Config<TUser>,
+    TServices extends Services<TUser> = Services<TUser>
+> extends Service<TConfig, Hooks, Application, TServices> {
 
     // Services
     public ws!: WebSocketServer;
-    public users: UsersManagementService<TUser>;
-    public router: Router;
+    public users!: TServices["users"];
+    public router!: Router;
 
     // Context
     public scopes: {[path: string]: SocketScope<TUser>} = {}
 
-    public constructor( 
+    public constructor(
         parent: AnyService, 
         config: TConfig,
-        services: {
-            users: TRegisteredService< UsersManagementService<TUser> >,
-            router: Router
-        },
-        app: Application, 
+        services: Services,
+        app: TApplication, 
     ) {
-
         super(parent, config, services, app);
-
+        
         this.users = this.services.users;
         this.router = this.services.router;
+        
     }
     
     /*----------------------------------
@@ -71,10 +74,6 @@ export default class WebSocketCommander<
     public loading: Promise<void> | undefined = undefined;
     protected async start() {
 
-        this.app.on('cleanup', async () => {
-            this.closeAll();
-        });
-
         this.users.on('disconnect', async (userId: string) => {
             this.disconnect(userId, 'Logout');
         });
@@ -126,7 +125,7 @@ export default class WebSocketCommander<
     }
 
     public async shutdown() {
-
+        this.closeAll();
     }
 
 	/*----------------------------------

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

@@ -58,6 +58,10 @@ export type THooks = {
     
 }
 
+export type TServices = {
+
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
@@ -66,7 +70,7 @@ export default abstract class UsersManagementService<
     TApplication extends Application,
     TJwtSession extends {} = {},
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
-> extends Service<TConfig, THooks, TApplication> {
+> extends Service<TConfig, THooks, TApplication, TServices> {
 
     /*----------------------------------
     - LIFECYCLE

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

@@ -42,7 +42,7 @@ export default class AuthenticationRouterService<
     protected async start() {
 
         // Decode current user
-        this.router.on('request', async (request: TRequest) => {
+        this.parent.on('request', async (request: TRequest) => {
 
             // TODO: Typings. (context.user ?)
             const decoded = await this.services.users.decode( request.req, true);
@@ -51,7 +51,7 @@ export default class AuthenticationRouterService<
         })
 
         // Check route permissions
-        this.router.on('resolved', async (route: TAnyRoute, request: TRequest) => {
+        this.parent.on('resolved', async (route: TAnyRoute, request: TRequest) => {
 
             if (route.options.auth !== undefined)
                 // TODO: How to pas the router type to router config ? Circular rfeerence ?

package/src/server/app/instance.ts

@@ -1,3 +0,0 @@
-import Application from '@/server';
-
-export default new Application