proteum 1.0.2 → 2.0.0-1

package/cli/compiler/common/generatedRouteModules.ts

@@ -0,0 +1,368 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ts from 'typescript';
+
+import writeIfChanged from '../writeIfChanged';
+
+type TRouteSide = 'client' | 'server';
+type TRouteRuntime = 'client' | 'server';
+
+type TImportedService = { importedName: string; localName: string };
+
+type TRouteDefinition = { args: ts.NodeArray<ts.Expression>; methodName: string; serviceLocalName: string };
+
+type TGeneratedClientRouteModuleOptions = { chunkId: string; filepath: string };
+
+type TWriteGeneratedRouteModuleOptions = {
+    outputFilepath: string;
+    runtime: TRouteRuntime;
+    side: TRouteSide;
+    sourceFilepath: string;
+    clientRoute?: TGeneratedClientRouteModuleOptions;
+    routeSourceFilepaths?: Set<string>;
+};
+
+const clientRouterImportSources = new Set(['@client/router', '@/client/router']);
+const routerMethods = new Set(['page', 'error', 'get', 'post', 'put', 'delete', 'patch']);
+
+const parseSourceFile = (filepath: string, code: string) =>
+    ts.createSourceFile(
+        filepath,
+        code,
+        ts.ScriptTarget.Latest,
+        true,
+        filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+
+const normalizeFilepath = (value: string) => path.resolve(value).replace(/\\/g, '/');
+
+const getNodeText = (sourceFile: ts.SourceFile, node: ts.Node) =>
+    sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+
+const routeModuleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+
+const resolveRouteImport = (sourceFilepath: string, moduleSpecifier: string, routeSourceFilepaths?: Set<string>) => {
+    if (!routeSourceFilepaths || !moduleSpecifier.startsWith('.')) return undefined;
+
+    const absoluteBasePath = path.resolve(path.dirname(sourceFilepath), moduleSpecifier);
+    const candidates = [
+        absoluteBasePath,
+        ...routeModuleExtensions.map((extension) => absoluteBasePath + extension),
+        ...routeModuleExtensions.map((extension) => path.join(absoluteBasePath, `index${extension}`)),
+    ];
+
+    return candidates.find((candidate) => routeSourceFilepaths.has(normalizeFilepath(candidate)));
+};
+
+const addImportedService = (importedServices: TImportedService[], importedName: string, localName: string) => {
+    if (
+        importedServices.some(
+            (importedService) =>
+                importedService.importedName === importedName && importedService.localName === localName,
+        )
+    ) {
+        return;
+    }
+
+    importedServices.push({ importedName, localName });
+};
+
+const collectImportedServices = (
+    sourceFile: ts.SourceFile,
+    side: TRouteSide,
+    stripRanges: Array<{ start: number; end: number }>,
+) => {
+    const importedServices: TImportedService[] = [];
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement)) continue;
+        if (!statement.importClause) continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+
+        const source = statement.moduleSpecifier.text;
+        const isClientRouterImport = side === 'client' && clientRouterImportSources.has(source);
+
+        if (source !== '@app' && !isClientRouterImport) continue;
+
+        if (isClientRouterImport && statement.importClause.name) {
+            addImportedService(importedServices, 'Router', statement.importClause.name.text);
+        }
+
+        for (const specifier of statement.importClause.namedBindings
+            ? ts.isNamedImports(statement.importClause.namedBindings)
+                ? statement.importClause.namedBindings.elements
+                : []
+            : []) {
+            addImportedService(
+                importedServices,
+                specifier.propertyName?.text || specifier.name.text,
+                specifier.name.text,
+            );
+        }
+
+        stripRanges.push({ start: statement.getStart(sourceFile), end: statement.getEnd() });
+    }
+
+    return importedServices;
+};
+
+const collectNestedRouteImports = (
+    sourceFile: ts.SourceFile,
+    sourceFilepath: string,
+    routeSourceFilepaths: Set<string> | undefined,
+    stripRanges: Array<{ start: number; end: number }>,
+) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement)) continue;
+        if (statement.importClause) continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+
+        const routeImportPath = resolveRouteImport(
+            sourceFilepath,
+            statement.moduleSpecifier.text,
+            routeSourceFilepaths,
+        );
+
+        if (!routeImportPath) continue;
+
+        stripRanges.push({ start: statement.getStart(sourceFile), end: statement.getEnd() });
+    }
+};
+
+const collectRouteDefinitions = (
+    sourceFile: ts.SourceFile,
+    importedServices: TImportedService[],
+    stripRanges: Array<{ start: number; end: number }>,
+) => {
+    const importedServiceNames = new Set(importedServices.map((importedService) => importedService.localName));
+    const definitions: TRouteDefinition[] = [];
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExpressionStatement(statement)) continue;
+        if (!ts.isCallExpression(statement.expression)) continue;
+        if (!ts.isPropertyAccessExpression(statement.expression.expression)) continue;
+
+        const callee = statement.expression.expression;
+        if (!ts.isIdentifier(callee.expression)) continue;
+        if (!routerMethods.has(callee.name.text)) continue;
+        if (!importedServiceNames.has(callee.expression.text)) continue;
+
+        definitions.push({
+            args: statement.expression.arguments,
+            methodName: callee.name.text,
+            serviceLocalName: callee.expression.text,
+        });
+
+        stripRanges.push({ start: statement.getStart(sourceFile), end: statement.getEnd() });
+    }
+
+    return definitions;
+};
+
+const buildRemainingSource = (sourceFile: ts.SourceFile, stripRanges: Array<{ start: number; end: number }>) => {
+    const sortedRanges = stripRanges.sort((a, b) => a.start - b.start);
+    const chunks: string[] = [];
+    let cursor = 0;
+
+    for (const range of sortedRanges) {
+        if (cursor < range.start) chunks.push(sourceFile.text.slice(cursor, range.start));
+        cursor = Math.max(cursor, range.end);
+    }
+
+    if (cursor < sourceFile.text.length) {
+        chunks.push(sourceFile.text.slice(cursor));
+    }
+
+    return chunks.join('').trim();
+};
+
+const normalizeRelativeImportPath = (value: string) => (value.startsWith('.') ? value : `./${value}`);
+
+const rebaseRelativeModuleSpecifiers = (code: string, outputFilepath: string, sourceFilepath: string) => {
+    const outputDir = path.dirname(outputFilepath);
+    const sourceDir = path.dirname(sourceFilepath);
+    const sourceFile = parseSourceFile(outputFilepath, code);
+    const replacements: Array<{ start: number; end: number; value: string }> = [];
+
+    const addReplacement = (literal: ts.StringLiteralLike) => {
+        if (!literal.text.startsWith('.')) return;
+
+        const absoluteTarget = path.resolve(sourceDir, literal.text);
+        const nextRelativePath = normalizeRelativeImportPath(
+            path.relative(outputDir, absoluteTarget).replace(/\\/g, '/'),
+        );
+
+        replacements.push({
+            start: literal.getStart(sourceFile),
+            end: literal.getEnd(),
+            value: JSON.stringify(nextRelativePath),
+        });
+    };
+
+    const visit = (node: ts.Node) => {
+        if (
+            (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier)
+        ) {
+            addReplacement(node.moduleSpecifier);
+        }
+
+        if (
+            ts.isCallExpression(node) &&
+            node.arguments.length > 0 &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) && node.expression.text === 'require'))
+        ) {
+            addReplacement(node.arguments[0]);
+        }
+
+        if (
+            ts.isImportTypeNode(node) &&
+            ts.isLiteralTypeNode(node.argument) &&
+            ts.isStringLiteral(node.argument.literal)
+        ) {
+            addReplacement(node.argument.literal);
+        }
+
+        ts.forEachChild(node, visit);
+    };
+
+    ts.forEachChild(sourceFile, visit);
+
+    return replacements
+        .sort((a, b) => b.start - a.start)
+        .reduce(
+            (currentCode, replacement) =>
+                currentCode.slice(0, replacement.start) + replacement.value + currentCode.slice(replacement.end),
+            code,
+        );
+};
+
+const buildDestructuring = (importedServices: TImportedService[]) => {
+    const parts = importedServices.map(({ importedName, localName }) =>
+        importedName === localName ? importedName : `${importedName}: ${localName}`,
+    );
+
+    return `const { ${parts.join(', ')} } = app;`;
+};
+
+const buildClientRegisterArgs = (
+    sourceFile: ts.SourceFile,
+    definition: TRouteDefinition,
+    clientRoute: TGeneratedClientRouteModuleOptions,
+) => {
+    const [, ...routeArgs] = [...definition.args];
+    const injectedOptions = `{ id: ${JSON.stringify(clientRoute.chunkId)}, filepath: ${JSON.stringify(clientRoute.filepath)} }`;
+
+    if (routeArgs.length === 1) {
+        return [injectedOptions, getNodeText(sourceFile, routeArgs[0])];
+    }
+
+    if (routeArgs.length === 2) {
+        if (ts.isObjectLiteralExpression(routeArgs[0])) {
+            return [
+                `{ ...(${getNodeText(sourceFile, routeArgs[0])}), id: ${JSON.stringify(clientRoute.chunkId)}, filepath: ${JSON.stringify(clientRoute.filepath)} }`,
+                getNodeText(sourceFile, routeArgs[1]),
+            ];
+        }
+
+        return [injectedOptions, getNodeText(sourceFile, routeArgs[0]), getNodeText(sourceFile, routeArgs[1])];
+    }
+
+    if (routeArgs.length === 3 && ts.isObjectLiteralExpression(routeArgs[0])) {
+        return [
+            `{ ...(${getNodeText(sourceFile, routeArgs[0])}), id: ${JSON.stringify(clientRoute.chunkId)}, filepath: ${JSON.stringify(clientRoute.filepath)} }`,
+            getNodeText(sourceFile, routeArgs[1]),
+            getNodeText(sourceFile, routeArgs[2]),
+        ];
+    }
+
+    throw new Error(
+        `Unsupported client route signature in ${sourceFile.fileName}. Expected Router.page/error with 2-4 arguments.`,
+    );
+};
+
+const buildRegisterStatements = (
+    sourceFile: ts.SourceFile,
+    side: TRouteSide,
+    definitions: TRouteDefinition[],
+    clientRoute?: TGeneratedClientRouteModuleOptions,
+) => {
+    if (side === 'client') {
+        if (!clientRoute) {
+            throw new Error(`Missing client route metadata for ${sourceFile.fileName}.`);
+        }
+
+        if (definitions.length !== 1) {
+            throw new Error(
+                `Frontend route definition files can contain only one route definition. ${definitions.length} were found in ${sourceFile.fileName}.`,
+            );
+        }
+
+        const definition = definitions[0];
+        const [routePath, ...routeArgs] = [...definition.args];
+        const finalArgs = [
+            getNodeText(sourceFile, routePath),
+            ...buildClientRegisterArgs(sourceFile, definition, clientRoute),
+        ];
+
+        return [`return ${definition.serviceLocalName}.${definition.methodName}(${finalArgs.join(', ')});`];
+    }
+
+    return definitions.map((definition) => {
+        const args = [...definition.args].map((arg) => getNodeText(sourceFile, arg));
+
+        return `${definition.serviceLocalName}.${definition.methodName}(${args.join(', ')});`;
+    });
+};
+
+export const getGeneratedRouteModuleFilepath = (generatedRoot: string, sourceRoot: string, sourceFilepath: string) =>
+    path.join(generatedRoot, 'route-modules', path.relative(sourceRoot, sourceFilepath));
+
+export const writeGeneratedRouteModule = ({
+    outputFilepath,
+    runtime,
+    side,
+    sourceFilepath,
+    clientRoute,
+    routeSourceFilepaths,
+}: TWriteGeneratedRouteModuleOptions) => {
+    const code = fs.readFileSync(sourceFilepath, 'utf8');
+    const sourceFile = parseSourceFile(sourceFilepath, code);
+    const stripRanges: Array<{ start: number; end: number }> = [];
+    const importedServices = collectImportedServices(sourceFile, side, stripRanges);
+    collectNestedRouteImports(sourceFile, sourceFilepath, routeSourceFilepaths, stripRanges);
+    const definitions = collectRouteDefinitions(sourceFile, importedServices, stripRanges);
+
+    if (definitions.length === 0) {
+        throw new Error(`No route definitions were found in ${sourceFilepath}.`);
+    }
+
+    const remainingSource = rebaseRelativeModuleSpecifiers(
+        buildRemainingSource(sourceFile, stripRanges),
+        outputFilepath,
+        sourceFilepath,
+    );
+    const registerStatements = buildRegisterStatements(sourceFile, side, definitions, clientRoute);
+    const runtimeAppImportPath = runtime === 'client' ? '@/client/index' : '@/server/.generated/app';
+
+    const content = `/*----------------------------------
+- GENERATED FILE
+----------------------------------*/
+
+// This file is generated by Proteum from ${path.relative(process.cwd(), sourceFilepath).replace(/\\/g, '/')}.
+// Do not edit it manually.
+
+import type __GeneratedRouteApp from ${JSON.stringify(runtimeAppImportPath)};
+
+${remainingSource}
+${remainingSource ? '\n' : ''}export const __register = (app: __GeneratedRouteApp) => {
+  ${buildDestructuring(importedServices)}
+  ${registerStatements.join('\n  ')}
+};
+`;
+
+    return writeIfChanged(outputFilepath, content);
+};

package/cli/compiler/common/index.ts

@@ -3,12 +3,9 @@
 ----------------------------------*/
 
 // npm
-import webpack from 'webpack';
 import dayjs from 'dayjs';
 import path from 'path';
-
-// Plugins
-const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+import { rspack, type Configuration } from '@rspack/core';
 
 // Core
 import cli from '../..';
@@ -22,32 +19,33 @@ import type { TAppSide } from '../../app';
 ----------------------------------*/
 
 export const regex = {
-    scripts: /\.(ts|tsx)$/,
+    scripts: /\.(ts|tsx|js|jsx)$/,
     style: /\.(css|less|scss)$/,
     images: /\.(bmp|gif|jpg|jpeg|png|ico|svg)$/, // SVG gérés par SVGR
     fonts: /\.(woff(2)?|ttf|eot)(\?v=\d+\.\d+\.\d+)?$/,
     staticAssetName: /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8][ext]',
-}
+};
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export type TCompileMode = 'dev' | 'prod'
+export type TCompileMode = 'dev' | 'prod';
+export type TCompileOutputTarget = 'dev' | 'bin';
 
 /*----------------------------------
 - BASE CONFIG
 ----------------------------------*/
 
-export default function createCommonConfig( 
-    app: App, 
-    side: TAppSide, 
+export default function createCommonConfig(
+    app: App,
+    side: TAppSide,
     mode: TCompileMode,
-): webpack.Configuration {
-
+    outputTarget: TCompileOutputTarget = mode === 'dev' ? 'dev' : 'bin',
+): Configuration {
     const dev = mode === 'dev';
-    const config: webpack.Configuration = {
-
+    const enableFilesystemCache = dev ? cli.args.cache !== false : cli.args.cache === true;
+    const config: Configuration = {
         // Project root
         context: app.paths.root,
 
@@ -66,16 +64,13 @@ export default function createCommonConfig(
         },
 
         plugins: [
-
-            // https://webpack.js.org/plugins/define-plugin/
-            new webpack.DefinePlugin({
-
+            new rspack.DefinePlugin({
                 // Flags
                 __DEV__: dev,
                 SERVER: side === 'server',
 
                 // Core
-                CORE_VERSION: JSON.stringify( cli.packageJson.version ),
+                CORE_VERSION: JSON.stringify(cli.packageJson.version),
                 CORE_PATH: JSON.stringify(cli.paths.core.root),
 
                 // Application
@@ -83,29 +78,15 @@ export default function createCommonConfig(
                 BUILD_ID: JSON.stringify(app.buildId),
                 APP_PATH: JSON.stringify(app.paths.root),
                 APP_NAME: JSON.stringify(app.identity.web.title),
-
+                APP_OUTPUT_DIR: JSON.stringify(path.basename(app.outputPath(outputTarget))),
+                PROTEUM_DEV_EVENT_PORT: JSON.stringify(dev ? (app.devEventPort ?? null) : null),
+                PROTEUM_ROUTER_PORT_OVERRIDE: JSON.stringify(app.routerPortOverride ?? null),
             }),
 
-            ...(side === 'client' && cli.args.analyze ? [
-
-                new BundleAnalyzerPlugin({
-                    defaultSizes: 'stat',
-                    openAnalyzer: false
-                }),
-
-            ] : []),
-
-            ...(dev ? [
-
-                // HMR
-                //new webpack.HotModuleReplacementPlugin()
-
-            ] : []),
-
+            ...(dev ? [] : []),
         ],
 
         resolve: {
-
             // Empêche le remplatcement des chemins vers les liens symboliques par leur vrai chemin
             // Permet de conserver le chemin des packages enregistrés via npm link
             // Equivalent tsconfig: preserveSymlinks: true
@@ -121,40 +102,25 @@ export default function createCommonConfig(
         // our own hints via the FileSizeReporter
         performance: false,
 
-        // Don't attempt to continue if there are any errors.
+        // Smoke builds should fail immediately on the first compilation error.
         bail: !dev,
 
-        // Persistent cache speeds up cold starts and incremental rebuilds.
-        cache: /*(dev || cli.args.cache === true) ? {
-            type: 'filesystem',
-            cacheDirectory: path.join(app.paths.cache, 'webpack', side),
-            compression: false,
-            buildDependencies: {
-                config: [__filename],
-            },
-        } : */false,
+        // Persistent cache speeds up repeated local dev and prod build invocations.
+        cache: enableFilesystemCache
+            ? {
+                  type: 'filesystem',
+                  cacheDirectory: path.join(app.paths.cache, 'rspack', side, mode),
+                  compression: false,
+                  buildDependencies: { config: [__filename] },
+              }
+            : false,
 
         // Increase compilation performance
         profile: false,
 
-        // Pour bundle-stats
-        // https://github.com/relative-ci/bundle-stats/tree/master/packages/cli#webpack-configuration
-        stats: {
-            cached: dev,
-            cachedAssets: dev,
-            chunks: dev,
-            chunkModules: dev,
-            colors: true,
-            hash: dev,
-            modules: dev,
-            reasons: dev,
-            timings: true,
-            version: dev,
-            errorDetails: true
-        },
-
-    }
+        // Keep output compact while preserving timing and error context.
+        stats: { colors: true, errors: true, errorDetails: true, timings: true, warnings: true },
+    };
 
     return config;
-
 }

package/cli/compiler/common/loaders/forbid-ssr-import.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = function forbidSsrImportLoader() {
+    const resourcePath = this.resourcePath || this.request || '<unknown>';
+
+    throw new Error(
+        [
+            'SSR-only module imported into the client bundle:',
+            resourcePath,
+            'Provide the browser implementation without the ".ssr" suffix and keep SSR-specific logic in "*.ssr.tsx" files.',
+        ].join('\n'),
+    );
+};

package/cli/compiler/common/rspackAliases.ts

@@ -0,0 +1,13 @@
+import fs from 'fs-extra';
+
+type TWebpackAliases = Record<string, string | string[]>;
+
+export const toRspackAliases = (aliases: TWebpackAliases) =>
+    Object.fromEntries(
+        Object.entries(aliases).map(([alias, value]) => {
+            const candidates = Array.isArray(value) ? value : [value];
+            const selectedCandidate = candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
+
+            return [alias, selectedCandidate];
+        }),
+    );

package/cli/compiler/common/scripts.ts

@@ -0,0 +1,37 @@
+import type { App, TAppSide } from '@cli/app';
+import type { RuleSetRule } from '@rspack/core';
+
+type TScriptRuleOptions = { app: App; side: TAppSide; dev: boolean };
+
+const shouldExcludeNodeModule = (filePath: string) => {
+    if (!filePath.includes('node_modules')) return false;
+
+    if (filePath.includes('node_modules/proteum') && !filePath.includes('node_modules/proteum/node_modules')) {
+        return false;
+    }
+
+    return true;
+};
+
+const getSwcTarget = (side: TAppSide) => (side === 'client' ? 'es2022' : 'es2021');
+
+module.exports = ({ side, dev }: TScriptRuleOptions): RuleSetRule[] => {
+    return [
+        {
+            loader: 'builtin:swc-loader',
+            type: 'javascript/auto',
+            exclude: shouldExcludeNodeModule,
+            options: {
+                sourceMaps: true,
+                jsc: {
+                    target: getSwcTarget(side),
+                    loose: true,
+                    parser: { syntax: 'typescript', tsx: true, decorators: false, dynamicImport: true },
+                    transform: {
+                        react: { runtime: 'automatic', importSource: 'preact', development: dev, refresh: false },
+                    },
+                },
+            },
+        },
+    ];
+};