5htp-core 0.1.2 → 0.2.1

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

@@ -0,0 +1,76 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+
+import RequestService from './service';
+
+import ApiClientService, { 
+    TApiFetchOptions, TFetcherList, TFetcherArgs, TFetcher 
+} from '@common/router/request/api';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class ApiClientRequest extends RequestService implements ApiClientService {
+
+    public async start() {
+
+    }
+
+    /*----------------------------------
+    - HIGH LEVEL
+    ----------------------------------*/
+
+    public get = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
+        this.createFetcher<TData>('GET', path, data, opts);
+
+    public post = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
+        this.createFetcher<TData>('POST', path, data, opts);
+
+    public put = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
+        this.createFetcher<TData>('PUT', path, data, opts);
+
+    public delete = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
+        this.createFetcher<TData>('DELETE', path, data, opts);
+
+    /*----------------------------------
+    - API CALLS FROM SERVER
+    ----------------------------------*/
+
+    public createFetcher<TData extends unknown = unknown>(...[method, path, data, options]: TFetcherArgs): TFetcher<TData> {
+        return { 
+            method, path, data, options,
+            then: () => { throw new Error("Async resolvers should not be run from server side."); },
+            run: () => { throw new Error("Async resolvers should not be run from server side."); },
+        };
+    }
+
+    public async fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees> {
+
+        const fetchedData: TObjetDonnees = { ...alreadyLoadedData };
+
+        for (const id in fetchers) {
+
+            const { method, path, data, options } = fetchers[id];
+            //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 internalHeaders = { accept: 'application/json' }
+            const request = this.request.children(method, path, data, { ...internalHeaders/*, ...headers*/ });
+            fetchedData[id] = await request.router.resolve(request).then(res => res.data);
+        }
+
+        return fetchedData;
+    } 
+}

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

@@ -8,34 +8,30 @@ import ISO6391 from 'iso-639-1';
 import accepts from 'accepts';
 import Bowser from "bowser";
 
-// Core libs
-import validateurs from '@server/data/input';
-import { TSchema, validate as validerSchema, TDonneesValidees } from '@common/data/input/validate';
-import app from '@server/app';
+// Core
+import BaseRequest from '@common/router/request';
 
-// Core libs: router
+// Specific
 import ServerResponse from '../response';
-import BaseRequest, { TFetcherArgs, TFetcher, TFetcherList } from '@common/router/request';
-
-// Extensions
-import AuthService from './services/auth';
-import SecurityService from './services/detect';
-import TrackingService from './services/tracking';
-
-const debug = true;
+import ApiClient from './api';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-import type { default as Router, HttpMethod, HttpHeaders } from '@server/services/router';
+import type { 
+    default as Router, Config as RouterConfig, 
+    HttpMethod, HttpHeaders
+} from '@server/services/router';
 
 const localeFilter = (input: any) => typeof input === 'string' && ISO6391.validate(input) ? input : undefined;
 
 /*----------------------------------
 - CONTEXTE
 ----------------------------------*/
-export default class ServerRequest extends BaseRequest {
+export default class ServerRequest<
+    TRouter extends Router = Router
+> extends BaseRequest {
 
     /*----------------------------------
     - PROPRIÉTÉS
@@ -53,15 +49,15 @@ export default class ServerRequest extends BaseRequest {
     public cookies: TObjetDonnees = {};
 
     // reponse
-    public response?: ServerResponse;
-    public router: Router;
+    public response?: ServerResponse<TRouter>;
+    public router: TRouter;
 
     // Origin
     public req: express.Request;
     public res: express.Response;
 
     // Services
-    //public analytics?: ua.Visitor;
+    public api: ApiClient;
 
     /*----------------------------------
     - INITIALISATION
@@ -75,7 +71,7 @@ export default class ServerRequest extends BaseRequest {
         headers: HttpHeaders | undefined,
 
         res: express.Response, 
-        router: Router ,
+        router: TRouter,
         isVirtual: boolean = false
     ) {
 
@@ -87,6 +83,7 @@ export default class ServerRequest extends BaseRequest {
         this.req = res.req;
         this.res = res
         this.router = router;
+        this.api = new ApiClient(this);
 
         this.host = this.req.get('host') as string;
         this.method = method;
@@ -96,16 +93,8 @@ export default class ServerRequest extends BaseRequest {
         this.cookies = res.req.cookies;
 
         this.ip = res.req.ip;
-        if (this.ip === '::1' && app.env.localIP)
-            this.ip = app.env.localIP;
 
         this.data = data || {};
-
-        // FIX: L'utilisation du sprad sur la classe Servercontext fait perdre le contexte this à ses méthodes
-        this.schema.validate = this.schema.validate.bind(this);
-        
-        //this.url = this.url.bind(this);
-
     }
 
     public children(method: HttpMethod, path: string, data: TObjetDonnees | undefined, headers?: HttpHeaders) {
@@ -163,74 +152,4 @@ export default class ServerRequest extends BaseRequest {
         const { os, browser } = info;
         return (os.name || 'Unknown OS') + ' ' + (os.versionName || os.version || '') + ' / ' + (browser.name || 'Unknown browser') + ' ' + (browser.version || '');
     }
-
-    /*----------------------------------
-    - SERVICES
-    ----------------------------------*/
-    public schema = {
-        ...validateurs,
-        // shortcut pour validation données requete
-        validate: async <TSchemaA extends TSchema>(schema: TSchemaA): Promise<TDonneesValidees<TSchemaA>> => {
-
-            console.log("Validate request data:", this.data);
-
-            // Les InputError seront propagées vers le middleware dédié à la gestion des erreurs
-            const { valeurs } = await validerSchema(
-                schema,
-                this.data, 
-                this.data, 
-                {}, 
-                {
-                    critique: true,
-                    validationComplete: true,
-                    avecDependances: false
-                },
-                []
-            );
-
-            return valeurs;
-        }
-    };
-
-    /*public url = (route: string, params: any = {}, absolu: boolean = true) =>
-        url(route, params, absolu);*/
-
-    public auth = new AuthService(this);
-
-    public tracking = new TrackingService(this);
-
-    public detect = new SecurityService(this);
-
-    public createFetcher(...[method, path, data, options]: TFetcherArgs) {
-        return { 
-            method, path, data, options,
-            then: () => { throw new Error("Async resolvers should not be run from server side."); },
-            run: () => { throw new Error("Async resolvers should not be run from server side."); },
-        } as TFetcher;
-    }
-
-    public async fetchSync(fetchers: TFetcherList): Promise<TObjetDonnees> {
-
-        const resolved: TObjetDonnees = {};
-
-        for (const id in fetchers) {
-
-            const { method, path, data, options } = fetchers[id];
-
-            debug && console.log(`[api] Resolving from internal api`, method, path, data);
-
-            const internalHeaders = { accept: 'application/json' }
-            const request = this.request.children(method, path, data, { ...internalHeaders/*, ...headers*/ });
-            resolved[id] = await request.router.resolve(request).then(res => res.data);
-
-        }
-
-        return resolved;
-
-    } 
-    
-    public fetchAsync(...args: TFetcherArgs): Promise<any> {
-        throw new Error("Async resolvers should not be run from server side.");
-    }
-
 }

package/src/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/src/server/services/router/response/index.ts

@@ -12,16 +12,16 @@ import fs from 'fs-extra';
 import express from 'express';
 
 // Core
-import { $ } from '@server/app';
-import { NotFound, Forbidden } from '@common/errors';
-
-// Libs métier
-import * as render from '../../../libs/pages/render';
-import filter from './filter';
+import Application from '@server/app';
+import type ServerRouter from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
 import { TRoute } from '@common/router';
-import BaseResponse, { TResponseData, PageResponse } from '@common/router/response';
-import { ClientContext } from '@client/context';
+import { NotFound, Forbidden } from '@common/errors';
+import BaseResponse, { TResponseData } from '@common/router/response';
+import Page from './page';
+
+// To move into a new npm module: json-mask
+import jsonMask from './mask';
 
 /*----------------------------------
 - TYPES
@@ -29,98 +29,145 @@ import { ClientContext } from '@client/context';
 
 const debug = true;
 
-export type TSsrData = {
+export type TBasicSSrData = {
     request: { data: TObjetDonnees, id: string },
-    page: { id: string, data?: TObjetDonnees },
-    user: User | null
+    page: { chunkId: string, data?: TObjetDonnees },
+    //user: User | null
 }
 
+export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
+    // Request context
+    {
+        app: Application,
+        context: TRouterContext<TRouter>, // = this
+        request: ServerRequest<TRouter>,
+        api: ServerRequest<TRouter>["api"],
+        response: ServerResponse<TRouter>,
+        route: TRoute,
+        page?: Page,
+        user: User
+    }
+    &
+    TRouterContextServices<TRouter>
+)
+
+type TRouterContextWithPage = With<TRouterContext, 'page'>
+
+export type TRouterContextServices<TRouter extends ServerRouter> = (
+    // 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"] >
+    }
+)
+
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
-export default class ServerResponse<TData extends TResponseData = TResponseData> extends BaseResponse<TData, ServerRequest> {
+export default class ServerResponse<
+    TRouter extends ServerRouter,
+    TRequestContext = TRouterContext<ServerRouter>,
+    TData extends TResponseData = TResponseData
+> extends BaseResponse<TData, ServerRequest<TRouter>> {
 
+    // Services
+    public app: Application;
+    public router: ServerRouter;
+
+    // Response metadata
     public statusCode: number = 200;
     public headers: {[cle: string]: string} = {}
-    private triggers: {[cle: string]: any[]} = {}
     public cookie: express.Response["cookie"];
 
+    // If data was provided by at lead one controller
     public wasProvided = false;
 
-    public constructor( request: ServerRequest ) {
+    public constructor( request: ServerRequest<TRouter> ) {
 
         super(request);
 
         this.cookie = this.request.res.cookie.bind(this.request.res);
+
+        this.router = request.router;
+        this.app = this.router.app;
     }
 
-    public async runController( route: TRoute, additionnalData?: TObjetDonnees ) {
+    public async runController( route: TRoute, additionnalData: {} = {} ) {
 
         this.route = route;
 
-        if (this.route.type === 'PAGE') {
+        // Create response context for controllers
+        const context = this.createContext(route);
+
+        // Run controller
+        const response = await this.route.controller( context );
+
+        // Handle response type
+        if (response === undefined)
+            return;
+
+        // No need to process the response
+        if (response instanceof ServerResponse)
+            return;
+        // Render react page to html
+        else if (response instanceof Page)
+            await this.render(response, context, additionnalData);
+        // Return HTML
+        else if (typeof response === 'string' && this.route.options.accept === 'html')
+            await this.html(response);
+        // Return JSON
+        else
+            await this.json(response);
+    }
 
-            const context = new ClientContext(this.request);
+    /*----------------------------------
+    - INTERNAL
+    ----------------------------------*/
 
-            // Prepare page & fetch data
-            const page = await context.createPage(this.route);
-            await page.fetchData();
-            if (additionnalData !== undefined) // Example: error message for error pages
-                page.data = { ...page.data, ...additionnalData }
+    // Start controller services
+    private createContext( route: TRoute ): TRequestContext {
 
-            // Render page
-            const document = await render.page(page, this, context);
-            this.html(document);
 
-            // 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");
+        const contextServices: Partial<TRouterContextServices<TRouter>> = {}
+        for (const serviceName in this.router.services) {
 
-        } else {
+            const routerService = this.router.services[serviceName];
+            contextServices[ serviceName ] = routerService.requestService( this.request );
 
-            // Validate form data
-            if (this.route.options.form !== undefined) {
-                const formData = await this.request.schema.validate( this.route.options.form );
-                console.log("FORM DATA VIA RESPONSE", formData);
-                this.request.data = { ...this.request.data, ...formData }
-            }
+        }
 
-            const controllerData = additionnalData === undefined
-                ? this.request.data
-                // Example: error message for error pages
-                : { ...this.request.data, ...additionnalData }
+        const context: TRequestContext = {
+            // Router context
+            app: this.app,
+            context: undefined as TRequestContext,
+            request: this.request,
+            response: this,
+            route: route,
+            api: this.request.api,
+            // Router services
+            ...(contextServices as TRouterContextServices<TRouter>),
+        }
 
-                // Run controller
-            const returnedData = await this.route.controller(this.request, controllerData);
+        context.context = context;
 
-            // Default data type for `return <raw data>`
-            if (returnedData !== undefined && !(returnedData instanceof ServerResponse)) {
-                if (typeof returnedData === 'string' && this.route.options.accept === 'html')
-                    await this.html(returnedData);
-                else
-                    await this.json(returnedData);
-            }
-        }
+        return context;
     }
 
-    /*----------------------------------
-    - INTERNAL
-    ----------------------------------*/
+    public async forSsr( page: Page<TRouter> ): Promise<TBasicSSrData> {
+
+        const customSsrData = await this.router.config.ssrData(this.request);
 
-    public async forSsr(page: PageResponse): Promise<TSsrData> {
         return {
             request: {
                 id: this.request.id,
                 data: this.request.data,
             },
             page: {
-                id: page.id,
+                chunkId: page.chunkId,
                 data: page.data
             },
-
-            user: this.request.user
-                ? await filter(this.request.user, $.auth.SsrMask, this.request.user)
-                : null
+            ...customSsrData
         }
     }
 
@@ -138,13 +185,34 @@ export default class ServerResponse<TData extends TResponseData = TResponseData>
     - DATA RESPONSE
     ----------------------------------*/
 
+    public async render( page: Page, context: TRouterContext, 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 }
+
+        // Render page
+        await this.router.runHook('render', page);
+        const document = await page.render();
+        this.html(document);
+
+        // 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");
+
+    }
+
     public async json(data?: any, mask?: string) {
 
-        // RAPPEL: On filter aussi les requetes internes, car leurs données seront imprimées au SSR pour le contexte client
+        // 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 filter(data, mask, this.request.user);
+            data = await jsonMask(data, mask, this.request.user);
 
         this.headers['Content-Type'] = 'application/json';
         this.data = this.request.isVirtual ? data : JSON.stringify(data);
@@ -170,17 +238,15 @@ export default class ServerResponse<TData extends TResponseData = TResponseData>
     // TODO: https://github.com/adonisjs/http-server/blob/develop/src/Response/index.ts#L430
     public file( fichier: string ) {
 
-        const app = this.request.router.app;
-
         // Securité
         if (fichier.includes('..'))
             throw new Forbidden("Disallowed");
 
         // Force absolute path
-        if (!fichier.startsWith( app.path.root ))
+        if (!fichier.startsWith( this.app.path.root ))
             fichier = fichier[0] === '/'
-                ? app.path.root + '/bin' + fichier
-                : app.path.data + '/' + fichier;
+                ? this.app.path.root + '/bin' + fichier
+                : this.app.path.data + '/' + fichier;
 
         console.log(`[response] Serving file "${fichier}"`);
 

package/src/server/services/router/response/{filter → mask}/index.ts

@@ -13,8 +13,6 @@ import Filter from './Filter';
 - TYPES
 ----------------------------------*/
 
-import type { User } from '@models';
-
 /*----------------------------------
 - CONFIG
 ----------------------------------*/