proteum 2.2.7 → 2.2.8

package/cli/compiler/artifacts/controllers.ts

@@ -120,12 +120,14 @@ export const generateControllerArtifacts = async () => {
     const connectedManifestControllers: TProteumManifestController[] = [];
 
     connectedProjectContracts.forEach(({ namespace, cachedContractFilepath, contract, sourceKind, sourceValue, typeImportModuleSpecifier, typingMode }) => {
+        let connectedTypeName: string | null = null;
+
         if (typingMode === 'local-typed' && typeImportModuleSpecifier) {
-            const typeName = `ConnectedControllers_${namespace.replace(/[^A-Za-z0-9_$]+/g, '_')}`;
+            connectedTypeName = `ConnectedControllers_${namespace.replace(/[^A-Za-z0-9_$]+/g, '_')}`;
             connectedControllerTypeImports.push(
-                `import type { TConnectedControllers as ${typeName} } from ${JSON.stringify(typeImportModuleSpecifier)};`,
+                `import type { TConnectedControllers as ${connectedTypeName} } from ${JSON.stringify(typeImportModuleSpecifier)};`,
             );
-            typeTree[namespace] = JSON.stringify({ rawType: typeName });
+            typeTree[namespace] = JSON.stringify({ rawType: connectedTypeName });
         } else {
             typeTree[namespace] = JSON.stringify({ runtimeOnly: true });
         }
@@ -164,7 +166,9 @@ export const generateControllerArtifacts = async () => {
                     hasInput: controller.hasInput,
                     httpPath: controller.httpPath,
                     methodName: controller.methodName,
-                    resultType: 'unknown',
+                    resultType: connectedTypeName
+                        ? `TConnectedControllerResult<${connectedTypeName}, ${JSON.stringify(controller.clientAccessor)}>`
+                        : 'unknown',
                 }),
             );
         });
@@ -228,6 +232,28 @@ type TControllerResult<TController, TMethod extends keyof TController> =
 
 type TControllerFetcher<TController, TMethod extends keyof TController> = TFetcher<TControllerResult<TController, TMethod>>;
 
+type TConnectedFallbackValue =
+    | string
+    | number
+    | boolean
+    | null
+    | TConnectedFallbackValue[]
+    | { [key: string]: TConnectedFallbackValue | undefined };
+
+type TConnectedControllerLeaf<TControllerTree, TAccessor extends string> =
+    TAccessor extends \`${'${infer THead}.${infer TTail}'}\`
+        ? THead extends keyof TControllerTree
+            ? TConnectedControllerLeaf<TControllerTree[THead], TTail>
+            : undefined
+        : TAccessor extends keyof TControllerTree
+            ? TControllerTree[TAccessor]
+            : undefined;
+
+type TConnectedControllerResult<TControllerTree, TAccessor extends string> =
+    TConnectedControllerLeaf<TControllerTree, TAccessor> extends (...args: infer TArgs) => TFetcher<infer TResult>
+        ? Awaited<TResult>
+        : TConnectedFallbackValue;
+
 export type TControllers = ${printControllerTree(typeTree, typeLeaf)};
 
 export const createControllers = (

package/cli/compiler/artifacts/services.ts

@@ -711,6 +711,68 @@ ${classMembers.join('\n')}
     };
 };
 
+const isNamespaceImportDeclaration = (statement: ts.ImportDeclaration) =>
+    statement.importClause?.namedBindings !== undefined && ts.isNamespaceImport(statement.importClause.namedBindings);
+
+const isClientServerStubSupportStatement = (statement: ts.Statement, appClassIdentifier: string) => {
+    if (ts.isTypeAliasDeclaration(statement)) {
+        return !new Set([
+            `${appClassIdentifier}Disks`,
+            `${appClassIdentifier}Router`,
+            `${appClassIdentifier}RouterPlugins`,
+        ]).has(statement.name.text);
+    }
+
+    return ts.isInterfaceDeclaration(statement) || ts.isModuleDeclaration(statement);
+};
+
+const createClientServerIndexDeclaration = (rootServices: TParsedService[]) => {
+    const sourceFile = createSourceFile(getAppServerEntryFilepath());
+    const appClass = getDefaultExportClassDeclaration(sourceFile);
+    const serviceTypesByRegisteredName = new Map(
+        rootServices.map((service) => [service.registeredName, `import("${service.importPath}").default`] as const),
+    );
+
+    const imports = sourceFile.statements
+        .filter((statement): statement is ts.ImportDeclaration => ts.isImportDeclaration(statement))
+        .filter((statement) => !isNamespaceImportDeclaration(statement))
+        .map((statement) => statement.getText(sourceFile));
+    const supportStatements = sourceFile.statements
+        .slice(0, sourceFile.statements.indexOf(appClass))
+        .filter((statement) => isClientServerStubSupportStatement(statement, app.identity.identifier))
+        .map((statement) => statement.getText(sourceFile));
+    const heritageClauses = appClass.heritageClauses?.map((clause) => clause.getText(sourceFile)).join(' ');
+    const properties = appClass.members
+        .filter((member): member is ts.PropertyDeclaration => ts.isPropertyDeclaration(member))
+        .filter((member) => !isPrivateOrProtectedInstanceMember(member))
+        .map((property) => {
+            const propertyName = getPropertyNameText(property.name);
+            if (!propertyName) return undefined;
+
+            const propertyType =
+                propertyName === 'Disks'
+                    ? 'object'
+                    : propertyName === 'Router'
+                      ? `${app.identity.identifier}Router`
+                      : property.type?.getText(sourceFile) || serviceTypesByRegisteredName.get(propertyName);
+            if (!propertyType) return undefined;
+
+            return `    public ${propertyName}: ${propertyType};`;
+        })
+        .filter((property): property is string => property !== undefined);
+
+    return `${imports.join('\n')}
+
+${supportStatements.join('\n\n')}
+
+type ${app.identity.identifier}Router = Router<${app.identity.identifier}>;
+
+export default class ${app.identity.identifier}${heritageClauses ? ` ${heritageClauses}` : ''} {
+${properties.join('\n')}
+}
+`;
+};
+
 const resolveManifestService = (service: TParsedService, parent: string): TProteumManifestService => ({
     kind: 'service',
     registeredName: service.registeredName,
@@ -730,6 +792,11 @@ export const generateServiceArtifacts = () => {
     const routerPluginServices = routerPlugins.map((service) => resolveManifestService(service, 'Router.plugins'));
     const commandServiceStubs = createCommandServiceStubDeclarations(rootServices);
 
+    writeIfChanged(
+        path.join(app.paths.client.generated, 'server-index.d.ts'),
+        createClientServerIndexDeclaration(rootServices),
+    );
+
     writeIfChanged(
         path.join(app.paths.client.generated, 'services.d.ts'),
         `declare type ${appClassIdentifier} = import("@/server/index").default;
@@ -737,18 +804,9 @@ export const generateServiceArtifacts = () => {
 declare module "@app" {
 
     import { ${appClassIdentifier} as ${appClassIdentifier}Client } from "@/client";
-    import ${appClassIdentifier}Server from "@/server/index";
   
     export const Router: ${appClassIdentifier}Client['Router'];
 
-    ${rootServices
-        .map((service) =>
-            service.registeredName !== 'Router'
-                ? `export const ${service.registeredName}: ${appClassIdentifier}Server["${service.registeredName}"];`
-                : '',
-        )
-        .join('\n')}
-
 }
     
 declare module '@models/types' {
@@ -894,26 +952,6 @@ declare module "@app" {
     export = ServerServices
 }
 
-declare module '@server/app' {
-
-    import { Application } from "@server/app";
-    import { Environment } from "@server/app";
-    import { ServicesContainer } from "@server/app/service/container";
-
-    abstract class ApplicationWithServices extends Application<
-        ServicesContainer<InstalledServices>
-    > {}
-
-    export interface Exported {
-        Application: typeof ApplicationWithServices,
-        Environment: Environment,
-    }
-
-    const foo: Exported;
-
-    export = foo;
-}
-
 declare module '@common/errors' {
         
     export * from '@common/errors/index';

package/cli/scaffold/templates.ts

@@ -191,6 +191,7 @@ export const createClientTsconfigTemplate = (paths: TTsconfigTemplatePaths) => `
             "@server/*": [${JSON.stringify(paths.frameworkServer)}],
 
             "@/client/context": ["./.proteum/client/context.ts"],
+            "@/server/index": ["./.proteum/client/server-index.d.ts"],
             "@generated/client/*": ["./.proteum/client/*"],
             "@generated/common/*": ["./.proteum/common/*"],
             "@generated/server/*": ["./.proteum/server/*"],
@@ -207,8 +208,7 @@ export const createClientTsconfigTemplate = (paths: TTsconfigTemplatePaths) => `
         ".",
         "../var/typings",
         ${JSON.stringify(paths.frameworkTypesGlobal)},
-        "../.proteum/client/services.d.ts",
-        "../server/index.ts"
+        "../.proteum/client/services.d.ts"
     ]
 }
 `;
@@ -228,7 +228,6 @@ export const createServerTsconfigTemplate = (paths: TTsconfigTemplatePaths) => `
             "@common/*": [${JSON.stringify(paths.frameworkCommon)}],
             "@server/*": [${JSON.stringify(paths.frameworkServer)}],
 
-            "@/client/context": ["./.proteum/client/context.ts"],
             "@generated/client/*": ["./.proteum/client/*"],
             "@generated/common/*": ["./.proteum/common/*"],
             "@generated/server/*": ["./.proteum/server/*"],

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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.2.7",
+	"version": "2.2.8",
 	"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;
     }