proteum 1.0.2 → 2.0.0-1

package/server/services/router/request/api.ts

@@ -6,27 +6,27 @@
 
 import RequestService from './service';
 
-import ApiClientService, { 
-    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher,
-    TDataReturnedByFetchers
+import ApiClientService, {
+    TFetcherList,
+    TFetcherArgs,
+    TFetcher,
+    TDataReturnedByFetchers,
 } from '@common/router/request/api';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class ApiClientRequest extends RequestService implements ApiClientService {
-
     /*----------------------------------
     - HIGH LEVEL
     ----------------------------------*/
 
-    public fetch<TProvidedData extends TFetcherList = TFetcherList>( 
-        fetchers: TFetcherList 
+    public fetch<TProvidedData extends TFetcherList = TFetcherList>(
+        _fetchers: TFetcherList,
     ): TDataReturnedByFetchers<TProvidedData> {
         throw new Error("api.fetch shouldn't be called here.");
     }
@@ -35,34 +35,36 @@ export default class ApiClientRequest extends RequestService implements ApiClien
     - PLACEHOLDERS
     ----------------------------------*/
 
-    public set( newData: TObjetDonnees ) {
-        throw new Error("api.set is not available on server side.");
+    public set(_newData: TObjetDonnees) {
+        throw new Error('api.set is not available on server side.');
     }
 
-    public reload( ids?: string | string[], params?: TObjetDonnees ) {
-        throw new Error("api.set is not available on server side.");
+    public reload(_ids?: string | string[], _params?: TObjetDonnees) {
+        throw new Error('api.set is not available on server side.');
     }
 
     /*----------------------------------
     - API CALLS FROM SERVER
     ----------------------------------*/
 
-    public createFetcher<TData extends unknown = unknown>(...[method, path, data, options]: TFetcherArgs): TFetcher<TData> {
-        return { 
-            method, path, data, options,
+    public createFetcher<TData extends unknown = unknown>(
+        ...[method, path, data, options]: TFetcherArgs
+    ): TFetcher<TData> {
+        return {
+            method,
+            path,
+            data,
+            options,
             // We don't put the then and catch methods so the api consumer on server side will know it's a fetcher and not a promize to wait
         } as TFetcher<TData>;
     }
 
     public async fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees> {
-
         const fetchedData: TObjetDonnees = { ...alreadyLoadedData };
 
         for (const id in fetchers) {
-
-            const fetcher = fetchers[id]
-            if (!fetcher)
-                continue;
+            const fetcher = fetchers[id];
+            if (!fetcher) continue;
 
             // Promise Fetcher (direct call from service method)
             if ('then' in fetcher) {
@@ -70,18 +72,17 @@ export default class ApiClientRequest extends RequestService implements ApiClien
                 continue;
             }
 
-            const { method, path, data, options } = fetcher;
+            const { method, path, data } = fetcher;
             //this.router.config.debug && console.log(`[api] Resolving from internal api`, method, path, data);
 
             // We don't fetch the already given data
-            if (id in fetchedData)
-                continue;
+            if (id in fetchedData) continue;
 
             // Create a children request to resolve the api data
             const request = this.request.children(method, path, data);
-            fetchedData[id] = await request.router.resolve(request).then(res => res.data);
+            fetchedData[id] = await request.router.resolve(request).then((res) => res.data);
         }
 
         return fetchedData;
-    } 
-}
+    }
+}

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

@@ -6,16 +6,13 @@
 import type express from 'express';
 import ISO6391 from 'iso-639-1';
 import accepts from 'accepts';
-import Bowser from "bowser";
+import Bowser from 'bowser';
 
 // Core
 import BaseRequest from '@common/router/request';
 
 // Specific
-import type { 
-    default as Router, Config as RouterConfig, 
-    HttpMethod, HttpHeaders
-} from '..';
+import type { HttpMethod, HttpHeaders } from '..';
 import ApiClient from './api';
 import ServerResponse from '../response';
 import type { TAnyRouter } from '..';
@@ -25,30 +22,24 @@ import type { TAnyRouter } from '..';
 ----------------------------------*/
 
 const localeFilter = (input: any) => {
-
     // Data type
-    if (typeof input !== 'string')
-        return;
+    if (typeof input !== 'string') return;
 
     // Extract ISO code
     let lang = input.trim().split(/[-_]/)[0].toLowerCase();
-    
+
     // Check size
-    if (!ISO6391.validate(lang))
-        return;
+    if (!ISO6391.validate(lang)) return;
 
     return lang.toUpperCase();
-}
+};
 
-export type UploadedFile = File
+export type UploadedFile = File;
 
 /*----------------------------------
 - CONTEXTE
 ----------------------------------*/
-export default class ServerRequest<
-    TRouter extends TAnyRouter = TAnyRouter
-> extends BaseRequest {
-
+export default class ServerRequest<TRouter extends TAnyRouter = TAnyRouter> extends BaseRequest {
     /*----------------------------------
     - PROPRIÉTÉS
     ----------------------------------*/
@@ -79,26 +70,24 @@ export default class ServerRequest<
     /*----------------------------------
     - INITIALISATION
     ----------------------------------*/
-    public constructor( 
-
+    public constructor(
         id: string,
-        method: HttpMethod, 
-        path: string, 
+        method: HttpMethod,
+        path: string,
         data: TObjetDonnees | undefined,
         headers: HttpHeaders | undefined,
 
-        res: express.Response, 
+        res: express.Response,
         router: TRouter,
-        isVirtual: boolean = false
+        isVirtual: boolean = false,
     ) {
-
         super(path);
 
         this.id = id;
         this.isVirtual = isVirtual;
 
         this.req = res.req;
-        this.res = res
+        this.res = res;
         this.router = router;
         this.api = new ApiClient(this);
 
@@ -116,48 +105,46 @@ export default class ServerRequest<
     }
 
     public children(method: HttpMethod, path: string, data: TObjetDonnees | undefined) {
-        const children = new ServerRequest( 
-            this.id, method, path, data, { ...this.headers, accept: 'application/json' },
-            this.res, this.router, true
+        const children = new ServerRequest(
+            this.id,
+            method,
+            path,
+            data,
+            { ...this.headers, accept: 'application/json' },
+            this.res,
+            this.router,
+            true,
         );
         children.user = this.user;
         return children;
     }
 
     private getLocale() {
-
         const fromQuery = localeFilter(this.req.query.lang);
         if (fromQuery) {
             this.res.cookie('lang', fromQuery);
             return fromQuery;
-        } 
+        }
 
-        const locale = (
+        const locale =
             // Member settings
-            this.user?.locale 
-            ||
+            this.user?.locale ||
             // URL
-            localeFilter( this.req.cookies.lang )
-            ||
+            localeFilter(this.req.cookies.lang) ||
             // Browser
-            localeFilter( this.req.acceptsLanguages()[0] )
-            || 
+            localeFilter(this.req.acceptsLanguages()[0]) ||
             // Default
-            'EN'
-        )
+            'EN';
 
-        return locale ? locale.toUpperCase() : 'EN'
+        return locale ? locale.toUpperCase() : 'EN';
     }
 
-    public cookie( key: string, consume: boolean = false ) {
-
-        const value = this.req.cookies[ key ];
+    public cookie(key: string, consume: boolean = false) {
+        const value = this.req.cookies[key];
 
-        if (consume)
-            this.res.clearCookie(key);
+        if (consume) this.res.clearCookie(key);
 
         return value;
-
     }
 
     /*----------------------------------
@@ -170,15 +157,21 @@ export default class ServerRequest<
     }
 
     public device(): Bowser.Parser.ParsedResult | undefined {
-        return this.headers['user-agent'] !== undefined
-            ? Bowser.parse(this.headers['user-agent'])
-            : undefined;
+        return this.headers['user-agent'] !== undefined ? Bowser.parse(this.headers['user-agent']) : undefined;
     }
 
     public deviceString(): string | undefined {
         const info = this.device();
         if (info === undefined) return undefined;
         const { os, browser } = info;
-        return (os.name || 'Unknown OS') + ' ' + (os.versionName || os.version || '') + ' / ' + (browser.name || 'Unknown browser') + ' ' + (browser.version || '');
+        return (
+            (os.name || 'Unknown OS') +
+            ' ' +
+            (os.versionName || os.version || '') +
+            ' / ' +
+            (browser.name || 'Unknown browser') +
+            ' ' +
+            (browser.version || '')
+        );
     }
-}
+}

package/server/services/router/request/service.ts

@@ -2,20 +2,16 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import type Router from '..';
+import type { TAnyRouter } from '..';
 import type ServerRequest from '.';
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default abstract class RequestService {
-
+export default abstract class RequestService<TRequest extends ServerRequest<TAnyRouter> = ServerRequest<TAnyRouter>> {
     public constructor(
-        public request: ServerRequest<Router>,
-        public router = request.router,
-        public app = router.app
-    ) {
-
-    }
-
-}
+        public request: TRequest,
+        public router: TRequest['router'] = request.router,
+        public app: TRequest['router']['app'] = router.app,
+    ) {}
+}

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

@@ -1,177 +1,140 @@
 import { InputError } from '@common/errors';
-import zod, { _ZodType } from 'zod';
-
-export type TRichTextValidatorOptions = {
-    attachements?: boolean
+import zod from 'zod';
+
+export type TRichTextValidatorOptions = { attachements?: boolean };
+export type TValidationSchema = zod.ZodTypeAny;
+export type TValidationShape = zod.ZodRawShape;
+
+type TChoiceOption = { value: PrimitiveValue; label: string };
+
+type TLexicalNode = {
+    type: string;
+    text?: string;
+    children?: TLexicalNode[];
+};
+
+type TLexicalRoot = {
+    root: {
+        type: 'root';
+        children: TLexicalNode[];
+    };
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+const hasChoiceValue = (value: unknown): value is { value: PrimitiveValue } => isRecord(value) && 'value' in value;
+
+const normalizeChoiceValue = (value: unknown): PrimitiveValue =>
+    (hasChoiceValue(value) ? value.value : value) as PrimitiveValue;
+
+const isLexicalNode = (value: unknown): value is TLexicalNode =>
+    isRecord(value) && typeof value.type === 'string';
+
+const isLexicalRoot = (value: unknown): value is TLexicalRoot => {
+    if (!isRecord(value)) return false;
+    if (!isRecord(value.root)) return false;
+    if (value.root.type !== 'root') return false;
+    return Array.isArray(value.root.children);
+};
+
+export const isZodSchema = (fields: unknown): fields is TValidationSchema => {
+    return (
+        typeof fields === 'object' &&
+        fields !== null &&
+        'safeParse' in fields &&
+        typeof (fields as TValidationSchema).safeParse === 'function'
+    );
+};
+
+export function toValidationSchema<TSchema extends TValidationSchema>(fields: TSchema): TSchema;
+export function toValidationSchema<TShape extends TValidationShape>(fields: TShape): zod.ZodObject<TShape>;
+export function toValidationSchema(
+    fields: TValidationSchema | TValidationShape,
+): TValidationSchema | zod.ZodObject<TValidationShape>;
+export function toValidationSchema(fields: TValidationSchema | TValidationShape) {
+    return isZodSchema(fields) ? fields : zod.object(fields);
 }
 
-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;
+// Legacy hook kept as an identity to preserve the public surface without relying on removed Zod internals.
+export const preprocessSchema = <TSchema extends zod.ZodObject<any>>(schema: TSchema): TSchema => schema;
 
-    const shape = schema.def.shape;
-    const newShape: Record<string, zod.ZodTypeAny> = {};
+const createChoiceValueSchema = (
+    choices: readonly string[] | readonly TChoiceOption[] | zod.ZodTypeAny,
+): zod.ZodTypeAny => {
+    if (isZodSchema(choices)) return choices;
 
-    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 allowedValues = new Set(choices.map((choice) => normalizeChoiceValue(choice)));
 
-const toPreprocess = {
+    return zod.custom<PrimitiveValue>((value) => allowedValues.has(normalizeChoiceValue(value)), {
+        message: 'Invalid choice.',
+    });
+};
 
-    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,  
+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;*/
-
+        // String = existing file URL, so callers can omit replacing an uploaded file.
         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);
-            }
+    choice: (
+        choices: readonly string[] | readonly TChoiceOption[] | zod.ZodTypeAny,
+        options: { multiple?: boolean } = {},
+    ) => {
+        const valueType = createChoiceValueSchema(choices);
+        const itemType = zod.union([zod.object({ value: valueType, label: zod.string() }), valueType]);
+        const choiceType = options.multiple ? zod.array(itemType) : itemType;
+
+        return choiceType.transform((value: unknown) => {
+            if (options.multiple) return (value as unknown[]).map((entry: unknown) => normalizeChoiceValue(entry));
+            return normalizeChoiceValue(value);
         });
     },
 
-    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;
-        }
+    richText: (opts: TRichTextValidatorOptions = {}) =>
+        schema.custom((value) => {
+            if (typeof value !== 'string') {
+                console.error('Invalid rich text format.', value);
+                return false;
+            }
 
-        // Validate each child node in root
-        for (const child of val.root.children) {
-            if (!validateLexicalNode(child, opts))
+            let parsed: unknown;
+            try {
+                parsed = JSON.parse(value);
+            } catch (error) {
+                console.error('Failed to parse rich text json:', error, value);
                 return false;
-        }
+            }
 
-        return true;
-    })
-}
+            if (!isLexicalRoot(parsed)) {
+                console.error('Invalid rich text value.', parsed);
+                return false;
+            }
 
-// Recursive function to validate each node
-function validateLexicalNode(node: any, opts: TRichTextValidatorOptions ) {
+            return parsed.root.children.every((child) => validateLexicalNode(child, opts));
+        }),
+};
 
-    // 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).");
+function validateLexicalNode(node: unknown, opts: TRichTextValidatorOptions) {
+    if (!isLexicalNode(node)) 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).');
+        return true;
+    }
 
-        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).");
+    if (['paragraph', 'heading', 'list', 'listitem'].includes(node.type)) {
+        if (!Array.isArray(node.children) || !node.children.every((child) => validateLexicalNode(child, 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;
+    }
 
+    if (node.type === 'image') {
+        // Attachments are validated by the upload pipeline; rich-text validation only enforces node shape.
+        return true;
     }
 
     return true;