proteum 2.1.0 → 2.1.2

package/server/app/container/trace/index.ts

@@ -0,0 +1,364 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+import type ApplicationContainer from '..';
+import {
+    traceCaptureModes,
+    type TTraceCaptureMode,
+    type TTraceCall,
+    type TTraceCallOrigin,
+    type TTraceEvent,
+    type TTraceEventType,
+    type TTraceSummaryValue,
+    type TRequestTrace,
+    type TRequestTraceListItem,
+} from '@common/dev/requestTrace';
+
+export type Config = {
+    enable: boolean;
+    requestsLimit: number;
+    eventsLimit: number;
+    capture: TTraceCaptureMode;
+    persistOnError: boolean;
+};
+
+type TTraceInspectable = object | PrimitiveValue | bigint | symbol | null | undefined | (() => void);
+type TTraceDetails = { [key: string]: TTraceInspectable };
+
+const capturePriority: Record<TTraceCaptureMode, number> = { summary: 0, resolve: 1, deep: 2 };
+const sensitiveKeyPattern =
+    /(^|\.)(authorization|cookie|set-cookie|password|pass|pwd|secret|token|refreshToken|accessToken|apiKey|apiSecret|secretAccessKey|accessKeyId|privateKey|session|jwt|rawBody)$/i;
+const maxStringLength = 240;
+
+const isTraceCaptureMode = (value: string): value is TTraceCaptureMode =>
+    traceCaptureModes.includes(value as TTraceCaptureMode);
+
+const isSensitiveKeyPath = (keyPath: string[]) => sensitiveKeyPattern.test(keyPath.join('.'));
+
+const summarizeString = (value: string) =>
+    value.length <= maxStringLength ? value : `${value.slice(0, maxStringLength)}…`;
+
+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: TTraceInspectable,
+    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 TTraceInspectable, 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, TTraceInspectable>;
+        entries[key] = summarizeValue(record[key], depth - 1, seen, [...keyPath, key]);
+    }
+
+    return { kind: 'object', constructorName, keys, entries, truncated: keys.length > Object.keys(entries).length };
+};
+
+const summarizeDetails = (details: TTraceDetails, capture: TTraceCaptureMode) => {
+    const depth = capture === 'deep' ? 3 : 1;
+    const summarized: { [key: string]: TTraceSummaryValue } = {};
+
+    for (const key of Object.keys(details)) {
+        summarized[key] = summarizeValue(details[key], depth, new WeakSet<object>(), [key]);
+    }
+
+    return summarized;
+};
+
+const summarizeCaptureValue = (value: TTraceInspectable, capture: TTraceCaptureMode, key: string) =>
+    summarizeValue(value, capture === 'deep' ? 3 : 1, new WeakSet<object>(), [key]);
+
+const nowIso = () => new Date().toISOString();
+
+export default class Trace {
+    private requests = new Map<string, TRequestTrace>();
+    private order: string[] = [];
+    private armedCapture?: TTraceCaptureMode;
+
+    public constructor(
+        private container: typeof ApplicationContainer,
+        private config: Config,
+    ) {}
+
+    public isEnabled() {
+        return __DEV__ && this.config.enable && this.container.Environment.profile === 'dev';
+    }
+
+    public armNextRequest(capture: string) {
+        if (!isTraceCaptureMode(capture)) {
+            throw new Error(`Unsupported trace capture mode "${capture}". Expected one of: ${traceCaptureModes.join(', ')}.`);
+        }
+
+        this.armedCapture = capture;
+        return capture;
+    }
+
+    public startRequest(input: {
+        id: string;
+        method: string;
+        path: string;
+        url: string;
+        headers: object;
+        data: object;
+        profilerSessionId?: string;
+        profilerOrigin?: string;
+        profilerParentRequestId?: string;
+    }) {
+        if (!this.isEnabled()) return;
+
+        const capture = this.armedCapture ?? this.config.capture;
+        this.armedCapture = undefined;
+
+        const trace: TRequestTrace = {
+            id: input.id,
+            method: input.method,
+            path: input.path,
+            url: input.url,
+            capture,
+            profilerSessionId: input.profilerSessionId,
+            profilerOrigin: input.profilerOrigin,
+            profilerParentRequestId: input.profilerParentRequestId,
+            startedAt: nowIso(),
+            droppedEvents: 0,
+            calls: [],
+            events: [],
+        };
+
+        this.requests.set(trace.id, trace);
+        this.order.push(trace.id);
+        this.trimRequestBuffer();
+
+        this.record(trace.id, 'request.start', { method: input.method, path: input.path, url: input.url, headers: input.headers, data: input.data });
+    }
+
+    public setRequestUser(requestId: string, user?: string) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return;
+
+        trace.user = user;
+        if (user) this.record(requestId, 'request.user', { user });
+    }
+
+    public getCapture(requestId: string) {
+        return this.requests.get(requestId)?.capture;
+    }
+
+    public shouldCapture(requestId: string, minimumCapture: TTraceCaptureMode) {
+        const capture = this.getCapture(requestId);
+        if (!capture) return false;
+
+        return capturePriority[capture] >= capturePriority[minimumCapture];
+    }
+
+    public record(requestId: string, type: TTraceEventType, details: TTraceDetails, minimumCapture: TTraceCaptureMode = 'summary') {
+        const trace = this.requests.get(requestId);
+        if (!trace || !this.shouldCapture(requestId, minimumCapture)) return;
+
+        if (trace.events.length >= this.config.eventsLimit) {
+            trace.droppedEvents++;
+            return;
+        }
+
+        const event: TTraceEvent = {
+            index: trace.events.length,
+            at: nowIso(),
+            elapsedMs: Math.max(0, Date.now() - Date.parse(trace.startedAt)),
+            type,
+            details: summarizeDetails(details, trace.capture),
+        };
+
+        trace.events.push(event);
+    }
+
+    public finishRequest(requestId: string, output: { statusCode: number; user?: string; errorMessage?: string }) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return;
+
+        if (output.user) trace.user = output.user;
+        trace.statusCode = output.statusCode;
+        trace.errorMessage = output.errorMessage;
+
+        this.record(
+            requestId,
+            'request.finish',
+            { statusCode: output.statusCode, user: output.user || '', errorMessage: output.errorMessage || '' },
+            'summary',
+        );
+
+        trace.finishedAt = nowIso();
+        trace.durationMs = Math.max(0, Date.parse(trace.finishedAt) - Date.parse(trace.startedAt));
+
+        if (this.config.persistOnError && trace.statusCode >= 500) {
+            trace.persistedFilepath = this.exportRequest(requestId);
+        }
+    }
+
+    public startCall(
+        requestId: string,
+        input: {
+            origin: TTraceCallOrigin;
+            label: string;
+            method?: string;
+            path?: string;
+            fetcherId?: string;
+            parentId?: string;
+            requestDataKeys?: string[];
+            requestData?: TTraceInspectable;
+        },
+    ) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return undefined;
+
+        const call: TTraceCall = {
+            id: `${requestId}:call:${trace.calls.length}`,
+            parentId: input.parentId,
+            origin: input.origin,
+            label: input.label,
+            method: input.method || '',
+            path: input.path || '',
+            fetcherId: input.fetcherId,
+            startedAt: nowIso(),
+            requestDataKeys: input.requestDataKeys || [],
+            requestData: input.requestData !== undefined ? summarizeCaptureValue(input.requestData, trace.capture, 'requestData') : undefined,
+            resultKeys: [],
+        };
+
+        trace.calls.push(call);
+        return call.id;
+    }
+
+    public finishCall(
+        requestId: string,
+        callId: string | undefined,
+        output: {
+            statusCode?: number;
+            errorMessage?: string;
+            resultKeys?: string[];
+            result?: TTraceInspectable;
+        } = {},
+    ) {
+        if (!callId) return;
+
+        const trace = this.requests.get(requestId);
+        const call = trace?.calls.find((candidate) => candidate.id === callId);
+        if (!trace || !call) return;
+
+        call.finishedAt = nowIso();
+        call.durationMs = Math.max(0, Date.parse(call.finishedAt) - Date.parse(call.startedAt));
+        call.statusCode = output.statusCode;
+        call.errorMessage = output.errorMessage;
+        call.resultKeys = output.resultKeys || [];
+        call.result = output.result !== undefined ? summarizeCaptureValue(output.result, trace.capture, 'result') : undefined;
+    }
+
+    public listRequests(limit = 20): TRequestTraceListItem[] {
+        return [...this.order]
+            .reverse()
+            .slice(0, limit)
+            .map((requestId) => this.requests.get(requestId))
+            .filter((trace): trace is TRequestTrace => trace !== undefined)
+            .map((trace) => ({
+                id: trace.id,
+                method: trace.method,
+                path: trace.path,
+                url: trace.url,
+                capture: trace.capture,
+                startedAt: trace.startedAt,
+                finishedAt: trace.finishedAt,
+                durationMs: trace.durationMs,
+                statusCode: trace.statusCode,
+                user: trace.user,
+                droppedEvents: trace.droppedEvents,
+                persistedFilepath: trace.persistedFilepath,
+                errorMessage: trace.errorMessage,
+                profilerSessionId: trace.profilerSessionId,
+                profilerOrigin: trace.profilerOrigin,
+                profilerParentRequestId: trace.profilerParentRequestId,
+                eventCount: trace.events.length,
+                callCount: trace.calls.length,
+            }));
+    }
+
+    public getLatestRequest() {
+        const latestRequestId = this.order[this.order.length - 1];
+        return latestRequestId ? this.requests.get(latestRequestId) : undefined;
+    }
+
+    public getRequest(requestId: string) {
+        return this.requests.get(requestId);
+    }
+
+    public exportRequest(requestId: string, filepath?: string) {
+        const trace = this.requests.get(requestId);
+        if (!trace) throw new Error(`Trace ${requestId} was not found.`);
+
+        const outputFilepath =
+            filepath ||
+            path.join(this.container.path.var, 'traces', trace.startedAt.slice(0, 10), `${trace.id}.json`);
+
+        fs.ensureDirSync(path.dirname(outputFilepath));
+        fs.writeJSONSync(outputFilepath, trace, { spaces: 2 });
+
+        trace.persistedFilepath = outputFilepath;
+
+        return outputFilepath;
+    }
+
+    private trimRequestBuffer() {
+        const overflow = this.order.length - this.config.requestsLimit;
+        if (overflow <= 0) return;
+
+        for (const requestId of this.order.splice(0, overflow)) {
+            this.requests.delete(requestId);
+        }
+    }
+}

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

@@ -2,10 +2,14 @@
 - DEPENDANCES
 ----------------------------------*/
 
+process.env.DOTENV_CONFIG_QUIET ??= 'true';
+
 // 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 +33,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 +124,31 @@ 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() {
-        console.log('Build date', BUILD_DATE);
-        console.log('Core version', CORE_VERSION);
+    public async start(options: TApplicationStartOptions = {}) {
         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')