proteum 1.0.0-1

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

@@ -0,0 +1,87 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+
+import RequestService from './service';
+
+import ApiClientService, { 
+    TApiFetchOptions, 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 
+    ): TDataReturnedByFetchers<TProvidedData> {
+        throw new Error("api.fetch shouldn't be called here.");
+    }
+
+    /*----------------------------------
+    - PLACEHOLDERS
+    ----------------------------------*/
+
+    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.");
+    }
+
+    /*----------------------------------
+    - API CALLS FROM SERVER
+    ----------------------------------*/
+
+    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;
+
+            // Promise Fetcher (direct call from service method)
+            if ('then' in fetcher) {
+                fetchedData[id] = await fetcher;
+                continue;
+            }
+
+            const { method, path, data, options } = 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;
+
+            // 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);
+        }
+
+        return fetchedData;
+    } 
+}

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

@@ -0,0 +1,184 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type express from 'express';
+import ISO6391 from 'iso-639-1';
+import accepts from 'accepts';
+import Bowser from "bowser";
+
+// Core
+import BaseRequest from '@common/router/request';
+
+// Specific
+import type { 
+    default as Router, Config as RouterConfig, 
+    HttpMethod, HttpHeaders
+} from '..';
+import ApiClient from './api';
+import ServerResponse from '../response';
+import type { TAnyRouter } from '..';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+const localeFilter = (input: any) => {
+
+    // Data type
+    if (typeof input !== 'string')
+        return;
+
+    // Extract ISO code
+    let lang = input.trim().split(/[-_]/)[0].toLowerCase();
+    
+    // Check size
+    if (!ISO6391.validate(lang))
+        return;
+
+    return lang.toUpperCase();
+}
+
+export type UploadedFile = File
+
+/*----------------------------------
+- CONTEXTE
+----------------------------------*/
+export default class ServerRequest<
+    TRouter extends TAnyRouter = TAnyRouter
+> extends BaseRequest {
+
+    /*----------------------------------
+    - PROPRIÉTÉS
+    ----------------------------------*/
+
+    public id: string;
+    public isVirtual: boolean = false;
+
+    // Requete
+    public method: HttpMethod;
+    public ip?: string;
+    public locale: string;
+    public domain: string;
+    public headers: HttpHeaders = {};
+    public cookies: TObjetDonnees = {};
+    public validatedData?: TObjetDonnees; // Results from the last schema.validate
+
+    // reponse
+    public response?: ServerResponse<TRouter>;
+    public router: TRouter;
+
+    // Origin
+    public req: express.Request;
+    public res: express.Response;
+
+    // Services
+    public api: ApiClient;
+
+    /*----------------------------------
+    - INITIALISATION
+    ----------------------------------*/
+    public constructor( 
+
+        id: string,
+        method: HttpMethod, 
+        path: string, 
+        data: TObjetDonnees | undefined,
+        headers: HttpHeaders | undefined,
+
+        res: express.Response, 
+        router: TRouter,
+        isVirtual: boolean = false
+    ) {
+
+        super(path);
+
+        this.id = id;
+        this.isVirtual = isVirtual;
+
+        this.req = res.req;
+        this.res = res
+        this.router = router;
+        this.api = new ApiClient(this);
+
+        this.url = this.req.protocol + '://' + this.req.get('host') + this.req.originalUrl;
+        this.host = this.req.get('host') as string;
+        this.method = method;
+        this.headers = headers || {};
+        this.locale = this.getLocale();
+        this.domain = res.req.hostname;
+        this.cookies = res.req.cookies;
+
+        this.ip = res.req.ip;
+
+        this.data = data || {};
+    }
+
+    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
+        );
+        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 = (
+            // Member settings
+            this.user?.locale 
+            ||
+            // URL
+            localeFilter( this.req.cookies.lang )
+            ||
+            // Browser
+            localeFilter( this.req.acceptsLanguages()[0] )
+            || 
+            // Default
+            'EN'
+        )
+
+        return locale ? locale.toUpperCase() : 'EN'
+    }
+
+    public cookie( key: string, consume: boolean = false ) {
+
+        const value = this.req.cookies[ key ];
+
+        if (consume)
+            this.res.clearCookie(key);
+
+        return value;
+
+    }
+
+    /*----------------------------------
+   - TESTS
+   ----------------------------------*/
+
+    public accepts(datatype: string | undefined) {
+        // https://github.com/jshttp/accepts
+        return datatype === undefined || datatype === '*' || accepts(this).type(datatype);
+    }
+
+    public device(): Bowser.Parser.ParsedResult | 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 || '');
+    }
+}

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

@@ -0,0 +1,21 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+import type Router from '..';
+import type ServerRequest from '.';
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default abstract class RequestService {
+
+    public constructor(
+        public request: ServerRequest<Router>,
+        public router = request.router,
+        public app = router.app
+    ) {
+
+    }
+
+}

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';