proteum 2.1.0 → 2.1.2

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

@@ -25,12 +25,6 @@ import UsersRequestService from './request';
 - TYPES
 ----------------------------------*/
 
-/*----------------------------------
-- CONFIG
-----------------------------------*/
-
-const LogPrefix = '[router][auth]';
-
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
@@ -59,11 +53,32 @@ export default class AuthenticationRouterService<
         this.users = this.config.users;
     }
 
+    private traceRouteAuth(
+        request: TRequest,
+        route: TAnyRoute,
+        details: Record<string, any>,
+        minimumCapture: 'summary' | 'resolve' | 'deep' = 'resolve',
+    ) {
+        this.app.container.Trace.record(
+            request.id,
+            'auth.route',
+            {
+                routePath: route.path || '',
+                routeId: route.options.id || '',
+                authInput: route.options.auth ?? null,
+                tracking: route.options.authTracking ?? null,
+                redirectLogged: route.options.redirectLogged ?? null,
+                ...details,
+            },
+            minimumCapture,
+        );
+    }
+
     public async ready() {
         // Decode current user
         this.parent.on('request', async (request: TRequest) => {
             // TODO: Typings. (context.user ?)
-            const decoded = await this.users.decode(request.req, true);
+            const decoded = await this.users.decode(request.req, true, request.id);
 
             request.user = decoded || null;
         });
@@ -72,10 +87,48 @@ export default class AuthenticationRouterService<
         this.parent.on('resolved', async (route: TAnyRoute, request: TRequest, response: ServerResponse<TRouter>) => {
             if (route.options.auth !== undefined) {
                 const tracking = route.options.authTracking ?? null;
+                const strategy =
+                    route.options.auth === false
+                        ? 'guest-only'
+                        : route.options.auth === null
+                          ? 'authenticated'
+                          : typeof route.options.auth === 'object'
+                            ? 'conditions'
+                            : route.options.auth === true
+                              ? tracking !== null && this.users.config.rules
+                                  ? 'user-via-rules'
+                                  : 'user'
+                              : tracking !== null && this.users.config.rules
+                                ? 'role-via-rules'
+                                : 'role';
+
+                this.traceRouteAuth(
+                    request,
+                    route,
+                    {
+                        phase: 'start',
+                        strategy,
+                    },
+                    'resolve',
+                );
 
                 // Guest-only routes can still redirect authenticated users away.
                 if (route.options.auth === false) {
                     const currentUser = this.users.check(request, false, tracking);
+                    const redirected = Boolean(route.options.redirectLogged && currentUser);
+
+                    this.traceRouteAuth(
+                        request,
+                        route,
+                        {
+                            phase: 'result',
+                            strategy,
+                            outcome: redirected ? 'redirected' : 'allowed',
+                            userPresent: currentUser !== null,
+                            redirectTo: redirected ? route.options.redirectLogged : null,
+                        },
+                        'resolve',
+                    );
 
                     if (route.options.redirectLogged && currentUser) response.redirect(route.options.redirectLogged);
                     return;
@@ -83,11 +136,13 @@ export default class AuthenticationRouterService<
 
                 if (route.options.auth === null) {
                     this.users.check(request, null, tracking);
+                    this.traceRouteAuth(request, route, { phase: 'result', strategy, outcome: 'allowed' }, 'resolve');
                     return;
                 }
 
                 if (typeof route.options.auth === 'object') {
                     this.users.check(request, route.options.auth as TAuthCheckConditions, tracking);
+                    this.traceRouteAuth(request, route, { phase: 'result', strategy, outcome: 'allowed' }, 'resolve');
                     return;
                 }
 
@@ -95,10 +150,32 @@ export default class AuthenticationRouterService<
                 if (route.options.auth === true) {
                     if (tracking !== null && this.users.config.rules) {
                         this.users.check(request, { role: 'USER' }, tracking);
+                        this.traceRouteAuth(
+                            request,
+                            route,
+                            {
+                                phase: 'result',
+                                strategy,
+                                outcome: 'allowed',
+                                requiredRole: 'USER',
+                            },
+                            'resolve',
+                        );
                         return;
                     }
 
                     this.users.check(request, true);
+                    this.traceRouteAuth(
+                        request,
+                        route,
+                        {
+                            phase: 'result',
+                            strategy,
+                            outcome: 'allowed',
+                            requiredRole: 'USER',
+                        },
+                        'resolve',
+                    );
                     return;
                 }
 
@@ -106,10 +183,32 @@ export default class AuthenticationRouterService<
 
                 if (tracking !== null && this.users.config.rules) {
                     this.users.check(request, { role: requiredRole }, tracking);
+                    this.traceRouteAuth(
+                        request,
+                        route,
+                        {
+                            phase: 'result',
+                            strategy,
+                            outcome: 'allowed',
+                            requiredRole,
+                        },
+                        'resolve',
+                    );
                     return;
                 }
 
                 this.users.check(request, requiredRole);
+                this.traceRouteAuth(
+                    request,
+                    route,
+                    {
+                        phase: 'result',
+                        strategy,
+                        outcome: 'allowed',
+                        requiredRole,
+                    },
+                    'resolve',
+                );
             }
         });
     }

package/server/services/cron/CronTask.ts

@@ -10,16 +10,33 @@ import cronParser, { CronExpression } from 'cron-parser';
 ----------------------------------*/
 
 import type CronManager from '.';
+import type {
+    TProfilerCronTask,
+    TProfilerCronTaskFrequency,
+    TProfilerCronTaskRunStatus,
+    TProfilerCronTaskTrigger,
+} from '@common/dev/profiler';
 
 export type TFrequence = string | Date;
 export type TRunner = () => Promise<any>;
+const nowIso = () => new Date().toISOString();
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
 export default class CronTask {
     public cron?: CronExpression;
+    public frequency!: TProfilerCronTaskFrequency;
     public nextInvocation?: Date;
+    public registeredAt = nowIso();
+    public running = false;
+    public lastTrigger?: TProfilerCronTaskTrigger;
+    public lastRunStartedAt?: string;
+    public lastRunFinishedAt?: string;
+    public lastRunDurationMs?: number;
+    public lastRunStatus?: TProfilerCronTaskRunStatus;
+    public lastErrorMessage?: string;
+    public runCount = 0;
 
     public constructor(
         private manager: CronManager,
@@ -35,6 +52,10 @@ export default class CronTask {
 
     public schedule(next: TFrequence) {
         this.cron = undefined;
+        this.frequency =
+            typeof next === 'string'
+                ? { kind: 'cron', value: next }
+                : { kind: 'date', value: next.toISOString() };
 
         // Cron expression
         if (typeof next === 'string') {
@@ -58,16 +79,63 @@ export default class CronTask {
         else this.nextInvocation = undefined;
     }
 
-    public run(now: boolean = false) {
+    public toProfilerTask(): TProfilerCronTask {
+        return {
+            name: this.nom,
+            registeredAt: this.registeredAt,
+            frequency: this.frequency,
+            autoexec: Boolean(this.autoexec),
+            automaticExecution: this.manager.isAutomaticExecutionEnabled(),
+            nextInvocation: this.nextInvocation?.toISOString(),
+            running: this.running,
+            lastTrigger: this.lastTrigger,
+            lastRunStartedAt: this.lastRunStartedAt,
+            lastRunFinishedAt: this.lastRunFinishedAt,
+            lastRunDurationMs: this.lastRunDurationMs,
+            lastRunStatus: this.lastRunStatus,
+            lastErrorMessage: this.lastErrorMessage,
+            runCount: this.runCount,
+        };
+    }
+
+    public async run(now: boolean = false, trigger: TProfilerCronTaskTrigger = 'scheduler') {
         // Update invocation date
         const maintenant = new Date();
         const runnable = this.nextInvocation !== undefined && this.nextInvocation.valueOf() <= maintenant.valueOf();
         if (runnable) this.scheduleNext();
-        else if (now === false) return;
+        else if (now === false) return false;
+
+        if (this.running) return false;
+
+        this.running = true;
+        this.lastTrigger = trigger;
+        const startedAt = nowIso();
+        this.lastRunStartedAt = startedAt;
+        this.lastRunFinishedAt = undefined;
+        this.lastRunDurationMs = undefined;
+        this.lastRunStatus = undefined;
+        this.lastErrorMessage = undefined;
 
         // Execution
-        this.runner().then(() => {
-            this.manager.config.debug && console.info(`Task runned.`);
-        });
+        try {
+            await this.runner();
+            this.runCount += 1;
+            const finishedAt = nowIso();
+            this.lastRunFinishedAt = finishedAt;
+            this.lastRunDurationMs = Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt));
+            this.lastRunStatus = 'completed';
+            this.manager.config.debug && console.info(`[cron][${this.nom}] Task completed.`);
+            return true;
+        } catch (error) {
+            this.runCount += 1;
+            const finishedAt = nowIso();
+            this.lastRunFinishedAt = finishedAt;
+            this.lastRunDurationMs = Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt));
+            this.lastRunStatus = 'error';
+            this.lastErrorMessage = error instanceof Error ? error.message : String(error);
+            throw error;
+        } finally {
+            this.running = false;
+        }
     }
 }

package/server/services/cron/index.ts

@@ -6,6 +6,7 @@
 import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
 import { NotFound } from '@common/errors';
+import type { TProfilerCronTaskTrigger } from '@common/dev/profiler';
 import context from '@server/context';
 
 /*----------------------------------
@@ -32,7 +33,7 @@ export type Services = {};
 
 export default class CronManager extends Service<Config, Hooks, Application, Application> {
     public static taches: { [nom: string]: CronTask } = {};
-    public static timer: NodeJS.Timeout;
+    public static timer?: NodeJS.Timeout;
 
     /*----------------------------------
     - LIFECICLE
@@ -40,8 +41,17 @@ export default class CronManager extends Service<Config, Hooks, Application, App
 
     public async ready() {
         clearInterval(CronManager.timer);
+        if (!this.isAutomaticExecutionEnabled()) {
+            this.config.debug && console.info('[cron] Automatic execution disabled in dev mode.');
+            return;
+        }
+
         CronManager.timer = setInterval(() => {
-            for (const id in CronManager.taches) CronManager.taches[id].run();
+            for (const id in CronManager.taches) {
+                void this.runTask(id, false, 'scheduler').catch((error) => {
+                    console.error(`[cron][${id}] Task failed.`, error);
+                });
+            }
         }, 10000);
     }
 
@@ -59,16 +69,12 @@ export default class CronManager extends Service<Config, Hooks, Application, App
      * @param autoexec true to execute the task immediatly
      * @returns The CronTask that just have been created
      */
-    public task(nom: string, frequence: TFrequence, run: TRunner, autoexec?: boolean) {
-        return new Promise<CronTask>((resolve, reject) => {
-            context.run({ channelType: 'cron', channelId: nom }, async () => {
-                CronManager.taches[nom] = new CronTask(this, nom, frequence, run, autoexec);
+    public async task(nom: string, frequence: TFrequence, run: TRunner, autoexec?: boolean) {
+        CronManager.taches[nom] = new CronTask(this, nom, frequence, run, autoexec);
 
-                if (autoexec) await CronManager.taches[nom].run(true);
+        if (autoexec && this.isAutomaticExecutionEnabled()) await this.runTask(nom, true, 'autoexec');
 
-                resolve(CronManager.taches[nom]);
-            });
-        });
+        return CronManager.taches[nom];
     }
 
     public async exec(nom: string) {
@@ -76,7 +82,8 @@ export default class CronManager extends Service<Config, Hooks, Application, App
 
         if (tache === undefined) throw new NotFound('Tâche NotFound: ' + nom);
 
-        await tache.run(true);
+        await this.runTask(nom, true, 'manual');
+        return tache;
     }
     public get(): typeof CronManager.taches;
     public get(name: string): CronTask;
@@ -87,4 +94,20 @@ export default class CronManager extends Service<Config, Hooks, Application, App
         if (cron === undefined) throw new Error(`L'instance de la tâche cron ${name} n'a pas été trouvée`);
         return cron;
     }
+
+    public isAutomaticExecutionEnabled() {
+        return !__DEV__;
+    }
+
+    public listTasks() {
+        return Object.values(CronManager.taches).map((task) => task.toProfilerTask());
+    }
+
+    private async runTask(name: string, now: boolean, trigger: TProfilerCronTaskTrigger) {
+        const task = this.get(name);
+
+        return context.run({ channelType: 'cron', channelId: name }, async () => {
+            return task.run(now, trigger);
+        });
+    }
 }

package/server/services/fetch/index.ts

@@ -7,9 +7,6 @@ import type { default as sharp, Sharp } from 'sharp';
 import fs from 'fs-extra';
 import got, { Method, Options, Response as GotResponse } from 'got';
 
-// Node
-import request from 'request';
-
 // Core: general
 import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
@@ -109,14 +106,10 @@ export default class FetchService extends Service<Config, Hooks, Application, Ap
     ----------------------------------*/
 
     public toBuffer(uri: string): Promise<Buffer> {
-        return new Promise<Buffer>((resolve, reject) => {
-            request(uri, { encoding: null }, (err, res, body) => {
-                if (err) return reject(err);
-
-                if (!body) return reject(`Body is empty for ${uri}.`);
+        return got(uri, { responseType: 'buffer', throwHttpErrors: false }).then((response) => {
+            if (!response.body || response.body.length === 0) throw new Error(`Body is empty for ${uri}.`);
 
-                resolve(body);
-            });
+            return response.body;
         });
     }
 

package/server/services/prisma/index.ts

@@ -23,6 +23,62 @@ import { NotFound } from '@common/errors';
 
 export type SqlQuery = ReturnType<ModelsManager['SQL']>;
 
+type DecimalLike = {
+    constructor?: { name?: string };
+    equals: (value: number) => boolean;
+    toNumber: () => number;
+    toString: () => string;
+};
+
+/*----------------------------------
+- HELPERS
+----------------------------------*/
+
+const isDecimalLike = (value: object): value is DecimalLike =>
+    'constructor' in value &&
+    'equals' in value &&
+    'toNumber' in value &&
+    'toString' in value &&
+    typeof value.constructor === 'function' &&
+    value.constructor.name === 'Decimal' &&
+    typeof value.equals === 'function' &&
+    typeof value.toNumber === 'function' &&
+    typeof value.toString === 'function';
+
+const isPlainObject = (value: object) => {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+
+const normalizeBigInt = (value: bigint) => {
+    const number = Number(value);
+    return Number.isSafeInteger(number) ? number : value.toString();
+};
+
+const normalizeDecimal = (value: DecimalLike) => {
+    const number = value.toNumber();
+    return Number.isFinite(number) && value.equals(number) ? number : value.toString();
+};
+
+const normalizeSqlScalar = (value: bigint | DecimalLike) =>
+    typeof value === 'bigint' ? normalizeBigInt(value) : normalizeDecimal(value);
+
+const normalizeSqlResult = <T>(value: T): T => {
+    if (typeof value === 'bigint') return normalizeSqlScalar(value) as T;
+
+    if (Array.isArray(value)) return value.map((item) => normalizeSqlResult(item)) as T;
+
+    if (value === null || value === undefined || typeof value !== 'object' || value instanceof Date) return value;
+
+    if (isDecimalLike(value)) return normalizeSqlScalar(value) as T;
+
+    if (!isPlainObject(value)) return value;
+
+    return Object.fromEntries(
+        Object.entries(value).map(([key, nestedValue]) => [key, normalizeSqlResult(nestedValue)]),
+    ) as T;
+};
+
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
@@ -33,6 +89,11 @@ export type Hooks = {};
 
 export type Services = {};
 
+// Fix: Do not know how to serialize a BigInt
+BigInt.prototype.toJSON = function () {
+    return normalizeBigInt(this.valueOf());
+};
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
@@ -43,7 +104,7 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
     public constructor(...args: TServiceArgs<ModelsManager>) {
         super(...args);
 
-        dotenv.config();
+        dotenv.config({ quiet: true });
 
         const databaseUrl = process.env.DATABASE_URL;
         if (!databaseUrl)
@@ -74,9 +135,10 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
     public SQL<TRowData extends {} | number | string>(strings: TemplateStringsArray, ...data: any[]) {
         const string = this.string(strings, ...data);
 
-        const query = () => {
-            return this.client.$queryRawUnsafe(string) as Promise<TRowData[]>;
-        };
+        const query = () =>
+            this.client.$queryRawUnsafe(string).then((resultatRequetes) => normalizeSqlResult(resultatRequetes)) as Promise<
+                TRowData[]
+            >;
 
         query.all = query;
         query.value = <TValue extends any = number>() =>