proteum 2.1.0 → 2.1.2

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,
     },
 }*/
 

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: '/',
-        }
-    })
-}