5htp-core 0.6.2-7 → 0.6.2-8

package/client/components/Input.tsx

@@ -13,8 +13,6 @@ import {
 
 // Core libs
 import { InputBaseProps, useMantineInput } from './utils';
-import { default as Validator } from '../../server/services/router/request/validation/validator';
-import type { SchemaValidators } from '@server/services/router/request/validation/validators';
 
 /*----------------------------------
 - TYPES

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.6.2-7",
+	"version": "0.6.2-8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",

package/server/app/service/index.ts

@@ -2,6 +2,9 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Npm
+import zod from 'zod';
+
 // Specific
 import type { Application } from "..";
 import type { Command } from "../commands"; 
@@ -10,6 +13,7 @@ import type { TControllerDefinition, TRoute } from '../../services/router';
 import { Anomaly } from "@common/errors";
 
 export { schema } from '../../services/router/request/validation/zod';
+export type { z } from '../../services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES: OPTIONS
@@ -52,7 +56,30 @@ export type TServiceArgs<TService extends AnyService> = [
 
 const LogPrefix = '[service]';
 
-export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
+type TDecoratorArgs = (
+    [path: string] |
+    [path: string, schema: zod.ZodSchema] |
+    [path: string, schema: zod.ZodSchema, options?: Omit<TControllerDefinition, 'controller'|'schema'|'path'>] |
+    [options: Omit<TControllerDefinition, 'controller'>]
+)
+
+export function Route( ...args: TDecoratorArgs ) {
+
+    let path: string | undefined;
+    let schema: zod.ZodSchema | undefined;
+    let options: Omit<TControllerDefinition, 'controller'|'schema'|'path'> = {};
+
+    if (typeof args[0] === 'object') {
+        const { path: path_, schema: schema_, ...options_ } = args[0];
+        path = path_;
+        schema = schema_;
+        options = options_;
+    } else {
+        path = args[0];
+        schema = args[1];
+        options = args[2] || {};
+    }
+
     return function (
         target: any,
         propertyKey: string,
@@ -61,8 +88,8 @@ export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
         // Store the original method
         const originalMethod = descriptor.value;
 
-        if (options.path === undefined)
-            options.path = target.constructor.name + '/' + propertyKey;
+        if (path === undefined)
+            path = target.constructor.name + '/' + propertyKey;
 
         // Ensure the class has a static property to collect routes
         if (!target.__routes) {
@@ -72,9 +99,9 @@ export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
         // Create route object
         const route: TRoute = {
             method: 'POST',
-            path: '/api/' + options.path,
+            path: '/api/' + path,
             controller: originalMethod,
-            schema: options.schema,
+            schema: schema,
             options: {
                 priority: options.priority || 0
             }

package/server/services/disks/index.ts

@@ -34,9 +34,9 @@ export type Services = {
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
-    MountpointList extends Services = {},
-    TConfig extends Config = Config,
-    TApplication extends Application = Application
+    MountpointList extends Services,
+    TConfig extends Config,
+    TApplication extends Application
 > extends Service<TConfig, Hooks, TApplication> {
 
     public default!: Driver;
@@ -45,7 +45,7 @@ export default class DisksManager<
     - LIFECYCLE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<DisksManager>) {
+    public constructor( ...args: TServiceArgs<DisksManager<MountpointList, TConfig, TApplication>>) {
 
         super(...args);
 

package/server/services/prisma/Facet.ts

@@ -1,6 +1,34 @@
 import type { Prisma, PrismaClient } from '@models/types';
 import * as runtime from '@/var/prisma/runtime/library.js';
 
+/*export type TDelegate<R> = {
+    findMany(args?: any): Promise<R[]>
+    findFirst(args?: any): Promise<R | null>
+}*/
+
+/*
+
+*/
+
+
+export type TDelegate<R> = PrismaClient[string];
+
+/*export type TExtractPayload<D extends TDelegate<never>> =
+  D extends { [K in symbol]: { types: { payload: infer P } } } ? P : never;
+
+export type TExtractPayload2<D> =
+  D extends { [K: symbol]: { types: Prisma.TypeMap<infer E>['model'][infer M] } }
+    ? Prisma.TypeMap<E>['model'][M & keyof Prisma.TypeMap<E>['model']]['payload']
+    : never;*/
+
+export type Transform<S extends TSubset, R, RT> = (
+    row: runtime.Types.Result.GetResult<
+        Prisma.$ProspectContactLeadPayload,
+        ReturnType<S>,
+        'findMany'
+    >[number]
+) => RT
+
 export type TWithStats = {
     $table: string,
     $key: string
@@ -13,12 +41,10 @@ export type TSubset = (...a: any[]) => Prisma.ProspectContactLeadFindFirstArgs &
 }
 
 export default class Facet<
-    D extends {
-        findMany(args?: any): Promise<any>
-        findFirst(args?: any): Promise<any>
-    },
+    D extends TDelegate<R>,
     S extends TSubset,
-    R
+    R, // Result type
+    RT // Transformed result type
 > {
     constructor(
 
@@ -28,18 +54,12 @@ export default class Facet<
         private readonly subset: S,
 
         /* the **ONLY** line that changed ↓↓↓ */
-        private readonly transform?: (
-            row: runtime.Types.Result.GetResult<
-                Prisma.$ProspectContactLeadPayload,
-                ReturnType<S>,
-                'findMany'
-            >[number]
-        ) => R,
+        private readonly transform?: Transform<S, R, RT>,
     ) { }
 
     public async findMany(
         ...args: Parameters<S>
-    ): Promise<R[]> {
+    ): Promise<RT[]> {
 
         const { withStats, ...subset } = this.subset(...args);
 
@@ -57,7 +77,7 @@ export default class Facet<
 
     public async findFirst(
         ...args: Parameters<S>
-    ): Promise<R | null> {
+    ): Promise<RT | null> {
 
         const { withStats, ...subset } = this.subset(...args);
 

package/server/services/prisma/index.ts

@@ -10,7 +10,7 @@ import type { Application } from '@server/app';
 import Service from '@server/app/service';
 
 // Specific
-import Facet, { TSubset } from './Facet';
+import Facet, { TDelegate, TSubset, Transform } from './Facet';
 
 /*----------------------------------
 - TYPES
@@ -52,13 +52,11 @@ export default class ModelsManager extends Service<Config, Hooks, Application> {
     }
 
     public Facet<
-        D extends {
-            findMany(args?: any): Promise<any>
-            findFirst(args?: any): Promise<any>
-        },
+        D extends TDelegate<R>,
         S extends TSubset,
-        R
-    >(...args: [D, S, R]) {
+        R,
+        RT
+    >(...args: [D, S, Transform<S, R, RT>]) {
 
         return new Facet(
             this.client,

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

@@ -1,5 +1,5 @@
 import { InputError } from '@common/errors';
-import zod from 'zod';
+import zod, { _ZodType } from 'zod';
 
 export type TRichTextValidatorOptions = {
     attachements?: boolean
@@ -46,18 +46,51 @@ function validateLexicalNode(node: any, opts: TRichTextValidatorOptions ) {
 export const schema = { 
     ...zod,  
 
-    file: (builder: (file: zod.ZodType<File>) => any) => schema.custom(val => {
+    file: () => {
 
         // 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 true;
+        /*if (typeof val === 'string')
+            return true;*/
 
-        // Default file validation
-        const fileInstance = zod.file();
+        return zod.file();
+    },
 
-        return builder(fileInstance).parse(val);
-    }),
+    int: () => zod.preprocess( val => {
+
+        if (typeof val === "string")
+            return Number.parseInt(val);
+          
+        return val;
+
+    }, zod.int()),
+
+    choice: ( choices: string[] | { value: any, label: string }[] | _ZodType, options: { multiple?: boolean } = {} ) => {
+
+        const normalizeValue = (value: any) => typeof value === 'object' ? value.value : value;
+
+        const valueType: _ZodType = Array.isArray(choices) 
+            ? zod.enum( choices.map(normalizeValue) ) 
+            : zod.string();
+
+        const itemType = zod.union([
+
+            zod.object({ value: valueType, label: zod.string() }),
+
+            valueType
+
+        ]);
+
+        const type = options.multiple ? zod.array( itemType ) : itemType;
+        
+        return type.transform(v => {
+            if (options.multiple) {
+                return v.map(normalizeValue);
+            } else {
+                return normalizeValue(v);
+            }
+        });
+    },
 
     richText: (opts: TRichTextValidatorOptions = {}) => schema.custom(val => {
 
@@ -94,4 +127,6 @@ export const schema = {
 
         return true;
     })
-}
+}
+
+export type { default as z } from 'zod';

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

@@ -41,7 +41,7 @@ export type TBasicSSrData = {
 export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
     // Request context
     {
-        app: Application,
+        app: TRouter["app"],
         context: TRouterContext<TRouter>, // = this
         request: ServerRequest<TRouter>,
         api: ServerRequest<TRouter>["api"],

package/server/services/schema/request.ts

@@ -2,15 +2,17 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Npm
+import zod from 'zod';
+import { SomeType } from 'zod/v4/core';
+ 
 // Core
 import { 
     default as Router, RequestService, Request as ServerRequest
 } from '@server/services/router';
 
-import Schema, { TSchemaFields, TValidatedData } from '@server/services/router/request/validation/schema';
-
-// Specific
-import ServerSchemaValidator from '.';
+// Ap
+import { schema } from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -25,38 +27,21 @@ export type TConfig = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class RequestValidator extends ServerSchemaValidator implements RequestService {
-
-    public constructor(
-        public request: ServerRequest<Router>,
-        public config: TConfig,
-        public router = request.router,
-        public app = router.app
-    ) {
-
-        super(app);
+export default(
+    request: ServerRequest<Router>,
+    config: TConfig,
+    router = request.router,
+    app = router.app
+) => ({
 
-    }
+    ...schema,
 
-    public validate<TSchemaFieldsA extends TSchemaFields>( 
-        fields: TSchemaFieldsA | Schema<TSchemaFieldsA> 
-    ): TValidatedData<TSchemaFieldsA> {
+    validate( fields: zod.ZodSchema | { [key: string]: zod.ZodSchema } ) {
 
         this.config.debug && console.log(LogPrefix, "Validate request data:", this.request.data);
 
-        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, {
-            debug: this.config.debug,
-            validateDeps: false,
-            validators: this
-        }, []);
-
-        // For logging
-        this.request.validatedData = values;
-
-        return values;
-    }
+        const schema = typeof fields === 'object' ? zod.object(fields) : fields;
 
-}
+        return schema.parse(this.request.data);
+    },
+})

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

@@ -8,7 +8,7 @@ import {
     RouterService
 } from '@server/services/router';
 
-import RequestValidator, { TConfig } from '../request';
+import makeRequestValidators from '../request';
 
 /*----------------------------------
 - TYPES
@@ -22,7 +22,7 @@ export default class SchemaRouterService<
     TUser extends {} = {}
 > extends RouterService {
 
-    public requestService( request: ServerRequest ): RequestValidator {
-        return new RequestValidator( request, this.config );
+    public requestService( request: ServerRequest ) {
+        return makeRequestValidators( request, this.config );
     }
 }

package/types/icons.d.ts

@@ -1 +1 @@
-export type TIcones = "solid/spinner-third"|"times"|"brands/whatsapp"|"info-circle"|"check-circle"|"exclamation-circle"|"times-circle"|"search"|"check"|"angle-down"|"arrow-left"|"arrow-right"|"meh-rolling-eyes"|"eye"|"trash"|"unlink"|"pen"|"link"|"file"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"plus"|"font"|"empty-set"|"plus-circle"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"
+export type TIcones = "times"|"solid/spinner-third"|"long-arrow-right"|"check-circle"|"rocket"|"user-circle"|"crosshairs"|"arrow-right"|"user-shield"|"shield-alt"|"chart-line"|"money-bill-wave"|"star"|"link"|"file-alt"|"long-arrow-left"|"plane-departure"|"plus-circle"|"comments-alt"|"chart-bar"|"calendar-alt"|"paper-plane"|"at"|"search"|"lightbulb"|"magnet"|"phone"|"brands/linkedin"|"brands/whatsapp"|"user"|"user-plus"|"sack-dollar"|"info-circle"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"plus"|"minus"|"trash"|"play"|"stop"|"clock"|"cog"|"ellipsis-h"|"check"|"regular/shield-check"|"angle-down"|"angle-up"|"solid/crown"|"eye"|"pen"|"file"|"envelope"|"coins"|"download"|"exclamation-circle"|"times-circle"|"meh-rolling-eyes"|"arrow-left"|"bars"|"chevron-left"|"bolt"|"key"|"power-off"|"comment-alt"|"question-circle"|"wind"|"minus-circle"|"external-link"|"brands/google"|"broom"|"solid/check-circle"|"solid/exclamation-triangle"|"solid/times-circle"|"hourglass"|"copy"|"users"|"bug"|"binoculars"|"building"|"briefcase"|"map-marker-alt"|"graduation-cap"|"coin"|"angle-left"|"angle-right"|"plug"|"arrow-to-bottom"|"solid/magic"|"industry"|"map-marker"|"calendar"|"fire"|"magic"|"globe"|"code"|"bold"|"italic"|"underline"|"font"|"strikethrough"|"subscript"|"superscript"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"unlink"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"

package/common/data/input/validate.ts

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

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

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

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

@@ -1,211 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Core
-import { CoreError, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
-
-// Specific
-import { default as Validator, EXCLUDE_VALUE, TValidatorDefinition } from './validator';
-import defaultValidators, { SchemaValidators, getFieldValidator } from './validators';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TSchemaFields = { 
-    [fieldName: string]: TSchemaFields | Schema<{}> | Validator<any> | TValidatorDefinition
-}
-
-type TSchemaOptions = {
-    opt?: boolean
-}
-
-export type TValidateOptions<TFields extends TSchemaFields = {}> = {
-    debug?: boolean,
-    throwError?: boolean,
-    ignoreMissing?: boolean,
-    only?: (keyof TFields)[],
-    validateDeps?: boolean,
-    autoCorrect?: boolean,
-    validators?: SchemaValidators
-}
-
-export type TValidationResult<TFields extends TSchemaFields> = {
-    values: TValidatedData<TFields>,
-    errorsCount: number,
-    erreurs: TListeErreursSaisie
-}
-
-export type TSchemaData<TSchema extends Schema<{}>> =
-    TValidationResult<TSchema["fields"]>
-
-export type TValidatedData<TFields extends TSchemaFields> = {
-    // For each field, the values returned by validator.validate()
-    [name in keyof TFields]: TFieldReturnType<TFields[name]>
-}
-
-type TFieldReturnType<TField> = TField extends TValidatorDefinition
-    ? TField[2]
-    : TField extends Schema<infer T>
-    ? TValidatedData<T>
-    : never
-
-/*----------------------------------
-- CONST
-----------------------------------*/
-
-const LogPrefix = '[schema][validator]';
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export default class Schema<TFields extends TSchemaFields> {
-
-    public constructor(
-        public fields: TFields,
-        public options: TSchemaOptions = {}
-    ) {
-
-    }
-
-    public getFieldValidator(
-        fieldName: string,
-        validators: SchemaValidators = defaultValidators
-    ): null | Validator<any> | Schema<{}> {
-
-        let field = this.fields[fieldName];
-        if (field === undefined) {
-
-            return null;
-
-        // TValidatorDefinition
-        } else
-            return getFieldValidator(field);
-    }
-
-    public validate<TDonnees extends TObjetDonnees>(
-        dataToValidate: Partial<TDonnees>,
-        opts: TValidateOptions<TFields> = {},
-        chemin: string[] = []
-    ): TValidatedData<TFields> {
-
-        const validators = opts.validators || defaultValidators;
-
-        // Check data type
-        if (typeof dataToValidate !== 'object')
-            throw new InputErrorSchema({ [chemin.join('.')]: ['Must be an object'] });
-    
-        // Default options
-        opts = {
-            debug: false,
-            throwError: true,
-            validateDeps: true,
-            autoCorrect: false,
-            ...opts,
-        }
-
-        const keysToValidate = (opts.only || Object.keys(this.fields)) as string[];
-    
-        // Validation de chacune d'entre elles
-        const output: Partial<TDonnees> = {};
-        let erreurs: TListeErreursSaisie = {};
-        let errorsCount = 0;
-        for (const fieldName of keysToValidate) {
-    
-            const validator = this.getFieldValidator(fieldName, validators);
-            if (validator === null) {
-                opts.debug && console.warn(LogPrefix, '[' + fieldName + ']', 'Exclusion (pas présent dans le schéma)');
-                continue;
-            }
-
-            // Create field path
-            const cheminA = [...chemin, fieldName]
-            const cheminAstr = cheminA.join('.')
-            const valOrigine = dataToValidate[fieldName];
-
-            // Validation
-            try {
-
-                const val = validator.validate(valOrigine, opts, cheminA);
-
-                // Exclusion seulement si explicitement demandé
-                // IMPORTANT: Conserver les values undefined
-                //      La présence d'un valeur undefined peut être utile, par exemple, pour indiquer qu'on souhaite supprimer une donnée
-                //      Exemple: undefinec = suppression fichier | Absende donnée = conservation fihcier actuel
-                if (val === EXCLUDE_VALUE)
-                    opts.debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
-                // Key not in the input data, we don't create an entry in the output
-                else if (fieldName in dataToValidate)
-                    output[fieldName] = val;
-
-                opts.debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
-
-            } catch (error) {
-
-                opts.debug && console.warn(LogPrefix, '[' + cheminA + ']', valOrigine, '|| CoreError:', error);
-
-                if (error instanceof InputErrorSchema) {
-
-                    erreurs = { ...erreurs, ...error.errors };
-                    errorsCount += Object.keys(error.errors).length;
-
-                } else if (error instanceof CoreError) {
-
-                    erreurs[cheminAstr] = [error.message]
-                    errorsCount++;
-
-                } else if (SERVER) {
-
-                    // Server: transmiss error & report bug
-                    throw error;
-
-                } else {
-
-                    console.error(LogPrefix, '[' + cheminA + ']', error);
-                    erreurs[cheminAstr] = ["Technical error while validating data"];
-                    errorsCount++;
-                }
-            }
-        }
-    
-        if (errorsCount !== 0)
-            throw new InputErrorSchema(erreurs);
-        
-        opts.debug && console.log(LogPrefix, '', dataToValidate, '=>', output);
-    
-        return output as TValidatedData<TFields>;
-    }
-
-    public validateWithDetails<TDonnees extends TObjetDonnees>(
-    
-        dataToValidate: Partial<TDonnees>,
-        allData: TDonnees,
-        output: TObjetDonnees = {},
-    
-        opts: TValidateOptions<TFields> = {},
-        chemin: string[] = []
-    
-    ): TValidationResult<TFields> {
-
-        let erreurs: TListeErreursSaisie = {};
-        let errorsCount = 0;
-
-        try {
-            this.validate(dataToValidate, opts, chemin);
-        } catch (error) {
-            if (error instanceof InputErrorSchema) {
-                erreurs = error.errors;
-                errorsCount = Object.keys(erreurs).length;
-            } else {
-                throw error;
-            }
-        }
-
-        return { 
-            values: output as TValidatedData<TFields>,
-            erreurs, 
-            errorsCount, 
-        };
-    }
-}

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

@@ -1,117 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import type { ComponentChild } from 'preact'
-
-// Core
-import { InputError } from '@common/errors';
-
-// Specific
-import type { TValidateOptions } from './schema';
-import type { SchemaValidators } from './validators';
-import type { InputBaseProps } from '@client/components/utils';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TValidatorDefinition<K extends keyof SchemaValidators = keyof SchemaValidators> = [
-    type: string, 
-    args: any[], 
-    returnType: string
-]
-
-// TODO: remove
-export type TValidatorOptions<TValue> = {
-
-    rendu?: TFieldRenderer,
-
-    // I don't remind what is options.activer about
-    activer?: (donnees: TObjetDonnees) => boolean,
-    onglet?: string, // Sert juste d'identifiant secondaire. Ex: nom onglet correspondant
-
-    // Executé après le validateur propre au type
-    dependances?: string[],
-    opt?: true,
-    defaut?: TValue,
-
-}
-
-export type TFieldRenderer = (props: any) => ComponentChild;
-
-type TNonEmptyValue = Exclude<any, undefined | '' | null>
-
-type TValidationArgs<TValue, TAllValues extends {}> = [
-    // For the value given as input in the validation function,
-    //  Only the empty values were escluded
-    val: TNonEmptyValue, 
-    validateOptions: TValidateOptions,
-    path: string[]
-]
-
-type TValidationFunction<TValue, TAllValues extends {} = {}> = (
-    ...args: TValidationArgs<TValue, TAllValues>
-) => TValue | typeof EXCLUDE_VALUE;
-
-type TValidateReturnType<
-    TOptions extends TValidatorOptions<TValue>, 
-    TValue extends any
-> = TOptions extends { opt: true } 
-    ? (undefined | TValue) 
-    : TValue
-
-/*----------------------------------
-- CONST
-----------------------------------*/
-
-export const EXCLUDE_VALUE = "action:exclure" as const;
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export default class Validator<
-    TValue, 
-    TOptions extends TValidatorOptions<TValue> = TValidatorOptions<TValue>,
-    //TComponent = React.FunctionComponent< InputBaseProps< TValue > >
-> {
-
-    public constructor( 
-        public type: string,
-        public validateType: TValidationFunction<TValue>, 
-        public options: TOptions,
-        public componentAttributes: Partial<InputBaseProps<TValue>> = {}
-    ) {
-
-        // Basic component attriutes
-        this.componentAttributes.required = options?.opt !== true;
-        //this.componentAttributes.validator = this;
-
-    }
-
-    public isEmpty = (val: any) => val === undefined || val === '' || val === null
-
-    public validate(...[ 
-        val, validateOptions, path
-    ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
-
-        // Required value
-        if (this.isEmpty(val)) {
-            // Optionnel, on skip
-            if (this.options.opt === true || (
-                validateOptions?.ignoreMissing === true
-                &&
-                val === undefined
-            ))
-                return undefined as TValidateReturnType<TOptions, TValue>;
-            // Requis
-            else
-                throw new InputError("Please enter a value");
-        }
-
-        // Validate type
-        return this.validateType(val, validateOptions, path) as TValidateReturnType<TOptions, TValue>;
-    }
-
-}

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

@@ -1,485 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import trim from 'validator/lib/trim';
-import isISO8601 from 'validator/lib/isISO8601';
-import toDate from 'validator/lib/toDate';
-import isEmail from 'validator/lib/isEmail';
-import isURL from 'validator/lib/isURL';
-
-import normalizeUrl, { Options as NormalizeUrlOptions } from 'normalize-url';
-
-// Core
-import { InputError } from '@common/errors';
-
-// Speciific
-import Schema, { TSchemaFields } from './schema'
-import Validator, { TValidatorOptions, EXCLUDE_VALUE, TValidatorDefinition } from './validator'
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TFileValidator = TValidatorOptions<File> & {
-    type?: string[], // Raccourci, ou liste de mimetype
-    taille?: number,
-    disk?: string, // Disk to upload files to
-}
-
-type TSchemaSubtype = Schema<{}> | TSchemaFields | TValidatorDefinition;
-
-type TSubtype = TSchemaSubtype | Validator<any> | TValidatorDefinition;
-
-/*----------------------------------
-- CONST
-----------------------------------*/
-
-export type TRichTextValidatorOptions = {
-    attachements?: TFileValidator
-}
-
-export const getFieldValidator = (field: TValidatorDefinition) => {
-
-    if (Array.isArray(field)) {
-
-        const [validatorName, validatorArgs] = field;
-        const getValidator = validators[validatorName];
-        if (getValidator === undefined)
-            throw new Error('Unknown validator: ' + validatorName);
-
-        return getValidator(...validatorArgs);
-
-        // TSchemaFields
-    } else if (field.constructor === Object) {
-
-        return new Schema(field as TSchemaFields);
-
-        // Schema
-    } else
-        return field as Validator<any>
-}
-
-// Recursive function to validate each node
-function validateLexicalNode(node: any, opts: TRichTextValidatorOptions ) {
-
-    // Each node should be an object with a `type` property
-    if (typeof node !== 'object' || !node.type || typeof node.type !== 'string')
-        throw new InputError("Invalid rich text value (3).");
-
-    // Validate text nodes
-    if (node.type === 'text') {
-
-        if (typeof node.text !== 'string')
-            throw new InputError("Invalid rich text value (4).");
-
-        // Validate paragraph, heading, or other structural nodes that may contain children
-    } else if (['paragraph', 'heading', 'list', 'listitem'].includes(node.type)) {
-
-        if (!Array.isArray(node.children) || !node.children.every(children => validateLexicalNode(children, opts))) {
-            throw new InputError("Invalid rich text value (5).");
-        }
-
-        // Files upload
-    } else if (node.type === 'image') {
-
-        // Check if allowed
-        /*if (opts.attachements === undefined)
-            throw new InputError("Image attachments not allowed in this rich text field.");*/
-
-        // TODO: check mime
-
-
-        // Upload file
-
-
-    }
-
-    return true;
-}
-
-/*----------------------------------
-- CLASS
-----------------------------------*/
-export class SchemaValidators {
-
-    /*----------------------------------
-    - UTILITIES
-    ----------------------------------*/
-    // Make every field optional
-    public partial = <TFields extends TSchemaFields>(schema: TFields, fieldsList?: (keyof TFields)[] ) => {
-
-        if (fieldsList === undefined)
-            fieldsList = Object.keys(schema) as (keyof TFields)[];
-
-        const partialSchema: Partial<TFields> = {};
-        for (const key of fieldsList) {
-
-            if (!(key in schema))
-                throw new Error("The field " + key + " is not in the schema.");
-
-            // Only if validator
-            if (schema[key] instanceof Validator)
-                partialSchema[key] = new Validator(schema[key].type, schema[key].validateType, {
-                    ...schema[key].options,
-                    opt: true
-                });
-            else
-                partialSchema[key] = schema[key];
-        }
-
-        return partialSchema as TFields;
-    }
-
-    /*----------------------------------
-    - CONTENEURS
-    ----------------------------------*/
-    public object = ( subtype?: TSchemaSubtype, { ...opts }: TValidatorOptions<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.");
-
-            // If no subtype, return the object as is
-            if (subtype === undefined)
-                return val;
-
-            // If subtype is a schema
-            const schema = getFieldValidator(subtype) as Schema<{}>;
-
-            // Validate schema
-            const value = schema.validate(val, options, path);
-            
-            return value;
-        }, opts)
-
-    public array = ( subtype: TSubtype, { choice, min, max, ...opts }: TValidatorOptions<any[]> & {
-        choice?: any[],
-        min?: number, 
-        max?: number
-    } = {}) => new Validator<any[]>('array', (items, options, path) => {
-
-        // Type
-        if (!Array.isArray(items))
-            throw new InputError("This value must be a list.");
-
-        // Items number
-        if ((min !== undefined && items.length < min))
-            throw new InputError(`Please select at least ${min} items.`);
-        if ((max !== undefined && items.length > max))
-            throw new InputError(`Please select maximum ${max} items.`);
-
-        // Verif each item
-        if (subtype === undefined)
-            return items;
-
-        const validator = getFieldValidator(subtype);
-
-        items = items.map( item =>
-            validator.validate( item, options, path )
-        )
-
-        return items;
-    }, {
-        ...opts,
-        //multiple: true, // Sélection multiple
-    })
-
-    public choice = (choices?: any[], { multiple, ...opts }: TValidatorOptions<any> & { 
-        multiple?: boolean 
-    } = {}) => new Validator<any>('choice', (val, options, path) => {
-
-        // Empty array = undefined if not required
-        if (val.length === 0 && opts.opt)
-            return undefined;
-
-        // Normalize for verifications
-        const choicesValues = choices?.map(v => typeof v === 'object' ? v.value : v)
-
-        const checkChoice = ( choice: any ) => {
-
-            // Choice object = extract value
-            //  We check for choice objec via the label prop, as the value can be undefined (and so, not transmitted)
-            if (typeof choice === 'object' && ('label' in choice) && typeof choice.label === 'string' && typeof choice.value !== 'object')
-                choice = choice.value;
-
-            // If choices list rpovided, check if the choice is in the choices list
-            if (choicesValues !== undefined && !choicesValues.includes(choice))
-                throw new InputError("Invalid value: " + choice + ". Must be: " + choicesValues.join(', '));
-
-            return choice;
-
-        }
-
-        // Check every choice
-        if (Array.isArray( val ))
-            val = val.map(checkChoice)
-        else 
-            val = checkChoice( val );
-
-        return val;
-
-    }, opts, { choices, multiple })
-
-    /*----------------------------------
-    - CHAINES
-    ----------------------------------*/
-    public string = ({ min, max, in: choices, ...opts }: TValidatorOptions<string> & { 
-        min?: number, 
-        max?: number,
-        in?: string[]
-    } = {}) => new Validator<string>('string', (val, options, path) => {
-
-        // Check type
-        if (val === '')
-            return undefined;
-        else if (typeof val === 'number')
-            return val.toString();
-        else if (typeof val !== 'string')
-            throw new InputError("This value must be a string.");
-
-        // 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 (options?.autoCorrect)
-                val = val.substring(0, max);
-            else
-                throw new InputError(`Must be up to ` + max + ' characters');
-
-        return val;
-        
-    }, opts)
-
-    public url = (opts: TValidatorOptions<string> & {
-        normalize?: NormalizeUrlOptions
-    } = {}) => 
-        new Validator<string>('url', (inputVal, options, path) => {
-
-            let val = this.string(opts).validate(inputVal, options, path);
-
-            // Check if URL
-            if (!isURL(val, {
-                // https://www.npmjs.com/package/validator
-            }))
-                throw new InputError(`Please provide a valid URL.`);
-
-            // Normalize
-            if (opts.normalize !== undefined)
-                val = normalizeUrl(val, opts.normalize);
-
-            return val;
-        }, opts)
-
-    public email = (opts: TValidatorOptions<string> & {} = {}) => 
-        new Validator<string>('email', (inputVal, options, path) => {
-
-            let val = this.string(opts).validate(inputVal, options, path);
-
-            if (!isEmail(val))
-                throw new InputError("Please enter a valid email address.");
-
-            // Disable normalzation !!! We should keep the email as it was entered by the user
-            /*const normalizedEmail = normalizeEmail(val, {
-                all_lowercase: true,
-                gmail_lowercase: true,
-                gmail_remove_dots: false,
-                gmail_remove_subaddress: true,
-                gmail_convert_googlemaildotcom: true,
-              
-                outlookdotcom_lowercase: true,
-                outlookdotcom_remove_subaddress: true,
-              
-                yahoo_lowercase: true,
-                yahoo_remove_subaddress: true,
-              
-                yandex_lowercase: true,
-
-                icloud_lowercase: true,
-                icloud_remove_subaddress: true,
-            });*/
-
-            const normalizedEmail = val.toLowerCase();
-            console.log("validate email, inou", val, normalizedEmail);
-
-            return normalizedEmail;
-        }, opts)
-
-    /*----------------------------------
-    - NOMBRES
-    ----------------------------------*/
-    // On ne spread pas min et max afin quils soient passés dans les props du composant
-    public number = (withDecimals: boolean) => ({ ...opts }: TValidatorOptions<number> & {
-        min?: number,
-        max?: number,
-        step?: number,
-    } = {}) => 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 (options?.autoCorrect)
-                val = opts.min;
-            else
-                throw new InputError("This value must be a number.");
-        }
-
-        // 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;
-    }, {
-        // Force une valeur par défaut si requis
-        defaut: opts.opt ? undefined : (opts.min || 0),
-        ...opts,
-    })
-
-    public int = this.number(false)   
-
-    public float = this.number(true) 
-
-    public bool = (opts: TValidatorOptions<boolean> & {} = {}) => 
-        new Validator<boolean>('bool', (val, options, path) => {
-
-            if (typeof val !== 'boolean' && !['true', 'false'].includes(val))
-                throw new InputError("This value must be a boolean.");
-
-            val = !!val;
-
-            return val;
-        }, {
-            defaut: false,
-            ...opts
-        })
-
-    /*----------------------------------
-    - AUTRES
-    ----------------------------------*/
-    public date = (opts: TValidatorOptions<Date> & {
-
-    } = {}) => new Validator<Date>('date', (val, options, path) => {
-
-        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 val;
-
-    }, {
-        //defaut: new Date,
-        ...opts,
-    })
-
-    public richText(opts: TValidatorOptions<string> & TRichTextValidatorOptions = {}) {
-        return new Validator<string>('richText', (val, options, path) => {
-
-            // We get a stringified json as input since the editor workds with JSON string
-            try {
-                val = JSON.parse(val);
-            } catch (error) {
-                console.error("Failed to parse rich text json:", error, val);
-                throw new InputError("Invalid rich text format.");
-            }
-
-            // Check that the root exists and has a valid type
-            if (!val || typeof val !== 'object' || typeof val.root !== 'object' || val.root.type !== 'root')
-                throw new InputError("Invalid rich text value (1).");
-
-            // Check if root has children array
-            if (!Array.isArray(val.root.children))
-                throw new InputError("Invalid rich text value (2).");
-
-            // Validate each child node in root
-            for (const child of val.root.children) {
-                validateLexicalNode(child, opts);
-            }
-
-            return val;
-
-        }, {
-            //defaut: new Date,
-            ...opts,
-        })
-    }
-
-    /*----------------------------------
-    - FICHIER
-    ----------------------------------*/
-    public file = ({ type, taille, ...opts }: TFileValidator & {
-
-    } = {}) => new Validator<File>('file', (val, options, path) => {
-
-        // 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 EXCLUDE_VALUE;
-
-        if (!(val instanceof File))
-            throw new InputError(`Must be a File (${typeof val} received)`);
-
-        // MIME
-        if (type !== undefined) {
-
-            const mimeMatch = type.some( t => t === val.type || val.type.startsWith(t + '/') );
-            if (!mimeMatch)
-                throw new InputError('Only the following formats are allowed: ' + type.join(', ') + '. The file you gave is ' + val.type + '.');
-
-        }
-
-        // 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 val;
-
-    }, {
-        //defaut: new Date,
-        ...opts,
-    })
-}
-
-const validators = new SchemaValidators();
-
-export default validators;