5htp-core 0.4.8 → 0.4.9-2

package/src/common/validation/schema.ts

@@ -6,13 +6,16 @@
 import { CoreError, TListeErreursSaisie, InputErrorSchema } from '@common/errors';
 
 // Specific
-import { default as Validator, EXCLUDE_VALUE } from './validator';
+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> }
+export type TSchemaFields = { 
+    [fieldName: string]: TSchemaFields | Schema<{}> | Validator<any> | TValidatorDefinition
+}
 
 type TSchemaOptions = {
     opt?: boolean
@@ -25,6 +28,7 @@ export type TValidateOptions<TFields extends TSchemaFields = {}> = {
     only?: (keyof TFields)[],
     validateDeps?: boolean,
     autoCorrect?: boolean,
+    validators?: SchemaValidators
 }
 
 export type TValidationResult<TFields extends TSchemaFields> = {
@@ -38,9 +42,15 @@ export type TSchemaData<TSchema extends Schema<{}>> =
 
 export type TValidatedData<TFields extends TSchemaFields> = {
     // For each field, the values returned by validator.validate()
-    [name in keyof TFields]: ReturnType<TFields[name]["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
 ----------------------------------*/
@@ -59,12 +69,29 @@ export default class Schema<TFields extends TSchemaFields> {
 
     }
 
+    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'] });
@@ -86,16 +113,11 @@ export default class Schema<TFields extends TSchemaFields> {
         let errorsCount = 0;
         for (const fieldName of keysToValidate) {
     
-            // La donnée est répertoriée dans le schema
-            let field = this.fields[fieldName];
-            let validator: Validator<any> | Schema<{}>;
-            if (field === undefined) {
+            const validator = this.getFieldValidator(fieldName, validators);
+            if (validator === null) {
                 opts.debug && console.warn(LogPrefix, '[' + fieldName + ']', 'Exclusion (pas présent dans le schéma)');
                 continue;
-            } else if (field.constructor === Object)
-                validator = new Schema(field as TSchemaFields);
-            else
-                validator = field as Validator<any>;
+            }
 
             // Create field path
             const cheminA = [...chemin, fieldName]
@@ -140,6 +162,7 @@ export default class Schema<TFields extends TSchemaFields> {
 
                 } else {
 
+                    console.error(LogPrefix, '[' + cheminA + ']', error);
                     erreurs[cheminAstr] = ["Technical error while validating data"];
                     errorsCount++;
                 }

package/src/common/validation/validator.ts

@@ -10,13 +10,21 @@ import { InputError } from '@common/errors';
 
 // Specific
 import type { TValidateOptions } from './schema';
+import type { SchemaValidators } from './validators';
 import type { InputBaseProps } from '@client/components/inputv3/base';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export type TValidator<TValue> = {
+export type TValidatorDefinition<K extends keyof SchemaValidators = keyof SchemaValidators> = [
+    type: string, 
+    args: any[], 
+    returnType: string
+]
+
+// TODO: remove
+export type TValidatorOptions<TValue> = {
 
     rendu?: TFieldRenderer,
 
@@ -48,7 +56,7 @@ type TValidationFunction<TValue, TAllValues extends {} = {}> = (
 ) => TValue | typeof EXCLUDE_VALUE;
 
 type TValidateReturnType<
-    TOptions extends TValidator<TValue>, 
+    TOptions extends TValidatorOptions<TValue>, 
     TValue extends any
 > = TOptions extends { opt: true } 
     ? (undefined | TValue) 
@@ -65,8 +73,8 @@ export const EXCLUDE_VALUE = "action:exclure" as const;
 ----------------------------------*/
 export default class Validator<
     TValue, 
-    TOptions extends TValidator<TValue> = TValidator<TValue>,
-    TComponent = React.FunctionComponent< InputBaseProps< TValue > >
+    TOptions extends TValidatorOptions<TValue> = TValidatorOptions<TValue>,
+    //TComponent = React.FunctionComponent< InputBaseProps< TValue > >
 > {
 
     public constructor( 

package/src/common/validation/validators.ts

@@ -17,29 +17,93 @@ import FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
 // Speciific
 import Schema, { TSchemaFields } from './schema'
-import Validator, { TValidator, EXCLUDE_VALUE } from './validator'
+import Validator, { TValidatorOptions, EXCLUDE_VALUE, TValidatorDefinition } from './validator'
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export type TFileValidator = TValidator<FileToUpload> & {
+export type TFileValidator = TValidatorOptions<FileToUpload> & {
     type?: string[], // Raccourci, ou liste de mimetype
-    taille?: number
+    taille?: number,
+    disk?: string, // Disk to upload files to
 }
 
-type TSchemaSubtype = Schema<{}> | TSchemaFields;
+type TSchemaSubtype = Schema<{}> | TSchemaFields | TValidatorDefinition;
 
-type TSubtype = TSchemaSubtype | Validator<any>;
+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 default class SchemaValidators {
+export class SchemaValidators {
 
     /*----------------------------------
     - UTILITIES
@@ -72,7 +136,7 @@ export default class SchemaValidators {
     /*----------------------------------
     - CONTENEURS
     ----------------------------------*/
-    public object = ( subtype?: TSchemaSubtype, { ...opts }: TValidator<object> & {
+    public object = ( subtype?: TSchemaSubtype, { ...opts }: TValidatorOptions<object> & {
 
     } = {}) => 
         new Validator<object>('object', (val, options, path) => {
@@ -86,9 +150,7 @@ export default class SchemaValidators {
                 return val;
 
             // If subtype is a schema
-            const schema = subtype.constructor === Object 
-                ? new Schema(subtype as TSchemaFields) 
-                : subtype as Schema<{}>;
+            const schema = getFieldValidator(subtype) as Schema<{}>;
 
             // Validate schema
             const value = schema.validate(val, options, path);
@@ -96,7 +158,7 @@ export default class SchemaValidators {
             return value;
         }, opts)
 
-    public array = ( subtype: TSubtype, { choice, min, max, ...opts }: TValidator<any[]> & {
+    public array = ( subtype: TSubtype, { choice, min, max, ...opts }: TValidatorOptions<any[]> & {
         choice?: any[],
         min?: number, 
         max?: number
@@ -116,9 +178,7 @@ export default class SchemaValidators {
         if (subtype === undefined)
             return items;
 
-        const validator = subtype.constructor === Object
-            ? new Schema(subtype as TSchemaFields)
-            : subtype as Schema<{}> | Validator<any>;
+        const validator = getFieldValidator(subtype);
 
         items = items.map( item =>
             validator.validate( item, options, path )
@@ -130,7 +190,7 @@ export default class SchemaValidators {
         //multiple: true, // Sélection multiple
     })
 
-    public choice = (choices?: any[], { multiple, ...opts }: TValidator<any> & { 
+    public choice = (choices?: any[], { multiple, ...opts }: TValidatorOptions<any> & { 
         multiple?: boolean 
     } = {}) => new Validator<any>('choice', (val, options, path) => {
 
@@ -169,7 +229,7 @@ export default class SchemaValidators {
     /*----------------------------------
     - CHAINES
     ----------------------------------*/
-    public string = ({ min, max, in: choices, ...opts }: TValidator<string> & { 
+    public string = ({ min, max, in: choices, ...opts }: TValidatorOptions<string> & { 
         min?: number, 
         max?: number,
         in?: string[]
@@ -205,7 +265,7 @@ export default class SchemaValidators {
         
     }, opts)
 
-    public url = (opts: TValidator<string> & {
+    public url = (opts: TValidatorOptions<string> & {
         normalize?: NormalizeUrlOptions
     } = {}) => 
         new Validator<string>('url', (inputVal, options, path) => {
@@ -225,7 +285,7 @@ export default class SchemaValidators {
             return val;
         }, opts)
 
-    public email = (opts: TValidator<string> & {} = {}) => 
+    public email = (opts: TValidatorOptions<string> & {} = {}) => 
         new Validator<string>('email', (inputVal, options, path) => {
 
             let val = this.string(opts).validate(inputVal, options, path);
@@ -263,7 +323,7 @@ export default class SchemaValidators {
     - NOMBRES
     ----------------------------------*/
     // On ne spread pas min et max afin quils soient passés dans les props du composant
-    public number = (withDecimals: boolean) => ({ ...opts }: TValidator<number> & {
+    public number = (withDecimals: boolean) => ({ ...opts }: TValidatorOptions<number> & {
         min?: number,
         max?: number,
         step?: number,
@@ -309,7 +369,7 @@ export default class SchemaValidators {
 
     public float = this.number(true) 
 
-    public bool = (opts: TValidator<boolean> & {} = {}) => 
+    public bool = (opts: TValidatorOptions<boolean> & {} = {}) => 
         new Validator<boolean>('bool', (val, options, path) => {
 
             if (typeof val !== 'boolean' && !['true', 'false'].includes(val))
@@ -326,7 +386,7 @@ export default class SchemaValidators {
     /*----------------------------------
     - AUTRES
     ----------------------------------*/
-    public date = (opts: TValidator<Date> & {
+    public date = (opts: TValidatorOptions<Date> & {
 
     } = {}) => new Validator<Date>('date', (val, options, path) => {
 
@@ -350,50 +410,36 @@ export default class SchemaValidators {
         ...opts,
     })
 
-    public richText = (opts: TValidator<string> & {
-        
-    } = {}) => new Validator<string>('richText', (val, options, path) => {
-
-        // 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).");
-
-        // Recursive function to validate each node
-        function validateNode(node) {
-            // 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).");
-            }
+    public richText(opts: TValidatorOptions<string> & TRichTextValidatorOptions = {}) {
+        return new Validator<string>('richText', (val, options, path) => {
 
-            // Validate paragraph, heading, or other structural nodes that may contain children
-            if (['paragraph', 'heading', 'list', 'listitem'].includes(node.type))
-                if (!Array.isArray(node.children) || !node.children.every(validateNode)) {
-                    throw new InputError("Invalid rich text value (5).");
+            // We get a stringified json as input since the editor workds with JSON string
+            try {
+                val = JSON.parse(val);
+            } catch (error) {
+                throw new InputError("Invalid rich text format.");
             }
 
-            return true;
-        }
+            // 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).");
 
-        // Validate each child node in root
-        for (const child of val.root.children) {
-            validateNode(child);
-        }
+            // Check if root has children array
+            if (!Array.isArray(val.root.children))
+                throw new InputError("Invalid rich text value (2).");
 
-        return val;
+            // Validate each child node in root
+            for (const child of val.root.children) {
+                validateLexicalNode(child, opts);
+            }
 
-    }, {
-        //defaut: new Date,
-        ...opts,
-    })
+            return val;
+
+        }, {
+            //defaut: new Date,
+            ...opts,
+        })
+    }
 
     /*----------------------------------
     - FICHIER
@@ -402,14 +448,14 @@ export default class SchemaValidators {
 
     } = {}) => new Validator<FileToUpload>('file', (val, options, path) => {
 
-        if (!(val instanceof FileToUpload))
-            throw new InputError(`Must be a File (${typeof val} received)`);
-
         // 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 FileToUpload))
+            throw new InputError(`Must be a File (${typeof val} received)`);
+
         // MIME
         if (type !== undefined) {
 
@@ -432,5 +478,8 @@ export default class SchemaValidators {
         //defaut: new Date,
         ...opts,
     })
+}
+
+const validators = new SchemaValidators();
 
-}
+export default validators;

package/src/server/services/router/http/multipart.ts

@@ -4,7 +4,6 @@
 
 // Npm
 import mime from 'mime-types';
-import multer from 'multer';
 
 // Core
 import FileToUpload from '@client/components/inputv3/file/FileToUpload';

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

@@ -44,7 +44,7 @@ export default class ServerRequest<
 
     // Requete
     public method: HttpMethod;
-    public ip: string;
+    public ip?: string;
     public locale: string;
     public domain: string;
     public headers: HttpHeaders = {};

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

@@ -3,11 +3,11 @@
 ----------------------------------*/
 
 // Core
+import type { Application } from '@server/app';
 
 // Specific
-import SchemaValidator, { TFileValidator } from '@common/validation/validators';
-
-import Validator, { EXCLUDE_VALUE,} from '@common/validation/validator';
+import { SchemaValidators, TFileValidator } from '@common/validation/validators';
+import Validator, { TValidatorOptions } from '@common/validation/validator';
 
 import type FileToUpload from '@client/components/inputv3/file/FileToUpload';
 
@@ -19,6 +19,28 @@ import type FileToUpload from '@client/components/inputv3/file/FileToUpload';
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class ServerSchemaValidator extends SchemaValidator {
+export default class ServerSchemaValidator extends SchemaValidators {
+
+    public constructor( public app: Application ) {
+        super();
+    }
+
+    public richText = (opts: TValidatorOptions<string> & {
+        attachements?: TFileValidator
+    } = {}) => new Validator<string>('richText', (val, options, path) => {
+
+        // Default validation
+        val = super.richText(opts).validate(val, options, path);
+
+        // Uploads are done in the business code since the process is specific to every case:
+        // - ID in the destination directory
+        // - Cleanup before upload
+
+        return val;
+
+    }, {
+        //defaut: new Date,
+        ...opts,
+    })
 
 }

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

@@ -34,7 +34,7 @@ export default class RequestValidator extends ServerSchemaValidator implements R
         public app = router.app
     ) {
 
-        super();
+        super(app);
 
     }
 
@@ -49,7 +49,8 @@ export default class RequestValidator extends ServerSchemaValidator implements R
         // 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
+            validateDeps: false,
+            validators: this
         }, []);
 
         return values;

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

@@ -0,0 +1,110 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Node
+import path from 'path';
+import md5 from 'md5';
+import { fromBuffer } from 'file-type';
+
+// Npm
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+
+// Core
+import type Driver from '@server/services/disks/driver';
+
+type SerializedLexicalNodeWithSrc = SerializedLexicalNode & { src: string };
+
+/*----------------------------------
+- METHODS
+----------------------------------*/
+const uploadAttachments = async ( 
+    value: SerializedEditorState, 
+    disk: Driver, 
+    destination: string,
+    oldState?: SerializedEditorState
+) => {
+
+    const usedFilesUrl: string[] = [];
+
+    // Deep check for images / files
+    const findFiles = async (
+        node: SerializedLexicalNode,
+        callback: (node: SerializedLexicalNodeWithSrc) => Promise<void>
+    ) => {
+
+        // Attachment
+        if (node.type === 'image' || node.type === 'file') {
+            if (typeof node.src === 'string') {
+                await callback(node as SerializedLexicalNodeWithSrc);
+            }
+            // Recursion
+        } else if (node.children) {
+            for (const child of node.children) {
+                await findFiles(child, callback);
+            }
+        }
+    }
+
+    const uploadFile = async (node: SerializedLexicalNodeWithSrc) => {
+
+        // Already uploaded
+        if (!node.src.startsWith('data:')) {
+            usedFilesUrl.push(node.src);
+            return node.src;
+        }
+
+        // Transform into buffer
+        node.src = node.src.replace(/^data:\w+\/\w+;base64,/, '');
+        const fileData = Buffer.from(node.src, 'base64');
+
+        // Parse file type from buffer
+        const fileType = await fromBuffer(fileData);
+        if (!fileType)
+            throw new Error('Failed to detect file type');
+
+        // Upload file to disk
+        const fileName = md5(node.src) + '.' + fileType.ext;
+        const filePath = path.join(destination, fileName);
+        const upoadedFile = await disk.outputFile('data', filePath, fileData, {
+            encoding: 'binary'
+        });
+
+        // Replace node.src with url
+        node.src = upoadedFile.path;
+        usedFilesUrl.push(node.src);
+    }
+
+    const deleteUnusedFile = async (node: SerializedLexicalNodeWithSrc) => {
+
+        // Should be a URL
+        if (node.src.startsWith('data:') || !node.src.startsWith('http'))
+            return;
+
+        // This file is used
+        if (usedFilesUrl.includes(node.src))
+            return;
+
+        // Extract file name
+        const fileName = path.basename(node.src);
+        const filePath = path.join(destination, fileName);
+
+        // Delete file from disk
+        await disk.delete('data', filePath);
+        console.log('Deleted file:', filePath);
+    }
+
+    // Find files in the editor state
+    for (const child of value.root.children) {
+        await findFiles(child, uploadFile);
+    }
+
+    // Old state given: remove unused attachments
+    if (oldState !== undefined) {
+        for (const child of oldState.root.children) {
+            await findFiles(child, deleteUnusedFile);
+        }
+    }
+}
+
+export default { uploadAttachments }