proteum 1.0.2 → 2.0.0-1

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

@@ -11,13 +11,16 @@
 import express from 'express';
 
 // Core
-import { Application } from '@server/app';
+import context from '@server/context';
 import type { AnyRouterService, default as ServerRouter, TServerRouter, TAnyRouter } from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
-import { TRoute, TAnyRoute, TDomainsList } from '@common/router';
+import { TMatchedRoute, TRoute, TAnyRoute, TDomainsList } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
 import BaseResponse, { TResponseData } from '@common/router/response';
+import { splitRouteSetupResult } from '@common/router/pageSetup';
 import Page from './page';
+import createControllers from '@/common/.generated/controllers';
+import type { TControllers } from '@/common/.generated/controllers';
 
 // To move into a new npm module: json-mask
 import jsonMask from './mask';
@@ -32,72 +35,62 @@ import type { TBasicUser } from '@server/services/auth';
 const debug = true;
 
 export type TBasicSSrData = {
-    request: { data: TObjetDonnees, id: string },
-    page: { chunkId: string, data?: TObjetDonnees },
-    user: TBasicUser | null,
-    domains: TDomainsList
-}
+    request: { data: TObjetDonnees; id: string };
+    page: { chunkId: string; data?: TObjetDonnees };
+    user: TBasicUser | null;
+    domains: TDomainsList;
+};
 
-export type TRouterContext<TRouter extends TServerRouter> = (
+export type TRouterContext<TRouter extends TServerRouter> =
     // Request context
     {
-        app: TRouter["app"],
-        context: TRouterContext<TRouter>, // = this
-        request: ServerRequest<TRouter>,
-        api: ServerRequest<TRouter>["api"],
-        response: ServerResponse<TRouter>,
-        route: TRoute,
-        page?: Page,
-
-        Router: TRouter,
-    }
-    & TRouterContextServices<TRouter>
-    & TRouterRequestContext<TRouter>
-)
-
-export type TRouterContextServices< 
-    TRouter extends TServerRouter,
-    TPlugins = TRouter["config"]["plugins"]
-> = (
+        app: TRouter['app'];
+        context: TRouterContext<TRouter>; // = this
+        request: ServerRequest<TRouter>;
+        api: ServerRequest<TRouter>['api'];
+        response: ServerResponse<TRouter>;
+        route: TAnyRoute<TRouterContext<TRouter>>;
+        page?: Page;
+
+        Router: TRouter;
+    } & TRouterContextServices<TRouter> &
+        TControllers &
+        TRouterRequestContext<TRouter>;
+
+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 TPlugins]: TPlugins[serviceName] extends AnyRouterService 
-            ? ReturnType<TPlugins[serviceName]["requestService"]> 
-            : TPlugins[serviceName]
-    }
-)
-
-export type TRouterRequestContext< 
-    TRouter extends TServerRouter
-> = ReturnType<TRouter["config"]["context"]>
+        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends AnyRouterService
+            ? Exclude<ReturnType<TPlugins[serviceName]['requestService']>, null | undefined>
+            : TPlugins[serviceName];
+    };
 
+export type TRouterRequestContext<TRouter extends TServerRouter> = ReturnType<TRouter['config']['context']>;
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 export default class ServerResponse<
     TRouter extends TAnyRouter,
-    TRequestContext = TRouterContext<TAnyRouter>,
-    TData extends TResponseData = TResponseData
+    TRequestContext extends TRouterContext<TRouter> = TRouterContext<TRouter>,
+    TData extends TResponseData = TResponseData,
 > extends BaseResponse<TData, ServerRequest<TRouter>> {
-
     // Services
-    public app: Application;
+    public app: TRouter['app'];
     public router: TRouter;
 
     // Response metadata
     public statusCode: number = 200;
-    public headers: {[cle: string]: string} = {}
-    public cookie: express.Response["cookie"];
-    public clearCookie: express.Response["clearCookie"];
+    public headers: { [cle: string]: string } = {};
+    public cookie: express.Response['cookie'];
+    public clearCookie: express.Response['clearCookie'];
     public canonicalUrl: URL;
 
     // If data was provided by at lead one controller
     public wasProvided = false;
 
-    public constructor( request: ServerRequest<TRouter> ) {
-
+    public constructor(request: ServerRequest<TRouter>) {
         super(request);
 
         this.cookie = this.request.res.cookie.bind(this.request.res);
@@ -110,44 +103,42 @@ export default class ServerResponse<
         this.canonicalUrl.search = '';
     }
 
-    public async runController( route: TAnyRoute, additionnalData: {} = {} ) {
-
+    public async runController(route: TAnyRoute<TRouterContext<TRouter>>, additionnalData: {} = {}) {
         this.route = route;
 
         // Update canonical url
         this.updateCanonicalUrl(route);
 
         // Create response context for controllers
-        const context = await this.createContext(route);
+        const requestContext = await this.createContext(route);
+        const contextStore = context.getStore() as
+            | { requestContext?: TRouterContext<TAnyRouter>; inputSchemaUsed?: boolean }
+            | undefined;
+        if (contextStore) {
+            contextStore.requestContext = requestContext;
+            contextStore.inputSchemaUsed = false;
+        }
 
         // Run controller
-        const content = await this.route.controller( context );
-        if (content === undefined)
-            return;
+        const content = await this.route.controller(requestContext);
+        if (content === undefined) return;
 
         // No need to process the content
-        if (content instanceof ServerResponse)
-            return;
+        if (content instanceof ServerResponse) return;
         // Render react page to html
-        else if (content instanceof Page)
-            await this.render(content, context, additionnalData);
+        else if (content instanceof Page) await this.render(content, requestContext, additionnalData);
         // Return HTML
-        else if (typeof content === 'string' && this.route.options.accept === 'html')
-            await this.html(content);
+        else if (typeof content === 'string' && this.route.options.accept === 'html') await this.html(content);
         // Return JSON
-        else
-            await this.json(content);
+        else await this.json(content);
     }
 
-    private updateCanonicalUrl( route: TAnyRoute ) {
-
-        if (!route.options.canonicalParams)
-            return;
+    private updateCanonicalUrl(route: TAnyRoute<TRouterContext<TRouter>>) {
+        if (!route.options.canonicalParams) return;
 
         for (const key of route.options.canonicalParams) {
-            const paramValue = this.request.data[ key ];
-            if (paramValue !== undefined)
-                this.canonicalUrl.searchParams.set(key, paramValue);
+            const paramValue = this.request.data[key];
+            if (paramValue !== undefined) this.canonicalUrl.searchParams.set(key, paramValue);
         }
     }
 
@@ -155,51 +146,58 @@ export default class ServerResponse<
     - INTERNAL
     ----------------------------------*/
 
-    // Start controller services
-    private async createContext( route: TRoute ): Promise<TRequestContext> {
+    public async resolveRouteOptions(
+        route: TMatchedRoute<TRouterContext<TRouter>>,
+    ): Promise<TMatchedRoute<TRouterContext<TRouter>>> {
+        const setup = route.options.setup;
+        if (!setup) return route;
+
+        const requestContext = await this.createContext(route);
+        const { options } = splitRouteSetupResult(((setup as any)({ ...requestContext, data: this.request.data }) as {}) || {});
+
+        return { ...route, options: { ...route.options, ...options } };
+    }
 
+    // Start controller services
+    private async createContext(route: TAnyRoute<TRouterContext<TRouter>>): Promise<TRequestContext> {
         const contextServices = this.router.createContextServices(this.request);
 
-        const customSsrData = this.router.config.context(this.request, this.app);
+        const customSsrData = this.router.config.context(this.request, this.app) as TRouterRequestContext<TRouter>;
 
         // TODO: transmiss safe data (especially for Router), as Router info could be printed on client side
-        const context: TRequestContext = {
+        const requestContext = {
             // Router context
             app: this.app,
-            context: undefined as TRequestContext,
+            context: undefined!,
             request: this.request,
             response: this,
             route: route,
             api: this.request.api,
 
             Router: this.router,
+            ...(this.app as {}),
+            ...createControllers(this.request.api),
 
             // Router services
             ...(contextServices as TRouterContextServices<TRouter>),
-            ...customSsrData
-        }
+            ...customSsrData,
+        } as TRequestContext;
 
-        context.context = context;
+        requestContext.context = requestContext;
 
-        return context;
+        return requestContext;
     }
 
-    public forSsr( page: Page<TRouter> ): TBasicSSrData {
-
+    public forSsr(page: Page<TRouter>): TBasicSSrData {
         const customSsrData = this.router.config.context(this.request, this.app);
 
         return {
-            request: {
-                id: this.request.id,
-                data: this.request.data,
-            },
-            page: {
-                chunkId: page.chunkId,
-                data: page.data
-            },
+            request: { id: this.request.id, data: this.request.data },
+            page: { chunkId: page.chunkId || '', data: page.data },
+            user: this.request.user,
             domains: this.router.config.domains,
-            ...customSsrData
-        }
+            ...customSsrData,
+        };
     }
 
     public status(code: number) {
@@ -207,29 +205,29 @@ export default class ServerResponse<
         return this;
     }
 
-    public setHeaders( headers: {[cle: string]: string} ) {
+    public setHeaders(headers: { [cle: string]: string }) {
         this.headers = { ...this.headers, ...headers };
         return this;
     }
-    
+
     /*----------------------------------
     - DATA RESPONSE
     ----------------------------------*/
 
-    public type( mimetype: string ) {
+    public type(mimetype: string) {
         this.headers['Content-Type'] = mimetype;
         return this;
     }
 
-    public async render( page: Page, context: TRouterContext<TRouter>, additionnalData: {} ) {
-
+    public async render(page: Page, context: TRouterContext<TRouter>, additionnalData: {}) {
         // Set page in context for the client side
         context.page = page;
-        
+
         // Prepare page & fetch data
         page.data = await page.fetchData();
-        if (additionnalData !== undefined) // Example: error message for error pages
-            page.data = { ...page.data, ...additionnalData }
+        if (additionnalData !== undefined)
+            // Example: error message for error pages
+            page.data = { ...page.data, ...additionnalData };
 
         // Render page
         await this.router.runHook('render', page);
@@ -238,51 +236,42 @@ export default class ServerResponse<
 
         // Never put html in the cache
         // Because assets urls need to be updated when their hash has been changed by a release
-        this.request.res.setHeader("Expires", "0");
-
+        this.request.res.setHeader('Expires', '0');
     }
 
     public async json(data?: any, mask?: string) {
-
         // RAPPEL: On jsonMask aussi les requetes internes, car leurs données seront imprimées au SSR pour le contexte client
         // filtreApi vérifie systèmatiquement si la donnée a été filtrée
         // NOTE: On évite le filtrage sans masque spécifié (performances + risques erreurs)
-        if (mask !== undefined)
-            data = await jsonMask(data, mask, this.request.user);
+        if (mask !== undefined) data = await jsonMask(data, mask);
 
         this.headers['Content-Type'] = 'application/json';
-        this.data = this.request.isVirtual ? data : JSON.stringify(data);
+        this.data = (this.request.isVirtual ? data : JSON.stringify(data)) as TData;
         return this.end();
     }
 
     public html(html: string) {
-
         this.headers['Content-Type'] = 'text/html';
-        this.data = html;
+        this.data = html as TData;
         return this.end();
-
     }
 
     public xml(xml: string) {
-
         this.headers['Content-Type'] = 'text/xml';
-        this.data = xml;
+        this.data = xml as TData;
         return this.end();
     }
 
     public text(text: string, mimetype: string = 'text/plain') {
-
         this.headers['Content-Type'] = mimetype;
-        this.data = text;
+        this.data = text as TData;
         return this.end();
     }
 
     // TODO: https://github.com/adonisjs/http-server/blob/develop/src/Response/index.ts#L430
-    public async file( filename: string, mimetype?: string ) {
-
+    public async file(filename: string, mimetype?: string) {
         // Securité
-        if (filename.includes('..'))
-            throw new Forbidden("Disallowed");
+        if (filename.includes('..')) throw new Forbidden('Disallowed');
 
         // // Force absolute path
         // if (!filename.startsWith( this.app.path.root ))
@@ -291,7 +280,9 @@ export default class ServerResponse<
         //         : this.app.path.data + '/' + filename;
         // Disk not provided = file response disabled
         if (this.router.disks === undefined)
-            throw new Anomaly("Router: Unable to return file response in router, because no disk has been given in the router config.");
+            throw new Anomaly(
+                'Router: Unable to return file response in router, because no disk has been given in the router config.',
+            );
 
         // Retirve disk driver
         const disk = this.router.disks.get('default');
@@ -299,29 +290,24 @@ export default class ServerResponse<
         // Verif existance
         const fileExists = await disk.exists('data', filename);
         if (!fileExists) {
-            console.log("File " + filename + " was not found.");
+            console.log('File ' + filename + ' was not found.');
             throw new NotFound();
         }
 
         // envoi filename
-        const file = await disk.readFile('data', filename, {
-            encoding: 'buffer'
-        });
-        this.data = file;
-        
+        const file = await disk.readFile('data', filename, { encoding: 'buffer' });
+        this.data = file as TData;
 
         // Mimetype
-        if (mimetype !== undefined)
-            this.headers['Content-Type'] = mimetype;
+        if (mimetype !== undefined) this.headers['Content-Type'] = mimetype;
 
         return this.end();
     }
 
     public redirect(url: string, code: number = 302, absolute: boolean = false) {
-
-        debug && console.log("[routeur][response] Redirect", url);
+        debug && console.log('[routeur][response] Redirect', url);
         this.statusCode = code;
-        this.headers['Location'] = this.router.url( url, {}, absolute );
+        this.headers['Location'] = this.router.url(url, {}, absolute);
         return this.end();
     }
 
@@ -334,5 +320,4 @@ export default class ServerResponse<
         this.wasProvided = false;
         return this;
     }
-
-}
+}

package/server/services/router/response/mask/Filter.ts

@@ -23,28 +23,23 @@ const maxLevel = 10; // Prévention contre les références circulaires
 - CLASS
 ----------------------------------*/
 export default class Filtre {
-
-    public constructor() {
-
-
-    }
+    public constructor() {}
 
     public filtrer(
         donnee: TObjet | Array<unknown> | Date,
         schema?: TSelecteur,
         chemin: string[] = [],
-        schemaParent?: TObjet
+        schemaParent?: TObjet,
     ): any {
-
         // Prévention contre les références circulaires
         if (chemin.length > maxLevel)
-            throw new Error(`Erreur: Niveau max (${maxLevel}) atteint via la branche ${chemin.join('.')}. Vérifier s'il n'existe pas une référence circulaire dans l'objet à filtrer.`)
+            throw new Error(
+                `Erreur: Niveau max (${maxLevel}) atteint via la branche ${chemin.join('.')}. Vérifier s'il n'existe pas une référence circulaire dans l'objet à filtrer.`,
+            );
 
         try {
-
             // Tableau: on itère chaque élement de celui-ci
             if (Array.isArray(donnee)) {
-
                 debug && console.log(`[requete][reponse][filtre]`, chemin.join('.'), ': Tableau');
 
                 return this.tableau(donnee, schema, chemin, schemaParent);
@@ -53,38 +48,25 @@ export default class Filtre {
                 // Si la donnée est une chaine, un nombre, etc ... On la traite comme s'il y avait un true
             } else if (
                 // Extrémité de la branche
-                schema === true
-                ||
+                schema === true ||
                 // Valeur non-itérable
-                !donnee
-                ||
-                typeof donnee !== 'object'
-                ||
+                !donnee ||
+                typeof donnee !== 'object' ||
                 donnee instanceof Date
             ) {
-
                 debug && console.log(`[requete][reponse][filtre]`, chemin.join('.'), ': Valeur');
 
-                return this.valeur(
-                    donnee,
-                    schema,
-                    chemin
-                );
+                return this.valeur(donnee, schema, chemin);
 
                 // Objet
             } else {
-
                 debug && console.log(`[requete][reponse][filtre]`, chemin.join('.'), ': Objet');
 
                 return this.objet(donnee, schema, chemin, schemaParent);
-
             }
-
         } catch (error) {
-
             console.error('Erreur =', error, '|| données =', donnee, '|| chemin =', chemin, '|| schema =', schema);
             throw new Error(`Erreur lors du filtrage. Infos ci-dessus.`);
-
         }
     }
 
@@ -93,9 +75,8 @@ export default class Filtre {
         schema: TSelecteur | undefined,
 
         chemin: string[],
-        schemaParent?: TObjet
+        schemaParent?: TObjet,
     ) {
-
         let retour: any[] = [];
 
         for (const iElem in donnee) {
@@ -105,9 +86,9 @@ export default class Filtre {
                     schema,
 
                     [...chemin, iElem],
-                    schemaParent
-                )
-            )
+                    schemaParent,
+                ),
+            );
         }
 
         return retour;
@@ -118,39 +99,34 @@ export default class Filtre {
         schema: TSelecteur | undefined,
 
         chemin: string[],
-        schemaParent?: TObjet
+        schemaParent?: TObjet,
     ) {
-
         if (typeof schema === 'object') {
-
             // Exemple: article ( titre enfant( @ ) )
             // Copie du schéma parent
             if (schema['@'] === true) {
-
                 if (schemaParent === undefined)
-                    throw new Error(`Référence au schéma parent trouvée, mais impossible d'accéder au schéma parent (schemaParent = undefined)`);
+                    throw new Error(
+                        `Référence au schéma parent trouvée, mais impossible d'accéder au schéma parent (schemaParent = undefined)`,
+                    );
 
                 schema = schemaParent;
 
                 // Exemple: *
                 // Parcours et filtre toutes les entrées
             } else if (schema['*'] === true) {
-
                 // L'itération se fera directement sur les données fournies
                 schema = undefined;
 
                 // Exemple: * ( nom symbole )
                 // Applique un selecteurs à toutes les entrées
             } else if (schema['*'] !== undefined) {
-
                 const schemaBranches = schema['*'];
                 schema = {};
 
                 // Applique le schema du wildcard à toutes les entrées de l'objet
                 // TODO: alternative plus performante
-                for (const cle in donnee)
-                    schema[cle] = schemaBranches;
-
+                for (const cle in donnee) schema[cle] = schemaBranches;
             }
         }
 
@@ -159,62 +135,46 @@ export default class Filtre {
         // Liste des clés à itérer
         let clesAiterer: string[];
         if (schema !== undefined)
-            clesAiterer = Object.keys(schema as object);
-        else // En dernier recours, on itère tout simplement les données de l'objet
-            clesAiterer = Object.keys(donnee);
+            clesAiterer = Object.keys(schema as object); // En dernier recours, on itère tout simplement les données de l'objet
+        else clesAiterer = Object.keys(donnee);
 
         // Objet
         for (const nomBranche of clesAiterer) {
-
             const cheminA = [...chemin, nomBranche];
             let donneeBranche = undefined;
 
             // Extraction de la valeur de la propriété
-            if (donneeBranche === undefined)
-                donneeBranche = donnee[nomBranche];
+            if (donneeBranche === undefined) donneeBranche = donnee[nomBranche];
 
             // Filtrage de la valeur de la propriété
-            retour[nomBranche] = this.filtrer(
-                donneeBranche,
-                schema !== undefined ? schema[nomBranche] : undefined,
+            const objectSchema = typeof schema === 'object' && schema !== null ? schema : undefined;
 
-                cheminA,
-
-                schema as TObjet
-            );
+            retour[nomBranche] = this.filtrer(donneeBranche, objectSchema?.[nomBranche], cheminA, schema as TObjet);
         }
 
         return retour;
     }
 
     // Traitement des données aux extrémités (auxquelles font référence les true)
-    private valeur(
-        donnee: any,
-        schema: TSelecteur,
-        chemin: string[]
-    ) {
-
+    private valeur(donnee: any, schema: TSelecteur | undefined, chemin: string[]) {
         // Si sélecteur wildcard
-        const wildcard = typeof schema === 'object' && schema['*'] === true
+        const wildcard = typeof schema === 'object' && schema['*'] === true;
 
         // Traitement des objets
         if (donnee && typeof donnee === 'object') {
-
             // Promise
             if (typeof donnee.then === 'function')
-                throw new Error(chemin.join('.') + ": Les promises ne sont pas autorisées en retour api, sauf via un getter de modèle.");
-
+                throw new Error(
+                    chemin.join('.') +
+                        ': Les promises ne sont pas autorisées en retour api, sauf via un getter de modèle.',
+                );
             // Sinon, wildcard obliatoire si on souhaite conserver l'objet entier
             else if (wildcard === false) {
-
-                if (donnee instanceof Date)
-                    return donnee.toISOString();
+                if (donnee instanceof Date) return donnee.toISOString();
                 // Mauvaise idée: Les instances de modèle Sequelize possèdent une méthode toString()
                 /*else if (typeof donnee.toString === 'function')
                     return donnee.toString();*/
-
             }
-
         }
 
         return donnee;
@@ -319,5 +279,4 @@ export default class Filtre {
             return false;
         }
     }*/
-
-}
+}