proteum 2.1.9 → 2.2.1

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/prisma/index.ts

@@ -46,6 +46,12 @@ type TPrismaExtensionOperation = {
     query: (args: unknown) => Promise<unknown>;
 };
 
+declare global {
+    interface BigInt {
+        toJSON: () => number | string;
+    }
+}
+
 /*----------------------------------
 - HELPERS
 ----------------------------------*/
@@ -173,21 +179,18 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
                 'DATABASE_URL is required before starting the Models service. Prisma 7 no longer auto-loads runtime env files.',
             );
 
-        const shouldTraceQueries = this.app.container.Trace.isEnabled();
-        const prismaClient = shouldTraceQueries
-            ? new PrismaClient({
-                  adapter: createMariaDbAdapter(databaseUrl),
-                  log: [{ emit: 'event', level: 'query' }],
-              })
-            : new PrismaClient({
-                  adapter: createMariaDbAdapter(databaseUrl),
-              });
-
-        if (!shouldTraceQueries) {
-            this.client = prismaClient;
+        if (!this.app.container.Trace.shouldInstrumentRequests()) {
+            this.client = new PrismaClient({
+                adapter: createMariaDbAdapter(databaseUrl),
+            });
             return;
         }
 
+        const prismaClient = new PrismaClient({
+            adapter: createMariaDbAdapter(databaseUrl),
+            log: [{ emit: 'event', level: 'query' }],
+        });
+
         prismaClient.$on('query', (event: TPrismaQueryEvent) => this.traceQuery(event));
 
         this.client = prismaClient.$extends(

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

@@ -510,7 +510,7 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
     private registerDevTraceRoutes(routes: express.Express) {
         if (!__DEV__ || this.app.env.profile !== 'dev') return;
 
-        if (this.app.container.Trace.isEnabled()) {
+        if (this.app.container.Trace.isDevTraceEnabled()) {
             routes.get('/__proteum/trace/requests', (req, res) => {
                 const rawLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
                 const parsedLimit = typeof rawLimit === 'string' ? Number.parseInt(rawLimit, 10) : NaN;

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,
@@ -131,7 +132,13 @@ export type Config<
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
 type TRouterServicesList = { [serviceName: string]: AnyRouterService };
 
-export type Hooks = {};
+export type Hooks = {
+    request: { args: [request: ServerRequest<TServerRouter>] };
+    'request.finished': { args: [request: ServerRequest<TServerRouter>] };
+    resolve: { args: [request: ServerRequest<TServerRouter>] };
+    resolved: { args: [route: TMatchedRoute, request: ServerRequest<TServerRouter>, response: ServerResponse<TServerRouter>] };
+    render: { args: [page: Page<TServerRouter>] };
+};
 
 export type TControllerDefinition = {
     path?: string;
@@ -221,6 +228,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 +280,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 +306,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 +365,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 +422,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 +431,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,
             }),
         };
@@ -573,6 +613,32 @@ export default class ServerRouter<
     /*----------------------------------
     - RESOLUTION
     ----------------------------------*/
+    private async finalizeRequest(
+        request: ServerRequest<this>,
+        output: {
+            statusCode: number;
+            user?: string;
+            errorMessage?: string;
+        },
+    ) {
+        this.app.container.Trace.finishRequest(request.id, output);
+
+        try {
+            await this.runHook('request.finished', request);
+        } catch (error) {
+            const typedError =
+                error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown request.finished hook error');
+
+            try {
+                await this.app.runHook('error', typedError, request);
+            } catch (hookError) {
+                console.error('request.finished hook error', typedError, 'Error hook failure', hookError);
+            }
+        } finally {
+            this.app.container.Trace.releaseRequest(request.id);
+        }
+    }
+
     public async middleware(req: express.Request, res: express.Response) {
         // Create request
         let requestId = uuid();
@@ -595,7 +661,7 @@ export default class ServerRouter<
             this,
         );
 
-        this.app.container.Trace.startRequest({
+        request.profiling = this.app.container.Trace.startRequest({
             id: request.id,
             method: request.method,
             path: request.path,
@@ -606,7 +672,15 @@ export default class ServerRouter<
             profilerOrigin: request.headers[profilerOriginHeader] || undefined,
             profilerParentRequestId: request.headers[profilerParentRequestIdHeader] || undefined,
         });
-        if (this.app.container.Trace.isEnabled()) res.setHeader(profilerTraceRequestIdHeader, request.id);
+        if (this.app.container.Trace.isDevTraceEnabled()) 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 {
@@ -617,7 +691,7 @@ export default class ServerRouter<
             // Bulk API Requests
             if (request.path === '/api' && typeof request.data.fetchers === 'object') {
                 await this.resolveApiBatch(request.data.fetchers, request);
-                this.app.container.Trace.finishRequest(request.id, {
+                await this.finalizeRequest(request, {
                     statusCode: request.res.statusCode || 200,
                     user: request.user?.email,
                 });
@@ -654,7 +728,7 @@ export default class ServerRouter<
                         },
                         'summary',
                     );
-                    this.app.container.Trace.finishRequest(request.id, {
+                    await this.finalizeRequest(request, {
                         statusCode: response.statusCode,
                         user: request.user?.email,
                     });
@@ -673,7 +747,7 @@ export default class ServerRouter<
                     'summary',
                 );
                 res.send(cachedPage.rendered);
-                this.app.container.Trace.finishRequest(request.id, {
+                await this.finalizeRequest(request, {
                     statusCode: response.statusCode,
                     user: request.user?.email,
                 });
@@ -697,19 +771,19 @@ export default class ServerRouter<
                 'summary',
             );
             res.send(response.data);
-            this.app.container.Trace.finishRequest(request.id, {
+            await this.finalizeRequest(request, {
                 statusCode: response.statusCode,
                 user: request.user?.email,
             });
         } else if (response.data !== 'true') {
-            this.app.container.Trace.finishRequest(request.id, {
+            await this.finalizeRequest(request, {
                 statusCode: res.statusCode || response.statusCode,
                 user: request.user?.email,
                 errorMessage: "Can't return data from the controller since response has already been sent via express.",
             });
             throw new Error("Can't return data from the controller since response has already been sent via express.");
         } else {
-            this.app.container.Trace.finishRequest(request.id, {
+            await this.finalizeRequest(request, {
                 statusCode: res.statusCode || response.statusCode,
                 user: request.user?.email,
             });
@@ -747,8 +821,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 +1006,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 +1038,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/request/index.ts

@@ -10,7 +10,7 @@ import Bowser from 'bowser';
 
 // Core
 import BaseRequest from '@common/router/request';
-import type { TTraceCallOrigin } from '@common/dev/requestTrace';
+import type { TRequestProfiling, TTraceCallOrigin } from '@common/dev/requestTrace';
 
 // Specific
 import type { HttpMethod, HttpHeaders } from '..';
@@ -74,6 +74,7 @@ export default class ServerRequest<TRouter extends TAnyRouter = TAnyRouter> exte
     // Services
     public api: ApiClient;
     public traceCall?: TRequestTraceCallContext;
+    public profiling!: TRequestProfiling;
 
     /*----------------------------------
     - INITIALISATION

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 };
-};