proteum 2.1.7 → 2.1.9

package/cli/compiler/artifacts/commands.ts

@@ -22,8 +22,15 @@ const readServerTsconfigPaths = () => {
     return compilerOptions.paths || {};
 };
 
-const createCommandsTsconfigContent = () =>
-    `${JSON.stringify(
+const getCommandsTsconfigFilepath = () => path.join(app.paths.root, 'commands', 'tsconfig.json');
+
+const getCommandsGlobalTypesPath = (commandsTsconfigFilepath: string) =>
+    cli.paths.relativeFrameworkPathFrom(commandsTsconfigFilepath, 'types', 'global');
+
+const createCommandsTsconfigContent = () => {
+    const commandsTsconfigFilepath = getCommandsTsconfigFilepath();
+
+    return `${JSON.stringify(
         {
             extends: '../server/tsconfig.json',
             compilerOptions: {
@@ -35,12 +42,13 @@ const createCommandsTsconfigContent = () =>
                     '@models/types': ['./.proteum/server/models.ts'],
                 },
             },
-            include: ['.', '../var/typings', '../node_modules/proteum/types/global', '../.proteum/server/commands.d.ts'],
+            include: ['.', '../var/typings', getCommandsGlobalTypesPath(commandsTsconfigFilepath), '../.proteum/server/commands.d.ts'],
         },
         null,
         4,
     )}
 `;
+};
 
 const legacyCommandsTsconfigContent = `{
     "extends": "../server/tsconfig.json",
@@ -105,8 +113,15 @@ const isManagedCommandsTsconfig = (content: string) => {
         };
 
         if (parsed.extends !== '../server/tsconfig.json') return false;
-        if (JSON.stringify(parsed.include || []) !== JSON.stringify(['.', '../var/typings', '../node_modules/proteum/types/global', '../.proteum/server/commands.d.ts']))
+        if (!Array.isArray(parsed.include) || parsed.include.length !== 4) return false;
+        if (parsed.include[0] !== '.' || parsed.include[1] !== '../var/typings') return false;
+        if (parsed.include[3] !== '../.proteum/server/commands.d.ts') return false;
+        if (
+            parsed.include[2] !== getCommandsGlobalTypesPath(getCommandsTsconfigFilepath()) &&
+            !parsed.include[2].includes('node_modules/proteum/types/global')
+        ) {
             return false;
+        }
 
         if (parsed.compilerOptions?.baseUrl !== undefined && parsed.compilerOptions.baseUrl !== '..') return false;
         if (parsed.compilerOptions?.rootDir !== undefined && parsed.compilerOptions.rootDir !== '..') return false;
@@ -119,7 +134,7 @@ const isManagedCommandsTsconfig = (content: string) => {
 
 const ensureCommandsTsconfig = () => {
     const commandsRoot = path.join(app.paths.root, 'commands');
-    const commandsTsconfigFilepath = path.join(commandsRoot, 'tsconfig.json');
+    const commandsTsconfigFilepath = getCommandsTsconfigFilepath();
     const nextContent = createCommandsTsconfigContent();
 
     if (!fs.existsSync(commandsRoot)) return;

package/cli/compiler/client/index.ts

@@ -21,17 +21,18 @@ import type { App } from '../../app';
 
 const debug = false;
 const ssrScriptPattern = /\.ssr\.(ts|tsx)$/;
-const normalizedCoreRoot = cli.paths.core.root.replace(/\\/g, '/');
+const normalizedCoreRoot = cli.paths.framework.activeRoot.replace(/\\/g, '/');
 const hmrClientEntry = path.join(cli.paths.core.root, 'client', 'dev', 'hmr.ts');
 
 const normalizeModulePath = (value?: string) => (value || '').replace(/\\/g, '/');
-const resolveFromAppOrCore = (app: App, request: string) =>
-    require.resolve(request, { paths: [app.paths.root, cli.paths.core.root] });
+const resolveFromAppOrCore = (_app: App, request: string) => cli.paths.resolveRequest(request);
 const rewriteFrameworkAliasTargets = (app: App, aliases: Record<string, string | string[]>) => {
-    const installedCoreRoot = normalizeModulePath(path.join(app.paths.root, 'node_modules', 'proteum'));
-    const activeCoreRoot = normalizeModulePath(cli.paths.core.root);
+    const installedCoreRoot = cli.paths.framework.installedRoot
+        ? normalizeModulePath(cli.paths.framework.installedRoot)
+        : undefined;
+    const activeCoreRoot = normalizeModulePath(cli.paths.framework.activeRoot);
 
-    if (installedCoreRoot === activeCoreRoot) return aliases;
+    if (!installedCoreRoot || installedCoreRoot === activeCoreRoot) return aliases;
 
     const rewriteCandidate = (candidate: string) =>
         normalizeModulePath(candidate).startsWith(installedCoreRoot + '/')
@@ -76,8 +77,7 @@ export default function createCompiler(
     logVerbose(`Creating compiler for client (${mode}).`);
     const dev = mode === 'dev';
     const outputPath = app.outputPath(outputTarget);
-    const installedCoreRoot = path.join(app.paths.root, 'node_modules', 'proteum');
-    const frameworkRoots = [cli.paths.core.root, installedCoreRoot];
+    const frameworkRoots = cli.paths.getFrameworkRoots();
     const transpileModuleDirectories = app.transpileModuleDirectories;
 
     const commonConfig = createCommonConfig(app, 'client', mode, outputTarget);
@@ -93,7 +93,7 @@ export default function createCompiler(
         );*/
 
     // Convert tsconfig paths into bundler aliases.
-    const { aliases } = app.aliases.client.forWebpack({ modulesPath: app.paths.root + '/node_modules' });
+    const { aliases } = app.aliases.client.forWebpack({ modulesPath: cli.paths.framework.appNodeModulesRoot });
     const resolvedAliases = rewriteFrameworkAliasTargets(app, aliases);
 
     // We're not supposed in any case to import server libs from client

package/cli/compiler/common/bundleAnalysis.ts

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import type { RspackPluginInstance } from '@rspack/core';
+import { UsageError } from 'clipanion';
 
 import cli from '../..';
 import type { App } from '../../app';
@@ -8,8 +9,56 @@ import type { App } from '../../app';
 const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
 
 export type TBundleAnalysisReportPaths = { reportPath: string; statsPath: string };
+export type TBundleAnalysisMode = 'server' | 'static';
+type TBundleAnalysisServerUrlArgs = {
+    listenHost: string;
+    listenPort: number | 'auto';
+    boundAddress?: string | { address?: string; port?: number } | null;
+};
+
+const defaultAnalyzerHost = '127.0.0.1';
+const defaultAnalyzerPort = 8888;
+let latestClientBundleAnalysisServerUrl: string | undefined;
 
 export const isBundleAnalysisEnabled = () => cli.args.analyze === true;
+export const isBundleAnalysisServerEnabled = () => cli.args.analyzeServe === true;
+export const getBundleAnalysisMode = (): TBundleAnalysisMode => (isBundleAnalysisServerEnabled() ? 'server' : 'static');
+
+const hasCliStringArg = (name: string) => typeof cli.args[name] === 'string' && (cli.args[name] as string).trim().length > 0;
+
+export const hasBundleAnalysisServerOverrides = () => hasCliStringArg('analyzeHost') || hasCliStringArg('analyzePort');
+
+export const getBundleAnalysisServerHost = () =>
+    hasCliStringArg('analyzeHost') ? String(cli.args.analyzeHost).trim() : defaultAnalyzerHost;
+
+export const getBundleAnalysisServerPort = (): number | 'auto' => {
+    const rawPort = hasCliStringArg('analyzePort') ? String(cli.args.analyzePort).trim() : '';
+    if (!rawPort) return defaultAnalyzerPort;
+    if (rawPort === 'auto') return 'auto';
+
+    const parsedPort = Number.parseInt(rawPort, 10);
+    if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
+        throw new UsageError(`Invalid analyzer port "${rawPort}". Use a number between 1 and 65535, or \`auto\`.`);
+    }
+
+    return parsedPort;
+};
+
+const createBundleAnalysisServerUrl = ({ listenHost, listenPort, boundAddress }: TBundleAnalysisServerUrlArgs) => {
+    const port =
+        typeof boundAddress === 'object' && boundAddress !== null && typeof boundAddress.port === 'number'
+            ? boundAddress.port
+            : listenPort;
+    const url = `http://${listenHost}:${port}`;
+    latestClientBundleAnalysisServerUrl = url;
+    return url;
+};
+
+export const consumeClientBundleAnalysisServerUrl = () => {
+    const url = latestClientBundleAnalysisServerUrl;
+    latestClientBundleAnalysisServerUrl = undefined;
+    return url;
+};
 
 export const getClientBundleAnalysisReportPaths = (
     app: App,
@@ -23,19 +72,25 @@ export const getClientBundleAnalysisReportPaths = (
 export const createClientBundleAnalysisPlugins = (app: App, outputTarget: 'dev' | 'bin'): RspackPluginInstance[] => {
     if (!isBundleAnalysisEnabled()) return [];
 
+    latestClientBundleAnalysisServerUrl = undefined;
+
     const { reportPath, statsPath } = getClientBundleAnalysisReportPaths(app, outputTarget);
+    const analyzerMode = getBundleAnalysisMode();
 
     fs.ensureDirSync(path.dirname(reportPath));
 
     return [
         new BundleAnalyzerPlugin({
-            analyzerMode: 'static',
+            analyzerMode,
+            analyzerHost: getBundleAnalysisServerHost(),
+            analyzerPort: getBundleAnalysisServerPort(),
             openAnalyzer: false,
             defaultSizes: 'parsed',
             reportFilename: reportPath,
             generateStatsFile: true,
             statsFilename: statsPath,
             logLevel: 'info',
+            analyzerUrl: createBundleAnalysisServerUrl,
         }),
     ];
 };

package/cli/compiler/common/index.ts

@@ -45,6 +45,11 @@ export default function createCommonConfig(
 ): Configuration {
     const dev = mode === 'dev';
     const enableFilesystemCache = dev ? cli.args.cache !== false : cli.args.cache === true;
+    const loaderModuleRoots = [
+        cli.paths.framework.appNodeModulesRoot,
+        cli.paths.framework.frameworkNodeModulesRoot,
+        path.join(cli.paths.core.cli, 'node_modules'),
+    ].filter((moduleRoot, index, list) => list.indexOf(moduleRoot) === index);
     const config: Configuration = {
         // Project root
         context: app.paths.root,
@@ -55,11 +60,7 @@ export default function createCommonConfig(
             // Support both install modes:
             // - npm i: loaders are often hoisted in app/node_modules
             // - npm link: loaders often live in framework/node_modules
-            modules: [
-                app.paths.root + '/node_modules',
-                cli.paths.core.root + '/node_modules',
-                cli.paths.core.cli + '/node_modules',
-            ],
+            modules: loaderModuleRoots,
             mainFields: ['loader', 'main'],
         },
 

package/cli/compiler/index.ts

@@ -9,6 +9,7 @@ import { rspack, type Compiler as RspackCompiler } from '@rspack/core';
 
 // Core
 import app from '../app';
+import cli from '..';
 import createServerConfig from './server';
 import createClientConfig from './client';
 import { TCompileMode, TCompileOutputTarget } from './common';
@@ -62,15 +63,21 @@ export default class Compiler {
         - Including React, so VSCode shows that JSX is missing
     */
     public fixNpmLinkIssues() {
-        const corePath = path.join(app.paths.root, '/node_modules/proteum');
-        if (!fs.lstatSync(corePath).isSymbolicLink())
-            return logVerbose("Not fixing npm issue because proteum wasn't installed with npm link.");
+        const installedFrameworkRoot = cli.paths.framework.installedRoot;
+
+        if (!installedFrameworkRoot || !fs.existsSync(installedFrameworkRoot)) {
+            return logVerbose("Not fixing npm link issues because the app can't see an installed Proteum package.");
+        }
+
+        if (!fs.lstatSync(installedFrameworkRoot).isSymbolicLink()) {
+            return logVerbose("Not fixing npm link issues because Proteum wasn't installed with npm link.");
+        }
 
         this.debug && logVerbose(`Fix NPM link issues ...`);
         const outputPath = app.outputPath(this.outputTarget);
 
-        const appModules = path.join(app.paths.root, 'node_modules');
-        const coreModules = path.join(corePath, 'node_modules');
+        const appModules = cli.paths.framework.appNodeModulesRoot;
+        const coreModules = cli.paths.framework.frameworkNodeModulesRoot;
 
         // When the 5htp package is installed from npm link,
         // Modules are installed locally and not glbally as with with the 5htp package from NPM.

package/cli/compiler/server/index.ts

@@ -51,10 +51,12 @@ const getDevGeneratedRuntimeEntries = (app: App) => ({
 });
 const normalizeModulePath = (value?: string) => (value || '').replace(/\\/g, '/');
 const rewriteFrameworkAliasTargets = (app: App, aliases: Record<string, string | string[]>) => {
-    const installedCoreRoot = normalizeModulePath(app.paths.root + '/node_modules/proteum');
-    const activeCoreRoot = normalizeModulePath(cli.paths.core.root);
+    const installedCoreRoot = cli.paths.framework.installedRoot
+        ? normalizeModulePath(cli.paths.framework.installedRoot)
+        : undefined;
+    const activeCoreRoot = normalizeModulePath(cli.paths.framework.activeRoot);
 
-    if (installedCoreRoot === activeCoreRoot) return aliases;
+    if (!installedCoreRoot || installedCoreRoot === activeCoreRoot) return aliases;
 
     const rewriteCandidate = (candidate: string) =>
         normalizeModulePath(candidate).startsWith(installedCoreRoot + '/')
@@ -80,12 +82,11 @@ export default function createCompiler(
     debug && console.info(`Creating compiler for server (${mode}).`);
     const dev = mode === 'dev';
     const outputPath = app.outputPath(outputTarget);
-    const installedCoreRoot = app.paths.root + '/node_modules/proteum';
-    const frameworkRoots = [cli.paths.core.root, installedCoreRoot];
+    const frameworkRoots = cli.paths.getFrameworkRoots();
     const transpileModuleDirectories = app.transpileModuleDirectories;
 
     const commonConfig = createCommonConfig(app, 'server', mode, outputTarget);
-    const { aliases } = app.aliases.server.forWebpack({ modulesPath: app.paths.root + '/node_modules' });
+    const { aliases } = app.aliases.server.forWebpack({ modulesPath: cli.paths.framework.appNodeModulesRoot });
     const resolvedAliases = rewriteFrameworkAliasTargets(app, aliases);
 
     // We're not supposed in any case to import client services from server

package/cli/index.ts

@@ -3,21 +3,62 @@ process.traceDeprecation = true;
 import { Cli } from 'clipanion';
 
 import cli from './context';
+import { resolveFrameworkInstallInfo } from './paths';
 import { proteumCommandNames } from './presentation/commands';
 import { renderCliOverview, renderCommandHelp, resolveCustomHelpRequest } from './presentation/help';
+import { renderCliWelcomeBanner } from './presentation/welcome';
 import { normalizeHelpArgv, normalizeLegacyArgv } from './runtime/argv';
 import { createCli, registeredCommands } from './runtime/commands';
 
+const formatInvocation = (argv: string[]) => ['proteum', ...argv].join(' ').trim();
+
+const shouldRenderSharedWelcomeBanner = ({
+    argv,
+    helpRequestKind,
+}: {
+    argv: string[];
+    helpRequestKind: 'none' | 'overview' | 'command';
+}) => {
+    if (helpRequestKind !== 'none') return true;
+    if (argv[0] !== 'dev') return true;
+
+    if (argv.length === 1) return false;
+
+    const action = argv[1];
+    if (action.startsWith('-')) return false;
+
+    return action === 'list' || action === 'stop';
+};
+
 export const runCli = async (argv: string[] = process.argv.slice(2)) => {
     const normalizedArgv = normalizeHelpArgv(normalizeLegacyArgv(argv), proteumCommandNames);
-    const clipanion = createCli(String(cli.packageJson.version || ''));
+    const version = String(cli.packageJson.version || '');
+    const proteumInstall = resolveFrameworkInstallInfo({
+        appRoot: cli.paths.appRoot,
+        framework: cli.paths.framework,
+    });
+    const clipanion = createCli(version);
     const initAvailable = true;
     const helpRequest = resolveCustomHelpRequest(normalizedArgv);
+    const shouldRenderWelcomeBanner = shouldRenderSharedWelcomeBanner({
+        argv: normalizedArgv,
+        helpRequestKind: helpRequest.kind,
+    });
+
+    if (shouldRenderWelcomeBanner) {
+        process.stderr.write(
+            `${await renderCliWelcomeBanner({
+                command: formatInvocation(normalizedArgv),
+                installSummary: proteumInstall.summary,
+                version,
+            })}\n\n`,
+        );
+    }
 
     if (helpRequest.kind === 'overview') {
         process.stdout.write(
             await renderCliOverview({
-                version: String(cli.packageJson.version || ''),
+                version,
                 workdir: process.cwd(),
                 initAvailable,
             }),