5htp-core 0.6.2 → 0.6.3-2

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

@@ -0,0 +1,180 @@
+import { InputError } from '@common/errors';
+import zod, { _ZodType } from 'zod';
+
+export type TRichTextValidatorOptions = {
+    attachements?: boolean
+}
+
+export const preprocessSchema = (schema: zod.ZodObject): zod.ZodObject => {
+
+    // Not working, data is {}
+    return schema;
+
+    if (!(schema instanceof zod.ZodObject))
+        return schema;
+
+    if (schema.withPreprocessing)
+        return schema;
+
+    const shape = schema.def.shape;
+    const newShape: Record<string, zod.ZodTypeAny> = {};
+
+    for (const key in shape) {
+
+        if (!['newEntity', 'email'].includes(key))
+            continue;
+
+        let current: zod.ZodTypeAny = shape[key];
+        while (current) {
+            
+            const origType = current.type;
+            const preprocessor = toPreprocess[origType];
+
+            if (origType === 'object') {
+                newShape[key] = preprocessSchema(current as zod.ZodObject);
+                break;
+            }
+
+            if (preprocessor) {
+                newShape[key] = preprocessor(current);
+                console.log('====newShape', key, newShape[key]);
+                break;
+            }
+
+            current = current.def;
+        }
+    }
+
+    const newSchema = zod.object(newShape);
+    newSchema.withPreprocessing = true;
+    return newSchema;
+}
+
+const toPreprocess = {
+
+    string: (zString: zod.ZodString) => zod.preprocess( val => {
+        return val === '' ? undefined : val;
+    }, zString),
+
+    int: (zInt: zod.ZodInt) => zod.preprocess( val => {
+        return typeof val === 'string' ? Number.parseInt(val) : val;
+    }, zInt),
+
+}
+
+export const schema = { 
+    ...zod,  
+
+    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;*/
+
+        return zod.file();
+    },
+
+    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 => {
+
+        if (typeof val !== 'string') {
+            console.error("Invalid rich text format.", val);
+            return false;
+        }
+
+        // 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);
+            return false;//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') {
+            console.error("Invalid rich text value (1).", val);
+            return false;//throw new InputError("Invalid rich text value (1).");
+        }
+
+        // Check if root has children array
+        if (!Array.isArray(val.root.children)) {
+            console.error("Invalid rich text value (2).", val);
+            return false;
+        }
+
+        // Validate each child node in root
+        for (const child of val.root.children) {
+            if (!validateLexicalNode(child, opts))
+                return false;
+        }
+
+        return true;
+    })
+}
+
+// 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;
+}
+
+export type { default as z } from 'zod';

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

@@ -12,7 +12,7 @@ import express from 'express';
 
 // Core
 import { Application } from '@server/app';
-import type ServerRouter from '@server/services/router';
+import type { RouterService, default as ServerRouter, TServerRouter } from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
 import { TRoute, TAnyRoute, TDomainsList } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
@@ -38,31 +38,40 @@ export type TBasicSSrData = {
     domains: TDomainsList
 }
 
-export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
+export type TRouterContext<TRouter extends TServerRouter> = (
     // Request context
     {
-        app: Application,
+        app: TRouter["app"],
         context: TRouterContext<TRouter>, // = this
         request: ServerRequest<TRouter>,
         api: ServerRequest<TRouter>["api"],
         response: ServerResponse<TRouter>,
         route: TRoute,
         page?: Page,
-        user: TBasicUser,
 
         Router: TRouter,
     }
-    //& TRouterContextServices<TRouter>
+    & TRouterContextServices<TRouter>
+    //& TRouterRequestContext<TRouter>
 )
 
-export type TRouterContextServices<TRouter extends ServerRouter> = (
+export type TRouterContextServices< 
+    TRouter extends TServerRouter,
+    TPlugins = TRouter["config"]["plugins"]
+> = (
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
-        [serviceName in keyof TRouter["services"]]: ReturnType< TRouter["services"][serviceName]["requestService"] >
+        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends RouterService 
+            ? ReturnType<TPlugins[serviceName]["requestService"]> 
+            : TPlugins[serviceName]
     }
 )
 
+export type TRouterRequestContext< 
+    TRouter extends TServerRouter
+> = ReturnType<TRouter["config"]["context"]>
+
 
 /*----------------------------------
 - CLASSE
@@ -212,7 +221,7 @@ export default class ServerResponse<
         return this;
     }
 
-    public async render( page: Page, context: TRouterContext, additionnalData: {} ) {
+    public async render( page: Page, context: TRouterContext<TRouter>, additionnalData: {} ) {
 
         // Set page in context for the client side
         context.page = page;
@@ -308,11 +317,11 @@ export default class ServerResponse<
         return this.end();
     }
 
-    public redirect(url: string, code: number = 302) {
+    public redirect(url: string, code: number = 302, absolute: boolean = false) {
 
         debug && console.log("[routeur][response] Redirect", url);
         this.statusCode = code;
-        this.headers['Location'] = this.router.url( url );
+        this.headers['Location'] = this.router.url( url, {}, absolute );
         return this.end();
     }
 

package/server/services/router/response/page/document.tsx

@@ -39,8 +39,9 @@ export default class DocumentRenderer<TRouter extends Router> {
                     <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="preload" as="font" href={"/public/icons.woff2?v=" + BUILD_ID} type="font/woff2" />
+                    <link rel="stylesheet" type="text/css" href="/public/icons.css" />
                     <link rel="stylesheet" type="text/css" href="/public/client.css" />
                     <ColorSchemeScript />
 
@@ -120,6 +121,7 @@ export default class DocumentRenderer<TRouter extends Router> {
 
     private styles( page: Page ) {
         return <>
+            <link rel="preload" as="font" href={"/public/icons.woff2?v=" + BUILD_ID} type="font/woff2" />
             <link rel="stylesheet" type="text/css" href={"/public/icons.css?" + BUILD_ID} />
             <link rel="preload" href="/public/client.css" as="style" />
             <link rel="stylesheet" type="text/css" href="/public/client.css" />
@@ -135,8 +137,8 @@ export default class DocumentRenderer<TRouter extends Router> {
 
     private async scripts( response: ServerResponse<TRouter>, page: Page ) {
 
-        const context = safeStringify( response.forSsr(page) );
-
+        const ssrData = response.forSsr(page);
+        const context = safeStringify( ssrData );
         const routesForClient = JSON.stringify( this.router.ssrRoutes );
 
         return <>

package/server/services/router/service.ts

@@ -11,7 +11,10 @@ import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type RequestService from './request/service';
 
-export type TRouterServiceArgs = TServiceArgs<RouterService>;
+export type TRouterServiceArgs = [
+    getConfig: TServiceArgs<RouterService>[1],
+    app: Application,
+];
 
 /*----------------------------------
 - SERVICE
@@ -20,10 +23,10 @@ export default abstract class RouterService<
     TConfig extends {} = {}
 > extends Service<TConfig, {}, Application> {
 
-    public constructor( ...args: TRouterServiceArgs) {
-        super(...args);
+    public constructor( ...[config, app]: TRouterServiceArgs) {
+        super(app, config, app);
     }
 
-    public abstract requestService( request: ServerRequest<Router> ): RequestService | null;
+    public abstract requestService( request: ServerRequest<RouterService> ): RequestService | {} | null;
 
 }

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
+    default as Router, TServerRouter, Request as ServerRequest
 } from '@server/services/router';
 
-import Schema, { TSchemaFields, TValidatedData } from '@server/services/router/request/validation/schema';
-
-// Specific
-import ServerSchemaValidator from '.';
+// Ap
+import { preprocessSchema, schema } from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -25,38 +27,23 @@ 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);
-
-    }
-
-    public validate<TSchemaFieldsA extends TSchemaFields>( 
-        fields: TSchemaFieldsA | Schema<TSchemaFieldsA> 
-    ): TValidatedData<TSchemaFieldsA> {
+export default(
+    request: ServerRequest< TServerRouter >,
+    config: TConfig,
+    router = request.router,
+    app = router.app
+) => ({
 
-        this.config.debug && console.log(LogPrefix, "Validate request data:", this.request.data);
+    ...schema,
 
-        const schema = fields instanceof Schema ? fields : new Schema(fields);
+    validate( fields: zod.ZodSchema | { [key: string]: zod.ZodSchema } ) {
 
-        // 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
-        }, []);
+        config.debug && console.log(LogPrefix, "Validate request data:", request.data);
 
-        // For logging
-        this.request.validatedData = values;
+        const schema = typeof fields === 'object' ? zod.object(fields) : fields;
 
-        return values;
-    }
+        const preprocessedSchema = preprocessSchema(schema);
 
-}
+        return preprocessedSchema.parse(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/global/utils.d.ts

@@ -63,11 +63,29 @@ declare type PrimitiveValue = string | number | boolean;
 - COPY FROM CLI/APP/INDEX.TS
 ----------------------------------*/
 
-type TEnvConfig = {
+/*type TEnvConfig = {
     name: 'local' | 'server',
-    profile: 'dev' | 'prod',
-    version: string,
-}
+    profile: 'dev' | 'testing' | 'prod',
+    
+    router: {
+        port: number,
+        domains: TDomainsList
+    },
+    database: {
+        name: string,
+        databases: string[],
+        host: string,
+        port: number,
+        login: string,
+        password: string,
+    },
+    console: {
+        enable: boolean,
+        debug: boolean,
+        bufferLimit: number,
+        level: TLogProfile,
+    },
+}*/
 
 type TServiceSetup = {
     id: string,

package/types/icons.d.ts

@@ -1 +1 @@
-export type TIcones = "solid/spinner-third"|"long-arrow-right"|"times-circle"|"brands/whatsapp"|"times"|"search"|"user"|"rocket"|"globe"|"bullhorn"|"briefcase"|"chart-line"|"handshake"|"ellipsis-h"|"brands/google"|"brands/reddit-alien"|"brands/linkedin-in"|"brands/github"|"robot"|"comments"|"user-friends"|"angle-down"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"info-circle"|"check-circle"|"exclamation-circle"|"bars"|"font"|"tag"|"compress"|"bolt"|"puzzle-piece"|"planet-ringed"|"chart-bar"|"power-off"|"heart"|"lock"|"eye"|"credit-card"|"at"|"brands/linkedin"|"key"|"database"|"solid/fire"|"usd-circle"|"lightbulb"|"solid/dollar-sign"|"download"|"code"|"solid/clock"|"exclamation"|"solid/download"|"seedling"|"palette"|"car"|"plane"|"university"|"hard-hat"|"graduation-cap"|"cogs"|"film"|"leaf"|"tshirt"|"utensils"|"map-marked-alt"|"dumbbell"|"stethoscope"|"concierge-bell"|"book"|"shield-alt"|"gavel"|"industry"|"square-root-alt"|"newspaper"|"pills"|"medal"|"capsules"|"balance-scale"|"home"|"praying-hands"|"shopping-cart"|"flask"|"futbol"|"microchip"|"satellite-dish"|"shipping-fast"|"passport"|"tools"|"user-circle"|"plus-circle"|"brands/twitter"|"brands/facebook"|"comment-alt"|"check"|"angle-left"|"angle-right"|"paper-plane"|"long-arrow-left"|"meh-rolling-eyes"|"arrow-left"|"arrow-right"|"trash"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"link"|"unlink"|"pen"|"file"|"plus"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"
+export type TIcones = "solid/spinner-third"|"times"|"at"|"star"|"plus"|"minus"|"trash"|"user-circle"|"search"|"long-arrow-right"|"lightbulb"|"long-arrow-left"|"magnet"|"phone"|"brands/linkedin"|"arrow-right"|"plane-departure"|"plus-circle"|"comments-alt"|"rocket"|"user-shield"|"shield-alt"|"chart-line"|"money-bill-wave"|"link"|"file-alt"|"paper-plane"|"solid/crown"|"eye"|"pen"|"file"|"angle-up"|"angle-down"|"envelope"|"play"|"stop"|"clock"|"cog"|"ellipsis-h"|"check"|"user-plus"|"sack-dollar"|"info-circle"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"regular/shield-check"|"download"|"brands/google"|"brands/whatsapp"|"crown"|"check-circle"|"exclamation-circle"|"times-circle"|"arrow-left"|"key"|"broom"|"arrow-to-bottom"|"minus-circle"|"map-marker-alt"|"solid/check-circle"|"solid/exclamation-triangle"|"solid/times-circle"|"hourglass"|"external-link"|"user"|"building"|"briefcase"|"graduation-cap"|"angle-left"|"angle-right"|"plug"|"magic"|"coins"|"coin"|"question-circle"|"meh-rolling-eyes"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"unlink"|"font"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"

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];
-};