5htp-core 0.4.8 → 0.4.9-1

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: K, 
+    args: Parameters<SchemaValidators[K]>, 
+    returnType: ReturnType<SchemaValidators[K]> 
+]
+
+// 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/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 }

package/src/{common/data/rte/index.ts → server/utils/rte.ts}

@@ -1,26 +1,35 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { $generateNodesFromDOM, $generateHtmlFromNodes } from '@lexical/html'; 
-import { $getRoot } from 'lexical';
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
 
+// Npm
+import { createHeadlessEditor } from '@lexical/headless';
+import { $generateNodesFromDOM, $generateHtmlFromNodes } from '@lexical/html';
+import { $getRoot, SerializedEditorState } from 'lexical';
 import { JSDOM } from 'jsdom';
 
-import editorNodes from './nodes';
+// Core
+import editorNodes from '@common/data/rte/nodes';
+import ExampleTheme from '@client/components/inputv3/Rte/themes/PlaygroundEditorTheme';
 
-export const htmlToJson = async (htmlString: string) => {
+/*----------------------------------
+- FUNCTIONS
+----------------------------------*/
+export const htmlToJson = async (htmlString: string): Promise<SerializedEditorState> => {
 
-    const editor = createHeadlessEditor({ 
-        nodes: editorNodes 
+    const editor = createHeadlessEditor({
+        nodes: editorNodes,
+        theme: ExampleTheme,
     });
-    
+
     await editor.update(() => {
 
         const root = $getRoot();
 
-        // In a headless environment you can use a package such as JSDom to parse the HTML string.
         const dom = new JSDOM(htmlString);
 
         // Once you have the DOM instance it's easy to generate LexicalNodes.
-        const lexicalNodes = $generateNodesFromDOM(editor, dom.window.document);
+        const lexicalNodes = $generateNodesFromDOM(editor, dom ? dom.window.document : window.document);
 
         lexicalNodes.forEach((node) => root.append(node));
     });
@@ -30,18 +39,20 @@ export const htmlToJson = async (htmlString: string) => {
 };
 
 export const jsonToHtml = async (jsonString: string) => {
-    
 
+    // Server side: simulate DOM environment
     const dom = new JSDOM(`<!DOCTYPE html><body></body>`);
     global.window = dom.window;
     global.document = dom.window.document;
     global.DOMParser = dom.window.DOMParser;
     global.MutationObserver = dom.window.MutationObserver;
-    
+
     // Create a headless Lexical editor instance
     const editor = createHeadlessEditor({
         namespace: 'headless',
         editable: false,
+        nodes: editorNodes,
+        theme: ExampleTheme,
     });
 
     // Set the editor state from JSON
@@ -49,14 +60,14 @@ export const jsonToHtml = async (jsonString: string) => {
     if (state.isEmpty())
         return null;
 
-    editor.setEditorState( state );
+    editor.setEditorState(state);
 
     // Generate HTML from the Lexical nodes
     const html = await editor.getEditorState().read(() => {
         return $generateHtmlFromNodes(editor);
-    });  
-    
-    // Clean up global variables set for JSDOM to avoid memory leaks
+    });
+
+        // Clean up global variables set for JSDOM to avoid memory leaks
     delete global.window;
     delete global.document;
     delete global.DOMParser;

package/src/client/components/inputv3/Rte/ExampleTheme.tsx

@@ -1,42 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-export default {
-    code: 'editor-code',
-    heading: {
-        h1: 'editor-heading-h1',
-        h2: 'editor-heading-h2',
-        h3: 'editor-heading-h3',
-        h4: 'editor-heading-h4',
-        h5: 'editor-heading-h5',
-    },
-    image: 'editor-image',
-    link: 'editor-link',
-    list: {
-        listitem: 'editor-listitem',
-        nested: {
-            listitem: 'editor-nested-listitem',
-        },
-        ol: 'editor-list-ol',
-        ul: 'editor-list-ul',
-    },
-    ltr: 'ltr',
-    paragraph: 'editor-paragraph',
-    placeholder: 'editor-placeholder',
-    quote: 'editor-quote',
-    rtl: 'rtl',
-    text: {
-        bold: 'editor-text-bold',
-        code: 'editor-text-code',
-        hashtag: 'editor-text-hashtag',
-        italic: 'editor-text-italic',
-        overflowed: 'editor-text-overflowed',
-        strikethrough: 'editor-text-strikethrough',
-        underline: 'editor-text-underline',
-        underlineStrikethrough: 'editor-text-underlineStrikethrough',
-    },
-};