proteum 2.1.0 → 2.1.1

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>() =>

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

@@ -21,8 +21,11 @@ import * as csp from 'express-csp-header';
 
 // Core
 import Container from '@server/app/container';
+import type CronManager from '@server/services/cron';
+import type CronTask from '@server/services/cron/CronTask';
 import type { TServerRouter } from '..';
 import { serverHotReloadMessageType } from '@common/dev/serverHotReload';
+import { explainSectionNames } from '@common/dev/diagnostics';
 
 // Middlewaees (core)
 import { isMutipart, MiddlewareFormData } from './multipart';
@@ -206,6 +209,7 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
             }),
         );
 
+        this.registerDevTraceRoutes(routes);
         routes.use(routeRequest);
 
         /*----------------------------------
@@ -227,4 +231,151 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
     public async cleanup() {
         this.http.close();
     }
+
+    private registerDevTraceRoutes(routes: express.Express) {
+        if (!__DEV__ || this.app.env.profile !== 'dev') return;
+
+        if (this.app.container.Trace.isEnabled()) {
+            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;
+                const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 20;
+
+                res.json({ requests: this.app.container.Trace.listRequests(limit) });
+            });
+
+            routes.get('/__proteum/trace/latest', (_req, res) => {
+                const request = this.app.container.Trace.getLatestRequest();
+                if (!request) {
+                    res.status(404).json({ error: 'No request trace is available yet.' });
+                    return;
+                }
+
+                res.json({ request });
+            });
+
+            routes.get('/__proteum/trace/requests/:id', (req, res) => {
+                const request = this.app.container.Trace.getRequest(req.params.id);
+                if (!request) {
+                    res.status(404).json({ error: `Trace ${req.params.id} was not found.` });
+                    return;
+                }
+
+                res.json({ request });
+            });
+
+            routes.post('/__proteum/trace/arm', (req, res) => {
+                const rawCapture = typeof req.body.capture === 'string' ? req.body.capture : 'deep';
+                const capture = this.app.container.Trace.armNextRequest(rawCapture);
+
+                res.json({ armed: true, capture });
+            });
+        }
+
+        routes.get('/__proteum/explain', (req, res) => {
+            const rawSections = [
+                ...(Array.isArray(req.query.section) ? req.query.section : req.query.section ? [req.query.section] : []),
+                ...(Array.isArray(req.query.sections)
+                    ? req.query.sections.flatMap((value) => (typeof value === 'string' ? value.split(',') : []))
+                    : typeof req.query.sections === 'string'
+                      ? req.query.sections.split(',')
+                      : []),
+            ]
+                .map((value) => (typeof value === 'string' ? value.trim() : ''))
+                .filter(Boolean);
+
+            try {
+                const diagnostics = this.app.getDevDiagnostics();
+                const sections = diagnostics.normalizeExplainSections(rawSections);
+                res.json(diagnostics.explain(sections));
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const isBadRequest = explainSectionNames.some((sectionName) => message.includes(sectionName)) || message.includes('Unknown explain section');
+                res.status(isBadRequest ? 400 : 500).json({ error: message });
+            }
+        });
+
+        routes.get('/__proteum/doctor', (req, res) => {
+            const rawStrict = Array.isArray(req.query.strict) ? req.query.strict[0] : req.query.strict;
+            const strict = rawStrict === '1' || rawStrict === 'true';
+
+            try {
+                res.json(this.app.getDevDiagnostics().doctor(strict));
+            } catch (error) {
+                res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+        });
+
+        routes.get('/__proteum/cron/tasks', (_req, res) => {
+            const cron = this.getCronManager();
+            res.json({
+                automaticExecution: cron?.isAutomaticExecutionEnabled() ?? false,
+                tasks: cron?.listTasks() ?? [],
+            });
+        });
+
+        routes.get('/__proteum/commands', (_req, res) => {
+            res.json({ commands: this.app.getDevCommands().list() });
+        });
+
+        routes.post('/__proteum/commands/run', async (req, res) => {
+            const commandPath = typeof req.body?.path === 'string' ? req.body.path.trim() : '';
+            if (!commandPath) {
+                res.status(400).json({ error: 'Command path is required.' });
+                return;
+            }
+
+            try {
+                const execution = await this.app.getDevCommands().run(commandPath);
+                res.json({ execution });
+            } catch (error) {
+                const execution =
+                    error instanceof Error && 'execution' in error && typeof error.execution === 'object'
+                        ? error.execution
+                        : undefined;
+                const statusCode = error instanceof Error && error.name === 'NotFound' ? 404 : 500;
+
+                res.status(statusCode).json({
+                    error: error instanceof Error ? error.message : String(error),
+                    execution,
+                });
+            }
+        });
+
+        routes.post('/__proteum/cron/tasks/run', async (req, res) => {
+            const cron = this.getCronManager();
+            if (!cron) {
+                res.status(404).json({ error: 'Cron service is not registered for this app.' });
+                return;
+            }
+
+            const name = typeof req.body?.name === 'string' ? req.body.name.trim() : '';
+            if (!name) {
+                res.status(400).json({ error: 'Cron task name is required.' });
+                return;
+            }
+
+            let task: CronTask;
+            try {
+                task = cron.get(name);
+            } catch (error) {
+                res.status(404).json({ error: error instanceof Error ? error.message : String(error) });
+                return;
+            }
+
+            try {
+                await cron.exec(name);
+                res.json({ task: task.toProfilerTask() });
+            } catch (error) {
+                res.status(500).json({
+                    error: error instanceof Error ? error.message : String(error),
+                    task: task.toProfilerTask(),
+                });
+            }
+        });
+    }
+
+    private getCronManager() {
+        return (this.app as typeof this.app & { Cron?: CronManager }).Cron;
+    }
 }