5htp-core 0.1.2 → 0.2.1

package/src/common/validation/validators.ts

@@ -0,0 +1,313 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import {
+    trim,
+    isISO8601, toDate,
+    isEmail, normalizeEmail,
+    isURL
+} from 'validator';
+
+// Core
+import { InputError } from '@common/errors';
+import File from '@common/data/file';
+import NormalizedFile from '@common/data/file';
+
+// Speciific
+import Validator, { TValidator } from './validator'
+
+// Components
+import NumberInput from '@client/components/input/Number';
+import Dropdown from '@client/components/dropdown.old';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TFileValidator = TValidator<NormalizedFile> & {
+    type?: (keyof typeof raccourcisMime) | string[], // Raccourci, ou liste de mimetype
+    taille?: number
+}
+
+/*----------------------------------
+- CONST
+----------------------------------*/
+
+const raccourcisMime = {
+    image: ['image/jpeg', 'image/png']
+}
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class SchemaValidator {
+
+    /*----------------------------------
+    - CONTENEURS
+    ----------------------------------*/
+    public object = ({ ...opts }: TValidator<object> & {} = {}) => 
+        new Validator<object>('object', (val, input, output) => {
+
+            // TODO: executer seulement coté serveur
+            /*if (typeof val === 'string' && val.startsWith('{'))
+                try {
+                    val = JSON.parse(val);
+                } catch (error) {
+                    console.error('Unable to convert the given string into an object.');
+                }*/
+
+            if (typeof val !== 'object' || val.constructor !== Object)
+                throw new InputError("This value must be an object.");
+
+            return val;
+        }, opts)
+
+    public array = (subtype?: Validator<any[]>, { choice, ...opts }: TValidator<any[]> & {
+        choice?: any[]
+    } = {}) => {
+
+        if (subtype !== undefined)
+            subtype.options.in = choice;
+
+        return new Validator<any[]>('array', (items, input, output, corriger) => {
+
+            //console.log('VALIDER ARRAY', items, input);
+
+            if (!Array.isArray(items))
+                throw new InputError("This value must be an array.");
+
+            // Verif items
+            if (subtype !== undefined) {
+                if (false/*subtype instanceof Schema*/) {
+
+                    console.log('TODO: VALIDER VIA SOUS SCHEMA');
+
+                } else {
+
+                    for (let i = 0; i < items.length; i++)
+                        items[i] = subtype.validate( items[i], items, items, corriger );
+
+                }
+            }
+
+            return items;
+        }, {
+            ...opts,
+            in: choice,
+            //multiple: true, // Sélection multiple
+            //subtype
+        })
+    }
+
+    public choice = (values: any[], opts: TValidator<any> & {} = {}) => 
+        new Validator<any>('object', (val, input, output) => {
+
+            if (!values.includes(val))
+                throw new InputError("Invalid value. Must be: " + values.join(', '));
+
+            return val;
+
+        }, opts)
+
+    /*----------------------------------
+    - CHAINES
+    ----------------------------------*/
+    public string = ({ min, max, ...opts }: TValidator<string> & { min?: number, max?: number } = {}) => 
+        new Validator<string>('string', (val, input, output, corriger?: boolean) => {
+
+            if (val === '')
+                return undefined;
+            else if (typeof val === 'number')
+                return val.toString();
+            else if (typeof val !== 'string')
+                throw new InputError("This value must be a string.");
+
+            // Espaces blancs
+            val = trim(val);
+
+            // Taille min
+            if (min !== undefined && val.length < min)
+                throw new InputError(`Must be at least ` + min + ' characters');
+
+            // Taille max
+            if (max !== undefined && val.length > max)
+                if (corriger)
+                    val = val.substring(0, max);
+                else
+                    throw new InputError(`Must be up to ` + max + ' characters');
+
+            return val;
+            
+        }, opts)
+
+    public url = (opts: TValidator<string> & {} = {}) => 
+        new Validator<string>('url', (inputVal, input, output, corriger?) => {
+
+            let val = this.string(opts).validate(inputVal, input, output, corriger);
+
+            if (!isURL(val, {
+                // https://www.npmjs.com/package/validator
+            }))
+                throw new InputError(`Please provide a valid URL.`);
+
+            return val;
+        }, opts)
+
+    public email = (opts: TValidator<string> & {} = {}) => 
+        new Validator<string>('email', (inputVal, input, output, corriger?: boolean) => {
+
+            let val = this.string(opts).validate(inputVal, input, output, corriger);
+
+            if (!isEmail(val))
+                throw new InputError("Please enter a valid email address.");
+
+            const retour = normalizeEmail(val);
+
+            return retour;
+        }, opts)
+
+    /*----------------------------------
+    - NOMBRES
+    ----------------------------------*/
+    // On ne spread pas min et max afin quils soient passés dans les props du composant
+    public number = (withDecimals: boolean) => ({ ...opts }: TValidator<number> & {
+        min?: number,
+        max?: number,
+    } = {}) => new Validator<number>('number', (val, input, output, corriger?: boolean) => {
+
+        // Vérifications suivantes inutiles si des values spécifiques ont été fournies
+        if (opts.in === undefined) {
+
+            // Tente conversion chaine en nombre
+            if (typeof val === 'string')
+                val = withDecimals ? parseFloat(val) : parseInt(val);
+            
+            if (opts.min === undefined)
+                opts.min = 0;
+            
+            // Type de donnée
+            if (Number.isNaN(val) || typeof val !== 'number') {
+                if (corriger)
+                    val = opts.min;
+                else
+                    throw new InputError("This value must be a number.");
+            }
+
+            // Minimum
+            if (val < opts.min)
+                if (corriger)
+                    val = opts.min;
+                else
+                    throw new InputError(`Must be at least ` + opts.min);
+
+            // Maximum
+            if (opts.max !== undefined && val > opts.max)
+                if (corriger)
+                    val = opts.max;
+                else
+                    throw new InputError(`Must be up to ` + opts.max);
+
+        }
+
+        return val;
+    }, {
+        // Force une valeur par défaut si requis
+        defaut: opts.opt ? undefined : (opts.min || 0),
+        rendu: NumberInput,
+        ...opts,
+    })
+
+    public int = this.number(false)   
+
+    public float = this.number(true) 
+
+    public bool = (opts: TValidator<boolean> & {} = {}) => 
+        new Validator<boolean>('bool', (val, input, output) => {
+
+            if (typeof val !== 'boolean' && !['true', 'false'].includes(val))
+                throw new InputError("This value must be a boolean.");
+
+            val = !!val;
+
+            return val;
+        }, {
+            defaut: false,
+            ...opts
+        })
+
+    /*----------------------------------
+    - AUTRES
+    ----------------------------------*/
+    public date = (opts: TValidator<Date> & {
+
+    } = {}) => new Validator<Date>('date', (val, input, output) => {
+
+        const chaine = typeof val == 'string';
+
+        // Chaine = format iso
+        if (chaine) {
+
+            if (!isISO8601(val))
+                throw new InputError("This value must be a date.");
+
+            val = toDate(val);
+
+        } else if (!(val instanceof Date))
+            throw new InputError("This value must be a date.");
+
+        return val;
+
+    }, {
+        //defaut: new Date,
+        ...opts,
+    })
+
+    /*----------------------------------
+    - FICHIER
+    ----------------------------------*/
+    protected validateFile = (
+        { type, taille, ...opts }: TFileValidator = {}, 
+        val: any, 
+        input: TObjetDonnees, 
+        output: TObjetDonnees
+    ): File | undefined => {
+
+        console.log('VALIDER FICHIER', type, val);
+
+        if (!(val instanceof NormalizedFile))
+            throw new InputError(`Must be a File (${typeof val} received)`);
+
+        // MIME
+        if (type !== undefined) {
+
+            let mimetypes: string[];
+
+            // Raccourcis
+            if (typeof type === 'string') {
+                if (type in raccourcisMime)
+                    mimetypes = raccourcisMime[type as keyof typeof raccourcisMime]
+                else
+                    throw new Error(`Aucune liste de mimetype référencée pour le type de fichier « ${type} »`);
+            } else
+                mimetypes = type;
+
+            // Vérification
+            const mimeFichier = val.type;
+            if (!mimetypes.includes(mimeFichier))
+                throw new InputError('Only the following formats are allowed: ' + mimetypes.join(', ') + '. The file you gave is ' + mimeFichier + '.');
+
+        }
+
+        // Taille
+        if (taille) {
+            const tailleFichier = val.size / 1024 / 1024; // Mo
+            if (tailleFichier > taille)
+                throw new InputError(`Le fichier ne doit pas faire plus de ${taille} Mo (taille reçue: ${tailleFichier} Mo)`);
+        }
+
+        return val;
+    }
+
+}

package/src/server/app/config.ts

@@ -16,28 +16,20 @@ import yaml from 'yaml';
 ----------------------------------*/
 
 declare global {
-    namespace Core {
-        namespace Config {
+    namespace Config {
 
-            type EnvName = TEnvConfig["name"];
+        type EnvName = TEnvConfig["name"];
 
-            type Env = TEnvConfig;
-            type Identity = AppIdentityConfig;
-            interface Services {}
-        }
+        type Env = TEnvConfig;
+        type Identity = AppIdentityConfig;
+        interface Services {}
     }
 }
 
 export type TEnvName = TEnvConfig["name"];
 export type TEnvConfig = {
-
     name: 'local' | 'server',
     profile: 'dev' | 'prod',
-    level: 'silly' | 'info' | 'warn' | 'error',
-
-    localIP: string,
-    domain: string,
-    url: string,
 }
 
 type AppIdentityConfig = {
@@ -65,8 +57,8 @@ type AppIdentityConfig = {
 }
 
 export type AppConfig = { 
-    env: Core.Config.Env, 
-    identity: Core.Config.Identity,
+    env: Config.Env, 
+    identity: Config.Identity,
 }
 
 /*----------------------------------
@@ -90,23 +82,13 @@ export default class ConfigParser {
     public env(): TEnvConfig {
         // We assume that when we run 5htp dev, we're in local
         // Otherwise, we're in production environment (docker)
-        console.log("Using environment:", process.env.NODE_ENV);
+        console.log("[app] Using environment:", process.env.NODE_ENV);
         return process.env.NODE_ENV === 'development' ? {
             name: 'local',
-            profile: 'dev',
-            level: 'silly',
-        
-            localIP: '86.76.176.80',
-            domain: 'localhost:3010',
-            url: 'http://localhost:3010',
+            profile: 'dev'
         } : {
             name: 'server',
             profile: 'prod',
-            level: 'silly',
-        
-            localIP: '86.76.176.80',
-            domain: 'megacharger.io',
-            url: 'https://megacharger.io',
         }
     }
 

package/src/server/app/index.ts

@@ -9,48 +9,53 @@ import fs from 'fs-extra';
 
 // Core
 import ConfigParser, { TEnvConfig } from './config';
+import { default as Service, AnyService } from './service';
+import type { default as Router, Request as ServerRequest } from '@server/services/router';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type THookName = 'ready' | 'cleanup' | 'error'
-type THook = () => Promise<void>;
+export { default as Service, TPriority } from './service';
 
-type TServiceOptions = {
-    instanciate: boolean
-}
+type Config = {
 
-abstract class AsyncService {
-    public abstract loading: Promise<void> | undefined;
-    public abstract load: () => Promise<void>;
-}
-abstract class Service {
-    public abstract load: () => void;
 }
 
-interface TServiceClass {
-    new(): AsyncService | Service;
+type Hooks = {
+    ready: {
+        args: [],
+    },
+    cleanup: {
+        args: [],
+    },
+    error: {
+        args: [error: Error, request?: ServerRequest<Router>],
+    }
 }
 
 declare global {
-    namespace Core {
-        interface Services { }
+
+    //interface Services { }    
+
+    interface AppHooks {
+       
     }
+
     interface User { }
 }
 
-const servicesObj = {}
-
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
-export class App {
+export default abstract class Application extends Service<Config, Hooks, /* TODO: this ? */Application> {
 
     /*----------------------------------
     - PROPERTIES
     ----------------------------------*/
 
+    public side = 'server' as 'server';
+
     // Context
     public hmr: __WebpackModuleApi.Hot | undefined = module.hot;
 
@@ -65,143 +70,101 @@ export class App {
 
     // Status
     public launched: boolean = false;
-    public loading: Promise<void>[] = [];
     public status = {
         services: false
     }
 
-    public services: Core.Services = new Proxy( servicesObj, {
-        get: (container, serviceId, receiver) => {
-
-            if (!( serviceId in container ) && typeof serviceId === 'string')
-                throw new Error(`Service not loaded: ${serviceId}`);
-
-            return container[serviceId];
-        }
-    }) as Core.Services;
-
-    public hooks: {[name in THookName]: THook[]} = {
-        ready: [],
-        cleanup: [],
-        error: []
-    }
+    private servicesList: AnyService[] = []
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
+    public env: TEnvConfig;
+    public abstract identity: Config.Identity;
+
     public constructor() {
 
+        // @ts-ignore: can't pass this to super
+        super();
+
         // Gestion crash
         process.on('unhandledRejection', (error: any, promise: any) => {
 
             console.error("Unhandled promise rejection:", error);
-
-            // Send email report
-            if (this.isLoaded('console'))
-                $.console.bugReport.server(error);
-            else
-                console.error(`Unable to send bug report: console service not loaded.`);
+            this.runHook('error', error);
 
         });
 
         // Load config files
         const configParser = new ConfigParser( this.path.root );
         this.env = configParser.env();
-        this.identity = configParser.identity();
-    }
-
-    // Configs
-    public config!: Core.Config.Services;
-    public identity: Core.Config.Identity;
-    public env: TEnvConfig;
-    public configure( config: Core.Config.Services) {
-        this.config = config;
-        console.log("Configure services with", this.config);
-    }
-
-    // Register a service
-    public register<TServiceName extends keyof Core.Services>( 
-        id: TServiceName, 
-        Service: TServiceClass, 
-        options: Partial<TServiceOptions> = {}
-    ) {
-
-        // Pas d'export default new Service pour chaque fichier de service,
-        //  dissuaded'importer ms service sn'importe où, ce qui créé des références circulaires
-        console.log(`[services] Registering service ${id} ...`);
-        const service = options.instanciate !== false ? new Service() : Service;
-        this.services[id as string] = service;
-
-        if ('load' in service) {
-
-            console.log(`[services] Starting service ${id} ...`);
-
-            // Lorsque service.load est async, une propriété loading doit etre présente 
-            //     De façon à ce que les autres services puissent savoir quand ce service est prêt
-            if ('loading' in service) {
-                
-                console.log(`[services] Waiting service ${id} to be fully loaded ...`);
-                service.loading = service.load().then(() => {
-                    console.info(`[service] Service ${id} successfully started.`);
-                }).catch(e => {
-                    // Bug report via email
-                    console.error(`[service] Error while starting the ${id} service:`, e);
-                    e.message = `Start ${id} service: ` + e.message;
-                    $.console.bugReport.server(e);
-                });;
-
-                this.loading.push(service.loading);
-                
-            } else
-                service.load();
-        }
     }
 
-    // Test if a service was registered
-    public isLoaded( id: keyof Core.Services ) {
-        return id in this.services;
-    }
-
-    public on( name: THookName, callback: THook ) {
-        this.hooks[ name ].push( callback );
-        return this;
-    }
+    /*----------------------------------
+    - REGISTER
+    ----------------------------------*/
 
-    public runHook( hookName: THookName ) {
-        console.info(`[hook] Run all ${hookName} hook (${this.hooks.ready.length}).`);
-        return Promise.all( 
-            this.hooks.ready.map(
-                cb => cb().catch(e => {
-                    console.error(`[hook] Error while executing hook ${hookName}:`, e);
-                })
-            ) 
-        ).then(() => {
-            console.info(`[hook] Hooks ${hookName} executed with success.`);
-        })
+    // Require a service at file scope
+    //  Only use in files where a service is strictly required 
+    public use<ServiceType extends Service<{}, {}, this>>( serviceName: string ): ServiceType | undefined {
+        return this[ serviceName ];
     }
 
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
-    public async launch() {
+
+    public async register() {
+
+    }
+    
+    public async start() {
 
         console.info(`[boot] Waiting for all services to be ready ...`);
-        await Promise.all( this.loading );
+        await this.startServices()
 
         console.info(`[boot] Launching application ...`);
         await this.runHook('ready');
 
-        // NOTE: Useless ?
-        /*if (this.hmr)
-            this.activateHMR();*/
+        console.info(`[boot] Run application-specific boot instructions ...`);
+        await this.boot();
 
         console.info(`[boot] Application is ready.`);
-        
         this.launched = true;
 
     }
 
+    public registerService( service: AnyService ) {
+        console.log(`[app] Register service`, service.constructor?.name);
+        this.servicesList.push(service);
+    }
+
+    public async startServices() {
+
+        console.log(`[app] Sorting ${this.servicesList.length} services by priority`);
+        this.servicesList.sort((s1, s2) => s2.priority - s1.priority);
+
+        console.log(`[app] Starting ${this.servicesList.length} services.`);
+        for (const service of this.servicesList) {
+            const serviceClassName = service.constructor?.name;
+            console.log(`[app] Start service`, serviceClassName);
+
+            if (service.register)
+                service.register();
+
+            if (service.start) {
+                service.started = service.start();
+                await service.started;
+            }
+        }
+
+        console.log(`[app] All ${this.servicesList.length} services were started.`);
+    }
+
+    public abstract boot(): Promise<void>;
+
+    // TODO: make it work
     private activateHMR() {
 
         if (!module.hot) return;
@@ -216,17 +179,16 @@ export class App {
             console.info(`Cleaning application ...`);
 
             // Services hooks
-            for (const id in this.services) {
+            /*for (const id in this.services) {
                 const service = this.services[id]
                 if (service.cleanup) {
                     console.info(`Cleaning ${id} service ...`);
                     service.cleanup();
                 }
-            }
+            }*/
 
             // Application specific hooks
-            for (const callback of this.hooks.cleanup)
-                callback();
+            this.runHook('cleanup');
 
             /*
             console.log("[nettoyage] Arrêt serveur socket ...");
@@ -239,9 +201,4 @@ export class App {
         });
     }
 
-}
-
-const app = new App;
-export const services = app.services;
-export const $ = app.services;
-export default app;
+}