5htp-core 0.3.7 → 0.3.9

package/src/common/validation/schema.ts

@@ -12,7 +12,7 @@ import { default as Validator, EXCLUDE_VALUE } from './validator';
 - TYPES
 ----------------------------------*/
 
-export type TSchemaFields = { [fieldName: string]: Schema<{}> | Validator<any> }
+export type TSchemaFields = { [fieldName: string]: TSchemaFields | Schema<{}> | Validator<any> }
 
 type TSchemaOptions = {
     opt?: boolean
@@ -60,134 +60,128 @@ export default class Schema<TFields extends TSchemaFields> {
     }
 
     public validate<TDonnees extends TObjetDonnees>(
-    
         dataToValidate: Partial<TDonnees>,
-        allData: TDonnees,
-        output: TObjetDonnees = {},
-    
         opts: TValidateOptions<TFields> = {},
         chemin: string[] = []
+    ): TValidatedData<TFields> {
+
+        // Check data type
+        if (typeof dataToValidate !== 'object')
+            throw new InputErrorSchema({ [chemin.join('.')]: ['Must be an object'] });
     
-    ): TValidationResult<TFields> {
-    
+        // Default options
         opts = {
             debug: false,
-            throwError: false,
+            throwError: true,
             validateDeps: true,
             autoCorrect: false,
             ...opts,
         }
-    
-        let outputSchema = output;
-        for (const branche of chemin)
-            outputSchema = outputSchema[branche];
 
-        const keysToValidate = opts.only || Object.keys(this.fields);
+        const keysToValidate = (opts.only || Object.keys(this.fields)) as string[];
     
         // Validation de chacune d'entre elles
+        const output: Partial<TDonnees> = {};
         let erreurs: TListeErreursSaisie = {};
         let errorsCount = 0;
         for (const fieldName of keysToValidate) {
     
             // La donnée est répertoriée dans le schema
-            const field = this.fields[fieldName];
+            let field = this.fields[fieldName];
+            let validator: Validator<any> | Schema<{}>;
             if (field === undefined) {
                 opts.debug && console.warn(LogPrefix, '[' + fieldName + ']', 'Exclusion (pas présent dans le schéma)');
                 continue;
-            }
+            } else if (field.constructor === Object)
+                validator = new Schema(field as TSchemaFields);
+            else
+                validator = field as Validator<any>;
 
+            // Create field path
             const cheminA = [...chemin, fieldName]
             const cheminAstr = cheminA.join('.')
-    
-            // Sous-schema
-            if (field instanceof Schema) {
-    
-                // Initialise la structure pour permettre l'assignement d'outputSchema
-                if (outputSchema[fieldName] === undefined)
-                    outputSchema[fieldName] = {}
-
-                // The corresponding data should be an object
-                const schemadata = dataToValidate[fieldName];
-                if (typeof schemadata !== 'object') {
-                    erreurs[ cheminAstr ] = [`Should be an object`];
+            const valOrigine = dataToValidate[fieldName];
+
+            // Validation
+            try {
+
+                const val = validator.validate(valOrigine, opts, cheminA);
+
+                // Exclusion seulement si explicitement demandé
+                // IMPORTANT: Conserver les values undefined
+                //      La présence d'un valeur undefined peut être utile, par exemple, pour indiquer qu'on souhaite supprimer une donnée
+                //      Exemple: undefinec = suppression fichier | Absende donnée = conservation fihcier actuel
+                if (val === EXCLUDE_VALUE)
+                    opts.debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
+                else
+                    output[fieldName] = val;
+
+                opts.debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
+
+            } catch (error) {
+
+                opts.debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| CoreError:', error);
+
+                if (error instanceof InputErrorSchema) {
+
+                    erreurs = { ...erreurs, ...error.erreursSaisie };
+                    errorsCount += Object.keys(error.erreursSaisie).length;
+
+                } else if (error instanceof CoreError) {
+
+                    erreurs[cheminAstr] = [error.message]
+                    errorsCount++;
+
+                } else if (SERVER) {
+
+                    // Server: transmiss error & report bug
+                    throw error;
+
+                } else {
+
+                    erreurs[cheminAstr] = ["Technical error while validating data"];
                     errorsCount++;
-                    continue;
                 }
+            }
+        }
     
-                // Validate the data
-                const validationSchema = field.validate(
-
-                    schemadata,
-                    allData,
-                    output,
-
-                    opts,
-                    cheminA
-                );
-                erreurs = { ...erreurs, ...validationSchema.erreurs };
-                errorsCount += validationSchema.errorsCount;
-    
-                // Pas besoin d'assigner, car output est passé en référence
-                //output[fieldName] = validationSchema.values;
+        if (errorsCount !== 0)
+            throw new InputErrorSchema(erreurs);
+        
+        opts.debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
     
+        return output as TValidatedData<TFields>;
+    }
+
+    public validateWithDetails<TDonnees extends TObjetDonnees>(
     
-            // I don't remind what is options.activer about
-            /*} else if (field.activer !== undefined && field.activer(allData) === false) {
+        dataToValidate: Partial<TDonnees>,
+        allData: TDonnees,
+        output: TObjetDonnees = {},
     
-                delete outputSchema[fieldName];*/
+        opts: TValidateOptions<TFields> = {},
+        chemin: string[] = []
     
-            // Validator
+    ): TValidationResult<TFields> {
+
+        let erreurs: TListeErreursSaisie = {};
+        let errorsCount = 0;
+
+        try {
+            this.validate(dataToValidate, opts, chemin);
+        } catch (error) {
+            if (error instanceof InputErrorSchema) {
+                erreurs = error.erreursSaisie;
+                errorsCount = Object.keys(erreurs).length;
             } else {
-    
-                // Champ composé de plusieurs values
-                const valOrigine = field.options.as === undefined
-                    ? dataToValidate[fieldName]
-                    // Le fieldName regroupe plusieurs values (ex: Periode)
-                    : field.options.as.map((nomVal: string) => dataToValidate[nomVal])
-    
-                // Validation
-                try {
-    
-                    const val = field.validate(valOrigine, allData, output, opts);
-    
-                    // Exclusion seulement si explicitement demandé
-                    // IMPORTANT: Conserver les values undefined
-                    //      La présence d'un valeur undefined peut être utile, par exemple, pour indiquer qu'on souhaite supprimer une donnée
-                    //      Exemple: undefinec = suppression fichier | Absende donnée = conservation fihcier actuel
-                    if (val === EXCLUDE_VALUE)
-                        opts.debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
-                    else
-                        outputSchema[fieldName] = val;
-    
-                    opts.debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
-    
-                } catch (error) {
-    
-                    opts.debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| CoreError:', error);
-    
-                    if (error instanceof CoreError) {
-    
-                        // Référencement erreur
-                        erreurs[cheminAstr] = [error.message]
-                        errorsCount++;
-    
-                    } else
-                        throw error;
-                }
+                throw error;
             }
         }
-    
-        if (errorsCount !== 0 && opts.throwError === true) {
-            throw new InputErrorSchema(erreurs);
-        }
-        
-        opts.debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
-    
+
         return { 
             values: output as TValidatedData<TFields>,
             erreurs, 
             errorsCount, 
         };
-    
     }
 }

package/src/common/validation/validator.ts

@@ -28,7 +28,6 @@ export type TValidator<TValue> = {
     dependances?: string[],
     opt?: true,
     defaut?: TValue,
-    as?: string[], // Mapping personnalisé
 
 }
 
@@ -40,9 +39,8 @@ type TValidationArgs<TValue, TAllValues extends {}> = [
     // For the value given as input in the validation function,
     //  Only the empty values were escluded
     val: TNonEmptyValue, 
-    input: TAllValues, 
-    output: Partial<TAllValues>, 
-    validateOptions?: TValidateOptions
+    validateOptions: TValidateOptions,
+    path: string[]
 ]
 
 type TValidationFunction<TValue, TAllValues extends {} = {}> = (
@@ -87,7 +85,7 @@ export default class Validator<
     public isEmpty = (val: any) => val === undefined || val === '' || val === null
 
     public validate(...[ 
-        val, input, output, validateOptions 
+        val, validateOptions, path
     ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
 
         // Required value
@@ -105,7 +103,7 @@ export default class Validator<
         }
 
         // Validate type
-        return this.validateType(val, input, output, validateOptions) as TValidateReturnType<TOptions, TValue>;
+        return this.validateType(val, validateOptions, path) as TValidateReturnType<TOptions, TValue>;
     }
 
 }

package/src/common/validation/validators.ts

@@ -17,7 +17,7 @@ import { InputError } from '@common/errors';
 import FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
 // Speciific
-import Schema from './schema'
+import Schema, { TSchemaFields } from './schema'
 import Validator, { TValidator } from './validator'
 
 // Components
@@ -32,6 +32,10 @@ export type TFileValidator = TValidator<FileToUpload> & {
     taille?: number
 }
 
+type TSchemaSubtype = Schema<{}> | TSchemaFields;
+
+type TSubtype = TSchemaSubtype | Validator<any>;
+
 /*----------------------------------
 - CONST
 ----------------------------------*/
@@ -48,30 +52,35 @@ export default class SchemaValidators {
     /*----------------------------------
     - CONTENEURS
     ----------------------------------*/
-    public object = ({ ...opts }: TValidator<object> & {} = {}) => 
-        new Validator<object>('object', (val, input, output) => {
+    public object = ( subtype?: TSchemaSubtype, { ...opts }: TValidator<object> & {
 
-            // 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.');
-                }*/
+    } = {}) => 
+        new Validator<object>('object', (val, options, path) => {
 
+            // The value should be an object
             if (typeof val !== 'object' || val.constructor !== Object)
                 throw new InputError("This value must be an object.");
 
-            return val;
+            // If no subtype, return the object as is
+            if (subtype === undefined)
+                return val;
+
+            // If subtype is a schema
+            const schema = subtype.constructor === Object 
+                ? new Schema(subtype as TSchemaFields) 
+                : subtype as Schema<{}>;
+
+            // Validate schema
+            const value = schema.validate(val, options, path);
+            
+            return value;
         }, opts)
 
-    public array = ( subtype?: Validator<any> | Schema<{}>, { 
-        choice, min, max, ...opts 
-    }: TValidator<any[]> & {
+    public array = ( subtype: TSubtype, { choice, min, max, ...opts }: TValidator<any[]> & {
         choice?: any[],
         min?: number, 
         max?: number
-    } = {}) => new Validator<any[]>('array', (items, input, output, corriger) => {
+    } = {}) => new Validator<any[]>('array', (items, options, path) => {
 
         // Type
         if (!Array.isArray(items))
@@ -84,32 +93,26 @@ export default class SchemaValidators {
             throw new InputError(`Please select maximum ${max} items.`);
 
         // Verif each item
-        if (subtype !== undefined) {
-            if (subtype instanceof Schema) {
+        if (subtype === undefined)
+            return items;
 
-                items = items.map( item =>
-                    subtype.validate( item, item, item, { }, []).values
-                )
+        const validator = subtype.constructor === Object
+            ? new Schema(subtype as TSchemaFields)
+            : subtype as Schema<{}> | Validator<any>;
 
-            } else {
-
-                items = items.map( item =>
-                    subtype.validate( item, items, items, corriger )
-                )
-
-            }
-        }
+        items = items.map( item =>
+            validator.validate( item, options, path )
+        )
 
         return items;
     }, {
         ...opts,
         //multiple: true, // Sélection multiple
-        //subtype
     })
 
     public choice = (choices?: any[], { multiple, ...opts }: TValidator<any> & { 
         multiple?: boolean 
-    } = {}) => new Validator<any>('choice', (val, input, output) => {
+    } = {}) => new Validator<any>('choice', (val, options, path) => {
 
         // Empty array = undefined if not required
         if (val.length === 0 && opts.opt)
@@ -145,11 +148,11 @@ export default class SchemaValidators {
     /*----------------------------------
     - CHAINES
     ----------------------------------*/
-    public string = ({ min, max, include, ...opts }: TValidator<string> & { 
+    public string = ({ min, max, in: choices, ...opts }: TValidator<string> & { 
         min?: number, 
         max?: number,
-        include?: string
-    } = {}) => new Validator<string>('string', (val, input, output, corriger?: boolean) => {
+        in?: string[]
+    } = {}) => new Validator<string>('string', (val, options, path) => {
 
         // Check type
         if (val === '')
@@ -162,13 +165,17 @@ export default class SchemaValidators {
         // Whitespace
         val = trim(val);
 
+        // In
+        if (choices !== undefined && !choices.includes(val))
+            throw new InputError(`Invalid value: ${val}. Must be one of: ${choices.join(', ')}`);
+
         // Min size
         if (min !== undefined && val.length < min)
             throw new InputError(`Must be at least ` + min + ' characters');
 
         // Max size
         if (max !== undefined && val.length > max)
-            if (corriger)
+            if (options?.autoCorrect)
                 val = val.substring(0, max);
             else
                 throw new InputError(`Must be up to ` + max + ' characters');
@@ -180,9 +187,9 @@ export default class SchemaValidators {
     public url = (opts: TValidator<string> & {
         normalize?: NormalizeUrlOptions
     } = {}) => 
-        new Validator<string>('url', (inputVal, input, output, corriger?) => {
+        new Validator<string>('url', (inputVal, options, path) => {
 
-            let val = this.string(opts).validate(inputVal, input, output, corriger);
+            let val = this.string(opts).validate(inputVal, options, path);
 
             // Check if URL
             if (!isURL(val, {
@@ -198,9 +205,9 @@ export default class SchemaValidators {
         }, opts)
 
     public email = (opts: TValidator<string> & {} = {}) => 
-        new Validator<string>('email', (inputVal, input, output, corriger?: boolean) => {
+        new Validator<string>('email', (inputVal, options, path) => {
 
-            let val = this.string(opts).validate(inputVal, input, output, corriger);
+            let val = this.string(opts).validate(inputVal, options, path);
 
             if (!isEmail(val))
                 throw new InputError("Please enter a valid email address.");
@@ -239,41 +246,36 @@ export default class SchemaValidators {
         min?: number,
         max?: number,
         step?: 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) {
+    } = {}) => new Validator<number>('number', (val, options, path) => {
 
-            // 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);
+        // 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 (options?.autoCorrect)
+                val = opts.min;
+            else
+                throw new InputError("This value must be a number.");
+        }
 
-            // Maximum
-            if (opts.max !== undefined && val > opts.max)
-                if (corriger)
-                    val = opts.max;
-                else
-                    throw new InputError(`Must be up to ` + opts.max);
+        // Minimum
+        if (val < opts.min)
+            if (options?.autoCorrect)
+                val = opts.min;
+            else
+                throw new InputError(`Must be at least ` + opts.min);
 
-        }
+        // Maximum
+        if (opts.max !== undefined && val > opts.max)
+            if (options?.autoCorrect)
+                val = opts.max;
+            else
+                throw new InputError(`Must be up to ` + opts.max);
 
         return val;
     }, {
@@ -288,7 +290,7 @@ export default class SchemaValidators {
     public float = this.number(true) 
 
     public bool = (opts: TValidator<boolean> & {} = {}) => 
-        new Validator<boolean>('bool', (val, input, output) => {
+        new Validator<boolean>('bool', (val, options, path) => {
 
             if (typeof val !== 'boolean' && !['true', 'false'].includes(val))
                 throw new InputError("This value must be a boolean.");
@@ -306,7 +308,7 @@ export default class SchemaValidators {
     ----------------------------------*/
     public date = (opts: TValidator<Date> & {
 
-    } = {}) => new Validator<Date>('date', (val, input, output) => {
+    } = {}) => new Validator<Date>('date', (val, options, path) => {
 
         const chaine = typeof val == 'string';
 

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() {