proteum 2.1.2 → 2.1.6

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

@@ -22,9 +22,19 @@ import cookieParser from 'cookie-parser';
 import Container from '@server/app/container';
 import type CronManager from '@server/services/cron';
 import type CronTask from '@server/services/cron/CronTask';
+import type { TBasicUser } from '@server/services/auth';
 import type { TServerRouter } from '..';
+import type { TDevConsoleLogLevel } from '@common/dev/console';
+import type { TPerfGroupBy } from '@common/dev/performance';
+import type { TDevSessionStartResponse, TDevSessionUserSummary } from '@common/dev/session';
 import { serverHotReloadMessageType } from '@common/dev/serverHotReload';
 import { explainSectionNames } from '@common/dev/diagnostics';
+import {
+    connectedProjectHealthPath,
+    connectedProjectProxyPathPrefix,
+    parseConnectedProjectProxyPath,
+} from '@common/connectedProjects';
+import { profilerTraceRequestIdHeader } from '@common/dev/profiler';
 
 // Middlewaees (core)
 import { isMutipart, MiddlewareFormData } from './multipart';
@@ -54,6 +64,15 @@ export type Hooks = {};
 
 type TContentSecurityPolicyOptions = NonNullable<Parameters<typeof helmet.contentSecurityPolicy>[0]>;
 type TContentSecurityPolicyDirectives = NonNullable<TContentSecurityPolicyOptions['directives']>;
+type TDevSessionAuthService = {
+    config: {
+        jwt: {
+            expiration: number;
+        };
+    };
+    createSession: (session: { email: string }, request: { id: string; res: express.Response }) => string;
+    decodeSession: (session: { email: string }, req: express.Request) => Promise<TBasicUser | null>;
+};
 
 const createContentSecurityPolicy = (config: Config['csp']): TContentSecurityPolicyOptions => {
     const directives: TContentSecurityPolicyDirectives = {
@@ -101,6 +120,153 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
         this.app.on('cleanup', () => this.cleanup());
     }
 
+    private resolveDevSessionAuthService(): TDevSessionAuthService {
+        const plugins = Object.values(this.router.config.plugins || {}) as Array<{ users?: unknown }>;
+
+        for (const plugin of plugins) {
+            const users = plugin?.users as Partial<TDevSessionAuthService> | undefined;
+            if (!users) continue;
+            if (typeof users.createSession !== 'function') continue;
+            if (typeof users.decodeSession !== 'function') continue;
+            if (typeof users.config?.jwt?.expiration !== 'number') continue;
+
+            return users as TDevSessionAuthService;
+        }
+
+        throw new Error('No auth router plugin with a compatible users service is registered.');
+    }
+
+    private summarizeDevSessionUser(user: TBasicUser): TDevSessionUserSummary {
+        return {
+            email: user.email,
+            name: user.name,
+            type: user.type,
+            roles: [...user.roles],
+            locale: user.locale ?? null,
+        };
+    }
+
+    private async verifyConnectedProjectsBeforeStart() {
+        for (const connectedProject of Object.values(this.app.connectedProjects || {})) {
+            const healthUrl = new URL(connectedProjectHealthPath, connectedProject.urlInternal).toString();
+
+            let response: Response;
+            try {
+                response = await fetch(healthUrl, {
+                    headers: { Accept: 'application/json' },
+                });
+            } catch (error) {
+                throw new Error(
+                    `Connected project "${connectedProject.namespace}" is unreachable at ${connectedProject.urlInternal}. ${error instanceof Error ? error.message : String(error)}`,
+                );
+            }
+
+            if (!response.ok) {
+                throw new Error(
+                    `Connected project "${connectedProject.namespace}" health check failed at ${healthUrl} with status ${response.status}.`,
+                );
+            }
+        }
+    }
+
+    private registerConnectedProjectRoutes(routes: express.Express) {
+        routes.get(connectedProjectHealthPath, (_req, res) => {
+            res.json({
+                connectedProjects: Object.keys(this.app.connectedProjects || {}),
+                identifier: this.app.identity.identifier,
+                ok: true,
+            });
+        });
+
+        routes.all(`${connectedProjectHealthPath}/*`, (_req, res) => {
+            res.status(404).json({ error: 'Unknown Proteum connected-project route.' });
+        });
+
+        routes.all(`${connectedProjectProxyPathPrefix}/:namespace/*`, async (req, res, next) => {
+            const parsed = parseConnectedProjectProxyPath(req.path);
+            if (!parsed) {
+                next();
+                return;
+            }
+
+            const connectedProject = this.app.connectedProjects?.[parsed.namespace];
+            if (!connectedProject) {
+                res.status(404).json({ error: `Unknown connected project "${parsed.namespace}".` });
+                return;
+            }
+
+            const search = new URL(req.originalUrl, 'http://proteum.local').search;
+            const targetUrl = new URL(`${parsed.httpPath}${search}`, connectedProject.urlInternal).toString();
+            const headers = new Headers();
+
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (!value) continue;
+                if (key === 'content-length' || key === 'host') continue;
+                headers.set(key, Array.isArray(value) ? value.join(', ') : String(value));
+            }
+
+            if (!headers.has('accept')) headers.set('accept', 'application/json');
+
+            const init: RequestInit = {
+                method: req.method,
+                headers,
+            };
+
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                if (req.files && Object.keys(req.files).length > 0) {
+                    res.status(501).json({
+                        error: `Connected project proxy does not support multipart payloads for ${parsed.namespace} yet.`,
+                    });
+                    return;
+                }
+
+                const contentType = String(req.headers['content-type'] || '').toLowerCase();
+
+                if (contentType.includes('application/json')) {
+                    headers.set('content-type', 'application/json');
+                    init.body = JSON.stringify(req.body || {});
+                } else if (contentType.includes('application/x-www-form-urlencoded')) {
+                    headers.set('content-type', 'application/x-www-form-urlencoded');
+                    init.body = new URLSearchParams(req.body as Record<string, string>).toString();
+                } else {
+                    headers.delete('content-type');
+                    init.body = undefined;
+                }
+            }
+
+            let response: Response;
+            try {
+                response = await fetch(targetUrl, init);
+            } catch (error) {
+                res.status(502).json({
+                    error: `Failed to proxy connected request to ${connectedProject.namespace}. ${error instanceof Error ? error.message : String(error)}`,
+                });
+                return;
+            }
+
+            const traceRequestId = response.headers.get(profilerTraceRequestIdHeader);
+            if (traceRequestId) res.setHeader(profilerTraceRequestIdHeader, traceRequestId);
+
+            const setCookie = typeof (response.headers as Headers & { getSetCookie?: () => string[] }).getSetCookie === 'function'
+                ? (response.headers as Headers & { getSetCookie: () => string[] }).getSetCookie()
+                : [];
+            if (setCookie.length > 0) {
+                res.setHeader('set-cookie', setCookie);
+            }
+
+            const contentType = response.headers.get('content-type') || '';
+            res.status(response.status);
+            if (contentType) res.setHeader('content-type', contentType);
+
+            if (contentType.includes('application/json')) {
+                res.json(await response.json());
+                return;
+            }
+
+            res.send(await response.text());
+        });
+    }
+
     /*----------------------------------
     - HOOKS
     ----------------------------------*/
@@ -143,6 +309,7 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
         );
         routes.use(apiMultipartOnly(MiddlewareFormData));
         if (this.config.cors !== undefined) routes.use(apiOnly(cors(this.config.cors)));
+        this.registerConnectedProjectRoutes(routes);
         routes.use(apiOnly(routeRequest));
 
         // Diverses protections (dont le disable x-powered-by)
@@ -231,6 +398,8 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
         /*----------------------------------
         - BOOT SERVICES
         ----------------------------------*/
+        await this.verifyConnectedProjectsBeforeStart();
+
         this.http.listen(this.config.port, () => {
             if (__DEV__ && typeof process.send === 'function') {
                 process.send({
@@ -311,6 +480,17 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
             }
         });
 
+        routes.get('/__proteum/explain/owner', (req, res) => {
+            const query = Array.isArray(req.query.query) ? req.query.query[0] : req.query.query;
+
+            try {
+                res.json(this.app.getDevDiagnostics().explainOwner(typeof query === 'string' ? query : ''));
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                res.status(message.includes('required') ? 400 : 500).json({ error: message });
+            }
+        });
+
         routes.get('/__proteum/doctor', (req, res) => {
             const rawStrict = Array.isArray(req.query.strict) ? req.query.strict[0] : req.query.strict;
             const strict = rawStrict === '1' || rawStrict === 'true';
@@ -322,6 +502,129 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
             }
         });
 
+        routes.get('/__proteum/doctor/contracts', (req, res) => {
+            const rawStrict = Array.isArray(req.query.strict) ? req.query.strict[0] : req.query.strict;
+            const strict = rawStrict === '1' || rawStrict === 'true';
+
+            try {
+                res.json(this.app.getDevDiagnostics().doctorContracts(strict));
+            } catch (error) {
+                res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/logs', (req, res) => {
+            const rawLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
+            const rawLevel = Array.isArray(req.query.level) ? req.query.level[0] : req.query.level;
+            const limit = Math.max(0, Math.min(500, Number(rawLimit) || 100));
+            const level = typeof rawLevel === 'string' ? (rawLevel as TDevConsoleLogLevel) : 'log';
+
+            try {
+                res.json(this.app.getDevDiagnostics().readLogs(limit, level));
+            } catch (error) {
+                res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/diagnose', (req, res) => {
+            const readString = (value: unknown) => (Array.isArray(value) ? value[0] : value);
+            const readNumber = (value: unknown, fallback: number) => {
+                const parsed = Number(readString(value));
+                return Number.isFinite(parsed) ? parsed : fallback;
+            };
+
+            try {
+                res.json(
+                    this.app.getDevDiagnostics().diagnose({
+                        logsLevel:
+                            typeof readString(req.query.logsLevel) === 'string'
+                                ? (readString(req.query.logsLevel) as TDevConsoleLogLevel)
+                                : 'warn',
+                        logsLimit: readNumber(req.query.logsLimit, 40),
+                        path: typeof readString(req.query.path) === 'string' ? readString(req.query.path) : undefined,
+                        query: typeof readString(req.query.query) === 'string' ? readString(req.query.query) : undefined,
+                        requestId: typeof readString(req.query.requestId) === 'string' ? readString(req.query.requestId) : undefined,
+                        strict: readString(req.query.strict) === '1' || readString(req.query.strict) === 'true',
+                    }),
+                );
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                res.status(message.includes('required') || message.includes('Diagnose requires') ? 400 : 500).json({ error: message });
+            }
+        });
+
+        routes.get('/__proteum/perf/top', (req, res) => {
+            const readString = (value: unknown) => (Array.isArray(value) ? value[0] : value);
+            const readNumber = (value: unknown, fallback: number) => {
+                const parsed = Number(readString(value));
+                return Number.isFinite(parsed) ? parsed : fallback;
+            };
+
+            try {
+                res.json(
+                    this.app.getDevDiagnostics().perfTop({
+                        groupBy: typeof readString(req.query.groupBy) === 'string' ? (readString(req.query.groupBy) as TPerfGroupBy) : undefined,
+                        limit: readNumber(req.query.limit, 12),
+                        since: typeof readString(req.query.since) === 'string' ? readString(req.query.since) : undefined,
+                    }),
+                );
+            } catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/perf/compare', (req, res) => {
+            const readString = (value: unknown) => (Array.isArray(value) ? value[0] : value);
+            const readNumber = (value: unknown, fallback: number) => {
+                const parsed = Number(readString(value));
+                return Number.isFinite(parsed) ? parsed : fallback;
+            };
+
+            try {
+                res.json(
+                    this.app.getDevDiagnostics().perfCompare({
+                        baseline: typeof readString(req.query.baseline) === 'string' ? readString(req.query.baseline) : undefined,
+                        groupBy: typeof readString(req.query.groupBy) === 'string' ? (readString(req.query.groupBy) as TPerfGroupBy) : undefined,
+                        limit: readNumber(req.query.limit, 12),
+                        target: typeof readString(req.query.target) === 'string' ? readString(req.query.target) : undefined,
+                    }),
+                );
+            } catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/perf/memory', (req, res) => {
+            const readString = (value: unknown) => (Array.isArray(value) ? value[0] : value);
+            const readNumber = (value: unknown, fallback: number) => {
+                const parsed = Number(readString(value));
+                return Number.isFinite(parsed) ? parsed : fallback;
+            };
+
+            try {
+                res.json(
+                    this.app.getDevDiagnostics().perfMemory({
+                        groupBy: typeof readString(req.query.groupBy) === 'string' ? (readString(req.query.groupBy) as TPerfGroupBy) : undefined,
+                        limit: readNumber(req.query.limit, 12),
+                        since: typeof readString(req.query.since) === 'string' ? readString(req.query.since) : undefined,
+                    }),
+                );
+            } catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/perf/request', (req, res) => {
+            const query = Array.isArray(req.query.query) ? req.query.query[0] : req.query.query;
+
+            try {
+                res.json(this.app.getDevDiagnostics().perfRequest(typeof query === 'string' ? query : ''));
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                res.status(message.includes('Could not find') || message.includes('required') ? 404 : 400).json({ error: message });
+            }
+        });
+
         routes.get('/__proteum/cron/tasks', (_req, res) => {
             const cron = this.getCronManager();
             res.json({
@@ -358,6 +661,55 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
             }
         });
 
+        routes.post('/__proteum/session/start', async (req, res) => {
+            const email = typeof req.body?.email === 'string' ? req.body.email.trim() : '';
+            const requiredRole = typeof req.body?.role === 'string' ? req.body.role.trim() : '';
+
+            if (!email) {
+                res.status(400).json({ error: 'Email is required.' });
+                return;
+            }
+
+            try {
+                const auth = this.resolveDevSessionAuthService();
+                const user = await auth.decodeSession({ email }, req);
+
+                if (!user) {
+                    res.status(404).json({ error: `No user could be resolved for "${email}".` });
+                    return;
+                }
+
+                if (requiredRole && !user.roles.includes(requiredRole)) {
+                    res.status(403).json({ error: `User "${email}" does not have required role "${requiredRole}".` });
+                    return;
+                }
+
+                const token = auth.createSession(
+                    { email },
+                    {
+                        id: `proteum-session:${Date.now()}`,
+                        res,
+                    },
+                );
+                const issuedAt = new Date().toISOString();
+                const expiresAt = new Date(Date.now() + auth.config.jwt.expiration).toISOString();
+                const response: TDevSessionStartResponse = {
+                    user: this.summarizeDevSessionUser(user),
+                    session: {
+                        token,
+                        cookieName: 'authorization',
+                        expiresInMs: auth.config.jwt.expiration,
+                        issuedAt,
+                        expiresAt,
+                    },
+                };
+
+                res.json(response);
+            } catch (error) {
+                res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
         routes.post('/__proteum/cron/tasks/run', async (req, res) => {
             const cron = this.getCronManager();
             if (!cron) {

package/server/services/router/index.ts

@@ -72,6 +72,8 @@ type TGeneratedRouteModule = { filepath: string; register?: TRouteModule['__regi
 
 type TGeneratedControllerDefinition = {
     path: string;
+    filepath: string;
+    sourceLocation: { line: number; column: number };
     Controller: new (request: TRouterContext<TServerRouter>) => { [method: string]: () => any };
     method: string;
 };
@@ -114,6 +116,7 @@ export type Config<
     disk?: string; // Disk driver ID
 
     currentDomain: string;
+    defaultRouteOptions?: Partial<TRouteOptions>;
 
     http: HttpServiceConfig;
 
@@ -353,7 +356,7 @@ export default class ServerRouter<
                     const controller = new definition.Controller(requestContext);
                     return controller[definition.method]();
                 },
-                options: { ...defaultOptions },
+                options: { ...defaultOptions, filepath: definition.filepath, sourceLocation: definition.sourceLocation },
             };
 
             this.controllers[route.path] = route;
@@ -363,6 +366,14 @@ export default class ServerRouter<
     public url = (path: string, params: {} = {}, absolute: boolean = true) =>
         buildUrl(path, params, this.config.currentDomain, absolute);
 
+    private buildRouteOptions(options: Partial<TRouteOptions> = {}): TRouteOptions {
+        return {
+            ...defaultOptions,
+            ...(this.config.defaultRouteOptions || {}),
+            ...options,
+        };
+    }
+
     /*----------------------------------
     - REGISTER
     ----------------------------------*/
@@ -378,12 +389,11 @@ export default class ServerRouter<
             regex,
             keys,
             controller: (context: TRouterContext<this>) => new Page(route, renderer, context, layout),
-            options: {
-                ...defaultOptions,
+            options: this.buildRouteOptions({
                 accept: 'html', // Les pages retournent forcémment du html
                 setup,
                 ...options,
-            },
+            }),
         };
 
         this.routes.push(route);
@@ -396,7 +406,7 @@ export default class ServerRouter<
         options: Partial<TRouteOptions>,
         renderer: TFrontRenderer<{}, { message: string }>,
     ) {
-        const finalOptions = { ...defaultOptions, ...options };
+        const finalOptions = this.buildRouteOptions(options);
 
         // Automatic layout form the nearest _layout folder
         const layout = getLayout('Error ' + code, finalOptions);
@@ -454,7 +464,7 @@ export default class ServerRouter<
             path: path,
             regex,
             keys: keys,
-            options: { ...defaultOptions, ...options },
+            options: this.buildRouteOptions(options),
             controller,
         };
 
@@ -711,6 +721,14 @@ export default class ServerRouter<
                     channelId: request.id,
                     method: request.method,
                     path: request.path,
+                    ...(request.traceCall
+                        ? {
+                              traceCallFetcherId: request.traceCall.fetcherId,
+                              traceCallId: request.traceCall.id,
+                              traceCallLabel: request.traceCall.label,
+                              traceCallOrigin: request.traceCall.origin,
+                          }
+                        : {}),
                 },
                 async () => {
                     const timeStart = Date.now();
@@ -745,6 +763,11 @@ export default class ServerRouter<
                                     path: request.path,
                                     accept: controllerRoute.options.accept || '',
                                     filepath: controllerRoute.options.filepath || '',
+                                    source: {
+                                        filepath: controllerRoute.options.filepath || '',
+                                        line: controllerRoute.options.sourceLocation?.line || 0,
+                                        column: controllerRoute.options.sourceLocation?.column || 0,
+                                    },
                                 },
                                 'summary',
                             );
@@ -777,6 +800,11 @@ export default class ServerRouter<
                                             routePath: route.path || '',
                                             routeId: route.options.id || '',
                                             filepath: route.options.filepath || '',
+                                            source: {
+                                                filepath: route.options.filepath || '',
+                                                line: route.options.sourceLocation?.line || 0,
+                                                column: route.options.sourceLocation?.column || 0,
+                                            },
                                         },
                                         'deep',
                                     );
@@ -797,6 +825,11 @@ export default class ServerRouter<
                                             routePath: route.path || '',
                                             routeId: route.options.id || '',
                                             filepath: route.options.filepath || '',
+                                            source: {
+                                                filepath: route.options.filepath || '',
+                                                line: route.options.sourceLocation?.line || 0,
+                                                column: route.options.sourceLocation?.column || 0,
+                                            },
                                         },
                                         'deep',
                                     );
@@ -816,6 +849,11 @@ export default class ServerRouter<
                                             routePath: route.path || '',
                                             routeId: route.options.id || '',
                                             filepath: route.options.filepath || '',
+                                            source: {
+                                                filepath: route.options.filepath || '',
+                                                line: route.options.sourceLocation?.line || 0,
+                                                column: route.options.sourceLocation?.column || 0,
+                                            },
                                         },
                                         'deep',
                                     );
@@ -867,6 +905,11 @@ export default class ServerRouter<
                 routePath: route.path || '',
                 routeId: route.options.id || '',
                 filepath: route.options.filepath || '',
+                source: {
+                    filepath: route.options.filepath || '',
+                    line: route.options.sourceLocation?.line || 0,
+                    column: route.options.sourceLocation?.column || 0,
+                },
                 accept: route.options.accept || '',
                 method: route.method,
             },
@@ -901,47 +944,7 @@ export default class ServerRouter<
     };
 
     private async resolveApiBatch(fetchers: TFetcherList, request: ServerRequest<this>) {
-        // TODO: use api.fetchSync instead
-
-        const responseData: TObjetDonnees = {};
-        for (const id in fetchers) {
-            const fetcher = fetchers[id];
-            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,
-            });
-
-            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 ?
-        }
+        const responseData = await request.api.fetchSync(fetchers, {});
 
         // Status
         request.res.status(200);