proteum 2.1.0-5 → 2.1.1

package/server/app/devCommands.ts

@@ -0,0 +1,192 @@
+import type { Application } from './index';
+import type { Commands } from './commands';
+import { normalizeDevCommandPath, type TDevCommandDefinition, type TDevCommandExecution } from '@common/dev/commands';
+import type { TTraceSummaryValue } from '@common/dev/requestTrace';
+import { NotFound } from '@common/errors';
+
+export type TGeneratedCommandDefinition = TDevCommandDefinition & {
+    Command: new (app: Application) => Commands<any>;
+};
+
+type TSerializableValue = object | PrimitiveValue | bigint | symbol | null | undefined | (() => void);
+
+const maxSummaryStringLength = 240;
+const sensitiveKeyPattern =
+    /(^|\.)(authorization|cookie|set-cookie|password|pass|pwd|secret|token|refreshToken|accessToken|apiKey|apiSecret|secretAccessKey|accessKeyId|privateKey|session|jwt|rawBody)$/i;
+
+const nowIso = () => new Date().toISOString();
+const getDurationMs = (startedAt: string, finishedAt: string) => Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt));
+const isSensitiveKeyPath = (keyPath: string[]) => sensitiveKeyPattern.test(keyPath.join('.'));
+const summarizeString = (value: string) =>
+    value.length <= maxSummaryStringLength ? value : `${value.slice(0, maxSummaryStringLength)}…`;
+
+const summarizeError = (error: Error): TTraceSummaryValue => ({
+    kind: 'error',
+    name: error.name,
+    message: error.message,
+    stack: error.stack?.split('\n').slice(0, 5).join('\n'),
+});
+
+const summarizeValue = (
+    value: TSerializableValue,
+    depth: number,
+    seen: WeakSet<object>,
+    keyPath: string[],
+): TTraceSummaryValue => {
+    if (isSensitiveKeyPath(keyPath)) return { kind: 'redacted', reason: `Sensitive key ${keyPath[keyPath.length - 1] || 'value'}` };
+    if (value === undefined) return { kind: 'undefined' };
+    if (value === null) return null;
+
+    if (typeof value === 'string') return summarizeString(value);
+    if (typeof value === 'number' || typeof value === 'boolean') return value;
+    if (typeof value === 'bigint') return { kind: 'bigint', value: value.toString() };
+    if (typeof value === 'symbol') return { kind: 'symbol', value: value.toString() };
+    if (typeof value === 'function') return { kind: 'function', name: value.name || 'anonymous' };
+
+    if (value instanceof Date) return { kind: 'date', value: value.toISOString() };
+    if (value instanceof Error) return summarizeError(value);
+    if (Buffer.isBuffer(value)) return { kind: 'buffer', byteLength: value.byteLength };
+    if (value instanceof Map) return { kind: 'map', size: value.size };
+    if (value instanceof Set) return { kind: 'set', size: value.size };
+
+    if (seen.has(value)) {
+        return {
+            kind: 'object',
+            constructorName: value.constructor?.name || 'Object',
+            keys: [],
+            entries: {},
+            truncated: true,
+        };
+    }
+
+    seen.add(value);
+
+    if (Array.isArray(value)) {
+        if (depth <= 0) return { kind: 'array', length: value.length, items: [], truncated: value.length > 0 };
+
+        const items = value
+            .slice(0, 10)
+            .map((item, index) => summarizeValue(item as TSerializableValue, depth - 1, seen, [...keyPath, `[${index}]`]));
+
+        return { kind: 'array', length: value.length, items, truncated: value.length > items.length };
+    }
+
+    const constructorName = value.constructor?.name || 'Object';
+    const keys = Object.keys(value);
+    if (depth <= 0) {
+        return { kind: 'object', constructorName, keys, entries: {}, truncated: keys.length > 0 };
+    }
+
+    const entries: { [key: string]: TTraceSummaryValue } = {};
+    for (const key of keys.slice(0, 20)) {
+        const record = value as Record<string, TSerializableValue>;
+        entries[key] = summarizeValue(record[key], depth - 1, seen, [...keyPath, key]);
+    }
+
+    return { kind: 'object', constructorName, keys, entries, truncated: keys.length > Object.keys(entries).length };
+};
+
+const serializeJsonResult = (value: unknown) => {
+    if (value === undefined) return undefined;
+
+    try {
+        return JSON.parse(JSON.stringify(value)) as unknown;
+    } catch {
+        return undefined;
+    }
+};
+
+export class DevCommandExecutionError extends Error {
+    public constructor(
+        message: string,
+        public execution: TDevCommandExecution,
+        public cause?: unknown,
+    ) {
+        super(message);
+        this.name = 'DevCommandExecutionError';
+    }
+}
+
+const loadGeneratedCommandDefinitions = () =>
+    (((require('@generated/server/commands') as { default?: TGeneratedCommandDefinition[] }).default || []) as TGeneratedCommandDefinition[]).sort(
+        (a, b) => a.path.localeCompare(b.path),
+    );
+
+export default class DevCommandsRegistry<TApplication extends Application = Application> {
+    private definitions = loadGeneratedCommandDefinitions();
+
+    public constructor(private app: TApplication) {}
+
+    public list() {
+        return this.definitions.map((definition) => ({
+            path: definition.path,
+            className: definition.className,
+            methodName: definition.methodName,
+            importPath: definition.importPath,
+            filepath: definition.filepath,
+            sourceLocation: definition.sourceLocation,
+            scope: definition.scope,
+        }));
+    }
+
+    private getDefinition(commandPath: string) {
+        const normalizedPath = normalizeDevCommandPath(commandPath);
+        const matchingDefinitions = this.definitions.filter((definition) => definition.path === normalizedPath);
+
+        if (matchingDefinitions.length === 0) {
+            throw new NotFound(`Command "${normalizedPath}" was not found.`);
+        }
+
+        if (matchingDefinitions.length > 1) {
+            throw new Error(`Command "${normalizedPath}" is ambiguous because it is registered more than once.`);
+        }
+
+        return matchingDefinitions[0];
+    }
+
+    public async run(commandPath: string): Promise<TDevCommandExecution> {
+        const definition = this.getDefinition(commandPath);
+        const startedAt = nowIso();
+
+        try {
+            const instance = new definition.Command(this.app);
+            const method = (instance as Record<string, unknown>)[definition.methodName];
+
+            if (typeof method !== 'function') {
+                throw new Error(
+                    `Command "${definition.path}" could not be executed because ${definition.className}.${definition.methodName} is not callable.`,
+                );
+            }
+
+            const value = await method.call(instance);
+            const finishedAt = nowIso();
+
+            return {
+                command: this.list().find((command) => command.path === definition.path) || definition,
+                startedAt,
+                finishedAt,
+                durationMs: getDurationMs(startedAt, finishedAt),
+                status: 'completed',
+                result:
+                    value === undefined
+                        ? undefined
+                        : {
+                              json: serializeJsonResult(value),
+                              summary: summarizeValue(value as TSerializableValue, 3, new WeakSet<object>(), ['result']),
+                          },
+            };
+        } catch (error) {
+            const finishedAt = nowIso();
+            const execution: TDevCommandExecution = {
+                command: this.list().find((command) => command.path === definition.path) || definition,
+                startedAt,
+                finishedAt,
+                durationMs: getDurationMs(startedAt, finishedAt),
+                status: 'error',
+                errorMessage: error instanceof Error ? error.message : String(error),
+            };
+
+            throw new DevCommandExecutionError(execution.errorMessage || `Command "${definition.path}" failed.`, execution, error);
+        }
+    }
+}

package/server/app/devDiagnostics.ts

@@ -0,0 +1,53 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+import type { Application } from './index';
+import {
+    buildDoctorResponse,
+    explainSectionNames,
+    pickExplainManifestSections,
+    type TDoctorResponse,
+    type TExplainSectionName,
+} from '@common/dev/diagnostics';
+import type { TProteumManifest } from '@common/dev/proteumManifest';
+
+const isExplainSectionName = (value: string): value is TExplainSectionName =>
+    explainSectionNames.includes(value as TExplainSectionName);
+
+export default class DevDiagnosticsRegistry<TApplication extends Application = Application> {
+    public constructor(private app: TApplication) {}
+
+    private getManifestFilepath() {
+        return path.join(this.app.container.path.root, '.proteum', 'manifest.json');
+    }
+
+    public readManifest(): TProteumManifest {
+        const filepath = this.getManifestFilepath();
+        if (!fs.existsSync(filepath)) {
+            throw new Error(`Proteum manifest not found at ${filepath}. Run a Proteum command that refreshes generated artifacts first.`);
+        }
+
+        return fs.readJsonSync(filepath) as TProteumManifest;
+    }
+
+    public normalizeExplainSections(rawSections: string[]) {
+        const sections = [...new Set(rawSections.map((section) => section.trim()).filter(Boolean))];
+        const invalidSections = sections.filter((section) => !isExplainSectionName(section));
+
+        if (invalidSections.length > 0) {
+            throw new Error(
+                `Unknown explain section(s): ${invalidSections.join(', ')}. Allowed values: ${explainSectionNames.join(', ')}.`,
+            );
+        }
+
+        return sections as TExplainSectionName[];
+    }
+
+    public explain(sectionNames: TExplainSectionName[] = []) {
+        return pickExplainManifestSections(this.readManifest(), sectionNames);
+    }
+
+    public doctor(strict = false): TDoctorResponse {
+        return buildDoctorResponse(this.readManifest(), strict);
+    }
+}

package/server/app/index.ts

@@ -5,7 +5,9 @@
 // Core
 import AppContainer from './container';
 import ApplicationService, { AnyService } from './service';
-import CommandsManager from './commands';
+import CommandsManager from './commandsManager';
+import DevCommandsRegistry from './devCommands';
+import DevDiagnosticsRegistry from './devDiagnostics';
 import ServicesContainer, { ServicesContainer as ServicesContainerClass, TServiceMetas } from './service/container';
 
 // Built-in
@@ -29,6 +31,10 @@ type Hooks = {
     error: { args: [error: Error, request?: ServerRequest<TServerRouter>] };
 };
 
+export type TApplicationStartOptions = {
+    skipRootServices?: string[];
+};
+
 export const Service = ServicesContainer;
 
 // Without prettify, we don't get a clear list of the class properties
@@ -116,21 +122,33 @@ export abstract class Application<
     ----------------------------------*/
 
     private commandsManager = new CommandsManager(this, { debug: true }, this);
+    private devCommandsRegistry?: DevCommandsRegistry<this>;
+    private devDiagnosticsRegistry?: DevDiagnosticsRegistry<this>;
 
     public command(...args: Parameters<CommandsManager['command']>) {
         return this.commandsManager.command(...args);
     }
 
+    public getDevCommands() {
+        this.devCommandsRegistry ??= new DevCommandsRegistry(this);
+        return this.devCommandsRegistry;
+    }
+
+    public getDevDiagnostics() {
+        this.devDiagnosticsRegistry ??= new DevDiagnosticsRegistry(this);
+        return this.devDiagnosticsRegistry;
+    }
+
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
 
-    public async start() {
+    public async start(options: TApplicationStartOptions = {}) {
         console.log('Build date', BUILD_DATE);
         console.log('Core version', CORE_VERSION);
         const startTime = Date.now();
 
-        const startingServices = await this.ready();
+        const startingServices = await this.ready(options);
         await Promise.all(startingServices);
         await this.runHook('ready');
 
@@ -181,8 +199,9 @@ export abstract class Application<
         return (service as AnyService & { ready: () => Promise<any> }).ready();
     }
 
-    public async ready() {
+    public async ready(options: TApplicationStartOptions = {}) {
         const startingServices: Promise<any>[] = [];
+        const skippedRootServices = new Set(options.skipRootServices || []);
 
         const processService = async (_propKey: string, service: AnyService) => {
             if (service.status !== 'starting') return;
@@ -208,6 +227,10 @@ export abstract class Application<
 
         for (const [serviceName, service] of this.listRootServices()) {
             const rootService = service as AnyService;
+            if (skippedRootServices.has(serviceName)) {
+                rootService.status = 'stopped';
+                continue;
+            }
 
             // TODO: move to router
             //  Application.on('service.ready')

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

@@ -104,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)