proteum 1.0.2 → 2.0.0

package/cli/compiler/common/bundleAnalysis.ts

@@ -0,0 +1,94 @@
+import fs from 'fs-extra';
+import path from 'path';
+import type { RspackPluginInstance } from '@rspack/core';
+
+import cli from '../..';
+import type { App } from '../../app';
+
+const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
+
+export type TBundleAnalysisReportPaths = { reportPath: string; statsPath: string };
+
+export const isBundleAnalysisEnabled = () => cli.args.analyze === true;
+
+export const getClientBundleAnalysisReportPaths = (
+    app: App,
+    outputTarget: 'dev' | 'bin',
+): TBundleAnalysisReportPaths => {
+    const reportDir = path.join(app.outputPath(outputTarget), 'bundle-analysis');
+
+    return { reportPath: path.join(reportDir, 'client.html'), statsPath: path.join(reportDir, 'client-stats.json') };
+};
+
+export const createClientBundleAnalysisPlugins = (app: App, outputTarget: 'dev' | 'bin'): RspackPluginInstance[] => {
+    if (!isBundleAnalysisEnabled()) return [];
+
+    const { reportPath, statsPath } = getClientBundleAnalysisReportPaths(app, outputTarget);
+
+    fs.ensureDirSync(path.dirname(reportPath));
+
+    return [
+        new BundleAnalyzerPlugin({
+            analyzerMode: 'static',
+            openAnalyzer: false,
+            defaultSizes: 'parsed',
+            reportFilename: reportPath,
+            generateStatsFile: true,
+            statsFilename: statsPath,
+            logLevel: 'info',
+        }),
+    ];
+};
+
+const sleep = (delayMs: number) => new Promise((resolve) => setTimeout(resolve, delayMs));
+
+const isJsonFileComplete = (filepath: string) => {
+    const fd = fs.openSync(filepath, 'r');
+
+    try {
+        const { size } = fs.fstatSync(fd);
+        if (size === 0) return false;
+
+        const readLength = Math.min(512, size);
+        const buffer = Buffer.alloc(readLength);
+        fs.readSync(fd, buffer, 0, readLength, size - readLength);
+
+        const tail = buffer.toString('utf8').trimEnd();
+        if (!tail.endsWith('}')) return false;
+
+        JSON.parse(fs.readFileSync(filepath, 'utf8'));
+        return true;
+    } catch {
+        return false;
+    } finally {
+        fs.closeSync(fd);
+    }
+};
+
+export const waitForClientBundleAnalysisArtifacts = async (
+    app: App,
+    outputTarget: 'dev' | 'bin',
+    timeoutMs: number = 30000,
+) => {
+    const startedAt = Date.now();
+    const { reportPath, statsPath } = getClientBundleAnalysisReportPaths(app, outputTarget);
+    let previousStatsSize = -1;
+
+    while (Date.now() - startedAt < timeoutMs) {
+        const reportExists = fs.existsSync(reportPath);
+        const statsExists = fs.existsSync(statsPath);
+
+        if (reportExists && statsExists) {
+            const { size } = fs.statSync(statsPath);
+            const sizeStable = size > 0 && size === previousStatsSize;
+
+            if (sizeStable && isJsonFileComplete(statsPath)) return;
+
+            previousStatsSize = size;
+        }
+
+        await sleep(250);
+    }
+
+    throw new Error(`Timed out waiting for bundle analysis artifacts to complete: ${reportPath}, ${statsPath}`);
+};

package/cli/compiler/common/clientManifest.ts

@@ -0,0 +1,67 @@
+import fs from 'fs-extra';
+import path from 'path';
+import type { Stats } from '@rspack/core';
+
+export type TClientManifestChunkAssets = { assets: string[]; css: string[]; js: string[] };
+
+export type TClientBuildManifest = {
+    publicPath: string;
+    entries: Record<string, TClientManifestChunkAssets>;
+    chunks: Record<string, TClientManifestChunkAssets>;
+};
+
+const filterAsset = (asset: string) => !asset.endsWith('.map');
+
+const classifyAssets = (assets: string[]): TClientManifestChunkAssets => {
+    const filtered = assets.filter(filterAsset);
+
+    return {
+        assets: filtered,
+        css: filtered.filter((asset) => asset.endsWith('.css')),
+        js: filtered.filter((asset) => asset.endsWith('.js')),
+    };
+};
+
+const normalizePublicPath = (publicPath?: string) => {
+    if (!publicPath || publicPath === 'auto') return '/public/';
+
+    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
+};
+
+export const getClientManifestPath = (outputPath: string) => path.join(outputPath, 'client-manifest.json');
+
+export const writeClientManifest = (stats: Stats, outputPath: string) => {
+    const statsJson = stats.toJson({
+        assets: true,
+        assetsByChunkName: true,
+        entrypoints: true,
+        namedChunkGroups: true,
+        publicPath: true,
+    });
+    const publicPath = normalizePublicPath(statsJson.publicPath);
+
+    const buildChunkAssets = (chunkGroup: { assets?: Array<string | { name?: string | null }> } | undefined) => {
+        const assets = (chunkGroup?.assets || [])
+            .map((asset) => (typeof asset === 'string' ? asset : asset.name || ''))
+            .filter(Boolean);
+
+        return classifyAssets(assets);
+    };
+
+    const entries = Object.fromEntries(
+        Object.entries(statsJson.entrypoints || {}).map(([name, chunkGroup]) => [name, buildChunkAssets(chunkGroup)]),
+    );
+
+    const chunks = Object.fromEntries(
+        Object.entries(statsJson.namedChunkGroups || {}).map(([name, chunkGroup]) => [
+            name,
+            buildChunkAssets(chunkGroup),
+        ]),
+    );
+
+    const manifest: TClientBuildManifest = { publicPath, entries, chunks };
+
+    fs.writeJsonSync(getClientManifestPath(outputPath), manifest, { spaces: 2 });
+
+    return manifest;
+};

package/cli/compiler/common/controllers.ts

@@ -0,0 +1,288 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+import path from 'path';
+import ts from 'typescript';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TControllerMethodMeta = { name: string; inputCallsCount: number; routePath: string };
+
+export type TControllerFileMeta = {
+    importPath: string;
+    filepath: string;
+    className: string;
+    routeBasePath: string;
+    methods: TControllerMethodMeta[];
+};
+
+export type TControllerServiceRoot = { alias: string; dir: string };
+
+type TControllerSearchDir = { importPrefix: string; root: string; serviceRoots?: TControllerServiceRoot[] };
+
+/*----------------------------------
+- HELPERS
+----------------------------------*/
+
+const getControllerSegments = (relativePath: string) => {
+    const segments = relativePath
+        .replace(/\.controller\.ts$/, '')
+        .split('/')
+        .filter(Boolean);
+
+    if (segments.length > 1 && segments[segments.length - 1] === segments[segments.length - 2]) {
+        segments.pop();
+    }
+
+    return segments;
+};
+
+const getControllerBasePathFromFilepath = (filepath: string, root: string, serviceRoots: TControllerServiceRoot[] = []) => {
+    const normalizedFilepath = filepath.replace(/\\/g, '/');
+    const serviceRoot = serviceRoots
+        .filter((candidate) => normalizedFilepath.startsWith(candidate.dir.replace(/\\/g, '/') + '/'))
+        .sort((a, b) => b.dir.length - a.dir.length)[0];
+
+    if (!serviceRoot) {
+        return getControllerSegments(path.relative(root, filepath).replace(/\\/g, '/')).join('/');
+    }
+
+    const segments = getControllerSegments(path.relative(serviceRoot.dir, filepath).replace(/\\/g, '/'));
+
+    if (segments[0]?.toLowerCase() === serviceRoot.alias.toLowerCase()) {
+        segments.shift();
+    }
+
+    return [serviceRoot.alias, ...segments].filter(Boolean).join('/');
+};
+
+const getGeneratedClassName = (filepath: string) => {
+    const filename = path.basename(filepath, '.ts').replace(/[^A-Za-z0-9_$]+/g, '_');
+    const normalized = filename.length ? filename : 'Controller';
+
+    return normalized[0].toUpperCase() + normalized.substring(1);
+};
+
+const buildImportPath = (searchDir: TControllerSearchDir, filepath: string) =>
+    searchDir.importPrefix + path.relative(searchDir.root, filepath).replace(/\\/g, '/').replace(/\.ts$/, '');
+
+const findControllerFiles = (dir: string): string[] => {
+    if (!fs.existsSync(dir)) return [];
+
+    const files: string[] = [];
+
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const filepath = path.join(dir, dirent.name);
+
+        if (dirent.isDirectory()) {
+            files.push(...findControllerFiles(filepath));
+            continue;
+        }
+
+        if (!dirent.isFile()) continue;
+        if (!dirent.name.endsWith('.controller.ts')) continue;
+
+        files.push(filepath);
+    }
+
+    return files;
+};
+
+const parseSourceFile = (filepath: string, code: string) =>
+    ts.createSourceFile(
+        filepath,
+        code,
+        ts.ScriptTarget.Latest,
+        true,
+        filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+
+const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) =>
+    !!node.modifiers?.some((modifier) => modifier.kind === kind);
+
+const getDefaultExportClass = (sourceFile: ts.SourceFile) => {
+    const classes = new Map<string, ts.ClassDeclaration>();
+
+    for (const statement of sourceFile.statements) {
+        if (ts.isClassDeclaration(statement) && statement.name) {
+            classes.set(statement.name.text, statement);
+
+            if (hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+                return statement;
+            }
+        }
+    }
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+
+        if (ts.isIdentifier(statement.expression)) {
+            return classes.get(statement.expression.text);
+        }
+    }
+
+    return undefined;
+};
+
+const getExportedString = (sourceFile: ts.SourceFile, exportName: string) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) continue;
+        if (!hasModifier(statement, ts.SyntaxKind.ExportKeyword)) continue;
+
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name)) continue;
+            if (declaration.name.text !== exportName) continue;
+            if (!declaration.initializer || !ts.isStringLiteral(declaration.initializer)) continue;
+
+            return declaration.initializer.text;
+        }
+    }
+
+    return undefined;
+};
+
+const countInputCalls = (method: ts.MethodDeclaration) => {
+    let inputCallsCount = 0;
+
+    const visit = (node: ts.Node) => {
+        if (
+            ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            node.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+            node.expression.name.text === 'input'
+        ) {
+            inputCallsCount++;
+        }
+
+        ts.forEachChild(node, visit);
+    };
+
+    if (method.body) ts.forEachChild(method.body, visit);
+
+    return inputCallsCount;
+};
+
+/*----------------------------------
+- EXPORTS
+----------------------------------*/
+
+export const indexControllers = (searchDirs: TControllerSearchDir[]) => {
+    const controllers: TControllerFileMeta[] = [];
+
+    for (const searchDir of searchDirs) {
+        const controllerFiles = findControllerFiles(searchDir.root);
+
+        for (const filepath of controllerFiles.sort((a, b) => a.localeCompare(b))) {
+            const code = fs.readFileSync(filepath, 'utf8');
+            const sourceFile = parseSourceFile(filepath, code);
+
+            const controllerPathOverride = getExportedString(sourceFile, 'controllerPath');
+            const defaultClass = getDefaultExportClass(sourceFile);
+
+            if (!defaultClass) continue;
+
+            const className = defaultClass.name?.text || getGeneratedClassName(filepath);
+            const routeBasePath =
+                controllerPathOverride ||
+                getControllerBasePathFromFilepath(filepath, searchDir.root, searchDir.serviceRoots || []);
+            const methods: TControllerMethodMeta[] = [];
+
+            for (const member of defaultClass.members) {
+                if (!ts.isMethodDeclaration(member)) continue;
+                if (!member.body) continue;
+                if (!member.name || !ts.isIdentifier(member.name)) continue;
+
+                const methodName = member.name.text;
+                const inputCallsCount = countInputCalls(member);
+
+                if (inputCallsCount > 1) {
+                    throw new Error(`${filepath}#${methodName} uses this.input() more than once.`);
+                }
+
+                methods.push({
+                    name: methodName,
+                    inputCallsCount,
+                    routePath: [routeBasePath, methodName].filter(Boolean).join('/'),
+                });
+            }
+
+            if (!methods.length) continue;
+
+            controllers.push({
+                filepath,
+                importPath: buildImportPath(searchDir, filepath),
+                className,
+                routeBasePath,
+                methods,
+            });
+        }
+    }
+
+    return controllers.sort((a, b) => a.filepath.localeCompare(b.filepath));
+};
+
+export const generateControllerClientTree = (controllers: TControllerFileMeta[]) => {
+    const root: Record<string, any> = {};
+
+    const insert = (segments: string[], valueFactory: () => string) => {
+        let cursor = root;
+
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const isLeaf = i === segments.length - 1;
+
+            if (isLeaf) {
+                cursor[segment] = valueFactory();
+                return;
+            }
+
+            cursor[segment] = cursor[segment] || {};
+            cursor = cursor[segment];
+        }
+    };
+
+    for (const controller of controllers) {
+        for (const method of controller.methods) {
+            insert(method.routePath.split('/'), () =>
+                JSON.stringify({
+                    importPath: controller.importPath,
+                    className: controller.className,
+                    methodName: method.name,
+                    routePath: '/api/' + method.routePath,
+                    hasInput: method.inputCallsCount > 0,
+                }),
+            );
+        }
+    }
+
+    return root;
+};
+
+export const printControllerTree = (
+    tree: Record<string, any>,
+    renderLeaf: (leaf: string) => string,
+    indentLevel: number = 1,
+) => {
+    const indent = '    '.repeat(indentLevel);
+    const lines: string[] = ['{'];
+
+    for (const key of Object.keys(tree).sort((a, b) => a.localeCompare(b))) {
+        const value = tree[key];
+
+        if (typeof value === 'string') {
+            lines.push(`${indent}${JSON.stringify(key)}: ${renderLeaf(value)},`);
+            continue;
+        }
+
+        lines.push(`${indent}${JSON.stringify(key)}: ${printControllerTree(value, renderLeaf, indentLevel + 1)},`);
+    }
+
+    lines.push(`${'    '.repeat(indentLevel - 1)}}`);
+
+    return lines.join('\n');
+};

package/cli/compiler/common/files/autres.ts

@@ -2,38 +2,27 @@ import { staticAssetName } from '../../../paths';
 
 import type App from '../../../app';
 
-module.exports = (app: App, dev: boolean, client: boolean) => ([
-
+module.exports = (app: App, dev: boolean, client: boolean) => [
     // Allow to use ?raw at the end of the module path to iport the raw content only
     // Example: import VisualParserSource from './Parsers/visual.js?raw';
-    {
-        resourceQuery: /raw/,
-        type: 'asset/source',
-    },
+    { resourceQuery: /raw/, type: 'asset/source' },
 
     // Client uniquement: Retourne le fichier correspondant au fichier dans le dossier public
     {
         test: /\.(xml|ico|wav|mp3)$/,
         //loader: 'file-loader',
         type: 'asset/resource',
-        generator: {
-            filename: staticAssetName
-        }
+        generator: { filename: staticAssetName },
     },
 
     // Texte brut
-    {
-        type: 'asset/source',
-        test: /\.(md|hbs|sql|txt|csv|html)$/,
-    },
+    { type: 'asset/source', test: /\.(md|hbs|sql|txt|csv|html)$/ },
 
     // Polices dans un fichier distinc dans le dossier dédié
     {
         test: /\.(woff(2)?|ttf|eot)(\?v=\d+\.\d+\.\d+)?$/,
         //loader: 'file-loader',
         type: 'asset/resource',
-        generator: {
-            filename: 'fonts/[name].[ext]'
-        }
-    }
-])
+        generator: { filename: 'fonts/[name].[ext]' },
+    },
+];

package/cli/compiler/common/files/images.ts

@@ -1,42 +1,45 @@
 import { staticAssetName } from '../../../paths';
-import type webpack from 'webpack';
+import type { RuleSetRule } from '@rspack/core';
+import type App from '../../../app';
 
-module.exports = (app: App, dev: boolean, client: boolean): webpack.RuleSetRule[] => {
+module.exports = (app: App, dev: boolean, client: boolean): RuleSetRule[] => {
+    return [
+        {
+            test: /\.(bmp|gif|png|jpe?g|ico|svg|webp)$/i,
+            type: 'asset',
+            parser: {
+                dataUrlCondition: {
+                    // < 4kb = importation inline
+                    // > 4kb = référence à l'url
+                    maxSize: 4 * 1024, // 4kb
+                },
+            },
+        },
 
-    return [{
-        test: /\.(bmp|gif|png|jpe?g|ico|svg|webp)$/i,
-        type: 'asset',
-        parser: {
-            dataUrlCondition: {
-                // https://webpack.js.org/guides/asset-modules/#general-asset-type
-                // < 4kb = importation inline
-                // > 4kb = référence à l'url
-                maxSize: 4 * 1024 // 4kb
-            }
-        }
+        ...(dev
+            ? []
+            : [
+                  {
+                      test: /\.(jpg|jpeg|png)$/i,
+                      type: 'javascript/auto',
+                      use: [
+                          {
+                              loader: 'responsive-loader',
+                              options: {
+                                  sizes: [320, 480, 640, 768, 1024, 1300],
+                                  placeholder: true,
+                                  placeholderSize: 20,
+                                  quality: 100,
+                                  publicPath: '/public',
 
-    },
+                                  // Triggers error
+                                  // cacheDirectory: true,
+                              },
+                          },
+                      ],
+                  },
+              ]),
 
-    ...(dev ? [] : [{
-        test: /\.(jpg|jpeg|png)$/i,
-        type: "javascript/auto",
-        use: [{
-            loader: "responsive-loader",
-            options: {
-                sizes: [320, 480, 640, 768, 1024, 1300],
-                placeholder: true,
-                placeholderSize: 20,
-                quality: 100,
-                publicPath: '/public',
-
-                // Triggers error
-            // cacheDirectory: true,
-            }
-        }],
-    }]),
-
-    {
-        test: /\.(webm|mp4|avi|mpk|mov|mkv)$/,
-        type: 'asset/resource',
-    },]
-}
+        { test: /\.(webm|mp4|avi|mpk|mov|mkv)$/, type: 'asset/resource' },
+    ];
+};

package/cli/compiler/common/files/style.ts

@@ -1,36 +1,26 @@
 // Plugons
-import MiniCssExtractPlugin from "mini-css-extract-plugin";
+import { rspack } from '@rspack/core';
 
 import type { App } from '../../../app';
 
-module.exports = (app: App, dev: Boolean, client: boolean) => {
-
-    console.log('app.paths.root', app.paths.root)
+module.exports = (app: App, dev: boolean, client: boolean) => {
+    const enableSourceMaps = dev;
+    const useStyleLoader = client && dev;
 
     return [
-
         // Apply PostCSS plugins including autoprefixer
-        {
-            loader: MiniCssExtractPlugin.loader
-        },
+        useStyleLoader ? { loader: 'style-loader' } : { loader: rspack.CssExtractRspackPlugin.loader },
 
         // Process external/third-party styles
-        {
-            exclude: [app.paths.root],
-            loader: 'css-loader',
-            options: {
-                sourceMap: dev
-            },
-        },
+        { exclude: [app.paths.root], loader: 'css-loader', options: { sourceMap: enableSourceMaps } },
 
         // Process internal/project styles (from root folder)
         {
             include: [app.paths.root],
             loader: 'css-loader',
             options: {
-                // CSS Loader https://github.com/webpack/css-loader
                 importLoaders: 1, // let postcss run on @imports
-                sourceMap: dev
+                sourceMap: enableSourceMaps,
             },
         },
 
@@ -40,7 +30,7 @@ module.exports = (app: App, dev: Boolean, client: boolean) => {
             options: {
                 postcssOptions: {
                     plugins: [
-                        /* Tailwind V4 */require('@tailwindcss/postcss')({
+                        /* Tailwind V4 */ require('@tailwindcss/postcss')({
                             // Ensure Tailwind scans the application sources even if the build
                             // process is launched from another working directory (e.g. Docker).
                             base: app.paths.root,
@@ -68,13 +58,12 @@ module.exports = (app: App, dev: Boolean, client: boolean) => {
                     // https://lesscss.org/usage/#less-options-math
                     math: 'always',
                 },
-            }
+            },
         },
 
         /*{
             test: /\.scss/,
             loader: process.env.framework + '/node_modules/sass-loader',
         }*/
-    ]
-
-}
+    ];
+};