5htp-core 0.1.2 → 0.2.0

package/src/common/data/input/validators/basic.ts

@@ -1,299 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import {
-    trim,
-    isISO8601, toDate,
-    isEmail, normalizeEmail,
-    isURL
-} from 'validator';
-
-// Libs
-import { InputError } from '@common/errors';
-import File from '@common/data/file';
-
-// Libs métier
-import { champ } from './build';
-import { TSchemaChamp } from '../validate';
-import NormalizedFile from '@common/data/file';
-
-// Components
-import NumberInput from '@client/components/input/Number';
-import Dropdown from '@client/components/dropdown.old';
-
-/*----------------------------------
-- CONTENEURS
-----------------------------------*/
-export const object = (opts: TSchemaChamp<object> & {} = {}) => champ<object>('object', {
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees) => {
-
-        // TODO: executer seulement coté serveur
-        /*if (typeof val === 'string' && val.startsWith('{'))
-            try {
-                val = JSON.parse(val);
-            } catch (error) {
-                console.error('Unable to convert the given string into an object.');
-            }*/
-
-        if (typeof val !== 'object' || val.constructor !== Object)
-            throw new InputError("This value must be an object.");
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-    },
-})
-
-export const array = (subtype?: Schema<any> | TSchemaChamp<any[]>, { choix, ...opts }: TSchemaChamp<any[]> & {} = {}) => {
-
-    if (subtype !== undefined)
-        subtype.choix = choix;
-
-    return champ<any[]>('array', {
-        ...opts,
-        choix,
-        multiple: true, // Sélection multiple
-        subtype,
-        valider: async (items: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees) => {
-
-            //console.log('VALIDER ARRAY', items, donneesSaisie);
-
-            if (!Array.isArray(items))
-                throw new InputError("This value must be an array.");
-
-            // Verif items
-            if (subtype !== undefined) {
-                if (subtype instanceof Schema) {
-
-                    console.log('TODO: VALIDER VIA SOUS SCHEMA');
-
-                } else {
-
-                    for (let i = 0; i < items.length; i++)
-                        items[i] = await subtype.valider(items[i], items);
-
-                }
-            }
-
-            return opts.valider ? await opts.valider(items, donneesSaisie, donneesRetour) : items;
-        },
-    })
-}
-
-export const choice = (values: any[], opts: TSchemaChamp<any> & {} = {}) => champ<any>('object', {
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees) => {
-
-        if (!values.includes(val))
-            throw new InputError("Invalid value. Must be: " + values.join(', '));
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-    },
-})
-
-/*----------------------------------
-- CHAINES
-----------------------------------*/
-export const string = ({ min, max, ...opts }: TSchemaChamp<string> = {}) => champ<string>('string', {
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => {
-
-        if (val === '')
-            val = undefined;
-        else if (typeof val === 'number')
-            return val.toString();
-        else if (typeof val !== 'string')
-            throw new InputError("This value must be a string.");
-
-        // Espaces blancs
-        val = trim(val);
-
-        // Taille min
-        if (val.length < min)
-            throw new InputError(`Must be at least ` + min + ' characters');
-
-        // Taille max
-        if (val.length > max)
-            if (corriger)
-                val = val.substring(0, max);
-            else
-                throw new InputError(`Must be up to ` + max + ' characters');
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-    },
-})
-
-export const url = (opts: TSchemaChamp<string> & {} = {}) => string({
-    ...opts,
-    valider: async (val: string, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => {
-
-        if (!isURL(val, {
-            // https://www.npmjs.com/package/validator
-        }))
-            throw new InputError(`Please provide a valid URL.`);
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour, corriger) : val;
-    },
-})
-
-export const email = (opts: TSchemaChamp<string> & {} = {}) => string({
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => {
-
-        if (!isEmail(val))
-            throw new InputError("Please enter a valid email address.");
-
-        const retour = normalizeEmail(val);
-
-        return opts.valider ? await opts.valider(retour, donneesSaisie, donneesRetour, corriger) : retour;
-
-    },
-})
-
-/*----------------------------------
-- NOMBRES
-----------------------------------*/
-// On ne spread pas min et max afin quils soient passés dans les props du composant
-const nombre = (float: boolean) => ({ ...opts }: TSchemaChamp<number> & {} = {}) => champ<number>('nombre', {
-    // Force une valeur par défaut si requis
-    defaut: opts.opt ? undefined : (opts.min || 0),
-    rendu: NumberInput,
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => {
-
-        // Vérifications suivantes inutiles si des valeurs spécifiques ont été fournies
-        if (opts.in === undefined) {
-
-            // Tente conversion chaine en nombre
-            if (typeof val === 'string')
-                val = float ? parseFloat(val) : parseInt(val);
-            
-            if (opts.min === undefined)
-                opts.min = 0;
-            
-            // Type de donnée
-            if (Number.isNaN(val) || typeof val !== 'number') {
-                if (corriger)
-                    val = opts.min;
-                else
-                    throw new InputError("This value must be a number.");
-            }
-
-            // Minimum
-            if (val < opts.min)
-                if (corriger)
-                    val = opts.min;
-                else
-                    throw new InputError(`Must be at least ` + opts.min);
-
-            // Maximum
-            if (opts.max !== undefined && val > opts.max)
-                if (corriger)
-                    val = opts.max;
-                else
-                    throw new InputError(`Must be up to ` + opts.max);
-
-        }
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour, corriger) : val;
-    },
-})
-
-export const int = nombre(false);   
-
-export const float = nombre(true);
-
-export const bool = (opts: TSchemaChamp<boolean> & {} = {}) => champ<boolean>('bool', {
-    defaut: false,
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees) => {
-
-        if (typeof val !== 'boolean' && !['true', 'false'].includes(val))
-            throw new InputError("This value must be a boolean.");
-
-        val = !!val;
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-
-    },
-})
-
-/*----------------------------------
-- AUTRES
-----------------------------------*/
-export const date = (opts: TSchemaChamp<Date> & {} = {}) => champ<Date>('date', {
-    //defaut: new Date,
-    ...opts,
-    valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees): Promise<Date> => {
-
-        const chaine = typeof val == 'string';
-
-        // Chaine = format iso
-        if (chaine) {
-
-            if (!isISO8601(val))
-                throw new InputError("This value must be a date.");
-
-            val = toDate(val);
-
-        } else if (!(val instanceof Date))
-            throw new InputError("This value must be a date.");
-
-        return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-
-    },
-})
-
-/*----------------------------------
-- FICHIER
-----------------------------------*/
-export type TOptsValidateurFichier = TSchemaChamp<object> & {
-    type?: (keyof typeof raccourcisMime) | string[], // Raccourci, ou liste de mimetype
-    taille?: number
-}
-const raccourcisMime = {
-    image: ['image/jpeg', 'image/png']
-}
-export const validateurFichier = async (
-    { type, taille, ...opts }: TOptsValidateurFichier = {}, 
-    val: any, 
-    donneesSaisie: TObjetDonnees, 
-    donneesRetour: TObjetDonnees
-): Promise<File | undefined> => {
-
-    console.log('VALIDER FICHIER', type, val);
-
-    if (!(val instanceof NormalizedFile))
-        throw new InputError(`Must be a File (${typeof val} received)`);
-
-    // MIME
-    if (type !== undefined) {
-
-        let mimetypes: string[];
-
-        // Raccourcis
-        if (typeof type === 'string') {
-            if (type in raccourcisMime)
-                mimetypes = raccourcisMime[type as keyof typeof raccourcisMime]
-            else
-                throw new Error(`Aucune liste de mimetype référencée pour le type de fichier « ${type} »`);
-        } else
-            mimetypes = type;
-
-        // Vérification
-        const mimeFichier = val.type;
-        if (!mimetypes.includes(mimeFichier))
-            throw new InputError('Only the following formats are allowed: ' + mimetypes.join(', ') + '. The file you gave is ' + mimeFichier + '.');
-
-    }
-
-    // Taille
-    if (taille) {
-        const tailleFichier = val.size / 1024 / 1024; // Mo
-        if (tailleFichier > taille)
-            throw new InputError(`Le fichier ne doit pas faire plus de ${taille} Mo (taille reçue: ${tailleFichier} Mo)`);
-    }
-
-    return opts.valider ? await opts.valider(val, donneesSaisie, donneesRetour) : val;
-}

package/src/common/data/input/validators/build.ts

@@ -1,63 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Libs
-import { InputError } from '@common/errors';
-import * as basicValidators from './basic';
-
-// Components
-import Input from '@client/components/input';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-import { TSchemaChampComplet, TSchema } from '../validate';
-
-export const EXCLURE_VALEUR = "action:exclure";
-
-/*----------------------------------
-- VALIDATION DE BASE
-----------------------------------*/
-// Remplace un simple !val, qui compterait un zéro comme une valeur vide
-export const valeurVide = (val: any) => val === undefined || val === '' || val === null;
-
-export const champ = <TValeur>(
-    type: string,
-    opts: Omit<TSchemaChampComplet<TValeur>, 'type'>
-): TSchemaChampComplet<TValeur> => {
-    return {
-        ...opts,
-        type: type,
-        rendu: Input,
-        valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, valider?: boolean) => {
-
-            if (valeurVide(val)) {
-                // Optionnel, on skip
-                if (opts.opt === true)
-                    return undefined;
-                // Requis
-                else
-                    throw new InputError("Please enter a value");
-            }
-
-            if (opts.valider !== undefined)
-                val = await opts.valider(val, donneesSaisie, donneesRetour, valider);
-
-            // La valeur ayant passé les étapes de validation
-            // On considère que son type correspond aintenant à celui attendu
-            return val as TValeur | undefined;
-        },
-    };
-}
-
-export default (validators) => ({
-
-    ...basicValidators,
-
-    ...validators,
-
-    new: <TSchemaA extends TSchema>(schema: TSchemaA): TSchemaA => schema,
-
-})

package/src/common/router/request.ts

@@ -1,83 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Core
-import Response, { TResponseData } from './response';
-import PageResponse from './response/page';
-import { TRoute } from '.';
-import type { HttpMethod } from "@server/services/router";
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-// Modeles
-import type { User } from '@models';
-
-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
-}
-
-/*----------------------------------
-- 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,
-    ) {
-
-    }
-
-    public api = {
-        get: <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-            this.createFetcher<TData>('GET', path, data, opts),
-
-        post: <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-            this.createFetcher<TData>('POST', path, data, opts),
-
-        put: <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-            this.createFetcher<TData>('PUT', path, data, opts),
-
-        delete: <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-            this.createFetcher<TData>('DELETE', path, data, opts),
-    }
-
-    public abstract createFetcher<TData extends unknown = unknown>(...args: TFetcherArgs): TFetcher<TData>;
-
-    public abstract fetchSync(fetchers: TFetcherList): Promise<TObjetDonnees>;
-
-    public abstract fetchAsync(...args: TFetcherArgs): Promise<any>;
-
-}

package/src/server/data/ApiClient.ts

@@ -1,119 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import { Logger } from "tslog";
-import axios, { AxiosResponse, AxiosRequestConfig, AxiosError } from 'axios';
-import httpAdapter from 'axios/lib/adapters/http';
-
-// Libs
-import Cache from '@server/data/Cache';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-declare module 'axios' {
-    export interface AxiosRequestConfig {
-        fallback?: string; // ID donnée cache
-        cache?: string; // ID donnée cache
-        cacheExpiration?: number | Date | null,
-        retry?: number;
-        debug?: boolean
-    }
-}
-
-const debug = false;
-
-/*----------------------------------
-- MODULE
-----------------------------------*/
-// FIX: On créé une nouvelle instance d'axios ici, car si on utilise l'instance globale,
-//  Les intercepteurs seront empilés à la suite à chaque reload HMR 
-export default axios.create({
-    timeout: process.env.environnement === 'local' 
-        ? 10000 // Connexion pourrie à la maison
-        : 5000,
-    validateStatus: function (status: number) {
-        return status >= 200 && status < 300;
-    },
-    adapter: async (config: AxiosRequestConfig) => {
-
-        //const logger = new Logger({ prefix: [config.url] });
-
-        console.log(`Création de la requête`, { params: config.params, data: config.data });
-
-        const envoyer = (tentative: number = 1) => httpAdapter(config).then(async (res: AxiosResponse) => {
-
-            console.log(`Status:`, res.status ,`Reponse:`, typeof res.data);
-
-            // Mise en cache
-            const cacheId: string | undefined = config.fallback || config.cache;
-            if (cacheId !== undefined) {
-                console.log(`Enregistrement de la réponse dans le cache (ID: ${cacheId})`);
-                await Cache.set(cacheId, res.data, config.cacheExpiration);
-            }
-
-            return res;
-
-        }).catch(async (err: AxiosError) => {
-
-            // err peut être une simple instance d'Error
-
-            console.error("Error during API request:", {
-                method: config.method,
-                url: config.url,
-                body: config.data,
-                headers: config.headers,
-            });
-
-            if (err.isAxiosError && err.response) {
-                console.error("Response:", {
-                    status: err.response.status + ' ' + err.response.statusText,
-                    headers: err.response.headers,
-                    body: err.response.data
-                });
-            }
-
-            throw err;
-
-            // Nouvelle tentative 
-            if (
-                config.retry !== undefined && tentative < config.retry 
-                && 
-                err.response !== undefined && err.response.status >= 400
-            ) {
-                console.log(`Tentative n°` + (tentative + 1));
-                return await envoyer(tentative + 1);
-            }
-
-            // Fallback via cache
-            const fallback = config.fallback === undefined
-                ? undefined
-                : await Cache.get(config.fallback)
-
-            // Aucun fallback = impossible de continuer
-            if (!err) {
-                console.log(`Aucun fallback disponible, on fait remonter l'erreur.`);
-                throw err;
-            } else
-                console.log(`Utilisation des données en fallback via le cache (ID: ${config.fallback})`/*, fallback*/);
-            
-            return {
-                data: fallback,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: config,
-                request: err.request
-            }
-
-
-        })
-
-        return config.cache === undefined
-            ? await envoyer()
-            : await Cache.get(config.cache, () => envoyer(), config.cacheExpiration);
-
-    }
-})

package/src/server/data/input.ts

@@ -1,41 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Libs métier
-import buildValidators, { EXCLURE_VALEUR, champ } from '@common/data/input/validators/build';
-import { validateurFichier, TOptsValidateurFichier } from '@common/data/input/validators/basic';
-
-/*----------------------------------
-- VALIDATEURS
-----------------------------------*/
-export default buildValidators({
-
-    file: ({ ...opts }: TOptsValidateurFichier & {}) => champ<object>('fichier', {
-        ...opts,
-        valider: async (val: any, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees) => {
-
-            // Chaine = url ancien fichier = exclusion de la valeur pour conserver l'ancien fichier
-            // NOTE: Si la valeur est présente mais undefined, alors on supprimera le fichier
-            if (typeof val === 'string')
-                return EXCLURE_VALEUR;
-
-            // Validation universelle
-            const fichier = await validateurFichier(opts, val, donneesSaisie, donneesRetour);
-
-            if (fichier === undefined)
-                return fichier;
-
-
-            // Résolution image
-            if (opts.sharp !== undefined) {
-
-
-
-            }
-
-            return opts.valider ? await opts.valider(fichier, donneesSaisie, donneesRetour) : fichier;
-        }
-    })
-
-});

package/src/server/libs/pages/document.static.tsx

@@ -1,41 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import React from 'react';
-
-// Core
-import app, { services } from '@server/app';
-
-/*----------------------------------
-- COMPOSANT
-----------------------------------*/
-export default () => {
-
-    const routesForClient = JSON.stringify(services.router.ssrRoutes);
-    return (
-        <html lang="en">
-            <head>
-                {/* Format */}
-                <meta charSet="utf-8" />
-                <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1" />
-
-                {/* CSS */}
-                <link rel="stylesheet" type="text/css" href="/public/icons.css" />
-                <link rel="preload" href="/public/client.css" as="style" />
-                <link rel="stylesheet" type="text/css" href="/public/client.css" />
-
-                {/* JS */}
-                <script type="text/javascript" dangerouslySetInnerHTML={{
-                    __html: `window.routes=${routesForClient};` + (app.env.profile === 'dev' ? 'window.dev = true;' : '')
-                }} />
-                <link rel="preload" href="/public/client.js" as="script" />
-                <script defer type="text/javascript" src="/public/client.js" />
-
-            </head>
-            <body></body>
-        </html>
-    );
-
-}