proteum 2.2.7 → 2.2.9

package/client/dev/profiler/ApexChart.tsx

@@ -18,7 +18,7 @@ export default function ApexChart({
         if (!target || !options) return;
 
         let disposed = false;
-        let chart: { destroy: () => void } | undefined;
+        let chart: { destroy: () => void; render: () => Promise<unknown> | void } | undefined;
 
         target.innerHTML = '';
         setErrorMessage(undefined);
@@ -29,8 +29,9 @@ export default function ApexChart({
                 if (disposed || !mountRef.current) return;
 
                 const ApexCharts = module.default;
-                chart = new ApexCharts(mountRef.current, options);
-                await chart.render();
+                const nextChart = new ApexCharts(mountRef.current, options);
+                chart = nextChart;
+                await nextChart.render();
             } catch (error) {
                 if (!disposed) setErrorMessage(readErrorMessage(error));
             }

package/common/dev/inspection.ts

@@ -713,12 +713,25 @@ const resolveGuidanceFile = ({
     fallbackFilepath: string;
     relativePath: string;
 }) => {
-    const localFilepath = joinPath(appRoot, relativePath);
-    if (fileExists(localFilepath)) return { filepath: localFilepath, warning: undefined as string | undefined };
+    const resolvedAppRoot = resolvePath(appRoot);
+    const repoRoot = findRepoRoot(resolvedAppRoot);
+    let currentRoot = resolvedAppRoot;
+
+    while (true) {
+        const localFilepath = joinPath(currentRoot, relativePath);
+        if (fileExists(localFilepath)) return { filepath: localFilepath, warning: undefined as string | undefined };
+
+        if (currentRoot === repoRoot) break;
+
+        const parentRoot = dirnamePath(currentRoot);
+        if (parentRoot === currentRoot) break;
+
+        currentRoot = parentRoot;
+    }
 
     return {
         filepath: fallbackFilepath,
-        warning: `Missing ${relativePath} in ${appRoot}; using ${fallbackFilepath}.`,
+        warning: `Missing ${relativePath} in ${appRoot} and its repository ancestors; using ${fallbackFilepath}.`,
     };
 };
 

package/common/dev/serverHotReload.ts

@@ -27,33 +27,34 @@ export type TServerReadyMessage = {
     connectedProjects?: TServerReadyConnectedProject[];
 };
 
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
 export const isServerHotReloadRequest = (value: unknown): value is TServerHotReloadRequest =>
-    typeof value === 'object' &&
-    value !== null &&
-    (value as TServerHotReloadRequest).type === serverHotReloadMessageType.request &&
-    Array.isArray((value as TServerHotReloadRequest).changedFiles);
+    isRecord(value) &&
+    value.type === serverHotReloadMessageType.request &&
+    Array.isArray(value.changedFiles);
 
 export const isServerHotReloadResult = (value: unknown): value is TServerHotReloadResult =>
-    typeof value === 'object' &&
-    value !== null &&
-    ((value as TServerHotReloadResult).type === serverHotReloadMessageType.succeeded ||
-        (value as TServerHotReloadResult).type === serverHotReloadMessageType.failed) &&
-    Array.isArray((value as TServerHotReloadResult).changedFiles);
+    isRecord(value) &&
+    (value.type === serverHotReloadMessageType.succeeded || value.type === serverHotReloadMessageType.failed) &&
+    Array.isArray(value.changedFiles);
 
 const isServerReadyConnectedProject = (value: unknown): value is TServerReadyConnectedProject =>
-    typeof value === 'object' &&
-    value !== null &&
-    typeof (value as TServerReadyConnectedProject).namespace === 'string' &&
-    typeof (value as TServerReadyConnectedProject).identifier === 'string' &&
-    typeof (value as TServerReadyConnectedProject).name === 'string' &&
-    typeof (value as TServerReadyConnectedProject).urlInternal === 'string' &&
-    typeof (value as TServerReadyConnectedProject).healthUrl === 'string';
-
-export const isServerReadyMessage = (value: unknown): value is TServerReadyMessage =>
-    typeof value === 'object' &&
-    value !== null &&
-    (value as TServerReadyMessage).type === serverHotReloadMessageType.ready &&
-    typeof (value as TServerReadyMessage).publicUrl === 'string' &&
-    ((value as TServerReadyMessage).connectedProjects === undefined ||
-        (Array.isArray((value as TServerReadyMessage).connectedProjects) &&
-            (value as TServerReadyMessage).connectedProjects.every(isServerReadyConnectedProject)));
+    isRecord(value) &&
+    typeof value.namespace === 'string' &&
+    typeof value.identifier === 'string' &&
+    typeof value.name === 'string' &&
+    typeof value.urlInternal === 'string' &&
+    typeof value.healthUrl === 'string';
+
+export const isServerReadyMessage = (value: unknown): value is TServerReadyMessage => {
+    if (!isRecord(value)) return false;
+
+    const connectedProjects = value.connectedProjects;
+    return (
+        value.type === serverHotReloadMessageType.ready &&
+        typeof value.publicUrl === 'string' &&
+        (connectedProjects === undefined ||
+            (Array.isArray(connectedProjects) && connectedProjects.every(isServerReadyConnectedProject)))
+    );
+};

package/eslint.js

@@ -14,6 +14,220 @@ const defaultIgnores = [
 const createZodTypeFactorySelector = (factoryName) =>
     `CallExpression[callee.type='MemberExpression'][callee.computed=false][callee.object.type='Identifier'][callee.object.name=/^(schema|z|zod)$/][callee.property.name='${factoryName}']`;
 
+const skippedTraversalKeys = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+
+const traverseNode = (node, visit, parent = null, parentKey = null) => {
+    if (!node || typeof node !== 'object') return;
+
+    visit(node, parent, parentKey);
+
+    for (const key of Object.keys(node)) {
+        if (skippedTraversalKeys.has(key)) continue;
+
+        const value = node[key];
+        if (Array.isArray(value)) {
+            value.forEach((child) => {
+                if (child && typeof child.type === 'string') traverseNode(child, visit, node, key);
+            });
+            continue;
+        }
+
+        if (value && typeof value.type === 'string') traverseNode(value, visit, node, key);
+    }
+};
+
+const collectPatternNames = (node, names = []) => {
+    if (!node) return names;
+
+    if (node.type === 'Identifier') {
+        names.push(node.name);
+        return names;
+    }
+
+    if (node.type === 'RestElement') return collectPatternNames(node.argument, names);
+    if (node.type === 'AssignmentPattern') return collectPatternNames(node.left, names);
+    if (node.type === 'TSParameterProperty') return collectPatternNames(node.parameter, names);
+
+    if (node.type === 'ArrayPattern') {
+        node.elements.forEach((element) => collectPatternNames(element, names));
+        return names;
+    }
+
+    if (node.type === 'ObjectPattern') {
+        node.properties.forEach((property) => {
+            if (property.type === 'Property') collectPatternNames(property.value, names);
+            if (property.type === 'RestElement') collectPatternNames(property.argument, names);
+        });
+    }
+
+    return names;
+};
+
+const nodeReferencesName = (node, names) => {
+    let references = false;
+
+    traverseNode(node, (child, parent, parentKey) => {
+        if (child.type !== 'Identifier' || !names.includes(child.name)) return;
+        if (parent?.type === 'MemberExpression' && parentKey === 'property' && parent.computed === false) return;
+        if (parent?.type === 'Property' && parentKey === 'key' && parent.computed === false) return;
+        if (parent?.type === 'MethodDefinition' && parentKey === 'key' && parent.computed === false) return;
+        if (parent?.type === 'PropertyDefinition' && parentKey === 'key' && parent.computed === false) return;
+
+        references = true;
+    });
+
+    return references;
+};
+
+const collectDerivedErrorNames = (node, baseNames) => {
+    const names = [...baseNames];
+    let changed = true;
+
+    while (changed) {
+        changed = false;
+
+        traverseNode(node, (child) => {
+            if (child.type === 'VariableDeclarator' && child.id?.type === 'Identifier' && nodeReferencesName(child.init, names)) {
+                if (!names.includes(child.id.name)) {
+                    names.push(child.id.name);
+                    changed = true;
+                }
+            }
+
+            if (
+                child.type === 'AssignmentExpression' &&
+                child.left?.type === 'Identifier' &&
+                nodeReferencesName(child.right, names)
+            ) {
+                if (!names.includes(child.left.name)) {
+                    names.push(child.left.name);
+                    changed = true;
+                }
+            }
+        });
+    }
+
+    return names;
+};
+
+const getCalleePropertyName = (callee) => {
+    if (!callee) return null;
+    if (callee.type === 'Identifier') return callee.name;
+    if (callee.type === 'MemberExpression') {
+        if (callee.property.type === 'Identifier') return callee.property.name;
+        if (callee.property.type === 'Literal') return String(callee.property.value);
+    }
+
+    return null;
+};
+
+const preservingCallNames = new Set([
+    'captureError',
+    'captureException',
+    'consoleError',
+    'handleError',
+    'logError',
+    'onError',
+    'reject',
+    'reportError',
+    'setError',
+    'setErrorMessage',
+]);
+
+const preservingMemberNames = new Set(['captureException', 'error', 'handleError', 'reject', 'warn']);
+
+const isPreservingCall = (callExpression, names) => {
+    const propertyName = getCalleePropertyName(callExpression.callee);
+    if (!propertyName) return false;
+
+    const isKnownPreserver =
+        preservingCallNames.has(propertyName) ||
+        (callExpression.callee.type === 'MemberExpression' && preservingMemberNames.has(propertyName));
+
+    return isKnownPreserver && nodeReferencesName(callExpression, names);
+};
+
+const handlerPreservesCaughtError = (node, names) => {
+    let preserves = false;
+
+    traverseNode(node, (child) => {
+        if (child.type === 'ThrowStatement' && nodeReferencesName(child.argument, names)) preserves = true;
+        if (child.type === 'CallExpression' && isPreservingCall(child, names)) preserves = true;
+    });
+
+    return preserves;
+};
+
+const directPromiseCatchHandlers = new Set([
+    'captureError',
+    'captureException',
+    'consoleError',
+    'handleError',
+    'logError',
+    'reportError',
+]);
+
+const isDirectPromiseCatchHandler = (node) => {
+    const name = getCalleePropertyName(node);
+    if (name && directPromiseCatchHandlers.has(name)) return true;
+    return node?.type === 'MemberExpression' && node.object?.type === 'Identifier' && node.object.name === 'console';
+};
+
+const createSwallowedErrorRule = () => ({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require caught errors to be preserved, reported, rethrown, or surfaced with original detail.',
+        },
+        messages: {
+            missingParam:
+                'Caught errors must be bound and preserved. Use `catch (error)` and rethrow, report, route, or surface original details.',
+            unusedParam:
+                'Caught error `{{name}}` is discarded. Rethrow it, report it, route it to app error handling, or surface its original details.',
+            unpreserved:
+                'Caught error `{{name}}` is used but not preserved. Rethrow it, report it, route it, or surface original error details.',
+        },
+        schema: [],
+    },
+    create(context) {
+        const reportHandler = (node, params, body) => {
+            const names = params.flatMap((param) => collectPatternNames(param));
+            if (names.length === 0) {
+                context.report({ node, messageId: 'missingParam' });
+                return;
+            }
+
+            const referencedName = names.find((name) => nodeReferencesName(body, [name]));
+            if (!referencedName) {
+                context.report({ node, messageId: 'unusedParam', data: { name: names[0] } });
+                return;
+            }
+
+            if (!handlerPreservesCaughtError(body, collectDerivedErrorNames(body, names))) {
+                context.report({ node, messageId: 'unpreserved', data: { name: referencedName } });
+            }
+        };
+
+        return {
+            CatchClause(node) {
+                reportHandler(node, node.param ? [node.param] : [], node.body);
+            },
+            "CallExpression[callee.type='MemberExpression'][callee.property.name='catch']"(node) {
+                const [handler] = node.arguments;
+                if (!handler) return;
+                if (isDirectPromiseCatchHandler(handler)) return;
+
+                if (handler.type !== 'ArrowFunctionExpression' && handler.type !== 'FunctionExpression') {
+                    context.report({ node: handler, messageId: 'missingParam' });
+                    return;
+                }
+
+                reportHandler(handler, handler.params, handler.body);
+            },
+        };
+    },
+});
+
 const createProteumEslintConfig = ({ ignores = [] } = {}) => [
     {
         ignores: [...defaultIgnores, ...ignores],
@@ -37,12 +251,18 @@ const createProteumEslintConfig = ({ ignores = [] } = {}) => [
         },
         plugins: {
             '@typescript-eslint': tseslint.plugin,
+            proteum: {
+                rules: {
+                    'no-swallowed-caught-error': createSwallowedErrorRule(),
+                },
+            },
             react: reactPlugin,
             'react-hooks': reactHooksPlugin,
             'jsx-a11y': jsxA11yPlugin,
         },
         rules: {
             '@typescript-eslint/no-explicit-any': 'error',
+            'proteum/no-swallowed-caught-error': 'error',
             'no-restricted-syntax': [
                 'error',
                 {

package/package.json

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

package/server/app/commands.ts

@@ -3,26 +3,25 @@
 ----------------------------------*/
 
 import { Command as ClipanionCommand, Option, UsageError } from 'clipanion';
-import type CurrentCommandApplication from '@/server/index';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
 export type TCommandApplication = {
-    env: {
+    env?: {
         profile?: string;
         name?: string;
         [key: string]: unknown;
     };
-    identity: {
+    identity?: {
         identifier?: string;
         [key: string]: unknown;
     };
-    getRootServices: () => Record<string, unknown>;
+    getRootServices?: () => Record<string, unknown>;
     findService?: (serviceId: string) => unknown;
-    models?: { client?: any };
-    Models?: { client?: any };
+    models?: { client?: object };
+    Models?: { client?: object };
 };
 
 export type TCommandService = {
@@ -33,23 +32,19 @@ export type TCommandService = {
 - COMMAND CLASSES
 ----------------------------------*/
 
-export abstract class Commands<TApplication extends TCommandApplication = CurrentCommandApplication> {
-    public app: CurrentCommandApplication;
+export abstract class Commands<TApplication extends TCommandApplication = TCommandApplication> {
+    public app: TApplication;
 
-    public constructor(app: CurrentCommandApplication) {
+    public constructor(app: TApplication) {
         this.app = app;
     }
 
-    public get services(): CurrentCommandApplication {
+    public get services(): TApplication {
         return this.app;
     }
 
-    public get models(): any {
-        const app = this.app as {
-            models?: { client?: any };
-            Models?: { client?: any };
-        };
-        const models = app.models?.client ?? app.Models?.client;
+    public get models(): object {
+        const models = this.app.models?.client ?? this.app.Models?.client;
 
         if (!models)
             throw new Error(`${this.constructor.name} tried to access models but no Models service is registered.`);

package/server/app/commandsManager.ts

@@ -197,13 +197,17 @@ const parseCommandOptionTokens = (tokens: string[]) => {
 - SERVICE
 ----------------------------------*/
 
-export default class CommandsManager extends Service<Config, Hooks, Application> {
+export default class CommandsManager extends Service<Config, Hooks, Application, object> {
     public priority = 2 as 2;
 
     public commandsIndex: CommandsList = {};
 
     private runtimeCli?: Cli;
 
+    public constructor(parent: object | 'self', config: Config | null | undefined, app: Application | 'self') {
+        super(parent, config, app);
+    }
+
     public command<TArgs extends any[]>(
         ...args:
             | [name: string, description: string, childrens: RuntimeCommand[]]

package/server/app/controller/index.ts

@@ -7,39 +7,88 @@ import zod from 'zod';
 
 // Core
 import context from '@server/context';
-import type { Application } from '../index';
-import type { TServiceModelsClient } from '../service';
-import type { TRouterContext, TAnyRouter } from '@server/services/router';
 import {
     toValidationSchema,
     type TValidationSchema,
     type TValidationShape,
 } from '@server/services/router/request/validation/zod';
+import type {
+    Request as ServerRequest,
+    Response as ServerResponse,
+    TAnyRouter,
+    TRouterContextServices,
+} from '@server/services/router';
 
 export { schema } from '@server/services/router/request/validation/zod';
-export type { z } from '@server/services/router/request/validation/zod';
+export type {
+    z,
+    TInferValidationSchema,
+    TTypedValidationSchema,
+    TValidationSchema,
+    TValidationShape,
+} from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TControllerRouter<TApplication extends Application = Application> = TApplication extends { Router: infer TRouter }
-    ? TRouter extends TAnyRouter
-        ? TRouter
-        : TAnyRouter
+type TControllerModelsClient<TApplication extends object = object> = TApplication extends {
+    Models: { client: infer TModels };
+}
+    ? TModels
+    : TApplication extends {
+            models: { client: infer TModels };
+        }
+      ? TModels
+      : object;
+
+type TControllerRouter<TRouter> = TRouter extends TAnyRouter ? TRouter : TAnyRouter;
+type TControllerApplicationRouter<TApplication extends object> = TApplication extends { Router: infer TRouter }
+    ? TControllerRouter<TRouter>
     : TAnyRouter;
 
-export type TControllerRequestContext<TApplication extends Application = Application> = TRouterContext<
-    TControllerRouter<TApplication>
->;
+export type TControllerRequestContext<
+    TApplication extends object = object,
+    TRouter extends object = object,
+    TRequestServices extends object = {},
+> = {
+    app: TApplication;
+    context: object;
+    request: ServerRequest<TControllerRouter<TRouter>>;
+    api: ServerRequest<TControllerRouter<TRouter>>['api'];
+    response: ServerResponse<TControllerRouter<TRouter>>;
+    route: object;
+    page?: object;
+    Router: TControllerRouter<TRouter>;
+} & (TRouter extends TAnyRouter ? TRouterContextServices<TControllerRouter<TRouter>> : {}) &
+    TRequestServices;
+
+type TControllerBaseContext<TApplication extends object> = {
+    app: TApplication;
+    request: { data: TObjetDonnees };
+};
+
+type TControllerDefaultContext<TApplication extends object, TRequestServices extends object> = {
+    app: TApplication;
+    context: object;
+    request: ServerRequest<TControllerApplicationRouter<TApplication>>;
+    api: ServerRequest<TControllerApplicationRouter<TApplication>>['api'];
+    response: ServerResponse<TControllerApplicationRouter<TApplication>>;
+    route: object;
+    page?: object;
+    Router: TControllerApplicationRouter<TApplication>;
+} & TRouterContextServices<TControllerApplicationRouter<TApplication>> &
+    TRequestServices;
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
 
 export default abstract class Controller<
-    TApplication extends Application = Application,
-    TContext extends TControllerRequestContext<TApplication> = TControllerRequestContext<TApplication>,
+    TApplication extends object = object,
+    TRouter extends object = object,
+    TRequestServices extends object = {},
+    TContext extends TControllerBaseContext<TApplication> = TControllerDefaultContext<TApplication, TRequestServices>,
 > {
     public constructor(public request: TContext) {}
 
@@ -51,9 +100,12 @@ export default abstract class Controller<
         return this.app;
     }
 
-    public get models(): TServiceModelsClient<TApplication> {
-        const app = this.app as { models?: { client?: unknown }; Models?: { client?: unknown } };
-        return (app.models?.client ?? app.Models?.client) as TServiceModelsClient<TApplication>;
+    public get models(): TControllerModelsClient<TApplication> {
+        const app = this.app as {
+            models?: { client?: TControllerModelsClient<TApplication> };
+            Models?: { client?: TControllerModelsClient<TApplication> };
+        };
+        return (app.models?.client ?? app.Models?.client) as TControllerModelsClient<TApplication>;
     }
 
     public input<TSchema extends TValidationSchema>(schema: TSchema): zod.output<TSchema>;

package/server/app/devCommands.ts

@@ -112,10 +112,10 @@ const loadGeneratedCommandDefinitions = () =>
         (a, b) => a.path.localeCompare(b.path),
     );
 
-export default class DevCommandsRegistry<TApplication extends Application = Application> {
+export default class DevCommandsRegistry {
     private definitions = loadGeneratedCommandDefinitions();
 
-    public constructor(private app: TApplication) {}
+    public constructor(private app: Application) {}
 
     public list() {
         return this.definitions.map((definition) => ({
@@ -150,7 +150,7 @@ export default class DevCommandsRegistry<TApplication extends Application = Appl
 
         try {
             const instance = new definition.Command(this.app);
-            const method = (instance as Record<string, unknown>)[definition.methodName];
+            const method = Reflect.get(instance, definition.methodName);
 
             if (typeof method !== 'function') {
                 throw new Error(

package/server/app/devDiagnostics.ts

@@ -36,8 +36,8 @@ const isExplainSectionName = (value: string): value is TExplainSectionName =>
 const isConsoleLogLevel = (value: string): value is TDevConsoleLogLevel =>
     ['silly', 'log', 'info', 'warn', 'error'].includes(value);
 
-export default class DevDiagnosticsRegistry<TApplication extends Application = Application> {
-    public constructor(private app: TApplication) {}
+export default class DevDiagnosticsRegistry {
+    public constructor(private app: Application) {}
 
     private getManifestFilepath() {
         return path.join(this.app.container.path.root, '.proteum', 'manifest.json');

package/server/app/index.ts

@@ -44,8 +44,13 @@ export const Service = ServicesContainer;
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
 export type ApplicationProperties = Prettify<keyof Application>;
-export type RootServicesOf<TApplication extends Application = Application> = Prettify<{
-    [TKey in Exclude<keyof TApplication, ApplicationProperties> as TApplication[TKey] extends AnyService ? TKey : never]: TApplication[TKey];
+type RootServiceCandidate = {
+    runHook: object;
+    getServiceInstance: object;
+    status: string | undefined;
+};
+export type RootServicesOf<TApplication extends object = object> = Prettify<{
+    [TKey in Exclude<keyof TApplication, ApplicationProperties> as TApplication[TKey] extends RootServiceCandidate ? TKey : never]: TApplication[TKey];
 }>;
 
 const isServiceInstance = (value: unknown): value is AnyService => {
@@ -56,19 +61,24 @@ const isServiceInstance = (value: unknown): value is AnyService => {
     return typeof service.runHook === 'function' && typeof service.getServiceInstance === 'function' && service.status !== undefined;
 };
 
+const createCommandsManager = (app: Application) => new CommandsManager(app, { debug: true }, app);
+const createDevCommandsRegistry = (app: Application) => new DevCommandsRegistry(app);
+const createDevDiagnosticsRegistry = (app: Application) => new DevDiagnosticsRegistry(app);
+
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
 export abstract class Application<
     TServicesContainer extends ServicesContainerClass = ServicesContainerClass,
     TUser extends TBasicUser = TBasicUser,
-> extends ApplicationService<Config, Hooks, Application, Application> {
+> extends ApplicationService<Config, Hooks, object, object> {
     public static identity = ConfigApplication.identity;
     public static setup = ConfigApplication.setup;
 
     public app!: this;
     public servicesContainer!: TServicesContainer;
     public userType!: TUser;
+    public declare Router: object;
 
     /*----------------------------------
     - PROPERTIES
@@ -122,21 +132,22 @@ export abstract class Application<
     - COMMANDS
     ----------------------------------*/
 
-    private commandsManager = new CommandsManager(this, { debug: true }, this);
-    private devCommandsRegistry?: DevCommandsRegistry<this>;
-    private devDiagnosticsRegistry?: DevDiagnosticsRegistry<this>;
+    private commandsManager?: CommandsManager;
+    private devCommandsRegistry?: DevCommandsRegistry;
+    private devDiagnosticsRegistry?: DevDiagnosticsRegistry;
 
     public command(...args: Parameters<CommandsManager['command']>) {
+        this.commandsManager ??= createCommandsManager(this as Application);
         return this.commandsManager.command(...args);
     }
 
     public getDevCommands() {
-        this.devCommandsRegistry ??= new DevCommandsRegistry(this);
+        this.devCommandsRegistry ??= createDevCommandsRegistry(this as Application);
         return this.devCommandsRegistry;
     }
 
     public getDevDiagnostics() {
-        this.devDiagnosticsRegistry ??= new DevDiagnosticsRegistry(this);
+        this.devDiagnosticsRegistry ??= createDevDiagnosticsRegistry(this as Application);
         return this.devDiagnosticsRegistry;
     }