proteum 2.1.9 → 2.2.0

package/server/app/container/trace/index.ts

@@ -1,7 +1,10 @@
 import fs from 'fs-extra';
 import path from 'path';
+import { createHash } from 'crypto';
 
 import type ApplicationContainer from '..';
+import context from '@server/context';
+import type { ChannelInfos } from '../console';
 import {
     traceCaptureModes,
     type TTraceCaptureMode,
@@ -17,6 +20,7 @@ import {
     type TTraceMemorySnapshot,
     type TRequestTraceListItem,
 } from '@common/dev/requestTrace';
+import type { TProteumManifest } from '@common/dev/proteumManifest';
 
 export type Config = {
     enable: boolean;
@@ -33,6 +37,10 @@ const capturePriority: Record<TTraceCaptureMode, number> = { summary: 0, resolve
 const sensitiveKeyPattern =
     /(^|\.)(authorization|cookie|set-cookie|password|pass|pwd|secret|token|refreshToken|accessToken|apiKey|apiSecret|secretAccessKey|accessKeyId|privateKey|session|jwt|rawBody)$/i;
 const maxStringLength = 240;
+const normalizeFilepath = (value: string) => value.replace(/\\/g, '/');
+const sqlCommentPattern = /\/\*[\s\S]*?\*\//g;
+const sqlLineCommentPattern = /--.*$/gm;
+const stackFilepathPatterns = [/\((\/.+?):\d+:\d+\)$/, /at (\/.+?):\d+:\d+$/];
 
 const isTraceCaptureMode = (value: string): value is TTraceCaptureMode =>
     traceCaptureModes.includes(value as TTraceCaptureMode);
@@ -176,6 +184,11 @@ export default class Trace {
     private requests = new Map<string, TRequestTrace>();
     private order: string[] = [];
     private armedCapture?: TTraceCaptureMode;
+    private manifestCache?: {
+        manifest: TProteumManifest;
+        mtimeMs: number;
+        serviceByFilepath: Map<string, string>;
+    };
     private activeMeasurements = new Map<
         string,
         {
@@ -193,6 +206,86 @@ export default class Trace {
         return __DEV__ && this.config.enable && this.container.Environment.profile === 'dev';
     }
 
+    private getContextChannel() {
+        return context.getStore() as ChannelInfos | undefined;
+    }
+
+    private readManifestCache() {
+        const manifestFilepath = path.join(this.container.path.root, '.proteum', 'manifest.json');
+        if (!fs.existsSync(manifestFilepath)) return undefined;
+
+        const stats = fs.statSync(manifestFilepath);
+        if (this.manifestCache && this.manifestCache.mtimeMs === stats.mtimeMs) return this.manifestCache;
+
+        const manifest = fs.readJSONSync(manifestFilepath) as TProteumManifest;
+        const serviceByFilepath = new Map<string, string>();
+        for (const service of [...manifest.services.app, ...manifest.services.routerPlugins]) {
+            if (!service.sourceFilepath) continue;
+            serviceByFilepath.set(normalizeFilepath(path.resolve(service.sourceFilepath)), service.registeredName);
+        }
+
+        this.manifestCache = {
+            manifest,
+            mtimeMs: stats.mtimeMs,
+            serviceByFilepath,
+        };
+
+        return this.manifestCache;
+    }
+
+    private getStackFilepaths(stack?: string) {
+        if (!stack) return [];
+
+        const filepaths: string[] = [];
+        for (const line of stack.split('\n')) {
+            const trimmedLine = line.trim();
+            let matchedFilepath: string | undefined;
+
+            for (const pattern of stackFilepathPatterns) {
+                const match = trimmedLine.match(pattern);
+                if (match?.[1]) {
+                    matchedFilepath = match[1];
+                    break;
+                }
+            }
+
+            if (!matchedFilepath) continue;
+            if (matchedFilepath.includes('/node_modules/')) continue;
+
+            filepaths.push(normalizeFilepath(path.resolve(matchedFilepath)));
+        }
+
+        return filepaths;
+    }
+
+    private inferServiceLabelFromStack(stack?: string) {
+        const manifestCache = this.readManifestCache();
+        if (!manifestCache) return undefined;
+
+        for (const filepath of this.getStackFilepaths(stack)) {
+            const serviceLabel = manifestCache.serviceByFilepath.get(filepath);
+            if (serviceLabel) return serviceLabel;
+        }
+
+        return undefined;
+    }
+
+    private createSqlFingerprint(query: string) {
+        const normalized = query
+            .replace(sqlCommentPattern, ' ')
+            .replace(sqlLineCommentPattern, ' ')
+            .replace(/'([^']|'')*'/g, '?')
+            .replace(/"([^"]|"")*"/g, '?')
+            .replace(/\b\d+(?:\.\d+)?\b/g, '?')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .toUpperCase();
+
+        if (!normalized) return undefined;
+
+        return createHash('sha1').update(normalized).digest('hex').slice(0, 12);
+    }
+
     public armNextRequest(capture: string) {
         if (!isTraceCaptureMode(capture)) {
             throw new Error(`Unsupported trace capture mode "${capture}". Expected one of: ${traceCaptureModes.join(', ')}.`);
@@ -330,6 +423,11 @@ export default class Trace {
             fetcherId?: string;
             connectedProjectNamespace?: string;
             connectedControllerAccessor?: string;
+            ownerLabel?: string;
+            ownerFilepath?: string;
+            serviceLabel?: string;
+            cacheKey?: string;
+            cachePhase?: string;
             parentId?: string;
             requestDataKeys?: string[];
             requestData?: TTraceInspectable;
@@ -337,6 +435,8 @@ export default class Trace {
     ) {
         const trace = this.requests.get(requestId);
         if (!trace) return undefined;
+        const channel = this.getContextChannel();
+        const inferredServiceLabel = input.serviceLabel || channel?.serviceLabel || this.inferServiceLabelFromStack(new Error().stack);
 
         const call: TTraceCall = {
             id: `${requestId}:call:${trace.calls.length}`,
@@ -348,6 +448,11 @@ export default class Trace {
             fetcherId: input.fetcherId,
             connectedProjectNamespace: input.connectedProjectNamespace,
             connectedControllerAccessor: input.connectedControllerAccessor,
+            ownerLabel: input.ownerLabel || channel?.ownerLabel,
+            ownerFilepath: input.ownerFilepath || channel?.ownerFilepath,
+            serviceLabel: inferredServiceLabel,
+            cacheKey: input.cacheKey || channel?.cacheKey,
+            cachePhase: input.cachePhase || channel?.cachePhase,
             startedAt: nowIso(),
             requestDataKeys: input.requestDataKeys || [],
             requestData: input.requestData !== undefined ? summarizeCaptureValue(input.requestData, trace.capture, 'requestData') : undefined,
@@ -405,6 +510,10 @@ export default class Trace {
             kind: TTraceSqlQueryKind;
             model?: string;
             operation: string;
+            ownerLabel?: string;
+            ownerFilepath?: string;
+            serviceLabel?: string;
+            connectedNamespace?: string;
             paramsJson?: unknown;
             paramsText?: string;
             query: string;
@@ -413,12 +522,15 @@ export default class Trace {
     ) {
         const trace = this.requests.get(requestId);
         if (!trace) return;
+        const channel = this.getContextChannel();
 
         const durationMs = Math.max(0, input.durationMs || 0);
         const finishedAt = input.finishedAt || nowIso();
         const finishedAtMs = Date.parse(finishedAt);
         const startedAt =
             Number.isFinite(finishedAtMs) && durationMs > 0 ? new Date(finishedAtMs - durationMs).toISOString() : finishedAt;
+        const fingerprint = this.createSqlFingerprint(input.query);
+        const inferredServiceLabel = input.serviceLabel || channel?.serviceLabel || this.inferServiceLabelFromStack(new Error().stack);
 
         const sqlQuery: TTraceSqlQuery = {
             id: `${requestId}:sql:${trace.sqlQueries.length}`,
@@ -433,6 +545,11 @@ export default class Trace {
             kind: input.kind,
             model: input.model,
             operation: input.operation,
+            fingerprint,
+            ownerLabel: input.ownerLabel || channel?.ownerLabel,
+            ownerFilepath: input.ownerFilepath || channel?.ownerFilepath,
+            serviceLabel: inferredServiceLabel,
+            connectedNamespace: input.connectedNamespace || channel?.connectedNamespace,
             paramsJson: input.paramsJson,
             paramsText: input.paramsText,
             query: input.query.trim(),

package/server/app/devDiagnostics.ts

@@ -186,6 +186,6 @@ export default class DevDiagnosticsRegistry<TApplication extends Application = A
     }
 
     public perfRequest(requestIdOrPath: string): TPerfRequestResponse {
-        return { request: resolvePerfRequest(this.readPerfRequests(), requestIdOrPath) };
+        return { request: resolvePerfRequest(this.readPerfRequests(), requestIdOrPath, this.readManifest()) };
     }
 }

package/server/app/index.ts

@@ -202,7 +202,11 @@ export abstract class Application<
         const connectedProject = this.getConnectedProject(namespace);
         if (connectedProject) return connectedProject;
 
-        throw new Error(`Connected project "${namespace}" is not configured on ${this.identity.identifier}.`);
+        throw new Error(
+            `Proteum connected boundary mismatch: "${namespace}" is not configured on ${this.identity.identifier}. ` +
+                `Likely fix: add connect.${namespace} in proteum.config.ts for this app or stop calling that connected namespace from this side. ` +
+                `Re-check both SSR and client navigation if the namespace is used from page render or setup code.`,
+        );
     }
 
     public register(service: AnyService) {

package/server/services/auth/index.ts

@@ -853,6 +853,9 @@ export default abstract class AuthService<
         return user as TUser;
     }
 
+    /**
+     * @deprecated Use `check(request, null, tracking)` to make the authenticated-user requirement explicit.
+     */
     public check(request: TRequest): TUser;
 
     public check(request: TRequest, conditions: null, tracking?: TAuthTrackingContext): TUser;
@@ -861,8 +864,14 @@ export default abstract class AuthService<
 
     public check(request: TRequest, conditions: false, tracking?: TAuthTrackingContext): null;
 
+    /**
+     * @deprecated Use `check(request, { role }, tracking)` or another explicit conditions object instead.
+     */
     public check(request: TRequest, role?: TUserRole | boolean): TUser | null;
 
+    /**
+     * @deprecated Use `check(request, { role, ...rules }, tracking)` with app-defined auth rules instead of legacy feature/action arguments.
+     */
     public check(request: TRequest, role: TUserRole | boolean, feature: FeatureKeys, action?: string): TUser | null;
 
     public check(

package/server/services/router/index.ts

@@ -37,6 +37,7 @@ import type { TSsrUnresolvedRoute, TRegisterPageArgs } from '@common/router/cont
 import { buildRegex, getRegisterPageArgs } from '@common/router/register';
 import { layoutsList, getLayout } from '@common/router/layouts';
 import {
+    profilerConnectedNamespaceHeader,
     profilerOriginHeader,
     profilerParentRequestIdHeader,
     profilerSessionIdHeader,
@@ -221,6 +222,7 @@ export default class ServerRouter<
             const methodName = match ? match[2] : '<anonymous>';*/
 
             const contextData = context.getStore() || { channelType: 'master' };
+            if (contextData.silentLogs) return;
 
             const requestPrefix =
                 contextData.channelType === 'request'
@@ -272,21 +274,18 @@ export default class ServerRouter<
 
     public async renderStatic(url: string, options: TRouteOptions['static'], rendered?: any) {
         // Wildcard: tell that the newly rendered pages should be cached
-        if (url === '*' || !url) return;
-
-        if (!rendered) {
-            console.log('[router] renderStatic: url', url);
+        if (url === '*' || !url) throw new Error(`Unable to cache a dynamic or empty URL.`);
 
+        if (rendered === undefined) {
             const fullUrl = this.url(url, {}, true);
             const response = await got(fullUrl, {
                 method: 'GET',
-                headers: { Accept: 'text/html', bypasscache: '1' },
+                headers: { Accept: 'text/html', bypasscache: '1', 'x-proteum-static-warmup': '1' },
                 throwHttpErrors: false,
             });
 
             if (response.statusCode !== 200) {
-                console.error('[router] renderStatic: page returned code', response.statusCode, fullUrl);
-                return;
+                throw new Error(`Static render returned ${response.statusCode} for ${fullUrl}`);
             }
 
             rendered = response.body;
@@ -301,17 +300,50 @@ export default class ServerRouter<
 
     private initStaticRoutes() {
         this.clearStaticRoutesRefreshInterval();
+        const staticEntries: Array<{ routePath: string; url: string; options: TRouteOptions['static'] }> = [];
+        const seenStaticUrls = new Set<string>();
 
         for (const route of this.routes) {
+            if (route.method !== 'GET' || route.options.accept !== 'html') continue;
+
             if (!route.options.static) continue;
 
             // Add to static pages
             // Should be a GET oage that don't take any parameter
             for (const url of route.options.static.urls) {
-                this.renderStatic(url, route.options.static);
+                if (!url || url === '*' || seenStaticUrls.has(url)) continue;
+
+                staticEntries.push({
+                    routePath: route.path || '(unknown route)',
+                    url,
+                    options: route.options.static,
+                });
+                seenStaticUrls.add(url);
             }
         }
 
+        void (async () => {
+            const warmedUrls: string[] = [];
+            let failedCount = 0;
+
+            for (const entry of staticEntries) {
+                try {
+                    await this.renderStatic(entry.url, entry.options);
+                    warmedUrls.push(entry.url);
+                } catch (error) {
+                    failedCount += 1;
+                    console.error('[router] Static warmup failed', entry.url, `route=${entry.routePath}`, error);
+                }
+            }
+
+            console.log(
+                '[router] Static warmup finished',
+                `warmed=${warmedUrls.length}`,
+                `failed=${failedCount}`,
+                `urls=${warmedUrls.length > 0 ? warmedUrls.join(', ') : 'none'}`,
+            );
+        })();
+
         // Every hours, refresh static pages
         this.staticRoutesRefreshInterval = setInterval(
             () => {
@@ -327,7 +359,9 @@ export default class ServerRouter<
         for (const pageUrl in this.cache) {
             const page = this.cache[pageUrl];
             if (page.expire && page.expire < Date.now()) {
-                this.renderStatic(pageUrl, page.options);
+                void this.renderStatic(pageUrl, page.options).catch((error) => {
+                    console.error('[router] Static refresh failed', pageUrl, error);
+                });
             }
         }
     }
@@ -382,7 +416,7 @@ export default class ServerRouter<
     ----------------------------------*/
 
     public page(...args: TRegisterPageArgs<any, TRouteOptions>) {
-        const { path, options, setup, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, data, renderer, layout } = getRegisterPageArgs(...args);
 
         const { regex, keys } = buildRegex(path);
 
@@ -391,10 +425,10 @@ export default class ServerRouter<
             path,
             regex,
             keys,
+            data,
             controller: (context: TRouterContext<this>) => new Page(route, renderer, context, layout),
             options: this.buildRouteOptions({
                 accept: 'html', // Les pages retournent forcémment du html
-                setup,
                 ...options,
             }),
         };
@@ -607,6 +641,14 @@ export default class ServerRouter<
             profilerParentRequestId: request.headers[profilerParentRequestIdHeader] || undefined,
         });
         if (this.app.container.Trace.isEnabled()) res.setHeader(profilerTraceRequestIdHeader, request.id);
+        if (cachedPage) {
+            this.app.container.Trace.record(
+                request.id,
+                'cache.hit',
+                { cacheKey: req.path, cachePhase: 'hit' },
+                'summary',
+            );
+        }
 
         let response: ServerResponse<this>;
         try {
@@ -747,8 +789,10 @@ export default class ServerRouter<
                     // This is for debugging
                     channelType: 'request',
                     channelId: request.id,
+                    silentLogs: request.headers['x-proteum-static-warmup'] === '1',
                     method: request.method,
                     path: request.path,
+                    connectedNamespace: request.headers[profilerConnectedNamespaceHeader] || undefined,
                     ...(request.traceCall
                         ? {
                               traceCallFetcherId: request.traceCall.fetcherId,
@@ -930,8 +974,6 @@ 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',
@@ -964,11 +1006,19 @@ export default class ServerRouter<
                 if (!staticUrl) continue;
 
                 console.log('[router] Set in cache', staticUrl);
+                this.app.container.Trace.record(
+                    response.request.id,
+                    'cache.write',
+                    { cacheKey: staticUrl, cachePhase: 'write' },
+                    'summary',
+                );
                 void this.renderStatic(
                     staticUrl,
                     route.options.static,
                     staticUrl === response.request.path ? response.data : undefined,
-                );
+                ).catch((error) => {
+                    console.error('[router] Static cache write failed', staticUrl, error);
+                });
             }
         }
 

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

@@ -6,6 +6,7 @@
 
 import { fromJson as errorFromJson } from '@common/errors';
 import {
+    profilerConnectedNamespaceHeader,
     profilerOriginHeader,
     profilerParentRequestIdHeader,
     profilerSessionIdHeader,
@@ -87,6 +88,7 @@ export default class ApiClientRequest extends RequestService implements ApiClien
 
         if (fetcher.options?.connected) {
             headers.set(profilerOriginHeader, this.getTraceCallOrigin());
+            headers.set(profilerConnectedNamespaceHeader, fetcher.options.connected.namespace);
 
             const profilerSessionId = this.request.headers[profilerSessionIdHeader];
             if (profilerSessionId) headers.set(profilerSessionIdHeader, profilerSessionId);
@@ -102,7 +104,11 @@ export default class ApiClientRequest extends RequestService implements ApiClien
 
         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}.`);
+            throw new Error(
+                `Proteum connected boundary mismatch: "${connected.namespace}" is not registered on ${this.request.router.app.identity.identifier}. ` +
+                    `Likely fix: declare connect.${connected.namespace} in proteum.config.ts for the consumer app or stop using that connected controller accessor here. ` +
+                    `Re-check both SSR and client navigation if this fetcher is used from a page data or render path.`,
+            );
         }
 
         const headers = this.buildConnectedRequestHeaders(fetcher);

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

@@ -17,7 +17,6 @@ import ServerRequest from '@server/services/router/request';
 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';
 import Page from './page';
 import createControllers from '@generated/common/controllers';
 import type { TControllers } from '@generated/common/controllers';
@@ -154,11 +153,18 @@ export default class ServerResponse<
         // Create response context for controllers
         const requestContext = await this.createContext(route);
         const contextStore = context.getStore() as
-            | { requestContext?: TRouterContext<TAnyRouter>; inputSchemaUsed?: boolean }
+            | {
+                  requestContext?: TRouterContext<TAnyRouter>;
+                  inputSchemaUsed?: boolean;
+                  ownerLabel?: string;
+                  ownerFilepath?: string;
+              }
             | undefined;
         if (contextStore) {
             contextStore.requestContext = requestContext;
             contextStore.inputSchemaUsed = false;
+            contextStore.ownerLabel = getRouteTraceTarget(route as TAnyRoute<TRouterContext<TServerRouter>>);
+            contextStore.ownerFilepath = route.options.filepath || undefined;
         }
 
         // Run controller
@@ -213,32 +219,6 @@ export default class ServerResponse<
     - INTERNAL
     ----------------------------------*/
 
-    public async resolveRouteOptions(
-        route: TMatchedRoute<TRouterContext<TRouter>>,
-    ): Promise<TMatchedRoute<TRouterContext<TRouter>>> {
-        const setup = route.options.setup;
-        if (!setup) return route;
-
-        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),
-                source: {
-                    filepath: route.options.filepath || '',
-                    line: route.options.sourceLocation?.line || 0,
-                    column: route.options.sourceLocation?.column || 0,
-                },
-            },
-            '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);

package/types/global/vendors.d.ts

@@ -3,6 +3,18 @@ declare module 'accepts' {
     export default accepts;
 }
 
+declare module '@babel/generator' {
+    const generate: any;
+    export default generate;
+}
+
+declare module '@babel/traverse' {
+    export type Binding = any;
+    export type NodePath<T = any> = any;
+    const traverse: any;
+    export default traverse;
+}
+
 declare module 'bytes' {
     const bytes: (value: string | number) => number;
     export default bytes;

package/types/vendors.d.ts

@@ -3,6 +3,18 @@ declare module 'accepts' {
     export default accepts;
 }
 
+declare module '@babel/generator' {
+    const generate: any;
+    export default generate;
+}
+
+declare module '@babel/traverse' {
+    export type Binding = any;
+    export type NodePath<T = any> = any;
+    const traverse: any;
+    export default traverse;
+}
+
 declare module 'bytes' {
     const bytes: (value: string | number) => number;
     export default bytes;

package/common/router/pageSetup.ts

@@ -1,51 +0,0 @@
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-import type { TRouteOptions } from '.';
-
-export const routeSetupOptionKeys = [
-    'priority',
-    'preload',
-    'domain',
-    'accept',
-    'raw',
-    'auth',
-    'authTracking',
-    'redirectLogged',
-    'static',
-    'whenStatic',
-    'canonicalParams',
-    'layout',
-    'TESTING',
-    'logging',
-] as const satisfies (keyof TRouteOptions)[];
-
-export const reservedRouteSetupKeys = ['id', 'filepath', 'bodyId', 'data', 'setup'] as const;
-
-const routeSetupOptionKeysSet = new Set<string>(routeSetupOptionKeys);
-const reservedRouteSetupKeysSet = new Set<string>(reservedRouteSetupKeys);
-
-export const getRouteSetupOptionKey = (key: string) => {
-    const normalizedKey = key.startsWith('_') ? key.substring(1) : key;
-
-    if (reservedRouteSetupKeysSet.has(normalizedKey)) throw new Error(`"${key}" is a reserved Router.page setup key.`);
-
-    return routeSetupOptionKeysSet.has(normalizedKey) ? (normalizedKey as keyof TRouteOptions) : null;
-};
-
-export const splitRouteSetupResult = (result: TObjetDonnees | undefined) => {
-    const options: Partial<TRouteOptions> = {};
-    const data: TObjetDonnees = {};
-
-    if (!result) return { options, data };
-
-    for (const key in result) {
-        const optionKey = getRouteSetupOptionKey(key);
-
-        if (optionKey) options[optionKey] = result[key];
-        else data[key] = result[key];
-    }
-
-    return { options, data };
-};