5htp-core 0.1.2 → 0.2.1

package/src/common/router/{response.ts → response/index.ts}

@@ -6,30 +6,26 @@
 import { FunctionalComponent } from "preact";
 
 // Core
-import { TRoute } from ".";
-import BaseRequest from './request';
-import { TClientRoute, TFrontRenderer } from '@client/router';
-import PageResponse from './response/page';
-import { ClientContext } from '@client/context';
+import { TRoute } from "..";
+import type ClientRequest from '@client/services/router';
+import Page from '@client/services/router/response/page'
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export { default as PageResponse } from './response/page';
-
-export type TResponseData = PageResponse | unknown
+type TResponseData = Page
 
 /*----------------------------------
 - CONTEXT
 ----------------------------------*/
 export default abstract class BaseResponse<
-    TData extends TResponseData = TResponseData,
-    TRequest extends BaseRequest = BaseRequest
+    TData extends TResponseData = Page,
+    TRequest extends ClientRequest = ClientRequest
 > {
 
-    public data?: any;
-    public request: With<TRequest, 'response'>;
+    public data?: TData;
+    public request: TRequest;
     public route?: TRoute;
 
     public constructor(
@@ -37,7 +33,7 @@ export default abstract class BaseResponse<
     ) {
         // ServerResponse et ClientResponse assignent request.response
         request.response = this;
-        this.request = request as With<TRequest, 'response'>;
+        this.request = request as TRequest;
     }
 
     public setRoute(route: TRoute) {

package/src/common/router/response/page.ts

@@ -2,19 +2,38 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import type { ComponentChild } from 'preact';
+import type { ComponentChild, FunctionComponent } from 'preact';
 
 // Core libs
-import { TClientRoute, TFrontRenderer } from '@client/router';
-import { TFetcherList } from '@common/router/request';
-import { history } from '@client/router/request/history';
-import { ClientContext } from '@client/context';
+import { ClientOrServerRouter, TClientOrServerContext } from '@common/router';
+import { TFetcherList, TDataReturnedByFetchers } from '@common/router/request/api';
+import { history } from '@client/services/router/request/history';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TResource = {
+// The function that fetch data from the api before to pass them as context to the renderer
+export type TDataProvider<TProvidedData extends TFetcherList = {}> = 
+    (context: TClientOrServerContext/* & TUrlData */) => TProvidedData
+
+
+
+// The function that renders routes
+export type TFrontRenderer<
+    TProvidedData extends TFetcherList = {}, 
+    TAdditionnalData = {},
+    TRouter = ClientOrServerRouter,
+> = FunctionComponent<(
+    TClientOrServerContext 
+    & 
+    TDataReturnedByFetchers<TProvidedData>
+    &
+    TAdditionnalData
+)>;
+
+// Script or CSS resource
+export type TPageResource = {
     id: string,
     attrs?: TObjetDonnees
 } & ({
@@ -27,70 +46,43 @@ type TResource = {
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export default class PageResponse {
-
-    // Render
-    public id: string;
-    public data: TObjetDonnees = {};
-    public loading: ComponentChild = false;
-    public component: TFrontRenderer;
+export default class PageResponse<TRouter extends ClientOrServerRouter = ClientOrServerRouter> {
 
     // Metadata
+    public chunkId: string;
     public title?: string;
     public description?: string;
     public bodyClass: Set<string> = new Set<string>();
     public bodyId?: string;
 
-    // resources
+    // Resources
     public amp?: boolean;
-    public scripts: TResource[] = [];
-    public style: TResource[] = [];
-
-    // State
-    public hash?: string; // Element id to scroll to
-
-    public constructor( 
-        public context: ClientContext,
-        public route: TClientRoute,
-        data: TObjetDonnees = {},
-    ) {
-        this.id = route.options.id; // Binded by the pages babel plugin
-        this.bodyId = route.options.bodyId;
-        this.component = route.renderer;
-        this.data = data;
-        this.hash = context.request.hash;
-    }
+    public scripts: TPageResource[] = [];
+    public style: TPageResource[] = [];
 
-    // API data fetchers
+    // Data
     public fetchers: TFetcherList = {};
+    public data: TObjetDonnees = {};
 
-    // Should be called AFTER rendering the page
-    public updateClient() {
+    public constructor(
+        public dataProvider: TDataProvider | null,
+        public renderer: TFrontRenderer,
+        public context: TClientOrServerContext
+    ) {
 
-        document.body.id = this.bodyId || this.id;
-        document.title = this.title || APP_NAME;
-        document.body.className = [...this.bodyClass].join(' ');
-        
+        this.chunkId = context.route.options["id"];
+       
     }
     
-
     public async fetchData() {
-        this.isDataLoaded = true;
-        this.data = await this.context.request.fetchSync(this.fetchers);
-        return this.data;
-    }
 
-    public setAllData( callback: (data: {[k: string]: any}) => void) { 
-        console.warn(`page.setAllData not yet attached to the page Reatc component.`); 
-    }
-    public setData( key: string, value: ((value: any) => void) | any ) {
-        this.setAllData(old => ({ 
-            ...old, 
-            [key]: typeof value === 'function' ? value(old[key]) : value 
-        }));
-    }
+        // Load the fetchers list to load data if needed
+        if (this.dataProvider)
+            this.fetchers = this.dataProvider({ ...this.context, ...this.context.request.data });
 
-    public go( url: string ) {
-        history?.replace(url);
+        // Execute the fetchers for missing data
+        console.log(`[router][page] Fetching api data:` + Object.keys(this.fetchers));
+        this.data = await this.context.request.api.fetchSync( this.fetchers, this.data );
+        return this.data;
     }
 }

package/src/common/validation/index.ts

@@ -0,0 +1,3 @@
+export { default as Schema } from './schema';
+export { default as Validators } from './validators';
+export { default as Validator } from './validator';

package/src/common/validation/schema.ts

@@ -0,0 +1,185 @@
+/*----------------------------------
+- 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> = {
+    // For each field, the values returned by validator.validate()
+    [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,95 @@
+/*----------------------------------
+- 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;
+
+type TValidateReturnType<
+    TOptions extends TValidator<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 TValidator<TValue> = TValidator<TValue>> {
+
+    public constructor( 
+        public type: string,
+        public validateType: TValidationFunction<TValue>, 
+        public options: TOptions
+    ) {
+
+    }
+
+    public isEmpty = (val: any) => val === undefined || val === '' || val === null
+
+    public validate(...[ val, input, output, correct ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
+
+        // Required value
+        if (this.isEmpty(val)) {
+            // Optionnel, on skip
+            if (this.options.opt === true)
+                return undefined as TValidateReturnType<TOptions, TValue>;
+            // Requis
+            else
+                throw new InputError("Please enter a value");
+        }
+
+        // Validate type
+        return this.validateType(val, input, output, correct) as TValidateReturnType<TOptions, TValue>;
+    }
+
+}