proteum 2.1.3-1 → 2.1.7

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;
 };
@@ -93,6 +95,9 @@ export type TApiResponseData = { data: any; triggers?: { [cle: string]: any } };
 
 export type HttpHeaders = { [cle: string]: string };
 
+const dynamicHtmlCacheControl = 'no-store, no-cache, must-revalidate, proxy-revalidate';
+const staticHtmlCacheControl = 'public, max-age=0, must-revalidate';
+
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
@@ -114,6 +119,7 @@ export type Config<
     disk?: string; // Disk driver ID
 
     currentDomain: string;
+    defaultRouteOptions?: Partial<TRouteOptions>;
 
     http: HttpServiceConfig;
 
@@ -353,7 +359,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 +369,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 +392,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 +409,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 +467,7 @@ export default class ServerRouter<
             path: path,
             regex,
             keys: keys,
-            options: { ...defaultOptions, ...options },
+            options: this.buildRouteOptions(options),
             controller,
         };
 
@@ -561,14 +574,10 @@ export default class ServerRouter<
     - RESOLUTION
     ----------------------------------*/
     public async middleware(req: express.Request, res: express.Response) {
-        // Don't cache HTML, because in case of update, assets file name will change (hash.ext)
-        // https://github.com/helmetjs/nocache/blob/main/index.ts
-        res.setHeader('Surrogate-Control', 'no-store');
-        res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
-
         // Create request
         let requestId = uuid();
         const cachedPage = req.headers['bypasscache'] ? undefined : this.cache[req.path];
+        this.applyHtmlCacheHeaders(res, Boolean(cachedPage));
         const headers: HttpHeaders = Object.fromEntries(
             Object.entries(req.headers).map(([key, value]) => [key, Array.isArray(value) ? value.join(', ') : value || '']),
         );
@@ -628,10 +637,39 @@ export default class ServerRouter<
             // Static pages
             if (cachedPage) {
                 console.log('[router] Get static page from cache', req.path);
+                res.status(response.statusCode);
+                res.header(response.headers);
+
+                if (response.headers['Location']) {
+                    res.send(response.data === undefined ? '' : response.data);
+                    this.app.container.Trace.record(
+                        request.id,
+                        'response.send',
+                        {
+                            cached: true,
+                            statusCode: response.statusCode,
+                            contentType: response.headers['Content-Type'] || '',
+                            headerKeys: Object.keys(response.headers),
+                            redirected: true,
+                        },
+                        'summary',
+                    );
+                    this.app.container.Trace.finishRequest(request.id, {
+                        statusCode: response.statusCode,
+                        user: request.user?.email,
+                    });
+                    return;
+                }
+
                 this.app.container.Trace.record(
                     request.id,
                     'response.send',
-                    { cached: true, statusCode: response.statusCode, contentType: 'text/html' },
+                    {
+                        cached: true,
+                        statusCode: response.statusCode,
+                        contentType: response.headers['Content-Type'] || 'text/html',
+                        headerKeys: Object.keys(response.headers),
+                    },
                     'summary',
                 );
                 res.send(cachedPage.rendered);
@@ -711,6 +749,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 +791,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 +828,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 +853,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 +877,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',
                                     );
@@ -832,6 +898,12 @@ export default class ServerRouter<
                         }
 
                         this.app.container.Trace.record(request.id, 'resolve.routes-evaluated', routeStats, 'resolve');
+
+                        if (isStatic) {
+                            resolve(response);
+                            return;
+                        }
+
                         this.app.container.Trace.record(request.id, 'resolve.not-found', { path: request.path }, 'summary');
                         reject(new NotFound());
                     } catch (error) {
@@ -867,6 +939,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,
             },
@@ -880,10 +957,19 @@ export default class ServerRouter<
         await response.runController(route);
         if (!response.wasProvided) return;
 
-        // Set in cache
-        if (response.request.path && route.options.static && route.options.static.urls.includes('*')) {
-            console.log('[router] Set in cache', response.request.path);
-            this.renderStatic(response.request.path, route.options.static, response.data);
+        if (response.request.path && route.options.static) {
+            const staticUrls = route.options.static.urls.includes('*') ? [response.request.path] : route.options.static.urls;
+
+            for (const staticUrl of staticUrls) {
+                if (!staticUrl) continue;
+
+                console.log('[router] Set in cache', staticUrl);
+                void this.renderStatic(
+                    staticUrl,
+                    route.options.static,
+                    staticUrl === response.request.path ? response.data : undefined,
+                );
+            }
         }
 
         const timeEndResolving = Date.now();
@@ -901,47 +987,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);
@@ -1005,4 +1051,17 @@ export default class ServerRouter<
 
         return response;
     }
+
+    private applyHtmlCacheHeaders(res: express.Response, isStaticHtml: boolean) {
+        if (isStaticHtml) {
+            res.removeHeader('Surrogate-Control');
+            res.setHeader('Cache-Control', staticHtmlCacheControl);
+            return;
+        }
+
+        // Don't cache dynamic HTML, because updated releases can change asset hashes.
+        // https://github.com/helmetjs/nocache/blob/main/index.ts
+        res.setHeader('Surrogate-Control', 'no-store');
+        res.setHeader('Cache-Control', dynamicHtmlCacheControl);
+    }
 }

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

@@ -4,6 +4,12 @@
 
 // Core
 
+import { fromJson as errorFromJson } from '@common/errors';
+import {
+    profilerOriginHeader,
+    profilerParentRequestIdHeader,
+    profilerSessionIdHeader,
+} from '@common/dev/profiler';
 import RequestService from './service';
 
 import ApiClientService, {
@@ -21,6 +27,128 @@ import ApiClientService, {
 - SERVICE
 ----------------------------------*/
 export default class ApiClientRequest extends RequestService implements ApiClientService {
+    private isApiFetcher(fetcher: TFetcher | Promise<unknown>): fetcher is TFetcher {
+        return typeof fetcher === 'object' && fetcher !== null && 'method' in fetcher && 'path' in fetcher;
+    }
+
+    private toTraceInspectable(data: unknown) {
+        if (data === null || data === undefined) return data;
+        if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') return data;
+        if (typeof data === 'bigint' || typeof data === 'symbol' || typeof data === 'function') return data;
+        if (typeof data === 'object') return data;
+
+        return undefined;
+    }
+
+    private getTraceCallOrigin() {
+        return this.request.path === '/api' ? 'api-batch-fetcher' as const : 'ssr-fetcher' as const;
+    }
+
+    private createTraceCall({
+        fetcherId,
+        method,
+        path,
+        data,
+        options,
+    }: {
+        fetcherId: string;
+        method: string;
+        path: string;
+        data: unknown;
+        options?: TFetcher['options'];
+    }) {
+        return this.request.router.app.container.Trace.startCall(this.request.id, {
+            origin: this.getTraceCallOrigin(),
+            label: fetcherId,
+            method,
+            path,
+            fetcherId,
+            ...(options?.connected
+                ? {
+                      connectedControllerAccessor: options.connected.controllerAccessor,
+                      connectedProjectNamespace: options.connected.namespace,
+                  }
+                : {}),
+            requestDataKeys: data && typeof data === 'object' ? Object.keys(data as Record<string, unknown>) : [],
+            requestData: this.toTraceInspectable(data),
+        });
+    }
+
+    private buildConnectedRequestHeaders(fetcher: TFetcher) {
+        const headers = new Headers();
+
+        for (const [key, value] of Object.entries(this.request.headers)) {
+            if (!value) continue;
+            if (key === 'content-length' || key === 'host') continue;
+            headers.set(key, value);
+        }
+
+        headers.set('accept', 'application/json');
+
+        if (fetcher.options?.connected) {
+            headers.set(profilerOriginHeader, this.getTraceCallOrigin());
+
+            const profilerSessionId = this.request.headers[profilerSessionIdHeader];
+            if (profilerSessionId) headers.set(profilerSessionIdHeader, profilerSessionId);
+            headers.set(profilerParentRequestIdHeader, this.request.id);
+        }
+
+        return headers;
+    }
+
+    private async resolveConnectedFetcher<TData>(fetcher: TFetcher<TData>) {
+        const connected = fetcher.options?.connected;
+        if (!connected) throw new Error('Connected fetcher metadata is missing.');
+
+        const connectedProject = this.request.router.app.connectedProjects?.[connected.namespace];
+        if (!connectedProject) {
+            throw new Error(`Connected project "${connected.namespace}" is not registered on ${this.request.router.app.identity.identifier}.`);
+        }
+
+        const headers = this.buildConnectedRequestHeaders(fetcher);
+        const url = new URL(fetcher.path, connectedProject.urlInternal).toString();
+        const init: RequestInit = {
+            method: fetcher.method,
+            headers,
+        };
+
+        if (fetcher.data) {
+            if (fetcher.method === 'GET') {
+                const params = new URLSearchParams();
+                for (const [key, value] of Object.entries(fetcher.data)) {
+                    if (value === undefined || value === null) continue;
+                    params.set(key, String(value));
+                }
+
+                return this.fetchConnectedResponse<TData>(`${url}?${params.toString()}`, init);
+            }
+
+            headers.set('content-type', 'application/json');
+            init.body = JSON.stringify(fetcher.data);
+        }
+
+        return this.fetchConnectedResponse<TData>(url, init);
+    }
+
+    private async fetchConnectedResponse<TData>(url: string, init: RequestInit) {
+        const response = await fetch(url, init);
+
+        if (!response.ok) {
+            const contentType = response.headers.get('content-type') || '';
+            const errorPayload = contentType.includes('application/json') ? await response.json() : await response.text();
+            const typedError =
+                typeof errorPayload === 'object' && errorPayload && 'code' in (errorPayload as object)
+                    ? (errorFromJson(errorPayload as any) as Error & { http?: number })
+                    : (new Error(typeof errorPayload === 'string' ? errorPayload : `Connected request failed with ${response.status}.`) as Error & {
+                          http?: number;
+                      });
+            typedError.http = response.status;
+            throw typedError;
+        }
+
+        return (await response.json()) as TData;
+    }
+
     /*----------------------------------
     - HIGH LEVEL
     ----------------------------------*/
@@ -67,39 +195,52 @@ export default class ApiClientRequest extends RequestService implements ApiClien
             if (!fetcher) continue;
 
             // Promise Fetcher (direct call from service method)
-            if ('then' in fetcher) {
+            if (!this.isApiFetcher(fetcher)) {
                 fetchedData[id] = await fetcher;
                 continue;
             }
 
-            const { method, path, data } = fetcher;
+            const { method, path, data, options } = fetcher;
             //this.router.config.debug && console.log(`[api] Resolving from internal api`, method, path, data);
 
             // We don't fetch the already given data
             if (id in fetchedData) continue;
 
-            // Create a children request to resolve the api data
-            const request = this.request.children(method, path, 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,
-            });
+            const callId = this.createTraceCall({ data, fetcherId: id, method, options, path });
 
             try {
-                const response = await request.router.resolve(request);
-                fetchedData[id] = response.data;
+                if (options?.connected) {
+                    fetchedData[id] = await this.resolveConnectedFetcher(fetcher);
+                } else {
+                    const request = this.request.children(method, path, data);
+                    if (callId)
+                        request.traceCall = {
+                            fetcherId: id,
+                            id: callId,
+                            label: id,
+                            origin: this.getTraceCallOrigin(),
+                        };
+
+                    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 as object | string | number | boolean | bigint | symbol | null | undefined,
+                    });
+                    continue;
+                }
+
                 this.request.router.app.container.Trace.finishCall(this.request.id, callId, {
-                    statusCode: response.statusCode,
+                    statusCode: 200,
                     resultKeys:
-                        response.data && typeof response.data === 'object' && !Array.isArray(response.data)
-                            ? Object.keys(response.data as Record<string, unknown>)
+                        fetchedData[id] && typeof fetchedData[id] === 'object' && !Array.isArray(fetchedData[id])
+                            ? Object.keys(fetchedData[id] as Record<string, unknown>)
                             : [],
-                    result: response.data,
+                    result: fetchedData[id] as object | string | number | boolean | bigint | symbol | null | undefined,
                 });
             } catch (error) {
                 const typedError = error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown error');

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

@@ -10,6 +10,7 @@ import Bowser from 'bowser';
 
 // Core
 import BaseRequest from '@common/router/request';
+import type { TTraceCallOrigin } from '@common/dev/requestTrace';
 
 // Specific
 import type { HttpMethod, HttpHeaders } from '..';
@@ -35,6 +36,12 @@ const localeFilter = (input: any) => {
 };
 
 export type UploadedFile = File;
+type TRequestTraceCallContext = {
+    fetcherId?: string;
+    id: string;
+    label: string;
+    origin: TTraceCallOrigin;
+};
 
 /*----------------------------------
 - CONTEXTE
@@ -66,6 +73,7 @@ export default class ServerRequest<TRouter extends TAnyRouter = TAnyRouter> exte
 
     // Services
     public api: ApiClient;
+    public traceCall?: TRequestTraceCallContext;
 
     /*----------------------------------
     - INITIALISATION

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

@@ -141,6 +141,11 @@ export default class ServerResponse<
                 target: getRouteTraceTarget(route as TAnyRoute<TRouterContext<TServerRouter>>),
                 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 || '',
             },
             'summary',
@@ -220,7 +225,14 @@ export default class ServerResponse<
         this.app.container.Trace.record(
             this.request.id,
             'setup.options',
-            { optionKeys: Object.keys(options) },
+            {
+                optionKeys: Object.keys(options),
+                source: {
+                    filepath: route.options.filepath || '',
+                    line: route.options.sourceLocation?.line || 0,
+                    column: route.options.sourceLocation?.column || 0,
+                },
+            },
             'resolve',
         );
 
@@ -260,6 +272,11 @@ export default class ServerResponse<
             {
                 target: getRouteTraceTarget(route as TAnyRoute<TRouterContext<TServerRouter>>),
                 routeId: route.options.id || '',
+                source: {
+                    filepath: route.options.filepath || '',
+                    line: route.options.sourceLocation?.line || 0,
+                    column: route.options.sourceLocation?.column || 0,
+                },
                 routerServiceKeys: Object.keys(contextServices),
                 controllerKeys: Object.keys(controllers),
                 customContextKeys: Object.keys(customSsrData as object),
@@ -318,6 +335,11 @@ export default class ServerResponse<
                 chunkId: page.chunkId || '',
                 dataKeys: Object.keys(page.data || {}),
                 data: page.data || {},
+                source: {
+                    filepath: page.route.options.filepath || '',
+                    line: page.route.options.sourceLocation?.line || 0,
+                    column: page.route.options.sourceLocation?.column || 0,
+                },
             },
             'resolve',
         );