proteum 2.1.2 → 2.1.3-1

package/common/dev/requestTrace.ts

@@ -82,8 +82,10 @@ export type TTraceCall = {
     errorMessage?: string;
     requestDataKeys: string[];
     requestData?: TTraceSummaryValue;
+    requestDataJson?: unknown;
     resultKeys: string[];
     result?: TTraceSummaryValue;
+    resultJson?: unknown;
 };
 
 export type TRequestTrace = {
@@ -103,6 +105,8 @@ export type TRequestTrace = {
     droppedEvents: number;
     persistedFilepath?: string;
     errorMessage?: string;
+    requestDataJson?: unknown;
+    resultJson?: unknown;
     calls: TTraceCall[];
     events: TTraceEvent[];
 };

package/common/dev/session.ts

@@ -0,0 +1,24 @@
+export type TDevSessionUserSummary = {
+    email: string;
+    name: string | null;
+    type: string;
+    roles: string[];
+    locale?: string | null;
+};
+
+export type TDevSessionPayload = {
+    token: string;
+    cookieName: 'authorization';
+    expiresInMs: number;
+    issuedAt: string;
+    expiresAt: string;
+};
+
+export type TDevSessionStartResponse = {
+    user: TDevSessionUserSummary;
+    session: TDevSessionPayload;
+};
+
+export type TDevSessionErrorResponse = {
+    error: string;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.1.2",
+	"version": "2.1.3-1",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/proteum.git",
 	"license": "MIT",

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

@@ -38,6 +38,44 @@ const isSensitiveKeyPath = (keyPath: string[]) => sensitiveKeyPattern.test(keyPa
 const summarizeString = (value: string) =>
     value.length <= maxStringLength ? value : `${value.slice(0, maxStringLength)}…`;
 
+const serializeJsonValue = (value: unknown, keyPath: string[], seen: WeakSet<object>): unknown => {
+    if (isSensitiveKeyPath(keyPath)) return `[redacted: Sensitive key ${keyPath[keyPath.length - 1] || 'value'}]`;
+    if (value === undefined || value === null) return value;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+    if (typeof value === 'bigint') return `${value.toString()}n`;
+    if (typeof value === 'symbol') return value.toString();
+    if (typeof value === 'function') return `[Function ${value.name || 'anonymous'}]`;
+
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof Error) return { name: value.name, message: value.message, stack: value.stack };
+    if (Buffer.isBuffer(value)) return `[Buffer ${value.byteLength} bytes]`;
+    if (value instanceof Map) return Array.from(value.entries()).map(([entryKey, entryValue], index) =>
+        serializeJsonValue([entryKey, entryValue], [...keyPath, `[${index}]`], seen),
+    );
+    if (value instanceof Set) {
+        return Array.from(value.values()).map((entryValue, index) => serializeJsonValue(entryValue, [...keyPath, `[${index}]`], seen));
+    }
+
+    if (typeof value !== 'object') return String(value);
+    if (seen.has(value)) return `[Circular ${value.constructor?.name || 'Object'}]`;
+
+    seen.add(value);
+
+    if (Array.isArray(value)) {
+        return value.map((item, index) => serializeJsonValue(item, [...keyPath, `[${index}]`], seen));
+    }
+
+    const serialized: Record<string, unknown> = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+        const nextValue = serializeJsonValue(entryValue, [...keyPath, entryKey], seen);
+        if (nextValue !== undefined) serialized[entryKey] = nextValue;
+    }
+
+    return serialized;
+};
+
+const serializeCaptureValue = (value: TTraceInspectable, key: string) => serializeJsonValue(value, [key], new WeakSet<object>());
+
 const summarizeError = (error: Error): TTraceSummaryValue => ({
     kind: 'error',
     name: error.name,
@@ -169,6 +207,7 @@ export default class Trace {
             profilerParentRequestId: input.profilerParentRequestId,
             startedAt: nowIso(),
             droppedEvents: 0,
+            requestDataJson: serializeCaptureValue(input.data, 'requestData'),
             calls: [],
             events: [],
         };
@@ -269,6 +308,7 @@ export default class Trace {
             startedAt: nowIso(),
             requestDataKeys: input.requestDataKeys || [],
             requestData: input.requestData !== undefined ? summarizeCaptureValue(input.requestData, trace.capture, 'requestData') : undefined,
+            requestDataJson: input.requestData !== undefined ? serializeCaptureValue(input.requestData, 'requestData') : undefined,
             resultKeys: [],
         };
 
@@ -298,6 +338,14 @@ export default class Trace {
         call.errorMessage = output.errorMessage;
         call.resultKeys = output.resultKeys || [];
         call.result = output.result !== undefined ? summarizeCaptureValue(output.result, trace.capture, 'result') : undefined;
+        call.resultJson = output.result !== undefined ? serializeCaptureValue(output.result, 'result') : undefined;
+    }
+
+    public setRequestResult(requestId: string, result: TTraceInspectable) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return;
+
+        trace.resultJson = serializeCaptureValue(result, 'result');
     }
 
     public listRequests(limit = 20): TRequestTraceListItem[] {

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

@@ -22,7 +22,9 @@ 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 { TDevSessionStartResponse, TDevSessionUserSummary } from '@common/dev/session';
 import { serverHotReloadMessageType } from '@common/dev/serverHotReload';
 import { explainSectionNames } from '@common/dev/diagnostics';
 
@@ -54,6 +56,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 +112,32 @@ 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,
+        };
+    }
+
     /*----------------------------------
     - HOOKS
     ----------------------------------*/
@@ -358,6 +395,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/response/index.ts

@@ -338,6 +338,7 @@ export default class ServerResponse<
         // NOTE: On évite le filtrage sans masque spécifié (performances + risques erreurs)
         if (mask !== undefined) data = await jsonMask(data, mask);
 
+        this.app.container.Trace.setRequestResult(this.request.id, data);
         this.headers['Content-Type'] = 'application/json';
         this.data = (this.request.isVirtual ? data : JSON.stringify(data)) as TData;
         return this.end();