5htp-core 0.1.2 → 0.2.0

package/src/common/validation/schema.ts

@@ -0,0 +1,184 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import { Erreur, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
+
+// Specific
+import { default as Validator, EXCLUDE_VALUE } from './validator';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TSchemaFields = { [fieldName: string]: Schema<{}> | Validator<any> }
+
+type TOptsValider = {
+    critique?: boolean,
+    validationComplete?: boolean,
+    avecDependances?: boolean,
+    corriger?: boolean,
+}
+
+export type TValidationResult<TFields extends TSchemaFields> = {
+    values: TValidatedData<TFields>,
+    nbErreurs: number,
+    erreurs: TListeErreursSaisie
+}
+
+export type TValidatedData<TFields extends TSchemaFields> = {
+    [name in keyof TFields]: ReturnType<TFields[name]["validate"]>
+}
+
+/*----------------------------------
+- CONST
+----------------------------------*/
+
+const debug = true;
+
+const LogPrefix = '[schema][validator]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class Schema<TFields extends TSchemaFields> {
+
+    public constructor(
+        public fields: TFields
+    ) {
+
+    }
+
+    public validate<TDonnees extends TObjetDonnees>(
+    
+        dataToValidate: Partial<TDonnees>,
+        allData: TDonnees,
+        output: TObjetDonnees = {},
+    
+        opts: TOptsValider = {},
+        chemin: string[] = []
+    
+    ): TValidationResult<TFields> {
+    
+        opts = {
+            critique: false,
+            validationComplete: false,
+            avecDependances: true,
+            corriger: false,
+            ...opts,
+        }
+    
+        const clesAvalider = Object.keys(opts.validationComplete === true ? this.fields : dataToValidate);
+    
+        let outputSchema = output;
+        for (const branche of chemin)
+            outputSchema = outputSchema[branche];
+    
+        // Validation de chacune d'entre elles
+        let erreurs: TListeErreursSaisie = {};
+        let nbErreurs = 0;
+        for (const champ of clesAvalider) {
+    
+            // La donnée est répertoriée dans le schema
+            const field = this.fields[champ];
+            if (field === undefined) {
+                debug && console.warn(LogPrefix, '[' + champ + ']', 'Exclusion (pas présent dans le schéma)');
+                continue;
+            }
+    
+            const cheminA = [...chemin, champ]
+            const cheminAstr = cheminA.join('.')
+    
+            // Sous-schema
+            if (field instanceof Schema) {
+    
+                // Initialise la structure pour permettre l'assignement d'outputSchema
+                if (outputSchema[champ] === undefined)
+                    outputSchema[champ] = {}
+
+                // The corresponding data should be an object
+                const schemadata = dataToValidate[champ];
+                if (typeof schemadata !== 'object') {
+                    erreurs[ cheminAstr ] = [`Should be an object`];
+                    nbErreurs++;
+                    continue;
+                }
+    
+                // Validate the data
+                const validationSchema = field.validate(
+
+                    schemadata,
+                    allData,
+                    output,
+
+                    opts,
+                    cheminA
+                );
+                erreurs = { ...erreurs, ...validationSchema.erreurs };
+                nbErreurs += validationSchema.nbErreurs;
+    
+                // Pas besoin d'assigner, car output est passé en référence
+                //output[champ] = validationSchema.values;
+    
+    
+            // I don't remind what is options.activer about
+            /*} else if (field.activer !== undefined && field.activer(allData) === false) {
+    
+                delete outputSchema[champ];*/
+    
+            // Validator
+            } else {
+    
+                // Champ composé de plusieurs values
+                const valOrigine = field.options.as === undefined
+                    ? dataToValidate[champ]
+                    // Le champ regroupe plusieurs values (ex: Periode)
+                    : field.options.as.map((nomVal: string) => dataToValidate[nomVal])
+    
+                // Validation
+                try {
+    
+                    const val = field.validate(valOrigine, allData, output, opts.corriger);
+    
+                    // 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)
+                        debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
+                    else
+                        outputSchema[champ] = val;
+    
+                    debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
+    
+                } catch (error) {
+    
+                    debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| Erreur:', error);
+    
+                    if (error instanceof Erreur) {
+    
+                        // Référencement erreur
+                        erreurs[cheminAstr] = [error.message]
+                        nbErreurs++;
+    
+                    } else
+                        throw error;
+                }
+            }
+        }
+    
+        if (nbErreurs !== 0 && opts.critique === true) {
+            throw new InputErrorSchema(erreurs);
+        }
+    
+        debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
+    
+        return { 
+            values: output as TValidatedData<TFields>,
+            erreurs, 
+            nbErreurs, 
+        };
+    
+    }
+}

package/src/common/validation/validator.ts

@@ -0,0 +1,88 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type { ComponentChild } from 'preact'
+
+// Core
+import { InputError } from '@common/errors';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TValidator<TValue> = {
+
+    rendu?: TFieldRenderer,
+
+    // I don't remind what is options.activer about
+    activer?: (donnees: TObjetDonnees) => boolean,
+    onglet?: string, // Sert juste d'identifiant secondaire. Ex: nom onglet correspondant
+
+    // Restrict to a specific set of values
+    in?: TValue[],
+
+    // Executé après le validateur propre au type
+    dependances?: string[],
+    opt?: true,
+    defaut?: TValue,
+    as?: string[], // Mapping personnalisé
+
+}
+
+export type TFieldRenderer = (props: any) => ComponentChild;
+
+type TNonEmptyValue = Exclude<any, undefined | '' | null>
+
+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>, 
+    corriger?: boolean
+]
+
+type TValidationFunction<TValue, TAllValues extends {} = {}> = (
+    ...args: TValidationArgs<TValue, TAllValues>
+    ) => TValue | typeof EXCLUDE_VALUE | undefined;
+
+/*----------------------------------
+- CONST
+----------------------------------*/
+
+export const EXCLUDE_VALUE = "action:exclure" as const;
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class Validator<TValue> {
+
+    public constructor( 
+        public type: string,
+        public validateType: TValidationFunction<TValue>, 
+        public options: TValidator<TValue>
+    ) {
+
+    }
+
+    public isEmpty = (val: any) => val === undefined || val === '' || val === null
+
+    public validate(...[ val, input, output, correct ]: TValidationArgs<TValue, {}>) {
+
+        // Required value
+        if (this.isEmpty(val)) {
+            // Optionnel, on skip
+            if (this.options.opt === true)
+                return undefined;
+            // Requis
+            else
+                throw new InputError("Please enter a value");
+        }
+
+        // Validate type
+        return this.validateType(val, input, output, correct);
+    }
+
+}

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',
         }
     }