5htp-core 0.1.2 → 0.2.1

package/src/common/data/input/validate.ts

@@ -24,53 +24,6 @@ const debug = false;
 
 //import type { Choix } from '@client/components/Champs/Base/Choix';
 
-export type TSchema = { [champ: string]: TSchema | TSchemaChampComplet }
-
-export type TSchemaChamp<TValeur> = {
-
-    rendu?: TBaseComposantChamp,
-    activer?: (donnees: TObjetDonnees) => boolean,
-    onglet?: string, // Sert juste d'identifiant secondaire. Ex: nom onglet correspondant
-
-    // Executé après le validateur propre au type
-    valider?: (val: TValeur, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => Promise<TValeur>,
-    dependances?: string[],
-    opt?: true,
-    defaut?: TValeur,
-    as?: string[], // Mapping personnalisé
-
-}
-
-export type TBaseComposantChamp = (props: any) => ComponentChild;
-
-export type TSchemaChampComplet<TValeur = unknown> = TSchemaChamp<TValeur> & {
-    type: string,
-    valider: (val: any, formData?: unknown) => Promise<TValeur | undefined>
-}
-
-/*----------------------------------
-- TYPES: VALIDATION SCHEMA
-----------------------------------*/
-type TOptsValider = {
-    critique?: boolean,
-    validationComplete?: boolean,
-    avecDependances?: boolean,
-    corriger?: boolean,
-}
-
-export type TDonneesValidees<TSchemaA extends TSchema> = {
-    [cle in keyof TSchemaA]: TSchemaA[cle]["type"] extends string
-    // Champ
-    ? ThenArg<ReturnType<TSchemaA[cle]["valider"]>>
-    // Schema
-    : TDonneesValidees<TSchemaA[cle]>
-}
-
-export type TRetourValidation<TSchemaA extends TSchema> = {
-    valeurs: TDonneesValidees<TSchemaA>,
-    nbErreurs: number,
-    erreurs: TListeErreursSaisie
-}
 
 /*----------------------------------
 - FONCTIONS
@@ -81,10 +34,10 @@ export const initDonnees = <TSchemaA extends TSchema>(
     schema: TSchemaA,
     donnees: TObjetDonnees,
     toutConserver: boolean = false
-): Partial<TDonneesValidees<TSchemaA>> => {
+): 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<TDonneesValidees<TSchemaA>> = toutConserver ? { ...donnees } : {}
+    let retour: Partial<TValidatedData<TSchemaA>> = toutConserver ? { ...donnees } : {}
 
     for (const nomChamp in schema) {
         const elem = schema[nomChamp];
@@ -107,120 +60,4 @@ export const initDonnees = <TSchemaA extends TSchema>(
 
 }
 
-export const validate = async <TSchemaA extends TSchema, TDonnees extends TObjetDonnees>(
-
-    schema: TSchemaA,
-
-    inputAvalider: Partial<TDonnees>,
-    inputComplet?: TDonnees,
-    output: TObjetDonnees = {},
-
-    opts: TOptsValider = {},
-    chemin: string[] = []
-
-): Promise<TRetourValidation<TSchemaA>> => {
-
-    opts = {
-        critique: false,
-        validationComplete: false,
-        avecDependances: true,
-        corriger: false,
-        ...opts,
-    }
-
-    const clesAvalider = Object.keys(opts.validationComplete === true ? schema : inputAvalider);
-
-    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 metas = schema[champ];
-        if (metas === undefined) {
-            debug && console.warn('[schema][valider][' + champ + ']', 'Exclusion (pas présent dans le schéma)');
-            continue;
-        }
-
-        const cheminA = [...chemin, champ].join('.')
-
-        // Sous-schema
-        if (isSchema(metas)) {
-
-            // Initialise la structure pour permettre l'assignement d'outputSchema
-            if (outputSchema[champ] === undefined)
-                outputSchema[champ] = {}
-
-            const validationSchema = await validate(
-                metas,
-                inputAvalider[champ],
-                inputComplet,
-                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.valeurs;
-
-
-
-        } else if (metas.activer !== undefined && metas.activer(inputComplet) === false) {
-
-            delete outputSchema[champ];
-
-        } else {
-
-            // Champ composé de plusieurs valeurs
-            const valOrigine = metas.as === undefined
-                ? inputAvalider[champ]
-                // Le champ regroupe plusieurs valeurs (ex: Periode)
-                : metas.as.map((nomVal: string) => inputAvalider[nomVal])
-
-            // Validation
-            try {
-
-                const val = await metas.valider(valOrigine, inputComplet, output, opts.corriger);
-
-                // Exclusion seulement si explicitement demandé
-                // IMPORTANT: Conserver les valeurs 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 === EXCLURE_VALEUR)
-                    debug && console.log('[schema][valider][' + cheminA + '] Exclusion demandée');
-                else
-                    outputSchema[champ] = val;
-
-                debug && console.log('[schema][valider][' + cheminA + ']', valOrigine, '=>', val);
-
-            } catch (error) {
-
-                debug && console.warn('[schema][valider][' + cheminA + ']', valOrigine, '|| Erreur:', error);
-
-                if (error instanceof Erreur) {
-
-                    // Référencement erreur
-                    erreurs[cheminA] = [error.message]
-                    nbErreurs++;
-
-                } else
-                    throw error;
-            }
-        }
-    }
-
-    if (nbErreurs !== 0 && opts.critique === true) {
-        throw new InputErrorSchema(erreurs);
-    }
-
-    debug && console.log('[schema][valider]', inputAvalider, '=>', output);
-
-    return { erreurs, nbErreurs, valeurs: output, };
-
-}
+export const validate = 

package/src/common/data/objets.ts

@@ -118,3 +118,28 @@ export const chemin = {
         
     }
 }
+
+export const callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
+    instance: TInstance, 
+    funcName: TCallableName
+): TInstance[TCallableName] & TInstance => {
+
+    const callableFunc = instance[funcName];
+    if (typeof callableFunc !== 'function')
+        throw new Error(`instance[funcName] isn't callable.`);
+
+    const callable = callableFunc.bind(instance);
+
+    const methods = [
+        ...Object.getOwnPropertyNames( Object.getPrototypeOf( instance )),
+        ...Object.getOwnPropertyNames( instance )
+    ];
+
+    for (const method of methods)
+        if (method !== 'constructor')
+            callable[ method ] = typeof instance[ method ] === 'function'
+                ? instance[ method ].bind( instance )
+                : instance[ method ];
+
+    return callable as TInstance[TCallableName] & TInstance;
+}

package/src/common/data/tableaux.ts

@@ -40,6 +40,14 @@ export function arrayToObj<Ttbl extends {[cle: string]: any}, Tcle extends strin
 
 export const somme = (tbl: number[]) => tbl.reduce((a: number, b: number) => a + b);
 
+export const arrayChunks = <TArray extends any[]>(array: TArray, size: number) => {
+
+    const arrays: TArray[] = [];
+    while (array.length > 0)
+        arrays.push( array.splice(0, size) as TArray );
+
+    return arrays;
+}
 
 export function array_sum( tbl: number[] ): number {
     return tbl.reduce((a: number, b: number) => a + b);

package/src/common/errors/index.ts

@@ -161,4 +161,6 @@ export const instancierViaCode = (
         case 404: return new NotFound( message, details);
         default: return new Anomaly( message, details);
     }
-}
+}
+
+export default Erreur;

package/src/common/router/index.ts

@@ -2,70 +2,89 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import { pathToRegexp, Key } from 'path-to-regexp';
-import type { ComponentChild } from 'preact';
+import { Layout } from './layouts';
 
 // types
 import type {
-    TRegisterPageArgs,
-    TClientRoute, 
-    TFrontRenderer 
-} from '@client/router';
+    default as ClientRouter,
+    TRouterContext as ClientRouterContext,
+    TRegisterPageArgs
+} from '@client/services/router';
 
-import type { ClientContext } from '@client/context';
+import type { 
+    default as ServerRouter, 
+    TRouterContext as ServerRouterContext,
+    TRouteHttpMethod 
+} from '@server/services/router';
 
-import type { TSchema } from '@common/data/input/validate';
+import type { TUserRole } from '@server/services/users';
 
-import type { TApiServerRoute } from '@server/services/router';
+import type { TAppArrowFunction } from '@common/app';
 
-import type { TUserRole } from '@server/services/auth/base';
+// Specfic
+import type ApiClient from './request/api';
+import type Request from './request';
+import type Response from './response';
+import type { default as Page, TFrontRenderer } from './response/page';
 
 /*----------------------------------
-- TYPES: layouts
+- TYPES: ROUTES
 ----------------------------------*/
 
-import layouts from '@/client/pages/**/_layout/index.tsx';
-
-type LayoutComponent = (attributes: { context: ClientContext }) => ComponentChild;
-export type Layout = { path: string, Component: LayoutComponent }
-const getLayout = (routePath: string | undefined): Layout | undefined => {
-    
-    let layout: Layout | undefined = layouts[''];
-    if (routePath) {
-        for (const layoutPath in layouts)
-            if (routePath === layoutPath || routePath.startsWith( layoutPath + '/' ))
-                layout = { path: layoutPath, Component: layouts[layoutPath] };
-    }
-    //layout && console.log(`${routePath}: Using Layout: ${layout.path}`);
-    return layout;
-}
+export type { Layout } from './layouts';
 
-/*----------------------------------
-- TYPES: ROUTES
-----------------------------------*/
+export type { default as Request } from './request';
+export type { default as Response } from './response';
 
-export type TBaseRoute = {
-    path: string,
+export type ClientOrServerRouter = ClientRouter | ServerRouter;
+
+export type TRoute<RouterContext extends TClientOrServerContext = TClientOrServerContext> = {
 
+    // Match
+    method: TRouteHttpMethod,
+    path: string,
     regex: RegExp,
     keys: (number | string)[],
 
+    // Execute
+    controller: TRouteController<RouterContext>,//TServerController<TRouter> | TFrontRenderer<TRouter>,
     options: TRouteOptions
 }
 
-export type TRoute = TApiServerRoute | TClientRoute;
-
-export type TErrorRoute = {
-    type: 'PAGE',
-    renderer: TFrontRenderer,
-    options: {}
+export type TErrorRoute<RouterContext extends TClientOrServerContext = TClientOrServerContext> = {
+    code,
+    controller: TRouteController<RouterContext>,
+    options: TRouteOptions
 }
 
+export type TClientOrServerContext<
+    TClientOnlyContextKeys extends keyof ClientRouterContext = keyof (ClientRouterContext | ServerRouterContext)
+> = (
+    (
+        {[serverContextKey in keyof ServerRouterContext/*Omit<ClientRouterContext, TClientOnlyContextKeys>*/]: undefined} 
+        & 
+        ClientRouterContext
+    )
+    | 
+    (
+        // Tell that all the keys of client context are existing but undefined
+        //  This avoids errors: "Property 'page' is optional in type '{ app: Application; ..."
+        //  When we destructure the context from the page controller
+        //  While making reference to a key only available in client context
+        // So here, we put the
+        {[clientContextKey in keyof ClientRouterContext/*Omit<ClientRouterContext, TClientOnlyContextKeys>*/]: undefined} 
+        & 
+        ServerRouterContext
+    )
+)
+
+export type TRouteController<RouterContext extends TClientOrServerContext = TClientOrServerContext> = 
+    (context: RouterContext) => /* Page to render */Page | /* Any data (html, json) */Promise<any>
+
 export type TRouteOptions = {
 
     // Injected by the page plugin
-    filepath: string,
+    filepath?: string,
 
     // Indexing
     bodyId?: string,
@@ -78,7 +97,7 @@ export type TRouteOptions = {
 
     // Access Restriction
     auth?: TUserRole | boolean,
-    form?: TSchema,
+    //form?: TSchema,
     layout?: false | Layout,
 
     TESTING?: boolean,
@@ -86,6 +105,11 @@ export type TRouteOptions = {
 
 }
 
+export type TRouteModule<TRegisteredRoute = any> = { 
+    // exporing __register is a way to know we axport a TAppArrowFunction
+    __register?: TAppArrowFunction<TRegisteredRoute> 
+}
+
 export const defaultOptions = {
     priority: 0,
 }
@@ -94,55 +118,10 @@ export const defaultOptions = {
 - BASE ROUTER
 ----------------------------------*/
 
-export default abstract class BaseRouter {
-
-    public page = <TControllerData extends TObjetDonnees = {}>(...args: TRegisterPageArgs<TControllerData>) =>
-        this.registerPage(...args);
-
-    public error = (code: number, options, renderer: TFrontRenderer<{ message: string }>) =>
-        this.registerErrorPage(code, options, renderer);
-
-    protected abstract registerPage(...page: TRegisterPageArgs ): any;
-
-    public errors: { [code: number]: TErrorRoute } = {};
-    protected registerErrorPage( code: number, options, renderer: TFrontRenderer ) {
-        return this.errors[code] = {
-            type: 'PAGE',
-            renderer,
-            options
-        };
-    }
-
-    protected getRegisterPageArgs(...args: TRegisterPageArgs) {
-
-        const [path, options, controller, renderer] = args;
-
-        // S'il s'agit d'une page, son id doit avoir été injecté via le plugin babel
-        if (options["id"] === undefined)
-            throw new Error(`ID not found for the following page route: ${path}`);
-
-        // Bind layout
-        if (options.layout !== false)
-            options.layout = getLayout(options.filepath);
-
-        return { path, options, controller, renderer }
-
-    }
-
-    protected buildRegex( path: string ) {
-
-        // pathToRegexp ne supporte plus les wildcards depuis 4.0
-        if (path.endsWith('*'))
-            path = path.substring(0, path.length - 1) + '(.*)';
-
-        // path => regex
-        const keys: Key[] = []
-        const regex = pathToRegexp(path, keys, {
-            sensitive: true
-        }); 
+export default abstract class RouterInterface {
 
-        return { keys, regex }
+    public abstract page<TControllerData extends TObjetDonnees = {}>(...args: TRegisterPageArgs<TControllerData>);
 
-    }
+    public abstract error(code: number, options, renderer: TFrontRenderer<{}, { message: string }>);
 
 }

package/src/common/router/layouts.ts

@@ -0,0 +1,50 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type { ComponentChild } from 'preact';
+// Core
+import type { ClientContext } from '@/client/context';
+// App
+import layouts from '@/client/pages/**/_layout/index.tsx';
+
+/*----------------------------------
+- CONST
+----------------------------------*/
+
+export const layoutsList = layouts as ImportedLayouts;
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+type LayoutComponent = (attributes: { context: ClientContext }) => ComponentChild;
+
+export type Layout = { path: string, Component: LayoutComponent }
+
+export type ImportedLayouts = {
+    [chunkId: string]: Layout["Component"]
+}
+
+/*----------------------------------
+- UTILS
+----------------------------------*/
+// TODO: getLayot only on server side, and pass the layout chunk id
+export const getLayout = (routePath: string | undefined): Layout | undefined => {
+
+    //console.log(`[router][layouts] Get layout for "${routePath}".`);
+    
+    let layout: Layout | undefined;
+    if (routePath) {
+        for (const layoutPath in layouts)
+            if (routePath === layoutPath || routePath.startsWith( layoutPath + '_' ))
+                layout = { 
+                    path: layoutPath, 
+                    Component: layouts[layoutPath] 
+                };
+    }
+
+    //console.log(`[router][layouts] Get layout for "${routePath}". Found:`, layout);
+
+    return layout;
+}

package/src/common/router/register.ts

@@ -0,0 +1,62 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { pathToRegexp, Key } from 'path-to-regexp';
+
+// Core
+import { getLayout } from './layouts';
+
+// types
+import type { TRouteOptions } from '.';
+import type { TDataProvider, TFrontRenderer } from './response/page';
+import type { TRegisterPageArgs } from '@client/services/router';
+
+/*----------------------------------
+- UTILS
+----------------------------------*/
+
+export const getRegisterPageArgs = (...args: TRegisterPageArgs) => {
+
+    let path: string;
+    let options: Partial<TRouteOptions> = {};
+    let controller: TDataProvider|null;
+    let renderer: TFrontRenderer;
+
+    if (args.length === 3)
+        ([path, controller, renderer] = args)
+    else
+        ([path, options, controller, renderer] = args)
+
+    // S'il s'agit d'une page, son id doit avoir été injecté via le plugin babel
+    const chunkId = options["id"];
+    if (chunkId === undefined)
+        throw new Error(`ID has not injected for the following page route: ${path}`);
+
+    // Bind layout
+    if (options.layout !== false)
+        options.layout = getLayout(chunkId);
+
+    return { path, options, controller, renderer }
+
+}
+
+export const buildRegex = ( path: string ) => {
+
+    // pathToRegexp ne supporte plus les wildcards depuis 4.0
+    if (path.endsWith('*'))
+        path = path.substring(0, path.length - 1) + '(.*)';
+
+    // path => regex
+    const keys: Key[] = []
+    const regex = pathToRegexp(path, keys, {
+        sensitive: true
+    }); 
+
+    return { 
+        keys: keys.map(k => k.name), 
+        regex 
+    }
+
+}

package/src/common/router/request/api.ts

@@ -0,0 +1,72 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+import type { HttpMethod } from '@server/services/router';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TFetcherList = { [id: string]: TFetcher }
+
+export type TFetcher<TData extends unknown = unknown> = {
+
+    // For async calls: api.post(...).then((data) => ...)
+    then: (callback: (data: TData) => void) => Promise<TData>,
+    run: () => Promise<TData>,
+    
+    method: HttpMethod,
+    path: string,
+    data?: object,
+    options?: TApiFetchOptions
+}
+
+export type TFetcherArgs = [
+    method: HttpMethod,
+    path: string,
+    data?: object,
+    options?: TApiFetchOptions
+]
+
+export type TApiFetchOptions = {
+    captcha?: string, // Action id (required by recaptcha)
+    onProgress?: (percent: number) => void
+}
+
+// https://stackoverflow.com/questions/44851268/typescript-how-to-extract-the-generic-parameter-from-a-type
+type TypeWithGeneric<T> = TFetcher<T>
+type extractGeneric<Type> = Type extends TypeWithGeneric<infer X> ? X : never
+
+export type TDataReturnedByFetchers<TProvidedData extends TFetcherList = {}> = {
+    [Property in keyof TProvidedData]: undefined | (extractGeneric<TProvidedData[Property]> extends ((...args: any[]) => any) 
+        ? ThenArg<ReturnType< extractGeneric<TProvidedData[Property]> >>
+        : extractGeneric<TProvidedData[Property]>
+    )
+}
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class ApiClient {
+
+    /*----------------------------------
+    - TOP LEVEL
+    ----------------------------------*/
+
+    public abstract get<TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions): TFetcher<TData>;
+
+    public abstract post<TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions): TFetcher<TData>;
+
+    public abstract put<TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions): TFetcher<TData>;
+
+    public abstract delete<TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions): TFetcher<TData>;
+
+    /*----------------------------------
+    - LOW LEVEL
+    ----------------------------------*/
+
+    public abstract createFetcher<TData extends unknown = unknown>(...args: TFetcherArgs): TFetcher<TData>;
+
+    public abstract fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees>;
+}

package/src/common/router/request/index.ts

@@ -0,0 +1,31 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import Response from '../response';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- CONTEXT
+----------------------------------*/
+export default abstract class BaseRequest {
+
+    // Permet d'accèder à l'instance complète via spread
+    public request: this = this;
+    public host!: string;
+
+    public data: TObjetDonnees = {};
+    public abstract response?: Response;
+    public user: User | null = null;
+
+    public constructor(
+        public path: string,
+    ) {
+
+    }
+}