proteum 2.1.0 → 2.1.1

package/server/services/router/index.ts

@@ -32,11 +32,16 @@ import BaseRouter, {
     defaultOptions,
     matchRoute,
     buildUrl,
-    TDomainsList,
 } from '@common/router';
 import type { TSsrUnresolvedRoute, TRegisterPageArgs } from '@common/router/contracts';
 import { buildRegex, getRegisterPageArgs } from '@common/router/register';
 import { layoutsList, getLayout } from '@common/router/layouts';
+import {
+    profilerOriginHeader,
+    profilerParentRequestIdHeader,
+    profilerSessionIdHeader,
+    profilerTraceRequestIdHeader,
+} from '@common/dev/profiler';
 import { TFetcherList } from '@common/router/request/api';
 import type { TFrontRenderer } from '@common/router/response/page';
 
@@ -108,7 +113,7 @@ export type Config<
 
     disk?: string; // Disk driver ID
 
-    domains: TDomainsList;
+    currentDomain: string;
 
     http: HttpServiceConfig;
 
@@ -356,7 +361,7 @@ export default class ServerRouter<
     }
 
     public url = (path: string, params: {} = {}, absolute: boolean = true) =>
-        buildUrl(path, params, this.config.domains, absolute);
+        buildUrl(path, params, this.config.currentDomain, absolute);
 
     /*----------------------------------
     - REGISTER
@@ -581,14 +586,33 @@ 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,
+            profilerSessionId: request.headers[profilerSessionIdHeader] || undefined,
+            profilerOrigin: request.headers[profilerOriginHeader] || undefined,
+            profilerParentRequestId: request.headers[profilerParentRequestIdHeader] || undefined,
+        });
+        if (this.app.container.Trace.isEnabled()) res.setHeader(profilerTraceRequestIdHeader, request.id);
+
         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 +628,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 +647,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 +714,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 +738,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 +758,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 +860,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);
 
@@ -757,10 +909,36 @@ export default class ServerRouter<
             if (!fetcher || !('method' in fetcher)) continue;
 
             const { method, path, data } = fetcher;
+            const callId = this.app.container.Trace.startCall(request.id, {
+                origin: 'api-batch-fetcher',
+                label: id,
+                method,
+                path,
+                fetcherId: id,
+                requestDataKeys: data && typeof data === 'object' ? Object.keys(data) : [],
+                requestData: data,
+            });
 
-            const response = await this.resolve(request.children(method, path, data));
-
-            responseData[id] = response.data;
+            try {
+                const response = await this.resolve(request.children(method, path, data));
+                responseData[id] = response.data;
+                this.app.container.Trace.finishCall(request.id, callId, {
+                    statusCode: response.statusCode,
+                    resultKeys:
+                        response.data && typeof response.data === 'object' && !Array.isArray(response.data)
+                            ? Object.keys(response.data as Record<string, unknown>)
+                            : [],
+                    result: response.data,
+                });
+            } catch (error) {
+                const typedError = error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown error');
+                const statusCode = 'http' in typedError ? Number((typedError as Error & { http?: number }).http) : undefined;
+                this.app.container.Trace.finishCall(request.id, callId, {
+                    statusCode: Number.isFinite(statusCode) ? statusCode : undefined,
+                    errorMessage: typedError.message,
+                });
+                throw error;
+            }
 
             // TODO: merge response.headers ?
         }
@@ -782,6 +960,16 @@ export default class ServerRouter<
 
         const response = new ServerResponse(request).status(code);
 
+        this.app.container.Trace.record(
+            request.id,
+            'error',
+            {
+                code,
+                error,
+            },
+            'summary',
+        );
+
         // Rapport / debug
         if (code === 500) {
             // Print the error here so the stacktrace appears in the bug report logs

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

@@ -80,7 +80,36 @@ export default class ApiClientRequest extends RequestService implements ApiClien
 
             // 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);
+            const callId = this.request.router.app.container.Trace.startCall(this.request.id, {
+                origin: 'ssr-fetcher',
+                label: id,
+                method,
+                path,
+                fetcherId: id,
+                requestDataKeys: data && typeof data === 'object' ? Object.keys(data) : [],
+                requestData: data,
+            });
+
+            try {
+                const response = await request.router.resolve(request);
+                fetchedData[id] = response.data;
+                this.request.router.app.container.Trace.finishCall(this.request.id, callId, {
+                    statusCode: response.statusCode,
+                    resultKeys:
+                        response.data && typeof response.data === 'object' && !Array.isArray(response.data)
+                            ? Object.keys(response.data as Record<string, unknown>)
+                            : [],
+                    result: response.data,
+                });
+            } catch (error) {
+                const typedError = error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown error');
+                const statusCode = 'http' in typedError ? Number((typedError as Error & { http?: number }).http) : undefined;
+                this.request.router.app.container.Trace.finishCall(this.request.id, callId, {
+                    statusCode: Number.isFinite(statusCode) ? statusCode : undefined,
+                    errorMessage: typedError.message,
+                });
+                throw error;
+            }
         }
 
         return fetchedData;

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

@@ -14,7 +14,7 @@ import express from 'express';
 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 { TMatchedRoute, TRoute, TAnyRoute, TDomainsList } from '@common/router';
+import { TMatchedRoute, TRoute, TAnyRoute } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
 import BaseResponse, { TResponseData } from '@common/router/response';
 import { splitRouteSetupResult } from '@common/router/pageSetup';
@@ -38,7 +38,7 @@ export type TBasicSSrData = {
     request: { data: TObjetDonnees; id: string };
     page: { chunkId: string; data?: TObjetDonnees };
     user: TBasicUser | null;
-    domains: TDomainsList;
+    currentDomain: string;
 };
 
 type TServerRouterApplication<TRouter extends TServerRouter> =
@@ -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;
     }
 
@@ -215,7 +277,7 @@ export default class ServerResponse<
             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,
+            currentDomain: this.router.config.currentDomain,
             ...customSsrData,
         };
     }
@@ -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/skills/clean-project-code/SKILL.md

@@ -32,10 +32,13 @@ Use fast search tools such as `rg` to verify references. Check exports, dynamic
 5. Keep uncertain cases.
 If code looks unused but safety is not clear, keep it and report it separately. Favor false negatives over unsafe deletions.
 
-6. Apply style only on touched files.
+6. Audit redundancy candidates across the project.
+List catalogs, constants, and functions that look redundant and could be centralized, unified, or merged. Treat this as a reporting task by default unless the user explicitly asked for structural refactoring. Give each candidate an impact score from 1 to 5, where 5 is the highest expected payoff for maintainability, consistency, or simplification.
+
+7. Apply style only on touched files.
 Follow the repository coding style for files you change. Run Prettier with the repo config, preferably on touched files only unless the user explicitly asks for repo-wide formatting.
 
-7. Verify.
+8. Verify.
 Run the smallest relevant verification available after edits. Prefer project-native checks. If no suitable automated verification exists, say so explicitly.
 
 ## Deletion Rules
@@ -50,6 +53,7 @@ Run the smallest relevant verification available after edits. Prefer project-nat
 Always report:
 - what was removed
 - what was intentionally left unchanged because it was uncertain
+- which catalogs, constants, and functions appear redundant across the project, with a proposed centralization or merge direction and an impact score from 1 to 5
 - what verification was run
 - what could not be verified automatically
 
@@ -59,5 +63,6 @@ When the user provides a cleanup brief, turn it into an execution checklist befo
 - instructions read
 - safe deletion targets identified
 - risky candidates deferred
+- redundancy candidates and impact scoring captured
 - formatting scope confirmed
 - verification plan chosen

package/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "failed",
+  "failedTests": []
+}

package/types/aliases.d.ts

@@ -18,6 +18,12 @@ declare module '@/server' {
     export = InstanceType<ServerApplicationClass>;
 }
 
+declare module '@/server/index' {
+    import ServerApplicationBase from '../server/app';
+
+    export default class ServerApplication extends ServerApplicationBase {}
+}
+
 declare module '@/client' {
     const ClientApplicationClass: import('../client/app').default;
     export = InstanceType<ClientApplicationClass>;

package/types/global/utils.d.ts

@@ -43,24 +43,17 @@ declare type PrimitiveValue = string | number | boolean;
 /*type TEnvConfig = {
     name: 'local' | 'server',
     profile: 'dev' | 'testing' | 'prod',
-    
+
     router: {
         port: number,
-        domains: TDomainsList
-    },
-    database: {
-        name: string,
-        databases: string[],
-        host: string,
-        port: number,
-        login: string,
-        password: string,
+        currentDomain: string
     },
-    console: {
+    trace: {
         enable: boolean,
-        debug: boolean,
-        bufferLimit: number,
-        level: TLogProfile,
+        requestsLimit: number,
+        eventsLimit: number,
+        capture: 'summary' | 'resolve' | 'deep',
+        persistOnError: boolean,
     },
 }*/