5htp-core 0.3.8 → 0.3.9

package/package.json

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

package/src/client/assets/css/components/button.less

@@ -25,7 +25,7 @@
 
     // Text
     text-decoration: none;
-    font-weight: 600;
+    font-weight: 500;
 
     // Colors
     background: var(--cBg);
@@ -90,12 +90,6 @@
 
     }
 
-    > .pastille {
-        position: absolute;
-        right: 10px;
-        bottom: 10px;
-    }
-
     /*----------------------------------
     - THEME
     ----------------------------------*/
@@ -230,9 +224,12 @@ ul.row {
             color: var(--cTxtImportant);
         }
 
-        // All the list items label must be aligned
         > .label {
+            // All the list items label must be aligned
             justify-content: flex-start;
+            // Since they're all horizontally aligned,
+            // Label = max width, so icon right are also aligned to right
+            flex: 1;
         }
 
         &.icon {
@@ -244,8 +241,7 @@ ul.row {
                 display: none;
                 position: absolute;
                 
-                background: fade(@cDark, 90%);
-                backdrop-filter: blur(20px) saturate(180%);
+                background: #111;
                 
                 height: @sizeComponent;
                 line-height: @sizeComponent;

package/src/client/assets/css/components/card.less

@@ -77,7 +77,7 @@
         }
     }
 
-    &.selected {
+    &.active {
 
         box-shadow: 0 0 0 3px @c1;
 
@@ -86,12 +86,6 @@
         }
     }
 
-    &.minimal {
-        background:transparent;
-        box-shadow: none;
-        border: solid 1px var(--cLine);
-    }
-
     /*----------------------------------
     - VARIANTS
     ----------------------------------*/

package/src/client/assets/css/text/icons.less

@@ -33,11 +33,14 @@ i {
 
     &.solid {
         color: var(--cAccent2);
-
-        width: @sizeComponent;
-        flex: 0 0 @sizeComponent;
-        height: @sizeComponent;
-        line-height: @sizeComponent;
+        background: var(--cBg);
+        border-radius: @radius;
+
+        // Normla size must fit inside a normal fit element
+        width: @sizeComponent * 0.75;
+        flex: 0 0 @sizeComponent * 0.75;
+        height: @sizeComponent * 0.75;
+        line-height: @sizeComponent * 0.75;
         //font-size: 0.9em;
     }
 

package/src/client/assets/css/text/text.less

@@ -103,8 +103,7 @@ strong {
     }
 }
 
-strong.number,
-header > strong {
+strong.number {
     //font-family: 'Montserrat';
     font-size: 1.3em;
     line-height: 1em;
@@ -181,7 +180,7 @@ pre {
 
     h2, h3, h4 {
         text-align: left;
-        margin: @spacing * 2 0;
+        margin: 1em 0;
     }
 
     h2 {

package/src/client/assets/css/theme.less

@@ -32,7 +32,7 @@
     // Flags
     @bg: @theme[background];
     @bgActive: if( @isLight, 
-        @bg - #111, 
+        @bg - #040404, 
         @bg + #111, 
     );
     @fg: @theme[foreground];

package/src/client/assets/css/utils/layouts.less

@@ -37,6 +37,10 @@
         > * {
             min-width: fit-content;
         }
+
+        &.menu {
+            min-height: @sizeComponent;
+        }
     }
 
     // Avec justify-content: center, les premiers élements sont cachés

package/src/client/components/Form.ts

@@ -109,7 +109,7 @@ export default function useForm<TFormData extends {}>(
     ----------------------------------*/
     const validate = (allData: Partial<TFormData> = data, validateAll: boolean = true) => {
 
-        const validated = schema.validate(allData, allData, {}, {
+        const validated = schema.validateWithDetails(allData, allData, {}, {
             // Ignore the fields where the vlaue has not been changed
             //  if the validation was triggered via onChange
             ignoreMissing: !validateAll,
@@ -138,6 +138,7 @@ export default function useForm<TFormData extends {}>(
             context.app.handleError(
                 new InputError("You have " + validated.errorsCount + " errors in the form.")
             );
+            console.log("validated", validated.erreurs);
             return;
         }
 

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

@@ -5,10 +5,11 @@
 // Npm
 import React from 'react';
 
+// Cpre
+import { Button } from '@client/components';
+
 // Specific
-import type { 
-    Choice,
-} from './ChoiceSelector';
+import type { Choice } from './ChoiceSelector';
 
 import type { Props } from '.';
 
@@ -19,10 +20,11 @@ import type { Props } from '.';
 /*----------------------------------
 - COMPONENT
 ----------------------------------*/
-export default ({ choice, currentList, onChange, multiple, includeCurrent }: {
+export default ({ choice, currentList, onChange, multiple, includeCurrent, format = 'badge' }: {
     choice: Choice,
     currentList: Choice[],
-    includeCurrent: boolean
+    includeCurrent?: boolean,
+    format?: 'list' | 'badge'
 } & Pick<Props, 'onChange'|'multiple'>) => {
 
     const isCurrent = currentList.some(c => c.value === choice.value);
@@ -30,7 +32,19 @@ export default ({ choice, currentList, onChange, multiple, includeCurrent }: {
 
     const showRemoveButton = multiple;
 
-    return isCurrent ? (
+    return format === 'list' ? (
+        <li>
+            <Button icon={isCurrent ? 'check-circle' : undefined} onClick={() => onChange( current => multiple 
+                ? (isCurrent 
+                    ? currentList.filter(item => item.value !== choice.value) 
+                    : [...(current || []), choice]
+                )
+                : isCurrent ? undefined : choice
+            )}>
+                {choice.label} 
+            </Button>
+        </li>
+    ) : isCurrent ? (
         <li class={"badge bg primary"+  (showRemoveButton ? ' pdr-05' : '')}>
             {choice.label}
 

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

@@ -25,14 +25,14 @@ type ChoicesFunc = (search: string) => Promise<Choices>
 export type Props = (
     {
         multiple: true,
-        value?: Choice[],
+        value?: Choice[] | Choice["value"][],
         onChange: StateUpdater<Choice[]>,
         validator?: ArrayValidator
     }
     |
     {
         multiple?: false,
-        value?: Choice,
+        value?: Choice | Choice["value"],
         onChange: StateUpdater<Choice>,
         validator?: StringValidator
     }
@@ -53,6 +53,7 @@ export type Props = (
     - we don't want the selector to be rendered before the dropdown content is dhown
     - this component is called multiple time
 */
+// ! OBSOLETE
 export default React.forwardRef<HTMLDivElement, Props>(({
     choices: initChoices, 
     validator, 

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

@@ -29,6 +29,25 @@ export type Props = DropdownProps & SelectorProps & {
 
 export type { Choice } from './ChoiceSelector';
 
+const ensureChoice = (choice: Choice | string, choices: Choice[]): Choice => {
+
+    // Allready a choice
+    if (typeof choice === 'object' && choice.label) {
+        return choice;
+    }
+
+    // Find the choice
+    const found = choices.find( c => c.value === choice);
+    if (found)
+        return found;
+
+    // Create a new choice
+    return {
+        label: choice,
+        value: choice
+    }
+}
+
 /*----------------------------------
 - COMONENT
 ----------------------------------*/
@@ -95,8 +114,8 @@ export default ({
     const currentList: Choice[] = current === undefined
         ? []
         : (Array.isArray(current) 
-            ? current 
-            : [current]
+            ? current.map( c => ensureChoice(c, choices))
+            : [ensureChoice(current, choices)]
         );
 
     /*----------------------------------
@@ -121,14 +140,7 @@ export default ({
     - RENDER
     ----------------------------------*/
 
-    const SelectedItems = ( enableSearch ? currentList : choices ).map( choice => (
-        <ChoiceElement choice={choice} 
-            currentList={currentList}
-            onChange={onChange}
-            multiple={multiple}
-            includeCurrent 
-        />
-    ))
+    const selectedItems = enableSearch ? currentList : choices
 
     const Search = enableSearch && (
         <Input  
@@ -145,7 +157,7 @@ export default ({
             overflowY: 'auto'
         }}>
             {choices.map( choice => (
-                <ChoiceElement choice={choice} 
+                <ChoiceElement format='badge' choice={choice} 
                     currentList={currentList}
                     onChange={onChange}
                     multiple={multiple}
@@ -156,14 +168,21 @@ export default ({
 
     return dropdown ? (
         <Popover content={(
-            <div class="card col" style={{ width: '300px' }}>
+            <div class="card col" style={{ width: '200px' }}>
 
                 <div class="col">
 
-                    {SelectedItems.length !== 0 && (
-                        <div class="row wrap">
-                            {SelectedItems}
-                        </div>
+                    {selectedItems.length !== 0 && (
+                        <ul class="menu col">
+                            {selectedItems.map( choice => (
+                                <ChoiceElement format='list' choice={choice} 
+                                    currentList={currentList}
+                                    onChange={onChange}
+                                    multiple={multiple}
+                                    includeCurrent 
+                                />
+                            ))} 
+                        </ul>
                     )}
 
                     {Search} 
@@ -173,10 +192,15 @@ export default ({
             </div>
         )} state={popoverState}>
             <Button icon={icon} iconR="chevron-down" {...otherProps}>
-                {title} {(multiple && currentList.length > 0) 
-                    ? <span class="badge s bg accent">{currentList.length}</span> 
-                    : null
-                }
+
+                {currentList.length === 0 ? <>
+                    {title}
+                </> : multiple ? <>
+                    {title} <span class="badge s bg accent">{currentList.length}</span> 
+                </> : <>
+                    {currentList[0].label}
+                </>}
+
             </Button>
         </Popover>
     ) : (
@@ -197,7 +221,15 @@ export default ({
                         )}</label>
 
                         <div class="row al-left wrap sp-05">
-                            {SelectedItems} 
+
+                            {selectedItems.map( choice => (
+                                <ChoiceElement format='badge' choice={choice} 
+                                    currentList={currentList}
+                                    onChange={onChange}
+                                    multiple={multiple}
+                                    includeCurrent 
+                                />
+                            ))} 
 
                             {Search}  
                         </div>

package/src/client/components/containers/Popover/index.tsx

@@ -21,7 +21,7 @@ export type Props = JSX.HTMLAttributes<HTMLDivElement> & {
 
     // Display
     content?: JSX.Element,
-    state: [boolean, StateUpdater<boolean>],
+    state?: [boolean, StateUpdater<boolean>],
     width?: number | string,
     disable?: boolean
     // Position
@@ -58,6 +58,9 @@ export default (props: Props) => {
     const refCont = React.useRef<HTMLElement>(null);
     const refContent = React.useRef<HTMLElement>(null);
 
+    if (state === undefined)
+        state = React.useState(false);
+
     const [shown, show] = state;
 
     // Màj visibilite

package/src/client/components/data/Time.tsx

@@ -4,36 +4,40 @@
 
 // Npm
 import React from 'react';
+import { ComponentChild } from 'preact';
 
 // Libs
-import { timeSince } from '@common/data/dates';
+import { timeSince, TDateInfo } from '@common/data/dates';
 
 /*----------------------------------
-- TYPES: IMPORTATIONS
+- TYPES
 ----------------------------------*/
+export type { TDateInfo } from '@common/data/dates';
 
-
-
-/*----------------------------------
-- TYPES: DECLARATIONS
-----------------------------------*/
+export const interval = {
+    day: 24 * 60 * 60,
+    hour: 60 * 60,
+    minute: 60,
+    second: 1
+}
 
 /*----------------------------------
 - COMPOSANT
 ----------------------------------*/
-export default ({ since }: {
-    since: Parameters<typeof timeSince>[0]
+export default ({ since, render }: {
+    since: Parameters<typeof timeSince>[0],
+    render?: (dateInfo: TDateInfo) => ComponentChild
 }) => {
 
-    const [text, setDisplay] = React.useState(timeSince(since));
+    const [time, setTime] = React.useState<TDateInfo | null>( timeSince(since) );
 
     React.useEffect(() => {
 
-        const textUpdate = setInterval(() => setDisplay(timeSince(since)), 10000);
+        const textUpdate = setInterval(() => setTime(timeSince(since)), 10000);
         return () => clearInterval(textUpdate);
 
     }, []);
 
-    return <>{text}</>;
+    return <>{time === null ? "?" : render ? render(time) : time.text}</>;
 
 }

package/src/client/components/inputv3/base.tsx

@@ -18,6 +18,7 @@ export type InputBaseProps<TValue> = {
     title: string, // Now mandatory
     required?: boolean,
     errors?: string[],
+    size?: TComponentSize,
 
     value: TValue,
     onChange?: (value: TValue) => void,

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

@@ -44,7 +44,7 @@ export type Props = {
 ----------------------------------*/
 export default ({ 
     // Decoration
-    icon, prefix, suffix, iconR, required,
+    icon, prefix, suffix, iconR, required, size,
     // State
     inputRef, errors,
     // Behavior
@@ -142,6 +142,8 @@ export default ({
         className += ' empty';
     if (focus)
         className += ' focus';
+    if (size !== undefined)
+        className += ' ' + size;
     if (errors?.length)
         className += ' error';
 

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

@@ -85,13 +85,8 @@ export default ({ service: clientRouter }: { service?: ClientRouter }) => {
         // WARNING: Don"t try to play with pages here, since the object will not be updated
         //  If needed to play with pages, do it in the setPages callback below
         // Unchanged path
-        if (request.path === currentRequest.path) {
-
-            // Scroll to component
-            if (request.hash) {
-                scrollToElement(request.hash);
-            }
-
+        if (request.path === currentRequest.path && request.hash !== currentRequest.hash) {
+            scrollToElement(request.hash);
             return;
         }
         
@@ -110,7 +105,14 @@ export default ({ service: clientRouter }: { service?: ClientRouter }) => {
         }
 
         // Fetch API data to hydrate the page
-        const newData = await newpage.fetchData();
+        let newData;
+        try {
+            newData = await newpage.fetchData();
+        } catch (error) {
+            console.error(LogPrefix, "Unable to fetch data:", error);
+            clientRouter.setLoading(false);
+            return;
+        }
 
         // Add page container
         setPages( pages => {

package/src/client/services/router/request/api.ts

@@ -163,7 +163,7 @@ export default class ApiClient implements ApiClientService {
 
                 return data;
 
-            });
+            })
 
         // Errors will be catched in the caller
 
@@ -229,14 +229,20 @@ export default class ApiClient implements ApiClientService {
     
             })
             .catch((e: AxiosError) => {
-    
+
                 if (e.response !== undefined) {
     
+                    // Transmiss error
                     console.warn(`[api] Failure:`, e);
-                    throw viaHttpCode(
+                    const error = viaHttpCode(
                         e.response.status || 500,
                         e.response.data
                     );
+
+                    // API Error hook
+                    this.app.handleError(error, e.response.status);
+
+                    throw error;
     
                 // Erreur réseau: l'utilisateur n'ets probablement plus connecté à internet
                 } else {

package/src/common/data/dates.ts

@@ -5,19 +5,35 @@ const timeAgo = new TimeAgo('en-US')
 
 import dayjs from 'dayjs';
 
-export const timeSince = (date: Date | number | string) => {
+export type TDateInfo = {
+    isPast: boolean,
+    delta: number,
+    text: string
+}
+
+export const timeSince = (date: Date | number | string): TDateInfo | null => {
 
     if (date === undefined)
-        return 'Inconnu';
+        return null;
 
     // Timeago ne prend que des dates et des timestamp
     if (typeof date === 'string') {
         date = Date.parse(date);
         if (isNaN(date))
-            return "?";
+            return null;
     }
 
-    return timeAgo.format(date);
+    // Get metas
+    const now = Date.now()
+    const timestamp = date instanceof Date ? date.getTime() : date;
+    const deltaSeconds = Math.abs( Math.round( (now - timestamp) / 1000 ));
+    const isPast = now > timestamp;
+
+    return {
+        text: timeAgo.format(date),
+        isPast,
+        delta: deltaSeconds
+    };
 }
 
 export const tempsRelatif = (time: number, nbChiffresInit?: number) => {

package/src/common/data/objets.ts

@@ -117,4 +117,21 @@ export const chemin = {
         valA[ brancheVal ] = val;
         
     }
+}
+
+export const groupBy = <TObj extends TObjetDonnees>(
+    items: TObj[], 
+    key: keyof TObj
+): {[key: string]: TObj[]} => {
+    
+    const grouped: {[key: string]: TObj[]} = {};
+
+    for (const item of items) {
+        const  indexValue  = item[key] as any;
+        if (grouped[ indexValue ] === undefined)
+            grouped[ indexValue ] = [];
+        grouped[ indexValue ].push(item);
+    }
+
+    return grouped;
 }

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,10 +148,11 @@ export default class SchemaValidators {
     /*----------------------------------
     - CHAINES
     ----------------------------------*/
-    public string = ({ min, max, ...opts }: TValidator<string> & { 
+    public string = ({ min, max, in: choices, ...opts }: TValidator<string> & { 
         min?: number, 
-        max?: number 
-    } = {}) => new Validator<string>('string', (val, input, output, corriger?: boolean) => {
+        max?: number,
+        in?: string[]
+    } = {}) => new Validator<string>('string', (val, options, path) => {
 
         // Check type
         if (val === '')
@@ -161,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');
@@ -179,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, {
@@ -197,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.");
@@ -238,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;
     }, {
@@ -287,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.");
@@ -305,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/app/service/index.ts

@@ -58,7 +58,7 @@ export default abstract class Service<
     TConfig extends TServiceConfig, 
     THooks extends THooksList,
     TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex
+    TServicesIndex extends StartedServicesIndex = {}
 > {
 
     public started?: Promise<void>;

package/src/server/app.tsconfig.json

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

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

@@ -188,7 +188,9 @@ export default class DatabaseManager {
 
             const table = db[field.table];
             if (table === undefined) {
-                console.error("Field infos:", field);
+                // We don't throw error, sinc eit can be a virtual table
+                //console.error("Field infos:", field);
+                return next();
                 throw new Error(`Table metadatas for ${field.db}.${field.table} were not loaded.`);
             }
 

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

@@ -385,7 +385,7 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
 
         // Build query
         return this.database.query(`
-            UPDATE ${tableName} SET ${egalitesData} WHERE ${egalitesWhere};
+            UPDATE \`${tableName}\` SET ${egalitesData} WHERE ${egalitesWhere};
         `, opts);
 
     }
@@ -406,23 +406,37 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
     - OPERATIONS: INSERT
     ----------------------------------*/
 
-    public tryInsert = (table: string, data: TObjetDonnees) =>
+    public tryInsert = <TData extends TObjetDonnees>(table: string, data: TData | TData[]) =>
         this.insert(table, data, { try: true });
 
+    public async insert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData, 
+        opts?: TInsertQueryOptions<TData>
+    ): Promise<TData>;
+
+    public async insert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData[], 
+        opts?: TInsertQueryOptions<TData[]>
+    ): Promise<TData>;
+
     public async insert<TData extends TObjetDonnees>(
         path: string, 
         data: TData | TData[], 
         opts: TInsertQueryOptions<TData> = {}
-    ): Promise<OkPacket> {
+    ): Promise<TData | TData[]> {
 
         const table = this.database.getTable(path);
 
         // Normalize data
-        if (!Array.isArray(data))
+        let returnSingleResult = false;
+        if (!Array.isArray(data)) {
             data = [data];
-        else if (data.length === 0) {
+            returnSingleResult = true;
+        } else if (data.length === 0) {
             console.warn(LogPrefix, `Insert nothing in ${path}. Cancelled.`);
-            return emptyOkPacket;
+            return [];
         }
 
         // Upsert
@@ -449,28 +463,14 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
                 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];
+        
+        return returnSingleResult ? data[0] : data;
     }
 
     private buildInsertStatement<TData extends TObjetDonnees>(

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

@@ -0,0 +1,28 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+import type Application from "@server/app";
+
+import type SQL from "@server/services/database";
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class Model<TData extends {}> {
+
+    public abstract tableName: string;
+
+    public constructor( app: Application & { SQL: SQL }, private SQL = app.SQL) {
+
+    }
+
+    public async create( data: TData | TData[] ): Promise< TData | TData[] > {
+        return await this.SQL.insert( this.tableName, data );
+    }
+
+}

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

@@ -598,7 +598,10 @@ declare type Routes = {
             console.warn(e);
 
         if (request.accepts("html"))
-            await response.runController(route, { message: e.message });
+            await response.runController(route, { 
+                message: e.message,
+                type: e.constructor.name
+            });
         else if (request.accepts("json"))
             await response.json(e.message);
         else

package/src/server/services/schema/request.ts

@@ -47,17 +47,10 @@ export default class RequestValidator extends ServerSchemaValidator implements R
         const schema = fields instanceof Schema ? fields : new Schema(fields);
 
         // Les InputError seront propagées vers le middleware dédié à la gestion des erreurs
-        const { values } = schema.validate(
-            this.request.data, 
-            this.request.data, 
-            {}, 
-            {
-                debug: this.config.debug,
-                throwError: true,
-                validateDeps: false
-            },
-            []
-        );
+        const values = schema.validate( this.request.data, {
+            debug: this.config.debug,
+            validateDeps: false
+        }, []);
 
         return values;
     }