proteum 2.1.2 → 2.1.6

package/client/dev/profiler/runtime.noop.ts

@@ -7,6 +7,7 @@ import type {
 } from '@common/dev/profiler';
 import type { TDevCommandDefinition, TDevCommandExecution } from '@common/dev/commands';
 import type { TDoctorResponse } from '@common/dev/diagnostics';
+import type { TDiagnoseResponse } from '@common/dev/inspection';
 import type { TProteumManifest } from '@common/dev/proteumManifest';
 
 type TProfilerState = {
@@ -25,7 +26,14 @@ type TProfilerState = {
         status: 'idle' | 'loading' | 'ready' | 'error';
         tasks: TProfilerCronTask[];
     };
+    diagnose: {
+        errorMessage?: string;
+        lastLoadedAt?: string;
+        response?: TDiagnoseResponse;
+        status: 'idle' | 'loading' | 'ready' | 'error';
+    };
     doctor: {
+        contracts?: TDoctorResponse;
         errorMessage?: string;
         lastLoadedAt?: string;
         response?: TDoctorResponse;
@@ -55,6 +63,9 @@ const noopState: TProfilerState = {
         status: 'idle',
         tasks: [],
     },
+    diagnose: {
+        status: 'idle',
+    },
     doctor: {
         status: 'idle',
     },
@@ -75,6 +86,7 @@ export const profilerRuntime = {
     runCommand: async (_path: string) => undefined,
     refreshCronTasks: async () => undefined,
     runCronTask: async (_name: string) => undefined,
+    refreshDiagnose: async (_sessionId?: string) => undefined,
     refreshDoctor: async () => undefined,
     refreshExplain: async () => undefined,
     ensureInitialSession: (_input: { path: string; requestId?: string; url: string }) => undefined,

package/client/dev/profiler/runtime.ts

@@ -1,3 +1,9 @@
+import {
+    type TPerfCompareResponse,
+    type TPerfGroupBy,
+    type TPerfMemoryResponse,
+    type TPerfTopResponse,
+} from '@common/dev/performance';
 import {
     profilerOriginHeader,
     profilerParentRequestIdHeader,
@@ -13,6 +19,7 @@ import {
 } from '@common/dev/profiler';
 import type { TDevCommandDefinition, TDevCommandExecution } from '@common/dev/commands';
 import type { TDoctorResponse } from '@common/dev/diagnostics';
+import type { TDiagnoseResponse } from '@common/dev/inspection';
 import type { TProteumManifest } from '@common/dev/proteumManifest';
 import type { TRequestTrace } from '@common/dev/requestTrace';
 
@@ -33,12 +40,20 @@ type TProfilerCronState = {
 };
 
 type TProfilerDoctorState = {
+    contracts?: TDoctorResponse;
     errorMessage?: string;
     lastLoadedAt?: string;
     response?: TDoctorResponse;
     status: 'idle' | 'loading' | 'ready' | 'error';
 };
 
+type TProfilerDiagnoseState = {
+    errorMessage?: string;
+    lastLoadedAt?: string;
+    response?: TDiagnoseResponse;
+    status: 'idle' | 'loading' | 'ready' | 'error';
+};
+
 type TProfilerExplainState = {
     errorMessage?: string;
     lastLoadedAt?: string;
@@ -46,12 +61,27 @@ type TProfilerExplainState = {
     status: 'idle' | 'loading' | 'ready' | 'error';
 };
 
+type TProfilerPerfState = {
+    baseline: string;
+    compare?: TPerfCompareResponse;
+    errorMessage?: string;
+    groupBy: TPerfGroupBy;
+    lastLoadedAt?: string;
+    memory?: TPerfMemoryResponse;
+    since: string;
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    target: string;
+    top?: TPerfTopResponse;
+};
+
 type TProfilerState = {
     activePanel: TProfilerPanel;
     commands: TProfilerCommandsState;
     cron: TProfilerCronState;
+    diagnose: TProfilerDiagnoseState;
     doctor: TProfilerDoctorState;
     explain: TProfilerExplainState;
+    perf: TProfilerPerfState;
     currentSessionId?: string;
     selectedSessionId?: string;
     sessions: TProfilerNavigationSession[];
@@ -124,12 +154,23 @@ const cloneCronState = (cron: TProfilerCronState) => ({
 });
 const cloneDoctorState = (doctor: TProfilerDoctorState) => ({
     ...doctor,
+    contracts: doctor.contracts ? cloneDoctorResponse(doctor.contracts) : undefined,
     response: doctor.response ? cloneDoctorResponse(doctor.response) : undefined,
 });
+const cloneDiagnoseState = (diagnose: TProfilerDiagnoseState) => ({
+    ...diagnose,
+    response: diagnose.response ? (JSON.parse(JSON.stringify(diagnose.response)) as TDiagnoseResponse) : undefined,
+});
 const cloneExplainState = (explain: TProfilerExplainState) => ({
     ...explain,
     manifest: explain.manifest ? cloneManifest(explain.manifest) : undefined,
 });
+const clonePerfState = (perf: TProfilerPerfState) => ({
+    ...perf,
+    compare: perf.compare ? (JSON.parse(JSON.stringify(perf.compare)) as TPerfCompareResponse) : undefined,
+    memory: perf.memory ? (JSON.parse(JSON.stringify(perf.memory)) as TPerfMemoryResponse) : undefined,
+    top: perf.top ? (JSON.parse(JSON.stringify(perf.top)) as TPerfTopResponse) : undefined,
+});
 const cloneCommandsState = (commands: TProfilerCommandsState) => ({
     ...commands,
     commands: commands.commands.map(cloneCommand),
@@ -156,12 +197,22 @@ class ProfilerRuntime {
             status: 'idle',
             tasks: [],
         },
+        diagnose: {
+            status: 'idle',
+        },
         doctor: {
             status: 'idle',
         },
         explain: {
             status: 'idle',
         },
+        perf: {
+            baseline: 'yesterday',
+            groupBy: 'path',
+            since: 'today',
+            status: 'idle',
+            target: 'today',
+        },
         sessions: [],
         uiState: initialUiState(),
     };
@@ -183,8 +234,10 @@ class ProfilerRuntime {
         this.state = { ...this.state, activePanel: panel, uiState: 'expanded' };
         safeSessionStorage.set(profilerStorageKey, 'expanded');
         this.emit();
+        if (panel === 'perf') void this.refreshPerf();
         if (panel === 'commands') void this.refreshCommands();
         if (panel === 'cron') void this.refreshCronTasks();
+        if (panel === 'diagnose') void this.refreshDiagnose();
         if (panel === 'doctor') void this.refreshDoctor();
         if (panel === 'doctor' || panel === 'explain') void this.refreshExplain();
     }
@@ -240,6 +293,89 @@ class ProfilerRuntime {
         }
     }
 
+    public setPerfFilters(filters: Partial<Pick<TProfilerPerfState, 'baseline' | 'groupBy' | 'since' | 'target'>>) {
+        this.state = {
+            ...this.state,
+            perf: {
+                ...this.state.perf,
+                ...filters,
+            },
+        };
+        this.emit();
+    }
+
+    public async refreshPerf(overrides: Partial<Pick<TProfilerPerfState, 'baseline' | 'groupBy' | 'since' | 'target'>> = {}) {
+        const nextPerf = {
+            ...this.state.perf,
+            ...overrides,
+        };
+        const topParams = new URLSearchParams({
+            groupBy: nextPerf.groupBy,
+            limit: '8',
+            since: nextPerf.since,
+        });
+        const compareParams = new URLSearchParams({
+            baseline: nextPerf.baseline,
+            groupBy: nextPerf.groupBy,
+            limit: '8',
+            target: nextPerf.target,
+        });
+        const memoryParams = new URLSearchParams({
+            groupBy: nextPerf.groupBy,
+            limit: '8',
+            since: nextPerf.since,
+        });
+
+        this.state = {
+            ...this.state,
+            perf: {
+                ...nextPerf,
+                errorMessage: undefined,
+                status: 'loading',
+            },
+        };
+        this.emit();
+
+        try {
+            const [topResponse, compareResponse, memoryResponse] = await Promise.all([
+                fetch(`/__proteum/perf/top?${topParams.toString()}`, { cache: 'no-store' }),
+                fetch(`/__proteum/perf/compare?${compareParams.toString()}`, { cache: 'no-store' }),
+                fetch(`/__proteum/perf/memory?${memoryParams.toString()}`, { cache: 'no-store' }),
+            ]);
+            const topBody = (await topResponse.json()) as TPerfTopResponse & { error?: string };
+            const compareBody = (await compareResponse.json()) as TPerfCompareResponse & { error?: string };
+            const memoryBody = (await memoryResponse.json()) as TPerfMemoryResponse & { error?: string };
+
+            if (!topResponse.ok) throw new Error(topBody.error || 'Failed to load perf top data.');
+            if (!compareResponse.ok) throw new Error(compareBody.error || 'Failed to load perf compare data.');
+            if (!memoryResponse.ok) throw new Error(memoryBody.error || 'Failed to load perf memory data.');
+
+            this.state = {
+                ...this.state,
+                perf: {
+                    ...nextPerf,
+                    compare: JSON.parse(JSON.stringify(compareBody)) as TPerfCompareResponse,
+                    errorMessage: undefined,
+                    lastLoadedAt: nowIso(),
+                    memory: JSON.parse(JSON.stringify(memoryBody)) as TPerfMemoryResponse,
+                    status: 'ready',
+                    top: JSON.parse(JSON.stringify(topBody)) as TPerfTopResponse,
+                },
+            };
+            this.emit();
+        } catch (error) {
+            this.state = {
+                ...this.state,
+                perf: {
+                    ...nextPerf,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    status: 'error',
+                },
+            };
+            this.emit();
+        }
+    }
+
     public async runCommand(commandPath: string) {
         this.state = {
             ...this.state,
@@ -353,16 +489,20 @@ class ProfilerRuntime {
         this.emit();
 
         try {
-            const response = await fetch('/__proteum/doctor', { cache: 'no-store' });
+            const [response, contractsResponse] = await Promise.all([
+                fetch('/__proteum/doctor', { cache: 'no-store' }),
+                fetch('/__proteum/doctor/contracts', { cache: 'no-store' }),
+            ]);
             const body = (await response.json()) as TDoctorResponse & { error?: string };
+            const contractsBody = (await contractsResponse.json()) as TDoctorResponse & { error?: string };
 
-            if (!response.ok) {
-                throw new Error(body.error || 'Failed to load doctor diagnostics.');
-            }
+            if (!response.ok) throw new Error(body.error || 'Failed to load doctor diagnostics.');
+            if (!contractsResponse.ok) throw new Error(contractsBody.error || 'Failed to load doctor contract diagnostics.');
 
             this.state = {
                 ...this.state,
                 doctor: {
+                    contracts: cloneDoctorResponse(contractsBody),
                     errorMessage: undefined,
                     lastLoadedAt: nowIso(),
                     response: cloneDoctorResponse(body),
@@ -383,6 +523,55 @@ class ProfilerRuntime {
         }
     }
 
+    public async refreshDiagnose(sessionId?: string) {
+        const session = this.getSession(sessionId || this.state.selectedSessionId || this.state.currentSessionId);
+        const params = new URLSearchParams();
+        if (session?.requestId) params.set('requestId', session.requestId);
+        else if (session?.path) params.set('query', session.path);
+
+        this.state = {
+            ...this.state,
+            diagnose: {
+                ...this.state.diagnose,
+                errorMessage: undefined,
+                status: 'loading',
+            },
+        };
+        this.emit();
+
+        try {
+            const response = await fetch(`/__proteum/diagnose${params.size > 0 ? `?${params.toString()}` : ''}`, {
+                cache: 'no-store',
+            });
+            const body = (await response.json()) as TDiagnoseResponse & { error?: string };
+
+            if (!response.ok) {
+                throw new Error(body.error || 'Failed to load diagnose data.');
+            }
+
+            this.state = {
+                ...this.state,
+                diagnose: {
+                    errorMessage: undefined,
+                    lastLoadedAt: nowIso(),
+                    response: JSON.parse(JSON.stringify(body)) as TDiagnoseResponse,
+                    status: 'ready',
+                },
+            };
+            this.emit();
+        } catch (error) {
+            this.state = {
+                ...this.state,
+                diagnose: {
+                    ...this.state.diagnose,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    status: 'error',
+                },
+            };
+            this.emit();
+        }
+    }
+
     public async refreshExplain() {
         this.state = {
             ...this.state,
@@ -784,8 +973,10 @@ class ProfilerRuntime {
             ...this.state,
             commands: cloneCommandsState(this.state.commands),
             cron: cloneCronState(this.state.cron),
+            diagnose: cloneDiagnoseState(this.state.diagnose),
             doctor: cloneDoctorState(this.state.doctor),
             explain: cloneExplainState(this.state.explain),
+            perf: clonePerfState(this.state.perf),
             sessions: this.state.sessions.map((candidate) => (candidate.id === session.id ? cloneSession(session) : candidate)),
         };
         this.emit();

package/client/services/router/request/api.ts

@@ -4,6 +4,7 @@
 
 // Core
 import type ClientApplication from '@client/app';
+import { buildConnectedProjectProxyPath } from '@common/connectedProjects';
 import { fromJson as errorFromJson, NetworkError } from '@common/errors';
 import ApiClientService, {
     TPostData,
@@ -270,7 +271,11 @@ export default class ApiClient implements ApiClientService {
     }
 
     public configure = (...[method, path, data, options = {}]: TFetcherArgs) => {
-        let url = this.router.url(path, {}, false);
+        const requestPath =
+            options.connected !== undefined
+                ? buildConnectedProjectProxyPath(options.connected.namespace, path)
+                : path;
+        let url = this.router.url(requestPath, {}, false);
 
         debug && console.log(`[api] Sending request`, method, url, data);
 

package/common/applicationConfig.ts

@@ -0,0 +1,173 @@
+import { normalizeConnectedProjectsConfig, type TConnectedProjectsConfig } from './connectedProjects';
+
+type TObjectRecord = Record<string, unknown>;
+
+export type TApplicationIdentityConfig = {
+    name: string;
+    identifier: string;
+    description: string;
+    author: {
+        name: string;
+        url: string;
+        email: string;
+    };
+    social?: TObjectRecord;
+    locale?: string;
+    language: string;
+    maincolor: string;
+    iconsPack?: string;
+    web: {
+        title: string;
+        titleSuffix: string;
+        fullTitle: string;
+        description: string;
+        version: string;
+        metas?: Record<string, string>;
+        jsonld?: Record<string, string>;
+    };
+};
+
+export type TApplicationSetupConfig = {
+    transpile?: string[];
+    connect?: TConnectedProjectsConfig;
+};
+
+const isRecord = (value: unknown): value is TObjectRecord =>
+    value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const readRequiredString = ({
+    filepath,
+    path,
+    value,
+}: {
+    filepath: string;
+    path: string;
+    value: unknown;
+}) => {
+    if (typeof value === 'string' && value.trim()) return value;
+
+    throw new Error(`Invalid ${path} in ${filepath}. Expected a non-empty string.`);
+};
+
+const readOptionalString = ({
+    filepath,
+    path,
+    value,
+}: {
+    filepath: string;
+    path: string;
+    value: unknown;
+}) => {
+    if (value === undefined) return undefined;
+
+    return readRequiredString({ filepath, path, value });
+};
+
+const readStringRecord = ({
+    filepath,
+    path,
+    value,
+}: {
+    filepath: string;
+    path: string;
+    value: unknown;
+}) => {
+    if (value === undefined) return undefined;
+    if (!isRecord(value)) throw new Error(`Invalid ${path} in ${filepath}. Expected an object of string values.`);
+
+    const output: Record<string, string> = {};
+
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string')
+            throw new Error(`Invalid ${path}.${key} in ${filepath}. Expected a string value.`);
+
+        output[key] = entry;
+    }
+
+    return output;
+};
+
+const readSocialConfig = ({
+    filepath,
+    value,
+}: {
+    filepath: string;
+    value: unknown;
+}) => {
+    if (value === undefined) return undefined;
+    if (!isRecord(value)) throw new Error(`Invalid social in ${filepath}. Expected an object.`);
+
+    return value;
+};
+
+export const normalizeTranspileConfig = (value: unknown): string[] => {
+    if (!Array.isArray(value)) return [];
+
+    return Array.from(new Set(value.map((entry) => (typeof entry === 'string' ? entry.trim() : '')).filter(Boolean)));
+};
+
+export const normalizeApplicationIdentityConfig = (
+    value: unknown,
+    filepath = 'identity.config.ts',
+): TApplicationIdentityConfig => {
+    if (!isRecord(value)) throw new Error(`Invalid identity config in ${filepath}. Expected an object export.`);
+
+    const author = value.author;
+    const web = value.web;
+
+    if (!isRecord(author)) throw new Error(`Invalid author in ${filepath}. Expected an object.`);
+    if (!isRecord(web)) throw new Error(`Invalid web in ${filepath}. Expected an object.`);
+
+    return {
+        name: readRequiredString({ filepath, path: 'name', value: value.name }),
+        identifier: readRequiredString({ filepath, path: 'identifier', value: value.identifier }),
+        description: readRequiredString({ filepath, path: 'description', value: value.description }),
+        author: {
+            name: readRequiredString({ filepath, path: 'author.name', value: author.name }),
+            url: readRequiredString({ filepath, path: 'author.url', value: author.url }),
+            email: readRequiredString({ filepath, path: 'author.email', value: author.email }),
+        },
+        social: readSocialConfig({ filepath, value: value.social }),
+        locale: readOptionalString({ filepath, path: 'locale', value: value.locale }),
+        language: readRequiredString({ filepath, path: 'language', value: value.language }),
+        maincolor: readRequiredString({ filepath, path: 'maincolor', value: value.maincolor }),
+        iconsPack: readOptionalString({ filepath, path: 'iconsPack', value: value.iconsPack }),
+        web: {
+            title: readRequiredString({ filepath, path: 'web.title', value: web.title }),
+            titleSuffix: readRequiredString({ filepath, path: 'web.titleSuffix', value: web.titleSuffix }),
+            fullTitle: readRequiredString({ filepath, path: 'web.fullTitle', value: web.fullTitle }),
+            description: readRequiredString({ filepath, path: 'web.description', value: web.description }),
+            version: readRequiredString({ filepath, path: 'web.version', value: web.version }),
+            metas: readStringRecord({ filepath, path: 'web.metas', value: web.metas }),
+            jsonld: readStringRecord({ filepath, path: 'web.jsonld', value: web.jsonld }),
+        },
+    };
+};
+
+export const normalizeApplicationSetupConfig = (
+    value: unknown,
+    filepath = 'proteum.config.ts',
+): TApplicationSetupConfig => {
+    if (value === undefined) return {};
+    if (!isRecord(value)) throw new Error(`Invalid setup config in ${filepath}. Expected an object export.`);
+    if ('transpileModules' in value) {
+        throw new Error(`Invalid setup config in ${filepath}. Use "transpile" instead of "transpileModules".`);
+    }
+
+    return {
+        transpile: normalizeTranspileConfig(value.transpile),
+        connect: normalizeConnectedProjectsConfig(value.connect),
+    };
+};
+
+class ApplicationConfigHelpers {
+    public static identity<const TIdentity extends TApplicationIdentityConfig>(config: TIdentity) {
+        return config;
+    }
+
+    public static setup<const TSetup extends TApplicationSetupConfig>(config: TSetup) {
+        return config;
+    }
+}
+
+export const Application = ApplicationConfigHelpers;

package/common/applicationConfigLoader.ts

@@ -0,0 +1,102 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'module';
+import * as ts from 'typescript';
+
+import {
+    Application as ApplicationConfig,
+    normalizeApplicationIdentityConfig,
+    normalizeApplicationSetupConfig,
+    type TApplicationIdentityConfig,
+    type TApplicationSetupConfig,
+} from './applicationConfig';
+import { loadOptionalProteumDotenv } from './env/proteumEnv';
+
+const moduleCache = new Map<string, unknown>();
+const supportedModuleExtensions = ['.ts', '.tsx', '.js', '.cjs', '.mjs', '.json'];
+
+const resolveLocalModulePath = (specifier: string, fromFilepath: string) => {
+    const basePath = path.resolve(path.dirname(fromFilepath), specifier);
+    const candidates = [
+        basePath,
+        ...supportedModuleExtensions.map((extension) => `${basePath}${extension}`),
+        ...supportedModuleExtensions.map((extension) => path.join(basePath, `index${extension}`)),
+    ];
+
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+    }
+
+    throw new Error(`Unable to resolve module "${specifier}" from ${fromFilepath}.`);
+};
+
+const loadTsModule = (filepath: string): unknown => {
+    const normalizedFilepath = path.resolve(filepath);
+    if (moduleCache.has(normalizedFilepath)) return moduleCache.get(normalizedFilepath);
+
+    const source = fs.readFileSync(normalizedFilepath, 'utf8');
+    const transpiled = ts.transpileModule(source, {
+        fileName: normalizedFilepath,
+        compilerOptions: {
+            module: ts.ModuleKind.CommonJS,
+            target: ts.ScriptTarget.ES2020,
+            esModuleInterop: true,
+            resolveJsonModule: true,
+            jsx: ts.JsxEmit.ReactJSX,
+        },
+    }).outputText;
+
+    const module = { exports: {} as Record<string, unknown> };
+    moduleCache.set(normalizedFilepath, module.exports);
+
+    const requireFromFile = createRequire(normalizedFilepath);
+    const runtimeRequire = (specifier: string) => {
+        if (specifier === 'proteum/config' || specifier === 'proteum/config.ts') return { Application: ApplicationConfig };
+
+        if (specifier.startsWith('.') || specifier.startsWith('/')) {
+            const resolved = resolveLocalModulePath(specifier, normalizedFilepath);
+
+            if (resolved.endsWith('.ts') || resolved.endsWith('.tsx')) return loadTsModule(resolved);
+
+            return requireFromFile(resolved);
+        }
+
+        return requireFromFile(specifier);
+    };
+
+    const evaluate = new Function('require', 'module', 'exports', '__filename', '__dirname', transpiled);
+    evaluate(runtimeRequire, module, module.exports, normalizedFilepath, path.dirname(normalizedFilepath));
+
+    moduleCache.set(normalizedFilepath, module.exports);
+
+    return module.exports;
+};
+
+const getDefaultExport = <T>(value: unknown): T => {
+    if (value && typeof value === 'object' && 'default' in (value as Record<string, unknown>))
+        return (value as { default: T }).default;
+
+    return value as T;
+};
+
+export const identityConfigFilename = 'identity.config.ts';
+export const setupConfigFilename = 'proteum.config.ts';
+
+export const resolveIdentityConfigFilepath = (appDir: string) => path.join(appDir, identityConfigFilename);
+export const resolveSetupConfigFilepath = (appDir: string) => path.join(appDir, setupConfigFilename);
+
+export const loadApplicationIdentityConfig = (appDir: string): TApplicationIdentityConfig => {
+    const filepath = resolveIdentityConfigFilepath(appDir);
+    if (!fs.existsSync(filepath)) throw new Error(`Missing ${identityConfigFilename} in ${appDir}.`);
+    loadOptionalProteumDotenv(appDir);
+
+    return normalizeApplicationIdentityConfig(getDefaultExport(loadTsModule(filepath)), filepath);
+};
+
+export const loadApplicationSetupConfig = (appDir: string): TApplicationSetupConfig => {
+    const filepath = resolveSetupConfigFilepath(appDir);
+    if (!fs.existsSync(filepath)) throw new Error(`Missing ${setupConfigFilename} in ${appDir}.`);
+    loadOptionalProteumDotenv(appDir);
+
+    return normalizeApplicationSetupConfig(getDefaultExport(loadTsModule(filepath)), filepath);
+};