5htp-core 0.6.2 → 0.6.3

package/common/data/input/validate.ts

@@ -1,54 +0,0 @@
-// https://github.com/adonisjs/validator
-
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-/*----------------------------------
-- CONSTANTES
-----------------------------------*/
-
-const debug = false;
-
-/*----------------------------------
-- TYPES: DECLARATION SCHEMA
-----------------------------------*/
-
-//import type { Choix } from '@client/components/Champs/Base/Choix';
-
-
-/*----------------------------------
-- FONCTIONS
-----------------------------------*/
-export const isSchema = <TElem extends TSchema | TSchemaChampComplet>(elem: TElem): elem is TSchema => !('type' in elem)
-
-export const initDonnees = <TSchemaA extends TSchema>(
-    schema: TSchemaA,
-    donnees: TObjetDonnees,
-    toutConserver: boolean = false
-): Partial<TValidatedData<TSchemaA>> => {
-
-    // toutConserver = true: on conserve toutes les données, y compris celles n'étant pas été définies dans le schéma
-    let retour: Partial<TValidatedData<TSchemaA>> = toutConserver ? { ...donnees } : {}
-
-    for (const nomChamp in schema) {
-        const elem = schema[nomChamp];
-
-        // Sous-schema
-        if (isSchema(elem)) {
-
-            retour[nomChamp] = initDonnees(elem, donnees[nomChamp] || {}, toutConserver);
-
-            // Champ
-        } else if (elem.defaut !== undefined && donnees[nomChamp] === undefined) {
-
-            retour[nomChamp] = elem.defaut;
-
-        } else
-            retour[nomChamp] = donnees[nomChamp];
-    }
-
-    return retour;
-
-}
-
-export const validate = 

package/server/services/router/request/validation/index.ts

@@ -1,23 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-import type { TValidatorDefinition } from './validator';
-import type { SchemaValidators } from './validators';
-
-/*----------------------------------
-- EXPORT
-----------------------------------*/
-
-export { default as Schema } from './schema';
-export type { TSchemaFields, TValidatedData } from './schema';
-
-export const field = new Proxy<SchemaValidators>({} as SchemaValidators, {
-    get: (target, propKey) => {
-        return (...args: any[]) => ([ propKey, args ]);
-    }
-}) as unknown as {
-    [K in keyof SchemaValidators]: SchemaValidators[K] extends (...args: any[]) => any
-    ? (...args: Parameters<SchemaValidators[K]>) => TValidatorDefinition<K>
-    : SchemaValidators[K];
-};

package/server/services/router/request/validation/schema.ts

@@ -1,211 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Core
-import { CoreError, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
-
-// Specific
-import { default as Validator, EXCLUDE_VALUE, TValidatorDefinition } from './validator';
-import defaultValidators, { SchemaValidators, getFieldValidator } from './validators';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TSchemaFields = { 
-    [fieldName: string]: TSchemaFields | Schema<{}> | Validator<any> | TValidatorDefinition
-}
-
-type TSchemaOptions = {
-    opt?: boolean
-}
-
-export type TValidateOptions<TFields extends TSchemaFields = {}> = {
-    debug?: boolean,
-    throwError?: boolean,
-    ignoreMissing?: boolean,
-    only?: (keyof TFields)[],
-    validateDeps?: boolean,
-    autoCorrect?: boolean,
-    validators?: SchemaValidators
-}
-
-export type TValidationResult<TFields extends TSchemaFields> = {
-    values: TValidatedData<TFields>,
-    errorsCount: number,
-    erreurs: TListeErreursSaisie
-}
-
-export type TSchemaData<TSchema extends Schema<{}>> =
-    TValidationResult<TSchema["fields"]>
-
-export type TValidatedData<TFields extends TSchemaFields> = {
-    // For each field, the values returned by validator.validate()
-    [name in keyof TFields]: TFieldReturnType<TFields[name]>
-}
-
-type TFieldReturnType<TField> = TField extends TValidatorDefinition
-    ? TField[2]
-    : TField extends Schema<infer T>
-    ? TValidatedData<T>
-    : never
-
-/*----------------------------------
-- CONST
-----------------------------------*/
-
-const LogPrefix = '[schema][validator]';
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export default class Schema<TFields extends TSchemaFields> {
-
-    public constructor(
-        public fields: TFields,
-        public options: TSchemaOptions = {}
-    ) {
-
-    }
-
-    public getFieldValidator(
-        fieldName: string,
-        validators: SchemaValidators = defaultValidators
-    ): null | Validator<any> | Schema<{}> {
-
-        let field = this.fields[fieldName];
-        if (field === undefined) {
-
-            return null;
-
-        // TValidatorDefinition
-        } else
-            return getFieldValidator(field);
-    }
-
-    public validate<TDonnees extends TObjetDonnees>(
-        dataToValidate: Partial<TDonnees>,
-        opts: TValidateOptions<TFields> = {},
-        chemin: string[] = []
-    ): TValidatedData<TFields> {
-
-        const validators = opts.validators || defaultValidators;
-
-        // Check data type
-        if (typeof dataToValidate !== 'object')
-            throw new InputErrorSchema({ [chemin.join('.')]: ['Must be an object'] });
-    
-        // Default options
-        opts = {
-            debug: false,
-            throwError: true,
-            validateDeps: true,
-            autoCorrect: false,
-            ...opts,
-        }
-
-        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) {
-    
-            const validator = this.getFieldValidator(fieldName, validators);
-            if (validator === null) {
-                opts.debug && console.warn(LogPrefix, '[' + fieldName + ']', 'Exclusion (pas présent dans le schéma)');
-                continue;
-            }
-
-            // Create field path
-            const cheminA = [...chemin, fieldName]
-            const cheminAstr = cheminA.join('.')
-            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');
-                // Key not in the input data, we don't create an entry in the output
-                else if (fieldName in dataToValidate)
-                    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.errors };
-                    errorsCount += Object.keys(error.errors).length;
-
-                } else if (error instanceof CoreError) {
-
-                    erreurs[cheminAstr] = [error.message]
-                    errorsCount++;
-
-                } else if (SERVER) {
-
-                    // Server: transmiss error & report bug
-                    throw error;
-
-                } else {
-
-                    console.error(LogPrefix, '[' + cheminA + ']', error);
-                    erreurs[cheminAstr] = ["Technical error while validating data"];
-                    errorsCount++;
-                }
-            }
-        }
-    
-        if (errorsCount !== 0)
-            throw new InputErrorSchema(erreurs);
-        
-        opts.debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
-    
-        return output as TValidatedData<TFields>;
-    }
-
-    public validateWithDetails<TDonnees extends TObjetDonnees>(
-    
-        dataToValidate: Partial<TDonnees>,
-        allData: TDonnees,
-        output: TObjetDonnees = {},
-    
-        opts: TValidateOptions<TFields> = {},
-        chemin: string[] = []
-    
-    ): TValidationResult<TFields> {
-
-        let erreurs: TListeErreursSaisie = {};
-        let errorsCount = 0;
-
-        try {
-            this.validate(dataToValidate, opts, chemin);
-        } catch (error) {
-            if (error instanceof InputErrorSchema) {
-                erreurs = error.errors;
-                errorsCount = Object.keys(erreurs).length;
-            } else {
-                throw error;
-            }
-        }
-
-        return { 
-            values: output as TValidatedData<TFields>,
-            erreurs, 
-            errorsCount, 
-        };
-    }
-}

package/server/services/router/request/validation/validator.ts

@@ -1,117 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import type { ComponentChild } from 'preact'
-
-// Core
-import { InputError } from '@common/errors';
-
-// Specific
-import type { TValidateOptions } from './schema';
-import type { SchemaValidators } from './validators';
-import type { InputBaseProps } from '@client/components/utils';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TValidatorDefinition<K extends keyof SchemaValidators = keyof SchemaValidators> = [
-    type: string, 
-    args: any[], 
-    returnType: string
-]
-
-// TODO: remove
-export type TValidatorOptions<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
-
-    // Executé après le validateur propre au type
-    dependances?: string[],
-    opt?: true,
-    defaut?: TValue,
-
-}
-
-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, 
-    validateOptions: TValidateOptions,
-    path: string[]
-]
-
-type TValidationFunction<TValue, TAllValues extends {} = {}> = (
-    ...args: TValidationArgs<TValue, TAllValues>
-) => TValue | typeof EXCLUDE_VALUE;
-
-type TValidateReturnType<
-    TOptions extends TValidatorOptions<TValue>, 
-    TValue extends any
-> = TOptions extends { opt: true } 
-    ? (undefined | TValue) 
-    : TValue
-
-/*----------------------------------
-- CONST
-----------------------------------*/
-
-export const EXCLUDE_VALUE = "action:exclure" as const;
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export default class Validator<
-    TValue, 
-    TOptions extends TValidatorOptions<TValue> = TValidatorOptions<TValue>,
-    //TComponent = React.FunctionComponent< InputBaseProps< TValue > >
-> {
-
-    public constructor( 
-        public type: string,
-        public validateType: TValidationFunction<TValue>, 
-        public options: TOptions,
-        public componentAttributes: Partial<InputBaseProps<TValue>> = {}
-    ) {
-
-        // Basic component attriutes
-        this.componentAttributes.required = options?.opt !== true;
-        //this.componentAttributes.validator = this;
-
-    }
-
-    public isEmpty = (val: any) => val === undefined || val === '' || val === null
-
-    public validate(...[ 
-        val, validateOptions, path
-    ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
-
-        // Required value
-        if (this.isEmpty(val)) {
-            // Optionnel, on skip
-            if (this.options.opt === true || (
-                validateOptions?.ignoreMissing === true
-                &&
-                val === undefined
-            ))
-                return undefined as TValidateReturnType<TOptions, TValue>;
-            // Requis
-            else
-                throw new InputError("Please enter a value");
-        }
-
-        // Validate type
-        return this.validateType(val, validateOptions, path) as TValidateReturnType<TOptions, TValue>;
-    }
-
-}