proteum 2.1.0-2 → 2.1.0-3

package/server/services/router/index.ts

@@ -581,14 +581,29 @@ export default class ServerRouter<
             this,
         );
 
+        this.app.container.Trace.startRequest({
+            id: request.id,
+            method: request.method,
+            path: request.path,
+            url: request.url,
+            headers: request.headers,
+            data: request.data,
+        });
+
         let response: ServerResponse<this>;
         try {
             // Hook
             await this.runHook('request', request);
+            this.app.container.Trace.setRequestUser(request.id, request.user?.email);
 
             // Bulk API Requests
             if (request.path === '/api' && typeof request.data.fetchers === 'object') {
-                return await this.resolveApiBatch(request.data.fetchers, request);
+                await this.resolveApiBatch(request.data.fetchers, request);
+                this.app.container.Trace.finishRequest(request.id, {
+                    statusCode: request.res.statusCode || 200,
+                    user: request.user?.email,
+                });
+                return;
             } else {
                 response = await this.resolve(
                     request,
@@ -604,7 +619,17 @@ export default class ServerRouter<
             // Static pages
             if (cachedPage) {
                 console.log('[router] Get static page from cache', req.path);
+                this.app.container.Trace.record(
+                    request.id,
+                    'response.send',
+                    { cached: true, statusCode: response.statusCode, contentType: 'text/html' },
+                    'summary',
+                );
                 res.send(cachedPage.rendered);
+                this.app.container.Trace.finishRequest(request.id, {
+                    statusCode: response.statusCode,
+                    user: request.user?.email,
+                });
                 return;
             }
 
@@ -613,9 +638,34 @@ export default class ServerRouter<
             // Headers
             res.header(response.headers);
             // Data
+            this.app.container.Trace.record(
+                request.id,
+                'response.send',
+                {
+                    cached: false,
+                    statusCode: response.statusCode,
+                    contentType: response.headers['Content-Type'] || '',
+                    headerKeys: Object.keys(response.headers),
+                },
+                'summary',
+            );
             res.send(response.data);
+            this.app.container.Trace.finishRequest(request.id, {
+                statusCode: response.statusCode,
+                user: request.user?.email,
+            });
         } else if (response.data !== 'true') {
+            this.app.container.Trace.finishRequest(request.id, {
+                statusCode: res.statusCode || response.statusCode,
+                user: request.user?.email,
+                errorMessage: "Can't return data from the controller since response has already been sent via express.",
+            });
             throw new Error("Can't return data from the controller since response has already been sent via express.");
+        } else {
+            this.app.container.Trace.finishRequest(request.id, {
+                statusCode: res.statusCode || response.statusCode,
+                user: request.user?.email,
+            });
         }
     }
 
@@ -655,6 +705,16 @@ export default class ServerRouter<
                 },
                 async () => {
                     const timeStart = Date.now();
+                    const routeStats = {
+                        total: this.routes.length,
+                        staticSkipped: 0,
+                        methodMismatch: 0,
+                        acceptMismatch: 0,
+                        pathMismatch: 0,
+                        matched: 0,
+                    };
+
+                    this.app.container.Trace.record(request.id, 'resolve.start', { isStatic: Boolean(isStatic) }, 'summary');
 
                     if (this.status === 'starting') {
                         console.log(LogPrefix, `Waiting for servert to be resdy before resolving request`);
@@ -669,6 +729,16 @@ export default class ServerRouter<
                         // Controller route
                         const controllerRoute = this.controllers[request.path];
                         if (controllerRoute !== undefined) {
+                            this.app.container.Trace.record(
+                                request.id,
+                                'resolve.controller-route',
+                                {
+                                    path: request.path,
+                                    accept: controllerRoute.options.accept || '',
+                                    filepath: controllerRoute.options.filepath || '',
+                                },
+                                'summary',
+                            );
                             // Create response
                             await response.runController(controllerRoute);
                             if (response.wasProvided) return resolve(response);
@@ -679,21 +749,81 @@ export default class ServerRouter<
 
                         // Classic routes
                         for (const route of this.routes) {
-                            if (isStatic && !route.options.whenStatic) continue;
+                            if (isStatic && !route.options.whenStatic) {
+                                routeStats.staticSkipped++;
+                                continue;
+                            }
 
                             // Match Method
-                            if (request.method !== route.method && route.method !== '*') continue;
+                            if (request.method !== route.method && route.method !== '*') {
+                                routeStats.methodMismatch++;
+                                if (this.app.container.Trace.shouldCapture(request.id, 'deep')) {
+                                    this.app.container.Trace.record(
+                                        request.id,
+                                        'resolve.route-skip',
+                                        {
+                                            reason: 'method',
+                                            routeMethod: route.method,
+                                            requestMethod: request.method,
+                                            routePath: route.path || '',
+                                            routeId: route.options.id || '',
+                                            filepath: route.options.filepath || '',
+                                        },
+                                        'deep',
+                                    );
+                                }
+                                continue;
+                            }
 
                             // Match Response format
-                            if (!request.accepts(route.options.accept)) continue;
+                            if (!request.accepts(route.options.accept)) {
+                                routeStats.acceptMismatch++;
+                                if (this.app.container.Trace.shouldCapture(request.id, 'deep')) {
+                                    this.app.container.Trace.record(
+                                        request.id,
+                                        'resolve.route-skip',
+                                        {
+                                            reason: 'accept',
+                                            routeAccept: route.options.accept || '',
+                                            routePath: route.path || '',
+                                            routeId: route.options.id || '',
+                                            filepath: route.options.filepath || '',
+                                        },
+                                        'deep',
+                                    );
+                                }
+                                continue;
+                            }
 
                             const isMatching = matchRoute(route, request);
-                            if (!isMatching) continue;
+                            if (!isMatching) {
+                                routeStats.pathMismatch++;
+                                if (this.app.container.Trace.shouldCapture(request.id, 'deep')) {
+                                    this.app.container.Trace.record(
+                                        request.id,
+                                        'resolve.route-skip',
+                                        {
+                                            reason: 'path',
+                                            routePath: route.path || '',
+                                            routeId: route.options.id || '',
+                                            filepath: route.options.filepath || '',
+                                        },
+                                        'deep',
+                                    );
+                                }
+                                continue;
+                            }
 
+                            routeStats.matched++;
                             await this.resolvedRoute(route, response, timeStart);
-                            if (response.wasProvided) return resolve(response);
+                            if (response.wasProvided) {
+                                this.app.container.Trace.record(request.id, 'resolve.routes-evaluated', routeStats, 'resolve');
+                                return resolve(response);
+                            }
                         }
 
+                        this.app.container.Trace.record(request.id, 'resolve.routes-evaluated', routeStats, 'resolve');
+                        this.app.container.Trace.record(request.id, 'resolve.not-found', { path: request.path }, 'summary');
                         reject(new NotFound());
                     } catch (error) {
                         const typedError =
@@ -721,6 +851,19 @@ export default class ServerRouter<
     private async resolvedRoute(route: TMatchedRoute, response: ServerResponse<this>, timeStart: number) {
         route = await response.resolveRouteOptions(route);
 
+        this.app.container.Trace.record(
+            response.request.id,
+            'resolve.route-match',
+            {
+                routePath: route.path || '',
+                routeId: route.options.id || '',
+                filepath: route.options.filepath || '',
+                accept: route.options.accept || '',
+                method: route.method,
+            },
+            'summary',
+        );
+
         // Run on resolution hooks. Ex: authentication check
         await this.runHook('resolved', route, response.request, response);
 
@@ -782,6 +925,16 @@ export default class ServerRouter<
 
         const response = new ServerResponse(request).status(code);
 
+        this.app.container.Trace.record(
+            request.id,
+            'error',
+            {
+                code,
+                error: error instanceof Error ? error : new Error(error.message),
+            },
+            'summary',
+        );
+
         // Rapport / debug
         if (code === 500) {
             // Print the error here so the stacktrace appears in the bug report logs

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

@@ -88,6 +88,11 @@ export type TRouterContextServices<
 
 export type TRouterRequestContext<TRouter extends TServerRouter> = TServerRouterCustomContext<TRouter>;
 
+const getRouteTraceTarget = (route: TAnyRoute<TRouterContext<TServerRouter>>) => {
+    if ('code' in route) return String(route.code);
+    return route.path || '';
+};
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
@@ -129,6 +134,18 @@ export default class ServerResponse<
         // Update canonical url
         this.updateCanonicalUrl(route);
 
+        this.app.container.Trace.record(
+            this.request.id,
+            'controller.start',
+            {
+                target: getRouteTraceTarget(route as TAnyRoute<TRouterContext<TServerRouter>>),
+                routeId: route.options.id || '',
+                filepath: route.options.filepath || '',
+                accept: route.options.accept || '',
+            },
+            'summary',
+        );
+
         // Create response context for controllers
         const requestContext = await this.createContext(route);
         const contextStore = context.getStore() as
@@ -141,16 +158,41 @@ export default class ServerResponse<
 
         // Run controller
         const content = await this.route.controller(requestContext);
-        if (content === undefined) return;
+        if (content === undefined) {
+            this.app.container.Trace.record(this.request.id, 'controller.result', { kind: 'undefined' }, 'summary');
+            return;
+        }
 
         // No need to process the content
-        if (content instanceof ServerResponse) return;
+        if (content instanceof ServerResponse) {
+            this.app.container.Trace.record(this.request.id, 'controller.result', { kind: 'response' }, 'summary');
+            return;
+        }
         // Render react page to html
-        else if (content instanceof Page) await this.render(content, requestContext, additionnalData);
+        else if (content instanceof Page) {
+            this.app.container.Trace.record(
+                this.request.id,
+                'controller.result',
+                { kind: 'page', chunkId: content.chunkId || '' },
+                'summary',
+            );
+            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') {
+            this.app.container.Trace.record(
+                this.request.id,
+                'controller.result',
+                { kind: 'html', length: content.length },
+                'summary',
+            );
+            await this.html(content);
+        }
         // Return JSON
-        else await this.json(content);
+        else {
+            this.app.container.Trace.record(this.request.id, 'controller.result', { kind: 'json', data: content }, 'resolve');
+            await this.json(content);
+        }
     }
 
     private updateCanonicalUrl(route: TAnyRoute<TRouterContext<TRouter>>) {
@@ -175,13 +217,20 @@ export default class ServerResponse<
         const requestContext = await this.createContext(route);
         const { options } = splitRouteSetupResult(((setup as any)({ ...requestContext, data: this.request.data }) as {}) || {});
 
+        this.app.container.Trace.record(
+            this.request.id,
+            'setup.options',
+            { optionKeys: Object.keys(options) },
+            'resolve',
+        );
+
         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 controllers = createControllers(this.request.api);
         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
@@ -196,7 +245,7 @@ export default class ServerResponse<
 
             Router: this.router,
             ...(this.app as {}),
-            ...createControllers(this.request.api),
+            ...controllers,
 
             // Router services
             ...(contextServices as TRouterContextServices<TRouter>),
@@ -205,6 +254,19 @@ export default class ServerResponse<
 
         requestContext.context = requestContext;
 
+        this.app.container.Trace.record(
+            this.request.id,
+            'context.create',
+            {
+                target: getRouteTraceTarget(route as TAnyRoute<TRouterContext<TServerRouter>>),
+                routeId: route.options.id || '',
+                routerServiceKeys: Object.keys(contextServices),
+                controllerKeys: Object.keys(controllers),
+                customContextKeys: Object.keys(customSsrData as object),
+            },
+            'resolve',
+        );
+
         return requestContext;
     }
 
@@ -249,6 +311,17 @@ export default class ServerResponse<
             // Example: error message for error pages
             page.data = { ...page.data, ...additionnalData };
 
+        this.app.container.Trace.record(
+            this.request.id,
+            'page.data',
+            {
+                chunkId: page.chunkId || '',
+                dataKeys: Object.keys(page.data || {}),
+                data: page.data || {},
+            },
+            'resolve',
+        );
+
         // Render page
         await this.router.runHook('render', page);
         const document = await page.render();

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

@@ -182,6 +182,22 @@ export default class DocumentRenderer<TRouter extends TServerRouter> {
         const ssrData = response.forSsr(page);
         const context = safeStringify(ssrData);
         const routesForClient = JSON.stringify(this.router.ssrRoutes);
+        const customContextKeys = Object.keys(ssrData).filter((key) => !['request', 'page', 'user', 'domains'].includes(key));
+
+        this.app.container.Trace.record(
+            response.request.id,
+            'ssr.payload',
+            {
+                chunkId: page.chunkId || '',
+                topLevelKeys: Object.keys(ssrData),
+                requestDataKeys: Object.keys(ssrData.request.data || {}),
+                pageDataKeys: Object.keys(ssrData.page.data || {}),
+                customContextKeys,
+                serializedBytes: Buffer.byteLength(context, 'utf8'),
+                routeCount: this.router.ssrRoutes.length,
+            },
+            'resolve',
+        );
 
         return (
             <>

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

@@ -62,6 +62,17 @@ export default class ServerPage<TRouter extends TServerRouter = TServerRouter> e
         // Ex: runtime added scripts, title, metas, ....
 
         const context = this.context as TPageRenderContext & TRouterContext<TRouter>;
+        const requestId = context.response.request.id;
+        this.app.container.Trace.record(
+            requestId,
+            'render.start',
+            {
+                chunkId: this.chunkId || '',
+                title: this.title || '',
+                routeId: this.route.options['id'] || '',
+            },
+            'summary',
+        );
         const html = renderToString(
             <App context={context as Parameters<typeof App>[0]['context'] & TRouterContext<TRouter>} />,
         );
@@ -82,7 +93,22 @@ export default class ServerPage<TRouter extends TServerRouter = TServerRouter> e
         if (page.theme)
             attrsBody.className += ' ' + page.theme;*/
 
-        return this.router.render.page(html, this, context.response);
+        return this.router.render.page(html, this, context.response).then((document) => {
+            this.app.container.Trace.record(
+                requestId,
+                'render.end',
+                {
+                    chunkId: this.chunkId || '',
+                    htmlLength: html.length,
+                    documentLength: document.length,
+                    styleCount: this.style.length,
+                    scriptCount: this.scripts.length,
+                },
+                'summary',
+            );
+
+            return document;
+        });
     }
 
     /*----------------------------------

package/doc/TODO.md

@@ -1,71 +0,0 @@
-* Fix erreurs type Client / Server context
-    * Server side: ServerContext
-    * Client side: ClientContext | ServerContext
-    * PageResponse extends Response
-* Toast service
-* ClientApplication hooks
-    app.on('bug')
-    app.on('error')
-
-
-# Dependancies injection
-
-# Full stack Pages
-
-```typescript
-import Router from '@server/services/router';
-import { TRouterContext as ServerServices } from '@server/services/router/response';
-import { TRouterContext as ClientServices } from '@client/services/router/response';
-
-abstract class Controller< 
-    TRouter extends Router, 
-    TData extends any = any,
-    TUserAccess extends string = string
-> {
-
-    abstract auth: TUserAccess;
-
-    abstract get( services: ServerServices<TRouter> ): Promise<TData>;
-
-    abstract render( context: TData, services: ClientServices<TRouter> ): ComponentChild;
-
-}
-```
-
-```typescript
-//? /headhunter/missions/suggested'
-class Missions extends Controller<CrossPath["router"]> {
-
-    auth = 'USER';
-
-    async get({ headhunting, response, auth  }) {
-
-        const user = await auth.check('USER');
-
-        const suggested =  await headhunting.missions.Suggest( user );
-    
-        return { suggested }
-    }
-
-    render({ page, api, suggested }) {
-        return (
-            <Page title="App title here" subtitle="SEO description here">{page.loading || <>
-    
-                <section class="col">
-    
-                    <header class="row">
-                        <h2 class="col-1">Suggested Missions</h2>
-                    </header>
-    
-                    <div class="grid xa3">
-                        {suggested.map( mission => (
-                            <MissionCard mission={mission} />
-                        ))}
-                    </div>
-                </section>
-    
-            </>}</Page>
-        )
-    }
-}
-```

package/doc/front/router.md

@@ -1,27 +0,0 @@
-# Disallowed
-
-- To destructure page data objects
-
-```
-route.page('/withdraw', { bodyId: 'withdraw' }, ({}, { api }) => ({
-
-    withdraw: api.get('/withdraw')
-
-}), ({ withdraw: { history, balance, minimum, fees } }, { api, modal, page, user }) => {
-
-    ...
-```
-
-Do instead:
-
-```
-route.page('/withdraw', { bodyId: 'withdraw' }, ({}, { api }) => ({
-
-    withdraw: api.get('/withdraw')
-
-}), ({ withdraw }, { api, modal, page, user }) => {
-
-    const { history, balance, minimum, fees } = withdraw;
-
-    ...
-```

package/server/services/router/http/session.ts.old

@@ -1,40 +0,0 @@
-// Npm
-import session from 'express-session';
-import { v4 as uuidv4 } from 'uuid';
-import redisConnector from 'connect-redis';
-const RedisStore = redisConnector(session);
-
-// Services
-import type { THttpConfig } from '@server/services/http';
-import Redis from '@server/services/redis';
-
-// Middleware
-export const createSessionMiddleware = (httpConfig: THttpConfig) => {
-    return session({
-
-        genid: (req) => {
-            return /*req.id;*/uuidv4(); // ID session via UUID
-        },
-
-        name: httpConfig.session.name,
-        store: new RedisStore({
-            client: Redis.instance,
-            ttl: httpConfig.session.duration // secondes
-        }),
-        secret: httpConfig.session.secret,
-
-        // Ces deux valeurs sont recommandes avec session filestore
-        // https://github.com/valery-barysok/session-file-store/blob/master/examples/express-example/app.js
-        resave: true, // Quand false, /admin/console réinitialise la session
-        saveUninitialized: true,
-
-        cookie: {
-            maxAge: httpConfig.session.duration * 1000, // millisecondes
-            //sameSite: true,
-            httpOnly: true,
-            // Les variables d'environnement sont des chaines
-            secure: httpConfig.ssl,
-            path: '/',
-        }
-    })
-}